1074 lines
33 KiB
JavaScript
1074 lines
33 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 20293dbce215808d.10cf9e27a9.js
|
|
* Module id: 800109
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t = e.i(358379),
|
|
n = e.i(594613),
|
|
r = e.i(462214),
|
|
o = e.i(888659);
|
|
e.i(996972), e.i(111558);
|
|
var i = e.i(520466);
|
|
function l(e) {
|
|
let n = t.useRef(void 0),
|
|
r = t.useCallback((t) => {
|
|
let n = e.map((e) => {
|
|
if (null != e) {
|
|
if ("function" == typeof e) {
|
|
let n = e(t);
|
|
return "function" == typeof n
|
|
? n
|
|
: () => {
|
|
e(null);
|
|
};
|
|
}
|
|
return (
|
|
(e.current = t),
|
|
() => {
|
|
e.current = null;
|
|
}
|
|
);
|
|
}
|
|
});
|
|
return () => {
|
|
n.forEach((e) => (null == e ? void 0 : e()));
|
|
};
|
|
}, e);
|
|
return t.useMemo(
|
|
() =>
|
|
e.every((e) => null == e)
|
|
? null
|
|
: (e) => {
|
|
n.current && (n.current(), (n.current = void 0)),
|
|
null != e && (n.current = r(e));
|
|
},
|
|
e,
|
|
);
|
|
}
|
|
e.i(425017);
|
|
let a = "active",
|
|
u = "selected",
|
|
s = { ...t },
|
|
c = !1,
|
|
d = 0,
|
|
f = () => "floating-ui-" + Math.random().toString(36).slice(2, 6) + d++,
|
|
m =
|
|
s.useId ||
|
|
function () {
|
|
let [e, r] = t.useState(() => (c ? f() : void 0));
|
|
return (
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
null == e && r(f());
|
|
}, []),
|
|
t.useEffect(() => {
|
|
c = !0;
|
|
}, []),
|
|
e
|
|
);
|
|
},
|
|
p = t.createContext(null),
|
|
v = t.createContext(null),
|
|
g = () => {
|
|
var e;
|
|
return (null == (e = t.useContext(p)) ? void 0 : e.id) || null;
|
|
};
|
|
function h(e) {
|
|
return "data-floating-ui-" + e;
|
|
}
|
|
function y(e) {
|
|
-1 !== e.current && (clearTimeout(e.current), (e.current = -1));
|
|
}
|
|
let w = h("safe-polygon");
|
|
function b(e, t, r) {
|
|
if (r && !(0, n.isMouseLikePointerType)(r)) return 0;
|
|
if ("number" == typeof e) return e;
|
|
if ("function" == typeof e) {
|
|
let n = e();
|
|
return "number" == typeof n ? n : null == n ? void 0 : n[t];
|
|
}
|
|
return null == e ? void 0 : e[t];
|
|
}
|
|
function x(e) {
|
|
return "function" == typeof e ? e() : e;
|
|
}
|
|
function E(e, r) {
|
|
void 0 === r && (r = {});
|
|
let { open: i, onOpenChange: l, dataRef: a, events: u, elements: s } = e,
|
|
{
|
|
enabled: c = !0,
|
|
delay: d = 0,
|
|
handleClose: f = null,
|
|
mouseOnly: m = !1,
|
|
restMs: p = 0,
|
|
move: h = !0,
|
|
} = r,
|
|
E = t.useContext(v),
|
|
S = g(),
|
|
C = (0, n.useLatestRef)(f),
|
|
R = (0, n.useLatestRef)(d),
|
|
T = (0, n.useLatestRef)(i),
|
|
M = (0, n.useLatestRef)(p),
|
|
A = t.useRef(),
|
|
L = t.useRef(-1),
|
|
P = t.useRef(),
|
|
N = t.useRef(-1),
|
|
k = t.useRef(!0),
|
|
O = t.useRef(!1),
|
|
D = t.useRef(() => {}),
|
|
I = t.useRef(!1),
|
|
B = (0, n.useEffectEvent)(() => {
|
|
var e;
|
|
let t = null == (e = a.current.openEvent) ? void 0 : e.type;
|
|
return (
|
|
(null == t ? void 0 : t.includes("mouse")) && "mousedown" !== t
|
|
);
|
|
});
|
|
t.useEffect(() => {
|
|
if (c)
|
|
return (
|
|
u.on("openchange", e),
|
|
() => {
|
|
u.off("openchange", e);
|
|
}
|
|
);
|
|
function e(e) {
|
|
let { open: t } = e;
|
|
t || (y(L), y(N), (k.current = !0), (I.current = !1));
|
|
}
|
|
}, [c, u]),
|
|
t.useEffect(() => {
|
|
if (!c || !C.current || !i) return;
|
|
function e(e) {
|
|
B() && l(!1, e, "hover");
|
|
}
|
|
let t = (0, n.getDocument)(s.floating).documentElement;
|
|
return (
|
|
t.addEventListener("mouseleave", e),
|
|
() => {
|
|
t.removeEventListener("mouseleave", e);
|
|
}
|
|
);
|
|
}, [s.floating, i, l, c, C, B]);
|
|
let j = t.useCallback(
|
|
function (e, t, n) {
|
|
void 0 === t && (t = !0), void 0 === n && (n = "hover");
|
|
let r = b(R.current, "close", A.current);
|
|
r && !P.current
|
|
? (y(L), (L.current = window.setTimeout(() => l(!1, e, n), r)))
|
|
: t && (y(L), l(!1, e, n));
|
|
},
|
|
[R, l],
|
|
),
|
|
_ = (0, n.useEffectEvent)(() => {
|
|
D.current(), (P.current = void 0);
|
|
}),
|
|
F = (0, n.useEffectEvent)(() => {
|
|
if (O.current) {
|
|
let e = (0, n.getDocument)(s.floating).body;
|
|
(e.style.pointerEvents = ""),
|
|
e.removeAttribute(w),
|
|
(O.current = !1);
|
|
}
|
|
}),
|
|
H = (0, n.useEffectEvent)(
|
|
() =>
|
|
!!a.current.openEvent &&
|
|
["click", "mousedown"].includes(a.current.openEvent.type),
|
|
);
|
|
t.useEffect(() => {
|
|
if (c && (0, o.isElement)(s.domReference)) {
|
|
let n = s.domReference,
|
|
o = s.floating;
|
|
return (
|
|
i && n.addEventListener("mouseleave", r),
|
|
h && n.addEventListener("mousemove", e, { once: !0 }),
|
|
n.addEventListener("mouseenter", e),
|
|
n.addEventListener("mouseleave", t),
|
|
o &&
|
|
(o.addEventListener("mouseleave", r),
|
|
o.addEventListener("mouseenter", u),
|
|
o.addEventListener("mouseleave", d)),
|
|
() => {
|
|
i && n.removeEventListener("mouseleave", r),
|
|
h && n.removeEventListener("mousemove", e),
|
|
n.removeEventListener("mouseenter", e),
|
|
n.removeEventListener("mouseleave", t),
|
|
o &&
|
|
(o.removeEventListener("mouseleave", r),
|
|
o.removeEventListener("mouseenter", u),
|
|
o.removeEventListener("mouseleave", d));
|
|
}
|
|
);
|
|
}
|
|
function e(e) {
|
|
if (
|
|
(y(L),
|
|
(k.current = !1),
|
|
(m && !(0, n.isMouseLikePointerType)(A.current)) ||
|
|
(x(M.current) > 0 && !b(R.current, "open")))
|
|
)
|
|
return;
|
|
let t = b(R.current, "open", A.current);
|
|
t
|
|
? (L.current = window.setTimeout(() => {
|
|
T.current || l(!0, e, "hover");
|
|
}, t))
|
|
: i || l(!0, e, "hover");
|
|
}
|
|
function t(e) {
|
|
if (H()) return void F();
|
|
D.current();
|
|
let t = (0, n.getDocument)(s.floating);
|
|
if (
|
|
(y(N), (I.current = !1), C.current && a.current.floatingContext)
|
|
) {
|
|
i || y(L),
|
|
(P.current = C.current({
|
|
...a.current.floatingContext,
|
|
tree: E,
|
|
x: e.clientX,
|
|
y: e.clientY,
|
|
onClose() {
|
|
F(), _(), H() || j(e, !0, "safe-polygon");
|
|
},
|
|
}));
|
|
let n = P.current;
|
|
t.addEventListener("mousemove", n),
|
|
(D.current = () => {
|
|
t.removeEventListener("mousemove", n);
|
|
});
|
|
return;
|
|
}
|
|
("touch" === A.current &&
|
|
(0, n.contains)(s.floating, e.relatedTarget)) ||
|
|
j(e);
|
|
}
|
|
function r(e) {
|
|
H() ||
|
|
(a.current.floatingContext &&
|
|
(null == C.current ||
|
|
C.current({
|
|
...a.current.floatingContext,
|
|
tree: E,
|
|
x: e.clientX,
|
|
y: e.clientY,
|
|
onClose() {
|
|
F(), _(), H() || j(e);
|
|
},
|
|
})(e)));
|
|
}
|
|
function u() {
|
|
y(L);
|
|
}
|
|
function d(e) {
|
|
H() || j(e, !1);
|
|
}
|
|
}, [s, c, e, m, h, j, _, F, l, i, T, E, R, C, a, H, M]),
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
var e, t;
|
|
if (
|
|
c &&
|
|
i &&
|
|
null != (e = C.current) &&
|
|
null != (e = e.__options) &&
|
|
e.blockPointerEvents &&
|
|
B()
|
|
) {
|
|
O.current = !0;
|
|
let e = s.floating;
|
|
if ((0, o.isElement)(s.domReference) && e) {
|
|
let r = (0, n.getDocument)(s.floating).body;
|
|
r.setAttribute(w, "");
|
|
let o = s.domReference,
|
|
i =
|
|
null == E ||
|
|
null == (t = E.nodesRef.current.find((e) => e.id === S)) ||
|
|
null == (t = t.context)
|
|
? void 0
|
|
: t.elements.floating;
|
|
return (
|
|
i && (i.style.pointerEvents = ""),
|
|
(r.style.pointerEvents = "none"),
|
|
(o.style.pointerEvents = "auto"),
|
|
(e.style.pointerEvents = "auto"),
|
|
() => {
|
|
(r.style.pointerEvents = ""),
|
|
(o.style.pointerEvents = ""),
|
|
(e.style.pointerEvents = "");
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}, [c, i, S, s, E, C, B]),
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
i || ((A.current = void 0), (I.current = !1), _(), F());
|
|
}, [i, _, F]),
|
|
t.useEffect(
|
|
() => () => {
|
|
_(), y(L), y(N), F();
|
|
},
|
|
[c, s.domReference, _, F],
|
|
);
|
|
let W = t.useMemo(() => {
|
|
function e(e) {
|
|
A.current = e.pointerType;
|
|
}
|
|
return {
|
|
onPointerDown: e,
|
|
onPointerEnter: e,
|
|
onMouseMove(e) {
|
|
let { nativeEvent: t } = e;
|
|
function r() {
|
|
k.current || T.current || l(!0, t, "hover");
|
|
}
|
|
(m && !(0, n.isMouseLikePointerType)(A.current)) ||
|
|
i ||
|
|
0 === x(M.current) ||
|
|
(I.current && e.movementX ** 2 + e.movementY ** 2 < 2) ||
|
|
(y(N),
|
|
"touch" === A.current
|
|
? r()
|
|
: ((I.current = !0),
|
|
(N.current = window.setTimeout(r, x(M.current)))));
|
|
},
|
|
};
|
|
}, [m, l, i, T, M]);
|
|
return t.useMemo(() => (c ? { reference: W } : {}), [c, W]);
|
|
}
|
|
let S = () => {},
|
|
C = t.createContext({
|
|
delay: 0,
|
|
initialDelay: 0,
|
|
timeoutMs: 0,
|
|
currentId: null,
|
|
setCurrentId: S,
|
|
setState: S,
|
|
isInstantPhase: !1,
|
|
});
|
|
function R(e) {
|
|
let { children: o, delay: i, timeoutMs: l = 0 } = e,
|
|
[a, u] = t.useReducer((e, t) => ({ ...e, ...t }), {
|
|
delay: i,
|
|
timeoutMs: l,
|
|
initialDelay: i,
|
|
currentId: null,
|
|
isInstantPhase: !1,
|
|
}),
|
|
s = t.useRef(null),
|
|
c = t.useCallback((e) => {
|
|
u({ currentId: e });
|
|
}, []);
|
|
return (
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
a.currentId
|
|
? null === s.current
|
|
? (s.current = a.currentId)
|
|
: a.isInstantPhase || u({ isInstantPhase: !0 })
|
|
: (a.isInstantPhase && u({ isInstantPhase: !1 }),
|
|
(s.current = null));
|
|
}, [a.currentId, a.isInstantPhase]),
|
|
(0, r.jsx)(C.Provider, {
|
|
value: t.useMemo(
|
|
() => ({ ...a, setState: u, setCurrentId: c }),
|
|
[a, c],
|
|
),
|
|
children: o,
|
|
})
|
|
);
|
|
}
|
|
function T(e, r) {
|
|
void 0 === r && (r = {});
|
|
let { open: o, onOpenChange: i, floatingId: l } = e,
|
|
{ id: a, enabled: u = !0 } = r,
|
|
s = null != a ? a : l,
|
|
c = t.useContext(C),
|
|
{
|
|
currentId: d,
|
|
setCurrentId: f,
|
|
initialDelay: m,
|
|
setState: p,
|
|
timeoutMs: v,
|
|
} = c;
|
|
return (
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
!u ||
|
|
(d &&
|
|
(p({ delay: { open: 1, close: b(m, "close") } }),
|
|
d !== s && i(!1)));
|
|
}, [u, s, i, p, d, m]),
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
function e() {
|
|
i(!1), p({ delay: m, currentId: null });
|
|
}
|
|
if (u && d && !o && d === s) {
|
|
if (v) {
|
|
let t = window.setTimeout(e, v);
|
|
return () => {
|
|
clearTimeout(t);
|
|
};
|
|
}
|
|
e();
|
|
}
|
|
}, [u, o, p, d, s, i, m, v]),
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
!u || (f !== S && o && f(s));
|
|
}, [u, o, f, s]),
|
|
c
|
|
);
|
|
}
|
|
let M = {
|
|
pointerdown: "onPointerDown",
|
|
mousedown: "onMouseDown",
|
|
click: "onClick",
|
|
},
|
|
A = {
|
|
pointerdown: "onPointerDownCapture",
|
|
mousedown: "onMouseDownCapture",
|
|
click: "onClickCapture",
|
|
},
|
|
L = (e) => {
|
|
var t, n;
|
|
return {
|
|
escapeKey:
|
|
"boolean" == typeof e
|
|
? e
|
|
: null != (t = null == e ? void 0 : e.escapeKey) && t,
|
|
outsidePress:
|
|
"boolean" == typeof e
|
|
? e
|
|
: null == (n = null == e ? void 0 : e.outsidePress) || n,
|
|
};
|
|
};
|
|
function P(e, r) {
|
|
void 0 === r && (r = {});
|
|
let { open: i, onOpenChange: l, elements: a, dataRef: u } = e,
|
|
{
|
|
enabled: s = !0,
|
|
escapeKey: c = !0,
|
|
outsidePress: d = !0,
|
|
outsidePressEvent: f = "pointerdown",
|
|
referencePress: m = !1,
|
|
referencePressEvent: p = "pointerdown",
|
|
ancestorScroll: g = !1,
|
|
bubbles: y,
|
|
capture: w,
|
|
} = r,
|
|
b = t.useContext(v),
|
|
x = (0, n.useEffectEvent)("function" == typeof d ? d : () => !1),
|
|
E = "function" == typeof d ? x : d,
|
|
S = t.useRef(!1),
|
|
{ escapeKey: C, outsidePress: R } = L(y),
|
|
{ escapeKey: T, outsidePress: P } = L(w),
|
|
N = t.useRef(!1),
|
|
k = (0, n.useEffectEvent)((e) => {
|
|
var t;
|
|
if (!i || !s || !c || "Escape" !== e.key || N.current) return;
|
|
let r = null == (t = u.current.floatingContext) ? void 0 : t.nodeId,
|
|
o = b ? (0, n.getNodeChildren)(b.nodesRef.current, r) : [];
|
|
if (!C && (e.stopPropagation(), o.length > 0)) {
|
|
let e = !0;
|
|
if (
|
|
(o.forEach((t) => {
|
|
var n;
|
|
if (
|
|
null != (n = t.context) &&
|
|
n.open &&
|
|
!t.context.dataRef.current.__escapeKeyBubbles
|
|
) {
|
|
e = !1;
|
|
return;
|
|
}
|
|
}),
|
|
!e)
|
|
)
|
|
return;
|
|
}
|
|
l(!1, (0, n.isReactEvent)(e) ? e.nativeEvent : e, "escape-key");
|
|
}),
|
|
O = (0, n.useEffectEvent)((e) => {
|
|
var t;
|
|
let r = () => {
|
|
var t;
|
|
k(e),
|
|
null == (t = (0, n.getTarget)(e)) ||
|
|
t.removeEventListener("keydown", r);
|
|
};
|
|
null == (t = (0, n.getTarget)(e)) || t.addEventListener("keydown", r);
|
|
}),
|
|
D = (0, n.useEffectEvent)((e) => {
|
|
var t;
|
|
let r = u.current.insideReactTree;
|
|
u.current.insideReactTree = !1;
|
|
let i = S.current;
|
|
if (
|
|
((S.current = !1),
|
|
("click" === f && i) || r || ("function" == typeof E && !E(e)))
|
|
)
|
|
return;
|
|
let s = (0, n.getTarget)(e),
|
|
c = "[" + h("inert") + "]",
|
|
d = (0, n.getDocument)(a.floating).querySelectorAll(c),
|
|
m = (0, o.isElement)(s) ? s : null;
|
|
for (; m && !(0, o.isLastTraversableNode)(m); ) {
|
|
let e = (0, o.getParentNode)(m);
|
|
if ((0, o.isLastTraversableNode)(e) || !(0, o.isElement)(e)) break;
|
|
m = e;
|
|
}
|
|
if (
|
|
d.length &&
|
|
(0, o.isElement)(s) &&
|
|
!(0, n.isRootElement)(s) &&
|
|
!(0, n.contains)(s, a.floating) &&
|
|
Array.from(d).every((e) => !(0, n.contains)(m, e))
|
|
)
|
|
return;
|
|
if ((0, o.isHTMLElement)(s) && j) {
|
|
let t = (0, o.isLastTraversableNode)(s),
|
|
n = (0, o.getComputedStyle)(s),
|
|
r = /auto|scroll/,
|
|
i = t || r.test(n.overflowX),
|
|
l = t || r.test(n.overflowY),
|
|
a = i && s.clientWidth > 0 && s.scrollWidth > s.clientWidth,
|
|
u = l && s.clientHeight > 0 && s.scrollHeight > s.clientHeight,
|
|
c = "rtl" === n.direction,
|
|
d =
|
|
u &&
|
|
(c
|
|
? e.offsetX <= s.offsetWidth - s.clientWidth
|
|
: e.offsetX > s.clientWidth),
|
|
f = a && e.offsetY > s.clientHeight;
|
|
if (d || f) return;
|
|
}
|
|
let p = null == (t = u.current.floatingContext) ? void 0 : t.nodeId,
|
|
v =
|
|
b &&
|
|
(0, n.getNodeChildren)(b.nodesRef.current, p).some((t) => {
|
|
var r;
|
|
return (0, n.isEventTargetWithin)(
|
|
e,
|
|
null == (r = t.context) ? void 0 : r.elements.floating,
|
|
);
|
|
});
|
|
if (
|
|
(0, n.isEventTargetWithin)(e, a.floating) ||
|
|
(0, n.isEventTargetWithin)(e, a.domReference) ||
|
|
v
|
|
)
|
|
return;
|
|
let g = b ? (0, n.getNodeChildren)(b.nodesRef.current, p) : [];
|
|
if (g.length > 0) {
|
|
let e = !0;
|
|
if (
|
|
(g.forEach((t) => {
|
|
var n;
|
|
if (
|
|
null != (n = t.context) &&
|
|
n.open &&
|
|
!t.context.dataRef.current.__outsidePressBubbles
|
|
) {
|
|
e = !1;
|
|
return;
|
|
}
|
|
}),
|
|
!e)
|
|
)
|
|
return;
|
|
}
|
|
l(!1, e, "outside-press");
|
|
}),
|
|
I = (0, n.useEffectEvent)((e) => {
|
|
var t;
|
|
let r = () => {
|
|
var t;
|
|
D(e),
|
|
null == (t = (0, n.getTarget)(e)) || t.removeEventListener(f, r);
|
|
};
|
|
null == (t = (0, n.getTarget)(e)) || t.addEventListener(f, r);
|
|
});
|
|
t.useEffect(() => {
|
|
if (!i || !s) return;
|
|
(u.current.__escapeKeyBubbles = C),
|
|
(u.current.__outsidePressBubbles = R);
|
|
let e = -1;
|
|
function t(e) {
|
|
l(!1, e, "ancestor-scroll");
|
|
}
|
|
function r() {
|
|
window.clearTimeout(e), (N.current = !0);
|
|
}
|
|
function d() {
|
|
e = window.setTimeout(
|
|
() => {
|
|
N.current = !1;
|
|
},
|
|
5 * !!(0, o.isWebKit)(),
|
|
);
|
|
}
|
|
let m = (0, n.getDocument)(a.floating);
|
|
c &&
|
|
(m.addEventListener("keydown", T ? O : k, T),
|
|
m.addEventListener("compositionstart", r),
|
|
m.addEventListener("compositionend", d)),
|
|
E && m.addEventListener(f, P ? I : D, P);
|
|
let p = [];
|
|
return (
|
|
g &&
|
|
((0, o.isElement)(a.domReference) &&
|
|
(p = (0, o.getOverflowAncestors)(a.domReference)),
|
|
(0, o.isElement)(a.floating) &&
|
|
(p = p.concat((0, o.getOverflowAncestors)(a.floating))),
|
|
!(0, o.isElement)(a.reference) &&
|
|
a.reference &&
|
|
a.reference.contextElement &&
|
|
(p = p.concat(
|
|
(0, o.getOverflowAncestors)(a.reference.contextElement),
|
|
))),
|
|
(p = p.filter((e) => {
|
|
var t;
|
|
return (
|
|
e !== (null == (t = m.defaultView) ? void 0 : t.visualViewport)
|
|
);
|
|
})).forEach((e) => {
|
|
e.addEventListener("scroll", t, { passive: !0 });
|
|
}),
|
|
() => {
|
|
c &&
|
|
(m.removeEventListener("keydown", T ? O : k, T),
|
|
m.removeEventListener("compositionstart", r),
|
|
m.removeEventListener("compositionend", d)),
|
|
E && m.removeEventListener(f, P ? I : D, P),
|
|
p.forEach((e) => {
|
|
e.removeEventListener("scroll", t);
|
|
}),
|
|
window.clearTimeout(e);
|
|
}
|
|
);
|
|
}, [u, a, c, E, f, i, l, g, s, C, R, k, T, O, D, P, I]),
|
|
t.useEffect(() => {
|
|
u.current.insideReactTree = !1;
|
|
}, [u, E, f]);
|
|
let B = t.useMemo(
|
|
() => ({
|
|
onKeyDown: k,
|
|
...(m && {
|
|
[M[p]]: (e) => {
|
|
l(!1, e.nativeEvent, "reference-press");
|
|
},
|
|
...("click" !== p && {
|
|
onClick(e) {
|
|
l(!1, e.nativeEvent, "reference-press");
|
|
},
|
|
}),
|
|
}),
|
|
}),
|
|
[k, l, m, p],
|
|
),
|
|
j = t.useMemo(
|
|
() => ({
|
|
onKeyDown: k,
|
|
onMouseDown() {
|
|
S.current = !0;
|
|
},
|
|
onMouseUp() {
|
|
S.current = !0;
|
|
},
|
|
[A[f]]: () => {
|
|
u.current.insideReactTree = !0;
|
|
},
|
|
}),
|
|
[k, f, u],
|
|
);
|
|
return t.useMemo(
|
|
() => (s ? { reference: B, floating: j } : {}),
|
|
[s, B, j],
|
|
);
|
|
}
|
|
function N(e) {
|
|
void 0 === e && (e = {});
|
|
let { nodeId: r } = e,
|
|
l = (function (e) {
|
|
let { open: r = !1, onOpenChange: o, elements: i } = e,
|
|
l = m(),
|
|
a = t.useRef({}),
|
|
[u] = t.useState(() => {
|
|
let e;
|
|
return (
|
|
(e = new Map()),
|
|
{
|
|
emit(t, n) {
|
|
var r;
|
|
null == (r = e.get(t)) || r.forEach((e) => e(n));
|
|
},
|
|
on(t, n) {
|
|
e.has(t) || e.set(t, new Set()), e.get(t).add(n);
|
|
},
|
|
off(t, n) {
|
|
var r;
|
|
null == (r = e.get(t)) || r.delete(n);
|
|
},
|
|
}
|
|
);
|
|
}),
|
|
s = null != g(),
|
|
[c, d] = t.useState(i.reference),
|
|
f = (0, n.useEffectEvent)((e, t, n) => {
|
|
(a.current.openEvent = e ? t : void 0),
|
|
u.emit("openchange", {
|
|
open: e,
|
|
event: t,
|
|
reason: n,
|
|
nested: s,
|
|
}),
|
|
null == o || o(e, t, n);
|
|
}),
|
|
p = t.useMemo(() => ({ setPositionReference: d }), []),
|
|
v = t.useMemo(
|
|
() => ({
|
|
reference: c || i.reference || null,
|
|
floating: i.floating || null,
|
|
domReference: i.reference,
|
|
}),
|
|
[c, i.reference, i.floating],
|
|
);
|
|
return t.useMemo(
|
|
() => ({
|
|
dataRef: a,
|
|
open: r,
|
|
onOpenChange: f,
|
|
elements: v,
|
|
events: u,
|
|
floatingId: l,
|
|
refs: p,
|
|
}),
|
|
[r, f, v, u, l, p],
|
|
);
|
|
})({
|
|
...e,
|
|
elements: { reference: null, floating: null, ...e.elements },
|
|
}),
|
|
a = e.rootContext || l,
|
|
u = a.elements,
|
|
[s, c] = t.useState(null),
|
|
[d, f] = t.useState(null),
|
|
p = (null == u ? void 0 : u.domReference) || s,
|
|
h = t.useRef(null),
|
|
y = t.useContext(v);
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
p && (h.current = p);
|
|
}, [p]);
|
|
let w = (0, i.useFloating)({
|
|
...e,
|
|
elements: { ...u, ...(d && { reference: d }) },
|
|
}),
|
|
b = t.useCallback(
|
|
(e) => {
|
|
let t = (0, o.isElement)(e)
|
|
? {
|
|
getBoundingClientRect: () => e.getBoundingClientRect(),
|
|
getClientRects: () => e.getClientRects(),
|
|
contextElement: e,
|
|
}
|
|
: e;
|
|
f(t), w.refs.setReference(t);
|
|
},
|
|
[w.refs],
|
|
),
|
|
x = t.useCallback(
|
|
(e) => {
|
|
((0, o.isElement)(e) || null === e) && ((h.current = e), c(e)),
|
|
((0, o.isElement)(w.refs.reference.current) ||
|
|
null === w.refs.reference.current ||
|
|
(null !== e && !(0, o.isElement)(e))) &&
|
|
w.refs.setReference(e);
|
|
},
|
|
[w.refs],
|
|
),
|
|
E = t.useMemo(
|
|
() => ({
|
|
...w.refs,
|
|
setReference: x,
|
|
setPositionReference: b,
|
|
domReference: h,
|
|
}),
|
|
[w.refs, x, b],
|
|
),
|
|
S = t.useMemo(
|
|
() => ({ ...w.elements, domReference: p }),
|
|
[w.elements, p],
|
|
),
|
|
C = t.useMemo(
|
|
() => ({ ...w, ...a, refs: E, elements: S, nodeId: r }),
|
|
[w, E, S, r, a],
|
|
);
|
|
return (
|
|
(0, n.useModernLayoutEffect)(() => {
|
|
a.dataRef.current.floatingContext = C;
|
|
let e =
|
|
null == y ? void 0 : y.nodesRef.current.find((e) => e.id === r);
|
|
e && (e.context = C);
|
|
}),
|
|
t.useMemo(
|
|
() => ({ ...w, context: C, refs: E, elements: S }),
|
|
[w, E, S, C],
|
|
)
|
|
);
|
|
}
|
|
function k() {
|
|
return (0, n.isMac)() && (0, n.isSafari)();
|
|
}
|
|
function O(e, r) {
|
|
void 0 === r && (r = {});
|
|
let { open: i, onOpenChange: l, events: a, dataRef: u, elements: s } = e,
|
|
{ enabled: c = !0, visibleOnly: d = !0 } = r,
|
|
f = t.useRef(!1),
|
|
m = t.useRef(-1),
|
|
p = t.useRef(!0);
|
|
t.useEffect(() => {
|
|
if (!c) return;
|
|
let e = (0, o.getWindow)(s.domReference);
|
|
function t() {
|
|
!i &&
|
|
(0, o.isHTMLElement)(s.domReference) &&
|
|
s.domReference ===
|
|
(0, n.activeElement)((0, n.getDocument)(s.domReference)) &&
|
|
(f.current = !0);
|
|
}
|
|
function r() {
|
|
p.current = !0;
|
|
}
|
|
function l() {
|
|
p.current = !1;
|
|
}
|
|
return (
|
|
e.addEventListener("blur", t),
|
|
k() &&
|
|
(e.addEventListener("keydown", r, !0),
|
|
e.addEventListener("pointerdown", l, !0)),
|
|
() => {
|
|
e.removeEventListener("blur", t),
|
|
k() &&
|
|
(e.removeEventListener("keydown", r, !0),
|
|
e.removeEventListener("pointerdown", l, !0));
|
|
}
|
|
);
|
|
}, [s.domReference, i, c]),
|
|
t.useEffect(() => {
|
|
if (c)
|
|
return (
|
|
a.on("openchange", e),
|
|
() => {
|
|
a.off("openchange", e);
|
|
}
|
|
);
|
|
function e(e) {
|
|
let { reason: t } = e;
|
|
("reference-press" === t || "escape-key" === t) && (f.current = !0);
|
|
}
|
|
}, [a, c]),
|
|
t.useEffect(
|
|
() => () => {
|
|
y(m);
|
|
},
|
|
[],
|
|
);
|
|
let v = t.useMemo(
|
|
() => ({
|
|
onMouseLeave() {
|
|
f.current = !1;
|
|
},
|
|
onFocus(e) {
|
|
if (f.current) return;
|
|
let t = (0, n.getTarget)(e.nativeEvent);
|
|
if (d && (0, o.isElement)(t)) {
|
|
if (k() && !e.relatedTarget) {
|
|
if (!p.current && !(0, n.isTypeableElement)(t)) return;
|
|
} else if (!(0, n.matchesFocusVisible)(t)) return;
|
|
}
|
|
l(!0, e.nativeEvent, "focus");
|
|
},
|
|
onBlur(e) {
|
|
f.current = !1;
|
|
let t = e.relatedTarget,
|
|
r = e.nativeEvent,
|
|
i =
|
|
(0, o.isElement)(t) &&
|
|
t.hasAttribute(h("focus-guard")) &&
|
|
"outside" === t.getAttribute("data-type");
|
|
m.current = window.setTimeout(() => {
|
|
var e;
|
|
let o = (0, n.activeElement)(
|
|
s.domReference ? s.domReference.ownerDocument : document,
|
|
);
|
|
(!t && o === s.domReference) ||
|
|
(0, n.contains)(
|
|
null == (e = u.current.floatingContext)
|
|
? void 0
|
|
: e.refs.floating.current,
|
|
o,
|
|
) ||
|
|
(0, n.contains)(s.domReference, o) ||
|
|
i ||
|
|
l(!1, r, "focus");
|
|
});
|
|
},
|
|
}),
|
|
[u, s.domReference, l, d],
|
|
);
|
|
return t.useMemo(() => (c ? { reference: v } : {}), [c, v]);
|
|
}
|
|
function D(e, t, n) {
|
|
let r = new Map(),
|
|
o = "item" === n,
|
|
i = e;
|
|
if (o && e) {
|
|
let { [a]: t, [u]: n, ...r } = e;
|
|
i = r;
|
|
}
|
|
return {
|
|
...("floating" === n && {
|
|
tabIndex: -1,
|
|
"data-floating-ui-focusable": "",
|
|
}),
|
|
...i,
|
|
...t
|
|
.map((t) => {
|
|
let r = t ? t[n] : null;
|
|
return "function" == typeof r ? (e ? r(e) : null) : r;
|
|
})
|
|
.concat(e)
|
|
.reduce(
|
|
(e, t) => (
|
|
t &&
|
|
Object.entries(t).forEach((t) => {
|
|
let [n, i] = t;
|
|
if (!(o && [a, u].includes(n)))
|
|
if (0 === n.indexOf("on")) {
|
|
if ((r.has(n) || r.set(n, []), "function" == typeof i)) {
|
|
var l;
|
|
null == (l = r.get(n)) || l.push(i),
|
|
(e[n] = function () {
|
|
for (
|
|
var e, t = arguments.length, o = Array(t), i = 0;
|
|
i < t;
|
|
i++
|
|
)
|
|
o[i] = arguments[i];
|
|
return null == (e = r.get(n))
|
|
? void 0
|
|
: e.map((e) => e(...o)).find((e) => void 0 !== e);
|
|
});
|
|
}
|
|
} else e[n] = i;
|
|
}),
|
|
e
|
|
),
|
|
{},
|
|
),
|
|
};
|
|
}
|
|
function I(e) {
|
|
void 0 === e && (e = []);
|
|
let n = e.map((e) => (null == e ? void 0 : e.reference)),
|
|
r = e.map((e) => (null == e ? void 0 : e.floating)),
|
|
o = e.map((e) => (null == e ? void 0 : e.item)),
|
|
i = t.useCallback((t) => D(t, e, "reference"), n),
|
|
l = t.useCallback((t) => D(t, e, "floating"), r),
|
|
a = t.useCallback((t) => D(t, e, "item"), o);
|
|
return t.useMemo(
|
|
() => ({ getReferenceProps: i, getFloatingProps: l, getItemProps: a }),
|
|
[i, l, a],
|
|
);
|
|
}
|
|
let B = new Map([
|
|
["select", "listbox"],
|
|
["combobox", "listbox"],
|
|
["label", !1],
|
|
]);
|
|
function j(e, r) {
|
|
var o, i;
|
|
void 0 === r && (r = {});
|
|
let { open: l, elements: a, floatingId: u } = e,
|
|
{ enabled: s = !0, role: c = "dialog" } = r,
|
|
d = m(),
|
|
f = (null == (o = a.domReference) ? void 0 : o.id) || d,
|
|
p = t.useMemo(() => {
|
|
var e;
|
|
return (
|
|
(null == (e = (0, n.getFloatingFocusElement)(a.floating))
|
|
? void 0
|
|
: e.id) || u
|
|
);
|
|
}, [a.floating, u]),
|
|
v = null != (i = B.get(c)) ? i : c,
|
|
h = null != g(),
|
|
y = t.useMemo(
|
|
() =>
|
|
"tooltip" === v || "label" === c
|
|
? {
|
|
["aria-" + ("label" === c ? "labelledby" : "describedby")]: l
|
|
? p
|
|
: void 0,
|
|
}
|
|
: {
|
|
"aria-expanded": l ? "true" : "false",
|
|
"aria-haspopup": "alertdialog" === v ? "dialog" : v,
|
|
"aria-controls": l ? p : void 0,
|
|
...("listbox" === v && { role: "combobox" }),
|
|
...("menu" === v && { id: f }),
|
|
...("menu" === v && h && { role: "menuitem" }),
|
|
...("select" === c && { "aria-autocomplete": "none" }),
|
|
...("combobox" === c && { "aria-autocomplete": "list" }),
|
|
},
|
|
[v, p, h, l, f, c],
|
|
),
|
|
w = t.useMemo(() => {
|
|
let e = { id: p, ...(v && { role: v }) };
|
|
return "tooltip" === v || "label" === c
|
|
? e
|
|
: { ...e, ...("menu" === v && { "aria-labelledby": f }) };
|
|
}, [v, p, f, c]),
|
|
b = t.useCallback(
|
|
(e) => {
|
|
let { active: t, selected: n } = e,
|
|
r = { role: "option", ...(t && { id: p + "-fui-option" }) };
|
|
switch (c) {
|
|
case "select":
|
|
case "combobox":
|
|
return { ...r, "aria-selected": n };
|
|
}
|
|
return {};
|
|
},
|
|
[p, c],
|
|
);
|
|
return t.useMemo(
|
|
() => (s ? { reference: y, floating: w, item: b } : {}),
|
|
[s, y, w, b],
|
|
);
|
|
}
|
|
e.s([
|
|
"FloatingDelayGroup",
|
|
() => R,
|
|
"useDelayGroup",
|
|
() => T,
|
|
"useDismiss",
|
|
() => P,
|
|
"useFloating",
|
|
() => N,
|
|
"useFocus",
|
|
() => O,
|
|
"useHover",
|
|
() => E,
|
|
"useInteractions",
|
|
() => I,
|
|
"useMergeRefs",
|
|
() => l,
|
|
"useRole",
|
|
() => j,
|
|
]);
|
|
};
|
|
|
|
export default moduleFactory;
|