1022 lines
33 KiB
JavaScript
1022 lines
33 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 20293dbce215808d.10cf9e27a9.js
|
|
* Module id: 11623
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t = e.i(462214),
|
|
n = e.i(358379),
|
|
r = e.i(909243),
|
|
o = e.i(7284),
|
|
i = e.i(479324),
|
|
l = e.i(593307),
|
|
a = e.i(887422),
|
|
u = e.i(621414),
|
|
s = e.i(257469),
|
|
c = e.i(349665),
|
|
d = e.i(845526),
|
|
f = e.i(686916),
|
|
m = e.i(389435),
|
|
p = e.i(855698),
|
|
v = e.i(938202),
|
|
g = e.i(450943),
|
|
h = e.i(427574),
|
|
y = e.i(800109),
|
|
w = e.i(124859),
|
|
b = e.i(321658),
|
|
x = e.i(221904),
|
|
E = e.i(989655),
|
|
S = e.i(20528),
|
|
C = e.i(814499),
|
|
R = e.i(610277),
|
|
T = e.i(46978);
|
|
function M(e, t) {
|
|
let n = e / t;
|
|
return Number.isNaN(n) ? 0 : n;
|
|
}
|
|
function A(e) {
|
|
let t = M(e.viewport, e.content),
|
|
n = e.scrollbar.paddingStart + e.scrollbar.paddingEnd;
|
|
return Math.max((e.scrollbar.size - n) * t, 18);
|
|
}
|
|
function L(e, t) {
|
|
return (n) => {
|
|
if (e[0] === e[1] || t[0] === t[1]) return t[0];
|
|
let r = (t[1] - t[0]) / (e[1] - e[0]);
|
|
return t[0] + r * (n - e[0]);
|
|
};
|
|
}
|
|
function P(e, t, n = "ltr") {
|
|
let r = A(t),
|
|
o = t.scrollbar.paddingStart + t.scrollbar.paddingEnd,
|
|
i = t.scrollbar.size - o,
|
|
l = t.content - t.viewport,
|
|
a = (function (e, [t, n]) {
|
|
return Math.min(n, Math.max(t, e));
|
|
})(e, "ltr" === n ? [0, l] : [-1 * l, 0]);
|
|
return L([0, l], [0, i - r])(a);
|
|
}
|
|
var N = e.i(600354);
|
|
function k(e) {
|
|
return e ? parseInt(e, 10) : 0;
|
|
}
|
|
e.s(["toInt", () => k], 211859);
|
|
var O = e.i(590029);
|
|
function D(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
|
|
return (r) => {
|
|
e?.(r), (!1 !== n && r.defaultPrevented) || t?.(r);
|
|
};
|
|
}
|
|
let [I, B] = (0, e.i(559394).createSafeContext)(
|
|
"ScrollAreaScrollbar was not found in tree",
|
|
),
|
|
j = (0, n.forwardRef)((e, r) => {
|
|
let {
|
|
sizes: o,
|
|
hasThumb: i,
|
|
onThumbChange: l,
|
|
onThumbPointerUp: a,
|
|
onThumbPointerDown: u,
|
|
onThumbPositionChange: s,
|
|
onDragScroll: c,
|
|
onWheelScroll: d,
|
|
onResize: f,
|
|
...m
|
|
} = e,
|
|
p = (0, S.useScrollAreaContext)(),
|
|
[v, g] = (0, n.useState)(null),
|
|
h = (0, N.useMergedRef)(r, (e) => g(e)),
|
|
y = (0, n.useRef)(null),
|
|
w = (0, n.useRef)(""),
|
|
{ viewport: b } = p,
|
|
x = o.content - o.viewport,
|
|
E = (0, O.useCallbackRef)(d),
|
|
T = (0, O.useCallbackRef)(s),
|
|
M = (0, C.useDebouncedCallback)(f, 10),
|
|
A = (e) => {
|
|
y.current &&
|
|
c({
|
|
x: e.clientX - y.current.left,
|
|
y: e.clientY - y.current.top,
|
|
});
|
|
};
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
let e = (e) => {
|
|
let t = e.target;
|
|
v?.contains(t) && E(e, x);
|
|
};
|
|
return (
|
|
document.addEventListener("wheel", e, { passive: !1 }),
|
|
() => document.removeEventListener("wheel", e, { passive: !1 })
|
|
);
|
|
}, [b, v, x, E]),
|
|
(0, n.useEffect)(T, [o, T]),
|
|
(0, R.useResizeObserver)(v, M),
|
|
(0, R.useResizeObserver)(p.content, M),
|
|
(0, t.jsx)(I, {
|
|
value: {
|
|
scrollbar: v,
|
|
hasThumb: i,
|
|
onThumbChange: (0, O.useCallbackRef)(l),
|
|
onThumbPointerUp: (0, O.useCallbackRef)(a),
|
|
onThumbPositionChange: T,
|
|
onThumbPointerDown: (0, O.useCallbackRef)(u),
|
|
},
|
|
children: (0, t.jsx)("div", {
|
|
...m,
|
|
ref: h,
|
|
"data-mantine-scrollbar": !0,
|
|
style: { position: "absolute", ...m.style },
|
|
onPointerDown: D(e.onPointerDown, (e) => {
|
|
e.preventDefault(),
|
|
0 === e.button &&
|
|
(e.target.setPointerCapture(e.pointerId),
|
|
(y.current = v.getBoundingClientRect()),
|
|
(w.current = document.body.style.webkitUserSelect),
|
|
(document.body.style.webkitUserSelect = "none"),
|
|
A(e));
|
|
}),
|
|
onPointerMove: D(e.onPointerMove, A),
|
|
onPointerUp: D(e.onPointerUp, (e) => {
|
|
let t = e.target;
|
|
t.hasPointerCapture(e.pointerId) &&
|
|
(e.preventDefault(), t.releasePointerCapture(e.pointerId));
|
|
}),
|
|
onLostPointerCapture: () => {
|
|
(document.body.style.webkitUserSelect = w.current),
|
|
(y.current = null);
|
|
},
|
|
}),
|
|
})
|
|
);
|
|
}),
|
|
_ = (0, n.forwardRef)((e, r) => {
|
|
let { sizes: o, onSizesChange: i, style: l, ...a } = e,
|
|
u = (0, S.useScrollAreaContext)(),
|
|
[s, c] = (0, n.useState)(),
|
|
d = (0, n.useRef)(null),
|
|
f = (0, N.useMergedRef)(r, d, u.onScrollbarXChange);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
d.current && c(getComputedStyle(d.current));
|
|
}, [d]),
|
|
(0, t.jsx)(j, {
|
|
"data-orientation": "horizontal",
|
|
...a,
|
|
ref: f,
|
|
sizes: o,
|
|
style: { ...l, "--sa-thumb-width": `${A(o)}px` },
|
|
onThumbPointerDown: (t) => e.onThumbPointerDown(t.x),
|
|
onDragScroll: (t) => e.onDragScroll(t.x),
|
|
onWheelScroll: (t, n) => {
|
|
if (u.viewport) {
|
|
let r = u.viewport.scrollLeft + t.deltaX;
|
|
e.onWheelScroll(r), r > 0 && r < n && t.preventDefault();
|
|
}
|
|
},
|
|
onResize: () => {
|
|
d.current &&
|
|
u.viewport &&
|
|
s &&
|
|
i({
|
|
content: u.viewport.scrollWidth,
|
|
viewport: u.viewport.offsetWidth,
|
|
scrollbar: {
|
|
size: d.current.clientWidth,
|
|
paddingStart: k(s.paddingLeft),
|
|
paddingEnd: k(s.paddingRight),
|
|
},
|
|
});
|
|
},
|
|
})
|
|
);
|
|
});
|
|
_.displayName = "@mantine/core/ScrollAreaScrollbarX";
|
|
let F = (0, n.forwardRef)((e, r) => {
|
|
let { sizes: o, onSizesChange: i, style: l, ...a } = e,
|
|
u = (0, S.useScrollAreaContext)(),
|
|
[s, c] = (0, n.useState)(),
|
|
d = (0, n.useRef)(null),
|
|
f = (0, N.useMergedRef)(r, d, u.onScrollbarYChange);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
d.current && c(window.getComputedStyle(d.current));
|
|
}, []),
|
|
(0, t.jsx)(j, {
|
|
...a,
|
|
"data-orientation": "vertical",
|
|
ref: f,
|
|
sizes: o,
|
|
style: { "--sa-thumb-height": `${A(o)}px`, ...l },
|
|
onThumbPointerDown: (t) => e.onThumbPointerDown(t.y),
|
|
onDragScroll: (t) => e.onDragScroll(t.y),
|
|
onWheelScroll: (t, n) => {
|
|
if (u.viewport) {
|
|
let r = u.viewport.scrollTop + t.deltaY;
|
|
e.onWheelScroll(r), r > 0 && r < n && t.preventDefault();
|
|
}
|
|
},
|
|
onResize: () => {
|
|
d.current &&
|
|
u.viewport &&
|
|
s &&
|
|
i({
|
|
content: u.viewport.scrollHeight,
|
|
viewport: u.viewport.offsetHeight,
|
|
scrollbar: {
|
|
size: d.current.clientHeight,
|
|
paddingStart: k(s.paddingTop),
|
|
paddingEnd: k(s.paddingBottom),
|
|
},
|
|
});
|
|
},
|
|
})
|
|
);
|
|
});
|
|
F.displayName = "@mantine/core/ScrollAreaScrollbarY";
|
|
let H = (0, n.forwardRef)((e, r) => {
|
|
let { orientation: o = "vertical", ...i } = e,
|
|
{ dir: l } = (0, T.useDirection)(),
|
|
a = (0, S.useScrollAreaContext)(),
|
|
u = (0, n.useRef)(null),
|
|
s = (0, n.useRef)(0),
|
|
[c, d] = (0, n.useState)({
|
|
content: 0,
|
|
viewport: 0,
|
|
scrollbar: { size: 0, paddingStart: 0, paddingEnd: 0 },
|
|
}),
|
|
f = M(c.viewport, c.content),
|
|
m = {
|
|
...i,
|
|
sizes: c,
|
|
onSizesChange: d,
|
|
hasThumb: !!(f > 0 && f < 1),
|
|
onThumbChange: (e) => {
|
|
u.current = e;
|
|
},
|
|
onThumbPointerUp: () => {
|
|
s.current = 0;
|
|
},
|
|
onThumbPointerDown: (e) => {
|
|
s.current = e;
|
|
},
|
|
},
|
|
p = (e, t) =>
|
|
(function (e, t, n, r = "ltr") {
|
|
let o = A(n),
|
|
i = t || o / 2,
|
|
l = n.scrollbar.paddingStart + i,
|
|
a = n.scrollbar.size - n.scrollbar.paddingEnd - (o - i),
|
|
u = n.content - n.viewport;
|
|
return L([l, a], "ltr" === r ? [0, u] : [-1 * u, 0])(e);
|
|
})(e, s.current, c, t);
|
|
return "horizontal" === o
|
|
? (0, t.jsx)(_, {
|
|
...m,
|
|
ref: r,
|
|
onThumbPositionChange: () => {
|
|
if (a.viewport && u.current) {
|
|
let e = P(a.viewport.scrollLeft, c, l);
|
|
u.current.style.transform = `translate3d(${e}px, 0, 0)`;
|
|
}
|
|
},
|
|
onWheelScroll: (e) => {
|
|
a.viewport && (a.viewport.scrollLeft = e);
|
|
},
|
|
onDragScroll: (e) => {
|
|
a.viewport && (a.viewport.scrollLeft = p(e, l));
|
|
},
|
|
})
|
|
: "vertical" === o
|
|
? (0, t.jsx)(F, {
|
|
...m,
|
|
ref: r,
|
|
onThumbPositionChange: () => {
|
|
if (a.viewport && u.current) {
|
|
let e = P(a.viewport.scrollTop, c);
|
|
0 === c.scrollbar.size
|
|
? u.current.style.setProperty("--thumb-opacity", "0")
|
|
: u.current.style.setProperty("--thumb-opacity", "1"),
|
|
(u.current.style.transform = `translate3d(0, ${e}px, 0)`);
|
|
}
|
|
},
|
|
onWheelScroll: (e) => {
|
|
a.viewport && (a.viewport.scrollTop = e);
|
|
},
|
|
onDragScroll: (e) => {
|
|
a.viewport && (a.viewport.scrollTop = p(e));
|
|
},
|
|
})
|
|
: null;
|
|
});
|
|
H.displayName = "@mantine/core/ScrollAreaScrollbarVisible";
|
|
let W = (0, n.forwardRef)((e, r) => {
|
|
let o = (0, S.useScrollAreaContext)(),
|
|
{ forceMount: i, ...l } = e,
|
|
[a, u] = (0, n.useState)(!1),
|
|
s = "horizontal" === e.orientation,
|
|
c = (0, C.useDebouncedCallback)(() => {
|
|
if (o.viewport) {
|
|
let e = o.viewport.offsetWidth < o.viewport.scrollWidth,
|
|
t = o.viewport.offsetHeight < o.viewport.scrollHeight;
|
|
u(s ? e : t);
|
|
}
|
|
}, 10);
|
|
return ((0, R.useResizeObserver)(o.viewport, c),
|
|
(0, R.useResizeObserver)(o.content, c),
|
|
i || a)
|
|
? (0, t.jsx)(H, {
|
|
"data-state": a ? "visible" : "hidden",
|
|
...l,
|
|
ref: r,
|
|
})
|
|
: null;
|
|
});
|
|
W.displayName = "@mantine/core/ScrollAreaScrollbarAuto";
|
|
let z = (0, n.forwardRef)((e, r) => {
|
|
let { forceMount: o, ...i } = e,
|
|
l = (0, S.useScrollAreaContext)(),
|
|
[a, u] = (0, n.useState)(!1);
|
|
return ((0, n.useEffect)(() => {
|
|
let { scrollArea: e } = l,
|
|
t = 0;
|
|
if (e) {
|
|
let n = () => {
|
|
window.clearTimeout(t), u(!0);
|
|
},
|
|
r = () => {
|
|
t = window.setTimeout(() => u(!1), l.scrollHideDelay);
|
|
};
|
|
return (
|
|
e.addEventListener("pointerenter", n),
|
|
e.addEventListener("pointerleave", r),
|
|
() => {
|
|
window.clearTimeout(t),
|
|
e.removeEventListener("pointerenter", n),
|
|
e.removeEventListener("pointerleave", r);
|
|
}
|
|
);
|
|
}
|
|
}, [l.scrollArea, l.scrollHideDelay]),
|
|
o || a)
|
|
? (0, t.jsx)(W, {
|
|
"data-state": a ? "visible" : "hidden",
|
|
...i,
|
|
ref: r,
|
|
})
|
|
: null;
|
|
});
|
|
z.displayName = "@mantine/core/ScrollAreaScrollbarHover";
|
|
let V = (0, n.forwardRef)((e, r) => {
|
|
let { forceMount: o, ...i } = e,
|
|
l = (0, S.useScrollAreaContext)(),
|
|
a = "horizontal" === e.orientation,
|
|
[u, s] = (0, n.useState)("hidden"),
|
|
c = (0, C.useDebouncedCallback)(() => s("idle"), 100);
|
|
return ((0, n.useEffect)(() => {
|
|
if ("idle" === u) {
|
|
let e = window.setTimeout(() => s("hidden"), l.scrollHideDelay);
|
|
return () => window.clearTimeout(e);
|
|
}
|
|
}, [u, l.scrollHideDelay]),
|
|
(0, n.useEffect)(() => {
|
|
let { viewport: e } = l,
|
|
t = a ? "scrollLeft" : "scrollTop";
|
|
if (e) {
|
|
let n = e[t],
|
|
r = () => {
|
|
let r = e[t];
|
|
n !== r && (s("scrolling"), c()), (n = r);
|
|
};
|
|
return (
|
|
e.addEventListener("scroll", r),
|
|
() => e.removeEventListener("scroll", r)
|
|
);
|
|
}
|
|
}, [l.viewport, a, c]),
|
|
o || "hidden" !== u)
|
|
? (0, t.jsx)(H, {
|
|
"data-state": "hidden" === u ? "hidden" : "visible",
|
|
...i,
|
|
ref: r,
|
|
onPointerEnter: D(e.onPointerEnter, () => s("interacting")),
|
|
onPointerLeave: D(e.onPointerLeave, () => s("idle")),
|
|
})
|
|
: null;
|
|
}),
|
|
X = (0, n.forwardRef)((e, r) => {
|
|
let { forceMount: o, ...i } = e,
|
|
l = (0, S.useScrollAreaContext)(),
|
|
{ onScrollbarXEnabledChange: a, onScrollbarYEnabledChange: u } = l,
|
|
s = "horizontal" === e.orientation;
|
|
return (
|
|
(0, n.useEffect)(
|
|
() => (
|
|
s ? a(!0) : u(!0),
|
|
() => {
|
|
s ? a(!1) : u(!1);
|
|
}
|
|
),
|
|
[s, a, u],
|
|
),
|
|
"hover" === l.type
|
|
? (0, t.jsx)(z, { ...i, ref: r, forceMount: o })
|
|
: "scroll" === l.type
|
|
? (0, t.jsx)(V, { ...i, ref: r, forceMount: o })
|
|
: "auto" === l.type
|
|
? (0, t.jsx)(W, { ...i, ref: r, forceMount: o })
|
|
: "always" === l.type
|
|
? (0, t.jsx)(H, { ...i, ref: r })
|
|
: null
|
|
);
|
|
});
|
|
X.displayName = "@mantine/core/ScrollAreaScrollbar";
|
|
let U = (0, n.forwardRef)((e, r) => {
|
|
let { style: o, ...i } = e,
|
|
l = (0, S.useScrollAreaContext)(),
|
|
a = B(),
|
|
{ onThumbPositionChange: u } = a,
|
|
s = (0, N.useMergedRef)(r, (e) => a.onThumbChange(e)),
|
|
c = (0, n.useRef)(void 0),
|
|
d = (0, C.useDebouncedCallback)(() => {
|
|
c.current && (c.current(), (c.current = void 0));
|
|
}, 100);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
let { viewport: e } = l;
|
|
if (e) {
|
|
let t = () => {
|
|
d(),
|
|
c.current ||
|
|
((c.current = (function (e, t = () => {}) {
|
|
let n = { left: e.scrollLeft, top: e.scrollTop },
|
|
r = 0;
|
|
return (
|
|
!(function o() {
|
|
let i = { left: e.scrollLeft, top: e.scrollTop },
|
|
l = n.left !== i.left,
|
|
a = n.top !== i.top;
|
|
(l || a) && t(),
|
|
(n = i),
|
|
(r = window.requestAnimationFrame(o));
|
|
})(),
|
|
() => window.cancelAnimationFrame(r)
|
|
);
|
|
})(e, u)),
|
|
u());
|
|
};
|
|
return (
|
|
u(),
|
|
e.addEventListener("scroll", t),
|
|
() => e.removeEventListener("scroll", t)
|
|
);
|
|
}
|
|
}, [l.viewport, d, u]),
|
|
(0, t.jsx)("div", {
|
|
"data-state": a.hasThumb ? "visible" : "hidden",
|
|
...i,
|
|
ref: s,
|
|
style: {
|
|
width: "var(--sa-thumb-width)",
|
|
height: "var(--sa-thumb-height)",
|
|
...o,
|
|
},
|
|
onPointerDownCapture: D(e.onPointerDownCapture, (e) => {
|
|
let t = e.target.getBoundingClientRect(),
|
|
n = e.clientX - t.left,
|
|
r = e.clientY - t.top;
|
|
a.onThumbPointerDown({ x: n, y: r });
|
|
}),
|
|
onPointerUp: D(e.onPointerUp, a.onThumbPointerUp),
|
|
})
|
|
);
|
|
});
|
|
U.displayName = "@mantine/core/ScrollAreaThumb";
|
|
let Y = (0, n.forwardRef)((e, n) => {
|
|
let { forceMount: r, ...o } = e,
|
|
i = B();
|
|
return r || i.hasThumb ? (0, t.jsx)(U, { ref: n, ...o }) : null;
|
|
});
|
|
Y.displayName = "@mantine/core/ScrollAreaThumb";
|
|
let $ = (0, n.forwardRef)(
|
|
({ children: e, style: n, onWheel: r, ...o }, i) => {
|
|
let l = (0, S.useScrollAreaContext)(),
|
|
a = (0, N.useMergedRef)(i, l.onViewportChange);
|
|
return (0, t.jsx)(w.Box, {
|
|
...o,
|
|
ref: a,
|
|
onWheel: (e) => {
|
|
if ((r?.(e), l.scrollbarXEnabled && l.viewport && e.shiftKey)) {
|
|
let {
|
|
scrollTop: t,
|
|
scrollHeight: n,
|
|
clientHeight: r,
|
|
scrollWidth: o,
|
|
clientWidth: i,
|
|
} = l.viewport;
|
|
o > i && (t < 1 || t >= n - r - 1) && e.stopPropagation();
|
|
}
|
|
},
|
|
style: {
|
|
overflowX: l.scrollbarXEnabled ? "scroll" : "hidden",
|
|
overflowY: l.scrollbarYEnabled ? "scroll" : "hidden",
|
|
...n,
|
|
},
|
|
children: (0, t.jsx)("div", {
|
|
...l.getStyles("content"),
|
|
ref: l.onContentChange,
|
|
children: e,
|
|
}),
|
|
});
|
|
},
|
|
);
|
|
$.displayName = "@mantine/core/ScrollAreaViewport";
|
|
let K = { scrollHideDelay: 1e3, type: "hover", scrollbars: "xy" },
|
|
Z = (0, v.createVarsResolver)(
|
|
(e, { scrollbarSize: t, overscrollBehavior: n, scrollbars: r }) => {
|
|
let o = n;
|
|
return (
|
|
n &&
|
|
r &&
|
|
("x" === r ? (o = `${n} auto`) : "y" === r && (o = `auto ${n}`)),
|
|
{
|
|
root: {
|
|
"--scrollarea-scrollbar-size": (0, m.rem)(t),
|
|
"--scrollarea-over-scroll-behavior": o,
|
|
},
|
|
}
|
|
);
|
|
},
|
|
),
|
|
q = (0, l.factory)((e, r) => {
|
|
let o = (0, i.useProps)("ScrollArea", K, e),
|
|
{
|
|
classNames: l,
|
|
className: a,
|
|
style: u,
|
|
styles: s,
|
|
unstyled: c,
|
|
scrollbarSize: d,
|
|
vars: f,
|
|
type: m,
|
|
scrollHideDelay: p,
|
|
viewportProps: v,
|
|
viewportRef: h,
|
|
onScrollPositionChange: w,
|
|
children: S,
|
|
offsetScrollbars: C,
|
|
scrollbars: R,
|
|
onBottomReached: T,
|
|
onTopReached: M,
|
|
overscrollBehavior: A,
|
|
attributes: L,
|
|
...P
|
|
} = o,
|
|
[N, k] = (0, n.useState)(!1),
|
|
[O, D] = (0, n.useState)(!1),
|
|
[I, B] = (0, n.useState)(!1),
|
|
j = (0, g.useStyles)({
|
|
name: "ScrollArea",
|
|
props: o,
|
|
classes: b.default,
|
|
className: a,
|
|
style: u,
|
|
classNames: l,
|
|
styles: s,
|
|
unstyled: c,
|
|
attributes: L,
|
|
vars: f,
|
|
varsResolver: Z,
|
|
}),
|
|
_ = (0, n.useRef)(null),
|
|
F = (0, y.useMergeRefs)([h, _]);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
if (!_.current || "present" !== C) return;
|
|
let e = _.current,
|
|
t = new ResizeObserver(() => {
|
|
let {
|
|
scrollHeight: t,
|
|
clientHeight: n,
|
|
scrollWidth: r,
|
|
clientWidth: o,
|
|
} = e;
|
|
D(t > n), B(r > o);
|
|
});
|
|
return t.observe(e), () => t.disconnect();
|
|
}, [_, C]),
|
|
(0, t.jsxs)(E.ScrollAreaRoot, {
|
|
getStyles: j,
|
|
type: "never" === m ? "always" : m,
|
|
scrollHideDelay: p,
|
|
ref: r,
|
|
scrollbars: R,
|
|
...j("root"),
|
|
...P,
|
|
children: [
|
|
(0, t.jsx)($, {
|
|
...v,
|
|
...j("viewport", { style: v?.style }),
|
|
ref: F,
|
|
"data-offset-scrollbars": !0 === C ? "xy" : C || void 0,
|
|
"data-scrollbars": R || void 0,
|
|
"data-horizontal-hidden":
|
|
"present" !== C || I ? void 0 : "true",
|
|
"data-vertical-hidden": "present" !== C || O ? void 0 : "true",
|
|
onScroll: (e) => {
|
|
v?.onScroll?.(e),
|
|
w?.({
|
|
x: e.currentTarget.scrollLeft,
|
|
y: e.currentTarget.scrollTop,
|
|
});
|
|
let {
|
|
scrollTop: t,
|
|
scrollHeight: n,
|
|
clientHeight: r,
|
|
} = e.currentTarget;
|
|
t - (n - r) >= -0.8 && T?.(), 0 === t && M?.();
|
|
},
|
|
children: S,
|
|
}),
|
|
("xy" === R || "x" === R) &&
|
|
(0, t.jsx)(X, {
|
|
...j("scrollbar"),
|
|
orientation: "horizontal",
|
|
"data-hidden":
|
|
"never" === m || ("present" === C && !I) || void 0,
|
|
forceMount: !0,
|
|
onMouseEnter: () => k(!0),
|
|
onMouseLeave: () => k(!1),
|
|
children: (0, t.jsx)(Y, { ...j("thumb") }),
|
|
}),
|
|
("xy" === R || "y" === R) &&
|
|
(0, t.jsx)(X, {
|
|
...j("scrollbar"),
|
|
orientation: "vertical",
|
|
"data-hidden":
|
|
"never" === m || ("present" === C && !O) || void 0,
|
|
forceMount: !0,
|
|
onMouseEnter: () => k(!0),
|
|
onMouseLeave: () => k(!1),
|
|
children: (0, t.jsx)(Y, { ...j("thumb") }),
|
|
}),
|
|
(0, t.jsx)(x.ScrollAreaCorner, {
|
|
...j("corner"),
|
|
"data-hovered": N || void 0,
|
|
"data-hidden": "never" === m || void 0,
|
|
}),
|
|
],
|
|
})
|
|
);
|
|
});
|
|
q.displayName = "@mantine/core/ScrollArea";
|
|
let G = (0, l.factory)((e, r) => {
|
|
let {
|
|
children: o,
|
|
classNames: l,
|
|
styles: a,
|
|
scrollbarSize: u,
|
|
scrollHideDelay: s,
|
|
type: c,
|
|
dir: d,
|
|
offsetScrollbars: f,
|
|
overscrollBehavior: m,
|
|
viewportRef: p,
|
|
onScrollPositionChange: v,
|
|
unstyled: g,
|
|
variant: h,
|
|
viewportProps: b,
|
|
scrollbars: x,
|
|
style: E,
|
|
vars: S,
|
|
onBottomReached: C,
|
|
onTopReached: R,
|
|
onOverflowChange: T,
|
|
...M
|
|
} = (0, i.useProps)("ScrollAreaAutosize", K, e),
|
|
A = (0, n.useRef)(null),
|
|
L = (0, y.useMergeRefs)([p, A]),
|
|
[P, N] = (0, n.useState)(!1),
|
|
k = (0, n.useRef)(!1);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
if (!T) return;
|
|
let e = A.current;
|
|
if (!e) return;
|
|
let t = () => {
|
|
let t = e.scrollHeight > e.clientHeight;
|
|
t !== P &&
|
|
(k.current ? T?.(t) : ((k.current = !0), t && T?.(!0)), N(t));
|
|
};
|
|
t();
|
|
let n = new ResizeObserver(t);
|
|
return n.observe(e), () => n.disconnect();
|
|
}, [T, P]),
|
|
(0, t.jsx)(w.Box, {
|
|
...M,
|
|
ref: r,
|
|
style: [{ display: "flex", overflow: "hidden" }, E],
|
|
children: (0, t.jsx)(w.Box, {
|
|
style: {
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
flex: 1,
|
|
overflow: "hidden",
|
|
...("y" === x && { minWidth: 0 }),
|
|
...("x" === x && { minHeight: 0 }),
|
|
...("xy" === x && { minWidth: 0, minHeight: 0 }),
|
|
...(!1 === x && { minWidth: 0, minHeight: 0 }),
|
|
},
|
|
children: (0, t.jsx)(q, {
|
|
classNames: l,
|
|
styles: a,
|
|
scrollHideDelay: s,
|
|
scrollbarSize: u,
|
|
type: c,
|
|
dir: d,
|
|
offsetScrollbars: f,
|
|
overscrollBehavior: m,
|
|
viewportRef: L,
|
|
onScrollPositionChange: v,
|
|
unstyled: g,
|
|
variant: h,
|
|
viewportProps: b,
|
|
vars: S,
|
|
scrollbars: x,
|
|
onBottomReached: C,
|
|
onTopReached: R,
|
|
"data-autosize": "true",
|
|
children: o,
|
|
}),
|
|
}),
|
|
})
|
|
);
|
|
});
|
|
(q.classes = b.default),
|
|
(G.displayName = "@mantine/core/ScrollAreaAutosize"),
|
|
(G.classes = b.default),
|
|
(q.Autosize = G),
|
|
e.s(["ScrollArea", () => q], 734520);
|
|
var J = e.i(70427);
|
|
let Q = {
|
|
__staticSelector: "Modal",
|
|
closeOnClickOutside: !0,
|
|
withinPortal: !0,
|
|
lockScroll: !0,
|
|
trapFocus: !0,
|
|
returnFocus: !0,
|
|
closeOnEscape: !0,
|
|
keepMounted: !1,
|
|
zIndex: (0, r.getDefaultZIndex)("modal"),
|
|
transitionProps: { duration: 200, transition: "fade-down" },
|
|
yOffset: "5dvh",
|
|
},
|
|
ee = (0, v.createVarsResolver)(
|
|
(e, { radius: t, size: n, yOffset: r, xOffset: o }) => ({
|
|
root: {
|
|
"--modal-radius": void 0 === t ? void 0 : (0, p.getRadius)(t),
|
|
"--modal-size": (0, p.getSize)(n, "modal-size"),
|
|
"--modal-y-offset": (0, m.rem)(r),
|
|
"--modal-x-offset": (0, m.rem)(o),
|
|
},
|
|
}),
|
|
),
|
|
et = (0, l.factory)((e, n) => {
|
|
let r = (0, i.useProps)("ModalRoot", Q, e),
|
|
{
|
|
classNames: o,
|
|
className: l,
|
|
style: u,
|
|
styles: s,
|
|
unstyled: c,
|
|
vars: d,
|
|
yOffset: f,
|
|
scrollAreaComponent: m,
|
|
radius: p,
|
|
fullScreen: v,
|
|
centered: y,
|
|
xOffset: w,
|
|
__staticSelector: b,
|
|
attributes: x,
|
|
...E
|
|
} = r,
|
|
S = (0, g.useStyles)({
|
|
name: b,
|
|
classes: a.default,
|
|
props: r,
|
|
className: l,
|
|
style: u,
|
|
classNames: o,
|
|
styles: s,
|
|
unstyled: c,
|
|
attributes: x,
|
|
vars: d,
|
|
varsResolver: ee,
|
|
});
|
|
return (0, t.jsx)(J.ModalProvider, {
|
|
value: {
|
|
yOffset: f,
|
|
scrollAreaComponent: m,
|
|
getStyles: S,
|
|
fullScreen: v,
|
|
},
|
|
children: (0, t.jsx)(h.ModalBase, {
|
|
ref: n,
|
|
...S("root"),
|
|
"data-full-screen": v || void 0,
|
|
"data-centered": y || void 0,
|
|
"data-offset-scrollbars": m === q.Autosize || void 0,
|
|
unstyled: c,
|
|
...E,
|
|
}),
|
|
});
|
|
});
|
|
function en(e = null) {
|
|
let r = (0, n.createContext)(e);
|
|
return [
|
|
({ children: e, value: n }) =>
|
|
(0, t.jsx)(r.Provider, { value: n, children: e }),
|
|
() => (0, n.useContext)(r),
|
|
];
|
|
}
|
|
(et.classes = a.default),
|
|
(et.displayName = "@mantine/core/ModalRoot"),
|
|
e.s(["createOptionalContext", () => en], 209276);
|
|
let [er, eo] = en();
|
|
function ei({ children: e }) {
|
|
let [o, i] = (0, n.useState)([]),
|
|
[l, a] = (0, n.useState)((0, r.getDefaultZIndex)("modal"));
|
|
return (0, t.jsx)(er, {
|
|
value: {
|
|
stack: o,
|
|
addModal: (e, t) => {
|
|
i((t) => [...new Set([...t, e])]),
|
|
a((e) =>
|
|
"number" == typeof t && "number" == typeof e
|
|
? Math.max(e, t)
|
|
: e,
|
|
);
|
|
},
|
|
removeModal: (e) => i((t) => t.filter((t) => t !== e)),
|
|
getZIndex: (e) => `calc(${l} + ${o.indexOf(e)} + 1)`,
|
|
currentId: o[o.length - 1],
|
|
maxZIndex: l,
|
|
},
|
|
children: e,
|
|
});
|
|
}
|
|
ei.displayName = "@mantine/core/ModalStack";
|
|
var el = e.i(328316),
|
|
ea = e.i(189772);
|
|
let eu = (0, n.forwardRef)(({ className: e, ...r }, i) => {
|
|
let l,
|
|
a =
|
|
((l = (0, el.useModalBaseContext)()),
|
|
(0, n.useEffect)(
|
|
() => (l.setTitleMounted(!0), () => l.setTitleMounted(!1)),
|
|
[],
|
|
),
|
|
l.getTitleId()),
|
|
u = (0, el.useModalBaseContext)();
|
|
return (0, t.jsx)(w.Box, {
|
|
component: "h2",
|
|
ref: i,
|
|
className: (0, o.default)({ [ea.default.title]: !u.unstyled }, e),
|
|
...r,
|
|
id: a,
|
|
});
|
|
});
|
|
(eu.displayName = "@mantine/core/ModalBaseTitle"),
|
|
e.s(["ModalBaseTitle", () => eu], 828013);
|
|
let es = (0, l.factory)((e, n) => {
|
|
let {
|
|
classNames: r,
|
|
className: o,
|
|
style: l,
|
|
styles: a,
|
|
vars: u,
|
|
...s
|
|
} = (0, i.useProps)("ModalTitle", null, e),
|
|
c = (0, J.useModalContext)();
|
|
return (0, t.jsx)(eu, {
|
|
ref: n,
|
|
...c.getStyles("title", {
|
|
classNames: r,
|
|
style: l,
|
|
styles: a,
|
|
className: o,
|
|
}),
|
|
...s,
|
|
});
|
|
});
|
|
(es.classes = a.default), (es.displayName = "@mantine/core/ModalTitle");
|
|
let ec = {
|
|
closeOnClickOutside: !0,
|
|
withinPortal: !0,
|
|
lockScroll: !0,
|
|
trapFocus: !0,
|
|
returnFocus: !0,
|
|
closeOnEscape: !0,
|
|
keepMounted: !1,
|
|
zIndex: (0, r.getDefaultZIndex)("modal"),
|
|
transitionProps: { duration: 200, transition: "fade-down" },
|
|
withOverlay: !0,
|
|
withCloseButton: !0,
|
|
},
|
|
ed = (0, l.factory)((e, o) => {
|
|
let {
|
|
title: l,
|
|
withOverlay: a,
|
|
overlayProps: m,
|
|
withCloseButton: p,
|
|
closeButtonProps: v,
|
|
children: g,
|
|
radius: h,
|
|
opened: y,
|
|
stackId: w,
|
|
zIndex: b,
|
|
...x
|
|
} = (0, i.useProps)("Modal", ec, e),
|
|
E = eo(),
|
|
S = !!l || p,
|
|
C =
|
|
E && w
|
|
? {
|
|
closeOnEscape: E.currentId === w,
|
|
trapFocus: E.currentId === w,
|
|
zIndex: E.getZIndex(w),
|
|
}
|
|
: {},
|
|
R = !1 !== a && (w && E ? E.currentId === w : y);
|
|
return (
|
|
(0, n.useEffect)(() => {
|
|
E &&
|
|
w &&
|
|
(y
|
|
? E.addModal(w, b || (0, r.getDefaultZIndex)("modal"))
|
|
: E.removeModal(w));
|
|
}, [y, w, b]),
|
|
(0, t.jsxs)(et, {
|
|
ref: o,
|
|
radius: h,
|
|
opened: y,
|
|
zIndex: E && w ? E.getZIndex(w) : b,
|
|
...x,
|
|
...C,
|
|
children: [
|
|
a &&
|
|
(0, t.jsx)(f.ModalOverlay, {
|
|
visible: R,
|
|
transitionProps: E && w ? { duration: 0 } : void 0,
|
|
...m,
|
|
}),
|
|
(0, t.jsxs)(c.ModalContent, {
|
|
radius: h,
|
|
__hidden: !!E && !!w && !!y && w !== E.currentId,
|
|
children: [
|
|
S &&
|
|
(0, t.jsxs)(d.ModalHeader, {
|
|
children: [
|
|
l && (0, t.jsx)(es, { children: l }),
|
|
p && (0, t.jsx)(s.ModalCloseButton, { ...v }),
|
|
],
|
|
}),
|
|
(0, t.jsx)(u.ModalBody, { children: g }),
|
|
],
|
|
}),
|
|
],
|
|
})
|
|
);
|
|
});
|
|
function ef(e = !1, t = {}) {
|
|
let [r, o] = (0, n.useState)(e),
|
|
i = (0, n.useCallback)(() => {
|
|
o((e) => e || (t.onOpen?.(), !0));
|
|
}, [t.onOpen]),
|
|
l = (0, n.useCallback)(() => {
|
|
o((e) => (e ? (t.onClose?.(), !1) : e));
|
|
}, [t.onClose]),
|
|
a = (0, n.useCallback)(() => {
|
|
r ? l() : i();
|
|
}, [l, i, r]);
|
|
return [r, { open: i, close: l, toggle: a }];
|
|
}
|
|
(ed.classes = a.default),
|
|
(ed.displayName = "@mantine/core/Modal"),
|
|
(ed.Root = et),
|
|
(ed.Overlay = f.ModalOverlay),
|
|
(ed.Content = c.ModalContent),
|
|
(ed.Body = u.ModalBody),
|
|
(ed.Header = d.ModalHeader),
|
|
(ed.Title = es),
|
|
(ed.CloseButton = s.ModalCloseButton),
|
|
(ed.Stack = ei),
|
|
e.s(["Modal", () => ed], 734911),
|
|
e.s(["useDisclosure", () => ef], 11623);
|
|
};
|
|
|
|
export default moduleFactory;
|