374 lines
13 KiB
JavaScript
374 lines
13 KiB
JavaScript
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-LPULNKJF.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-42LCURWG.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-G3PMV62Z.js";
|
|
|
|
// node_modules/@radix-ui/primitive/dist/index.mjs
|
|
var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
|
|
function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
|
|
return function handleEvent(event) {
|
|
originalEventHandler?.(event);
|
|
if (checkForDefaultPrevented === false || !event.defaultPrevented) {
|
|
return ourEventHandler?.(event);
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/@radix-ui/react-context/dist/index.mjs
|
|
var React = __toESM(require_react(), 1);
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
function createContext2(rootComponentName, defaultContext) {
|
|
const Context = React.createContext(defaultContext);
|
|
Context.displayName = rootComponentName + "Context";
|
|
const Provider = (props) => {
|
|
const { children, ...context } = props;
|
|
const value = React.useMemo(() => context, Object.values(context));
|
|
return (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
|
|
};
|
|
Provider.displayName = rootComponentName + "Provider";
|
|
function useContext2(consumerName) {
|
|
const context = React.useContext(Context);
|
|
if (context) return context;
|
|
if (defaultContext !== void 0) return defaultContext;
|
|
throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
|
|
}
|
|
return [Provider, useContext2];
|
|
}
|
|
function createContextScope(scopeName, createContextScopeDeps = []) {
|
|
let defaultContexts = [];
|
|
function createContext3(rootComponentName, defaultContext) {
|
|
const BaseContext = React.createContext(defaultContext);
|
|
BaseContext.displayName = rootComponentName + "Context";
|
|
const index = defaultContexts.length;
|
|
defaultContexts = [...defaultContexts, defaultContext];
|
|
const Provider = (props) => {
|
|
const { scope, children, ...context } = props;
|
|
const Context = scope?.[scopeName]?.[index] || BaseContext;
|
|
const value = React.useMemo(() => context, Object.values(context));
|
|
return (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
|
|
};
|
|
Provider.displayName = rootComponentName + "Provider";
|
|
function useContext2(consumerName, scope) {
|
|
const Context = scope?.[scopeName]?.[index] || BaseContext;
|
|
const context = React.useContext(Context);
|
|
if (context) return context;
|
|
if (defaultContext !== void 0) return defaultContext;
|
|
throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
|
|
}
|
|
return [Provider, useContext2];
|
|
}
|
|
const createScope = () => {
|
|
const scopeContexts = defaultContexts.map((defaultContext) => {
|
|
return React.createContext(defaultContext);
|
|
});
|
|
return function useScope(scope) {
|
|
const contexts = scope?.[scopeName] || scopeContexts;
|
|
return React.useMemo(
|
|
() => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
|
|
[scope, contexts]
|
|
);
|
|
};
|
|
};
|
|
createScope.scopeName = scopeName;
|
|
return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
|
|
}
|
|
function composeContextScopes(...scopes) {
|
|
const baseScope = scopes[0];
|
|
if (scopes.length === 1) return baseScope;
|
|
const createScope = () => {
|
|
const scopeHooks = scopes.map((createScope2) => ({
|
|
useScope: createScope2(),
|
|
scopeName: createScope2.scopeName
|
|
}));
|
|
return function useComposedScopes(overrideScopes) {
|
|
const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
|
|
const scopeProps = useScope(overrideScopes);
|
|
const currentScope = scopeProps[`__scope${scopeName}`];
|
|
return { ...nextScopes2, ...currentScope };
|
|
}, {});
|
|
return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
|
|
};
|
|
};
|
|
createScope.scopeName = baseScope.scopeName;
|
|
return createScope;
|
|
}
|
|
|
|
// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
|
|
var React2 = __toESM(require_react(), 1);
|
|
var useLayoutEffect2 = globalThis?.document ? React2.useLayoutEffect : () => {
|
|
};
|
|
|
|
// node_modules/@radix-ui/react-id/dist/index.mjs
|
|
var React3 = __toESM(require_react(), 1);
|
|
var useReactId = React3[" useId ".trim().toString()] || (() => void 0);
|
|
var count = 0;
|
|
function useId(deterministicId) {
|
|
const [id, setId] = React3.useState(useReactId());
|
|
useLayoutEffect2(() => {
|
|
if (!deterministicId) setId((reactId) => reactId ?? String(count++));
|
|
}, [deterministicId]);
|
|
return deterministicId || (id ? `radix-${id}` : "");
|
|
}
|
|
|
|
// node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
|
|
var React4 = __toESM(require_react(), 1);
|
|
function useCallbackRef(callback) {
|
|
const callbackRef = React4.useRef(callback);
|
|
React4.useEffect(() => {
|
|
callbackRef.current = callback;
|
|
});
|
|
return React4.useMemo(() => ((...args) => callbackRef.current?.(...args)), []);
|
|
}
|
|
|
|
// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
|
|
var React6 = __toESM(require_react(), 1);
|
|
var React22 = __toESM(require_react(), 1);
|
|
|
|
// node_modules/@radix-ui/react-use-effect-event/dist/index.mjs
|
|
var React5 = __toESM(require_react(), 1);
|
|
var useReactEffectEvent = React5[" useEffectEvent ".trim().toString()];
|
|
var useReactInsertionEffect = React5[" useInsertionEffect ".trim().toString()];
|
|
|
|
// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
|
|
var useInsertionEffect = React6[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
|
|
function useControllableState({
|
|
prop,
|
|
defaultProp,
|
|
onChange = () => {
|
|
},
|
|
caller
|
|
}) {
|
|
const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
|
|
defaultProp,
|
|
onChange
|
|
});
|
|
const isControlled = prop !== void 0;
|
|
const value = isControlled ? prop : uncontrolledProp;
|
|
if (true) {
|
|
const isControlledRef = React6.useRef(prop !== void 0);
|
|
React6.useEffect(() => {
|
|
const wasControlled = isControlledRef.current;
|
|
if (wasControlled !== isControlled) {
|
|
const from = wasControlled ? "controlled" : "uncontrolled";
|
|
const to = isControlled ? "controlled" : "uncontrolled";
|
|
console.warn(
|
|
`${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
|
|
);
|
|
}
|
|
isControlledRef.current = isControlled;
|
|
}, [isControlled, caller]);
|
|
}
|
|
const setValue = React6.useCallback(
|
|
(nextValue) => {
|
|
if (isControlled) {
|
|
const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
|
|
if (value2 !== prop) {
|
|
onChangeRef.current?.(value2);
|
|
}
|
|
} else {
|
|
setUncontrolledProp(nextValue);
|
|
}
|
|
},
|
|
[isControlled, prop, setUncontrolledProp, onChangeRef]
|
|
);
|
|
return [value, setValue];
|
|
}
|
|
function useUncontrolledState({
|
|
defaultProp,
|
|
onChange
|
|
}) {
|
|
const [value, setValue] = React6.useState(defaultProp);
|
|
const prevValueRef = React6.useRef(value);
|
|
const onChangeRef = React6.useRef(onChange);
|
|
useInsertionEffect(() => {
|
|
onChangeRef.current = onChange;
|
|
}, [onChange]);
|
|
React6.useEffect(() => {
|
|
if (prevValueRef.current !== value) {
|
|
onChangeRef.current?.(value);
|
|
prevValueRef.current = value;
|
|
}
|
|
}, [value, prevValueRef]);
|
|
return [value, setValue, onChangeRef];
|
|
}
|
|
function isFunction(value) {
|
|
return typeof value === "function";
|
|
}
|
|
|
|
// node_modules/@radix-ui/react-presence/dist/index.mjs
|
|
var React23 = __toESM(require_react(), 1);
|
|
var React7 = __toESM(require_react(), 1);
|
|
function useStateMachine(initialState, machine) {
|
|
return React7.useReducer((state, event) => {
|
|
const nextState = machine[state][event];
|
|
return nextState ?? state;
|
|
}, initialState);
|
|
}
|
|
var Presence = (props) => {
|
|
const { present, children } = props;
|
|
const presence = usePresence(present);
|
|
const child = typeof children === "function" ? children({ present: presence.isPresent }) : React23.Children.only(children);
|
|
const ref = useStableComposedRefs(presence.ref, getElementRef(child));
|
|
const forceMount = typeof children === "function";
|
|
return forceMount || presence.isPresent ? React23.cloneElement(child, { ref }) : null;
|
|
};
|
|
Presence.displayName = "Presence";
|
|
function usePresence(present) {
|
|
const [node, setNode] = React23.useState();
|
|
const stylesRef = React23.useRef(null);
|
|
const prevPresentRef = React23.useRef(present);
|
|
const prevAnimationNameRef = React23.useRef("none");
|
|
const initialState = present ? "mounted" : "unmounted";
|
|
const [state, send] = useStateMachine(initialState, {
|
|
mounted: {
|
|
UNMOUNT: "unmounted",
|
|
ANIMATION_OUT: "unmountSuspended"
|
|
},
|
|
unmountSuspended: {
|
|
MOUNT: "mounted",
|
|
ANIMATION_END: "unmounted"
|
|
},
|
|
unmounted: {
|
|
MOUNT: "mounted"
|
|
}
|
|
});
|
|
React23.useEffect(() => {
|
|
const currentAnimationName = getAnimationName(stylesRef.current);
|
|
prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
|
|
}, [state]);
|
|
useLayoutEffect2(() => {
|
|
const styles = stylesRef.current;
|
|
const wasPresent = prevPresentRef.current;
|
|
const hasPresentChanged = wasPresent !== present;
|
|
if (hasPresentChanged) {
|
|
const prevAnimationName = prevAnimationNameRef.current;
|
|
const currentAnimationName = getAnimationName(styles);
|
|
if (present) {
|
|
send("MOUNT");
|
|
} else if (currentAnimationName === "none" || styles?.display === "none") {
|
|
send("UNMOUNT");
|
|
} else {
|
|
const isAnimating = prevAnimationName !== currentAnimationName;
|
|
if (wasPresent && isAnimating) {
|
|
send("ANIMATION_OUT");
|
|
} else {
|
|
send("UNMOUNT");
|
|
}
|
|
}
|
|
prevPresentRef.current = present;
|
|
}
|
|
}, [present, send]);
|
|
useLayoutEffect2(() => {
|
|
if (node) {
|
|
let timeoutId;
|
|
const ownerWindow = node.ownerDocument.defaultView ?? window;
|
|
const handleAnimationEnd = (event) => {
|
|
const currentAnimationName = getAnimationName(stylesRef.current);
|
|
const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
|
|
if (event.target === node && isCurrentAnimation) {
|
|
send("ANIMATION_END");
|
|
if (!prevPresentRef.current) {
|
|
const currentFillMode = node.style.animationFillMode;
|
|
node.style.animationFillMode = "forwards";
|
|
timeoutId = ownerWindow.setTimeout(() => {
|
|
if (node.style.animationFillMode === "forwards") {
|
|
node.style.animationFillMode = currentFillMode;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
};
|
|
const handleAnimationStart = (event) => {
|
|
if (event.target === node) {
|
|
prevAnimationNameRef.current = getAnimationName(stylesRef.current);
|
|
}
|
|
};
|
|
node.addEventListener("animationstart", handleAnimationStart);
|
|
node.addEventListener("animationcancel", handleAnimationEnd);
|
|
node.addEventListener("animationend", handleAnimationEnd);
|
|
return () => {
|
|
ownerWindow.clearTimeout(timeoutId);
|
|
node.removeEventListener("animationstart", handleAnimationStart);
|
|
node.removeEventListener("animationcancel", handleAnimationEnd);
|
|
node.removeEventListener("animationend", handleAnimationEnd);
|
|
};
|
|
} else {
|
|
send("ANIMATION_END");
|
|
}
|
|
}, [node, send]);
|
|
return {
|
|
isPresent: ["mounted", "unmountSuspended"].includes(state),
|
|
ref: React23.useCallback((node2) => {
|
|
stylesRef.current = node2 ? getComputedStyle(node2) : null;
|
|
setNode(node2);
|
|
}, [])
|
|
};
|
|
}
|
|
function setRef(ref, value) {
|
|
if (typeof ref === "function") {
|
|
return ref(value);
|
|
} else if (ref !== null && ref !== void 0) {
|
|
ref.current = value;
|
|
}
|
|
}
|
|
function useStableComposedRefs(...refs) {
|
|
const refsRef = React23.useRef(refs);
|
|
refsRef.current = refs;
|
|
return React23.useCallback((node) => {
|
|
const currentRefs = refsRef.current;
|
|
let hasCleanup = false;
|
|
const cleanups = currentRefs.map((ref) => {
|
|
const cleanup = setRef(ref, node);
|
|
if (!hasCleanup && typeof cleanup === "function") {
|
|
hasCleanup = true;
|
|
}
|
|
return cleanup;
|
|
});
|
|
if (hasCleanup) {
|
|
return () => {
|
|
for (let i = 0; i < cleanups.length; i++) {
|
|
const cleanup = cleanups[i];
|
|
if (typeof cleanup === "function") {
|
|
cleanup();
|
|
} else {
|
|
setRef(currentRefs[i], null);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}, []);
|
|
}
|
|
function getAnimationName(styles) {
|
|
return styles?.animationName || "none";
|
|
}
|
|
function getElementRef(element) {
|
|
let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
|
|
let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
|
|
if (mayWarn) {
|
|
return element.ref;
|
|
}
|
|
getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
|
|
mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
|
|
if (mayWarn) {
|
|
return element.props.ref;
|
|
}
|
|
return element.props.ref || element.ref;
|
|
}
|
|
|
|
export {
|
|
composeEventHandlers,
|
|
createContext2,
|
|
createContextScope,
|
|
useLayoutEffect2,
|
|
useId,
|
|
useCallbackRef,
|
|
useControllableState,
|
|
Presence
|
|
};
|
|
//# sourceMappingURL=chunk-NSBG64MI.js.map
|