@pixpilot/shadcn-ui 0.1.0 → 0.4.1

package/dist/node_modules/.pnpm/@diceui_shared@0.12.0_@floating-ui_react@0.27.16_react-dom@19.2.0_react@19.2.0__react@1_2c51ffe880f01dd537d5b6a13313daf4/node_modules/@diceui/shared/dist/index.js

@@ -0,0 +1,555 @@
+import { __commonJS, __require, __toCommonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { floating_ui_react_esm_exports, init_floating_ui_react_esm } from "../../../../../@floating-ui_react@0.27.16_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/@floating-ui/react/dist/floating-ui.react.esm.js";
+
+//#region ../../node_modules/.pnpm/@diceui+shared@0.12.0_@floating-ui+react@0.27.16_react-dom@19.2.0_react@19.2.0__react@1_2c51ffe880f01dd537d5b6a13313daf4/node_modules/@diceui/shared/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@diceui+shared@0.12.0_@floating-ui+react@0.27.16_react-dom@19.2.0_react@19.2.0__react@1_2c51ffe880f01dd537d5b6a13313daf4/node_modules/@diceui/shared/dist/index.js": ((exports) => {
+	var React32 = __require("react");
+	var react = (init_floating_ui_react_esm(), __toCommonJS(floating_ui_react_esm_exports));
+	var ReactDOM = __require("react-dom");
+	function _interopNamespace(e) {
+		if (e && e.__esModule) return e;
+		var n = Object.create(null);
+		if (e) Object.keys(e).forEach(function(k) {
+			if (k !== "default") {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function() {
+						return e[k];
+					}
+				});
+			}
+		});
+		n.default = e;
+		return Object.freeze(n);
+	}
+	var React32__namespace = /* @__PURE__ */ _interopNamespace(React32);
+	var ReactDOM__namespace = /* @__PURE__ */ _interopNamespace(ReactDOM);
+	var DATA_ITEM_ATTR = "data-dice-collection-item";
+	var DirectionContext = React32__namespace.createContext(void 0);
+	function useDirection(dirProp) {
+		const contextDir = React32__namespace.useContext(DirectionContext);
+		return dirProp ?? contextDir ?? "ltr";
+	}
+	var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React32__namespace.useLayoutEffect : React32__namespace.useEffect;
+	function useCallbackRef(callback) {
+		const callbackRef = React32__namespace.useRef(callback);
+		React32__namespace.useEffect(() => {
+			callbackRef.current = callback;
+		});
+		return React32__namespace.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+	}
+	function compareNodePosition(a, b) {
+		const position = a.compareDocumentPosition(b);
+		if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) return -1;
+		if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) return 1;
+		return 0;
+	}
+	function useControllableState({ prop, defaultProp, onChange = () => {} }) {
+		const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({
+			defaultProp,
+			onChange
+		});
+		const isControlled = prop !== void 0;
+		const value = isControlled ? prop : uncontrolledProp;
+		const handleChange = useCallbackRef(onChange);
+		return [value, React32__namespace.useCallback((nextValue) => {
+			if (isControlled) {
+				const value2 = typeof nextValue === "function" ? nextValue(prop) : nextValue;
+				if (value2 !== prop) handleChange(value2);
+			} else setUncontrolledProp(nextValue);
+		}, [
+			isControlled,
+			prop,
+			setUncontrolledProp,
+			handleChange
+		])];
+	}
+	function useUncontrolledState({ defaultProp, onChange }) {
+		const uncontrolledState = React32__namespace.useState(defaultProp);
+		const [value] = uncontrolledState;
+		const prevValueRef = React32__namespace.useRef(value);
+		const handleChange = useCallbackRef(onChange);
+		React32__namespace.useEffect(() => {
+			if (prevValueRef.current !== value) {
+				handleChange(value);
+				prevValueRef.current = value;
+			}
+		}, [value, handleChange]);
+		return uncontrolledState;
+	}
+	var LRUCache = class {
+		cache;
+		maxSize;
+		keyOrder;
+		constructor(maxSize) {
+			this.cache = /* @__PURE__ */ new Map();
+			this.maxSize = maxSize;
+			this.keyOrder = [];
+		}
+		get(key) {
+			const value = this.cache.get(key);
+			if (value !== void 0) {
+				const index = this.keyOrder.indexOf(key);
+				if (index > -1) {
+					this.keyOrder.splice(index, 1);
+					this.keyOrder.push(key);
+				}
+			}
+			return value;
+		}
+		set(key, value) {
+			if (this.cache.has(key)) {
+				this.cache.set(key, value);
+				const index = this.keyOrder.indexOf(key);
+				if (index > -1) this.keyOrder.splice(index, 1);
+			} else {
+				if (this.keyOrder.length >= this.maxSize) {
+					const lruKey = this.keyOrder.shift();
+					if (lruKey !== void 0) this.cache.delete(lruKey);
+				}
+				this.cache.set(key, value);
+			}
+			this.keyOrder.push(key);
+		}
+		clear() {
+			this.cache.clear();
+			this.keyOrder.length = 0;
+		}
+		get size() {
+			return this.cache.size;
+		}
+	};
+	var collatorCache = new LRUCache(10);
+	var normalizedCache = new LRUCache(1e3);
+	function useFormControl(form) {
+		const [trigger, setTrigger] = React32__namespace.useState(null);
+		return {
+			isFormControl: trigger ? form || !!trigger.closest("form") : true,
+			trigger,
+			onTriggerChange: setTrigger
+		};
+	}
+	function useFormReset({ form, defaultValue, onReset }) {
+		const onResetCallback = useCallbackRef(onReset);
+		React32__namespace.useEffect(() => {
+			if (!form) return;
+			function onFormReset() {
+				if (defaultValue !== void 0) onResetCallback?.(defaultValue);
+			}
+			form.addEventListener("reset", onFormReset);
+			return () => form.removeEventListener("reset", onFormReset);
+		}, [
+			form,
+			defaultValue,
+			onResetCallback
+		]);
+	}
+	var useLayoutEffect4 = globalThis?.document ? React32__namespace.useLayoutEffect : () => {};
+	var useReactId = React32__namespace[" useId ".trim().toString()] || (() => void 0);
+	var count = 0;
+	function useId(deterministicId) {
+		const [id, setId] = React32__namespace.useState(typeof useReactId === "function" ? useReactId() : void 0);
+		useLayoutEffect4(() => {
+			if (!deterministicId) setId((reactId) => reactId ?? String(count++));
+		}, [deterministicId]);
+		return deterministicId || (id ? `dice-${id}` : "");
+	}
+	function useItemCollection({ ref, attr = DATA_ITEM_ATTR }) {
+		const getItems = React32__namespace.useCallback(() => {
+			const collectionNode = ref.current;
+			if (!collectionNode) return [];
+			const items = Array.from(collectionNode.querySelectorAll(`[${attr}]`));
+			if (items.length === 0) return [];
+			return items.sort(compareNodePosition);
+		}, [ref, attr]);
+		return {
+			getItems,
+			getEnabledItems: React32__namespace.useCallback(() => {
+				return getItems().filter((item) => item.getAttribute("aria-disabled") !== "true");
+			}, [getItems])
+		};
+	}
+	function useMounted() {
+		const [mounted, setMounted] = React32__namespace.useState(false);
+		useLayoutEffect4(() => {
+			setMounted(true);
+		}, []);
+		return mounted;
+	}
+	function usePrevious(value) {
+		const ref = React32__namespace.useRef({
+			value,
+			previous: value
+		});
+		return React32__namespace.useMemo(() => {
+			if (ref.current.value !== value) {
+				ref.current.previous = ref.current.value;
+				ref.current.value = value;
+			}
+			return ref.current.previous;
+		}, [value]);
+	}
+	function useSize(element) {
+		const [size2, setSize] = React32__namespace.useState(void 0);
+		useLayoutEffect4(() => {
+			if (element) {
+				setSize({
+					width: element.offsetWidth,
+					height: element.offsetHeight
+				});
+				const resizeObserver = new ResizeObserver((entries) => {
+					if (!Array.isArray(entries)) return;
+					if (!entries.length) return;
+					const entry = entries[0];
+					let width;
+					let height;
+					if (entry && "borderBoxSize" in entry) {
+						const borderSizeEntry = entry.borderBoxSize;
+						const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+						width = borderSize.inlineSize;
+						height = borderSize.blockSize;
+					} else {
+						width = element.offsetWidth;
+						height = element.offsetHeight;
+					}
+					setSize({
+						width,
+						height
+					});
+				});
+				resizeObserver.observe(element, { box: "border-box" });
+				return () => resizeObserver.unobserve(element);
+			}
+			setSize(void 0);
+		}, [element]);
+		return size2;
+	}
+	function useStateMachine(config) {
+		const [state, setState] = React32__namespace.useState(config.initial);
+		return [state, React32__namespace.useCallback((event) => {
+			setState((currentState) => {
+				return config.states[currentState]?.[event] ?? currentState;
+			});
+		}, [config.states])];
+	}
+	function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+		return function handleEvent(event) {
+			originalEventHandler?.(event);
+			if (checkForDefaultPrevented === false || !event.defaultPrevented) return ourEventHandler?.(event);
+		};
+	}
+	function setRef(ref, value) {
+		if (typeof ref === "function") return ref(value);
+		if (ref !== null && ref !== void 0) ref.current = value;
+	}
+	function composeRefs(...refs) {
+		return (node) => {
+			let hasCleanup = false;
+			const cleanups = refs.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(refs[i], null);
+				}
+			};
+		};
+	}
+	function useComposedRefs(...refs) {
+		return React32__namespace.useCallback(composeRefs(...refs), refs);
+	}
+	var visuallyHidden = {
+		border: 0,
+		clip: "rect(0 0 0 0)",
+		clipPath: "inset(50%)",
+		height: "1px",
+		margin: "-1px",
+		overflow: "hidden",
+		padding: 0,
+		position: "absolute",
+		whiteSpace: "nowrap",
+		width: "1px"
+	};
+	function VisuallyHiddenInput(props) {
+		const { control, value, checked, bubbles = true, type = "hidden", onReset, style,...inputProps } = props;
+		const isCheckInput = type === "checkbox" || type === "radio" || type === "switch";
+		const inputRef = React32__namespace.useRef(null);
+		const prevValue = usePrevious(type === "hidden" ? value : checked);
+		const controlSize = useSize(control);
+		React32__namespace.useEffect(() => {
+			const input = inputRef.current;
+			if (!input) return;
+			const inputProto = window.HTMLInputElement.prototype;
+			const propertyKey = isCheckInput ? "checked" : "value";
+			const eventType = isCheckInput ? "click" : "input";
+			const currentValue = isCheckInput ? checked : JSON.stringify(value);
+			const setter = Object.getOwnPropertyDescriptor(inputProto, propertyKey).set;
+			if (prevValue !== currentValue && setter) {
+				const event = new Event(eventType, { bubbles });
+				setter.call(input, currentValue);
+				input.dispatchEvent(event);
+			}
+		}, [
+			prevValue,
+			value,
+			checked,
+			bubbles,
+			isCheckInput
+		]);
+		useFormReset({
+			form: inputRef.current?.form ?? null,
+			defaultValue: isCheckInput ? checked : value,
+			onReset: (resetValue) => {
+				onReset?.(resetValue);
+			}
+		});
+		return /* @__PURE__ */ React32__namespace.createElement("input", {
+			type,
+			...inputProps,
+			ref: inputRef,
+			"aria-hidden": isCheckInput,
+			tabIndex: -1,
+			defaultChecked: isCheckInput ? checked : void 0,
+			style: {
+				...props.style,
+				...controlSize,
+				...visuallyHidden
+			}
+		});
+	}
+	function createContext3(rootComponentName, defaultValue) {
+		const Context = React32__namespace.createContext(defaultValue);
+		Context.displayName = rootComponentName;
+		function Provider(props) {
+			const { children,...contextValue } = props;
+			const value = React32__namespace.useMemo(() => contextValue, Object.values(contextValue));
+			return /* @__PURE__ */ React32__namespace.createElement(Context.Provider, { value }, children);
+		}
+		Provider.displayName = `${rootComponentName}Provider`;
+		function useContext3(consumerName, optional) {
+			const context = React32__namespace.useContext(Context);
+			if (!context && !optional) throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+			if (context) return context;
+			if (defaultValue !== void 0) return defaultValue;
+		}
+		return [Provider, useContext3];
+	}
+	function getElementRef(element) {
+		if (!React32__namespace.isValidElement(element)) return void 0;
+		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;
+	}
+	var isSlottable = function isSlottable2(child) {
+		return React32__namespace.isValidElement(child) && child.type === Slottable;
+	};
+	function mergeProps(slotProps, childProps) {
+		const overrideProps = { ...childProps };
+		for (const propName in childProps) {
+			const slotPropValue = slotProps[propName];
+			const childPropValue = childProps[propName];
+			if (/^on[A-Z]/.test(propName)) {
+				if (typeof slotPropValue === "function" && typeof childPropValue === "function") overrideProps[propName] = (...args) => {
+					childPropValue(...args);
+					slotPropValue(...args);
+				};
+				else if (typeof slotPropValue === "function") overrideProps[propName] = slotPropValue;
+			} else if (propName === "style" && slotPropValue && childPropValue) overrideProps[propName] = {
+				...slotPropValue,
+				...childPropValue
+			};
+			else if (propName === "className") overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+		}
+		return {
+			...slotProps,
+			...overrideProps
+		};
+	}
+	var SlotClone = React32__namespace.forwardRef((props, forwardedRef) => {
+		const { children,...slotProps } = props;
+		if (!React32__namespace.isValidElement(children)) return React32__namespace.Children.count(children) > 1 ? React32__namespace.Children.only(null) : null;
+		const childrenRef = getElementRef(children);
+		const mergedProps = mergeProps(slotProps, children.props);
+		if (typeof children.type === "string") return React32__namespace.cloneElement(children, {
+			...mergedProps,
+			ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
+		});
+		return React32__namespace.cloneElement(children, {
+			...mergedProps,
+			ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef
+		});
+	});
+	SlotClone.displayName = "SlotClone";
+	var Slot = React32__namespace.forwardRef((props, forwardedRef) => {
+		const { children,...slotProps } = props;
+		const childrenArray = React32__namespace.Children.toArray(children);
+		const slottable = childrenArray.find(isSlottable);
+		if (!slottable) return /* @__PURE__ */ React32__namespace.createElement(SlotClone, {
+			...slotProps,
+			ref: forwardedRef
+		}, children);
+		if (!React32__namespace.isValidElement(slottable)) return null;
+		const newElement = slottable.props.children;
+		const newChildren = childrenArray.map((child) => {
+			if (child === slottable) {
+				if (React32__namespace.Children.count(newElement) > 1) return React32__namespace.Children.only(null);
+				return React32__namespace.isValidElement(newElement) ? newElement.props.children : null;
+			}
+			return child;
+		});
+		return /* @__PURE__ */ React32__namespace.createElement(SlotClone, {
+			...slotProps,
+			ref: forwardedRef
+		}, React32__namespace.isValidElement(newElement) ? React32__namespace.cloneElement(newElement, void 0, newChildren) : null);
+	});
+	Slot.displayName = "Slot";
+	var Slottable = React32__namespace.memo(function Slottable2({ children }) {
+		return /* @__PURE__ */ React32__namespace.createElement(React32__namespace.Fragment, null, children);
+	});
+	Slottable.displayName = "Slottable";
+	function createPrimitive(element) {
+		const Primitive2 = React32__namespace.forwardRef((props, forwardedRef) => {
+			const { asChild,...primitiveProps } = props;
+			if (asChild) return React32__namespace.createElement(Slot, {
+				...primitiveProps,
+				ref: forwardedRef
+			});
+			return React32__namespace.createElement(element, {
+				...primitiveProps,
+				ref: forwardedRef
+			});
+		});
+		Primitive2.displayName = `Primitive.${String(element)}`;
+		return Primitive2;
+	}
+	var cache = /* @__PURE__ */ new Map();
+	var Primitive = new Proxy({}, { get: (_, element) => {
+		const key = element;
+		if (!cache.has(key)) cache.set(key, createPrimitive(key));
+		return cache.get(key);
+	} });
+	var Portal = React32__namespace.forwardRef((props, forwardedRef) => {
+		const { container: containerProp,...portalProps } = props;
+		const mounted = useMounted();
+		const container = containerProp ?? (mounted ? globalThis.document?.body : null);
+		if (!container) return null;
+		return ReactDOM__namespace.createPortal(/* @__PURE__ */ React32__namespace.createElement(Primitive.div, {
+			...portalProps,
+			ref: forwardedRef
+		}), container);
+	});
+	Portal.displayName = "Portal";
+	var Presence = (props) => {
+		const { present, children } = props;
+		const presence = usePresence(present);
+		const child = typeof children === "function" ? children({ present: presence.isPresent }) : React32__namespace.Children.only(children);
+		const ref = useComposedRefs(presence.ref, getElementRef(child));
+		return typeof children === "function" || presence.isPresent ? React32__namespace.cloneElement(child, { ref }) : null;
+	};
+	Presence.displayName = "Presence";
+	function usePresence(present) {
+		const [node, setNode] = React32__namespace.useState();
+		const stylesRef = React32__namespace.useRef({});
+		const prevPresentRef = React32__namespace.useRef(present);
+		const prevAnimationNameRef = React32__namespace.useRef("none");
+		const [state, send] = useStateMachine({
+			initial: present ? "mounted" : "unmounted",
+			states: {
+				mounted: {
+					UNMOUNT: "unmounted",
+					ANIMATION_OUT: "unmountSuspended"
+				},
+				unmountSuspended: {
+					MOUNT: "mounted",
+					ANIMATION_END: "unmounted"
+				},
+				unmounted: { MOUNT: "mounted" }
+			}
+		});
+		React32__namespace.useEffect(() => {
+			const currentAnimationName = getAnimationName(stylesRef.current);
+			prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+		}, [state]);
+		useLayoutEffect4(() => {
+			const styles = stylesRef.current;
+			const wasPresent = prevPresentRef.current;
+			if (wasPresent !== present) {
+				const prevAnimationName = prevAnimationNameRef.current;
+				const currentAnimationName = getAnimationName(styles);
+				if (present) send("MOUNT");
+				else if (currentAnimationName === "none" || styles?.display === "none") send("UNMOUNT");
+				else if (wasPresent && prevAnimationName !== currentAnimationName) send("ANIMATION_OUT");
+				else send("UNMOUNT");
+				prevPresentRef.current = present;
+			}
+		}, [present, send]);
+		useLayoutEffect4(() => {
+			if (node) {
+				let onAnimationEnd2 = function(event) {
+					const isCurrentAnimation = getAnimationName(stylesRef.current).includes(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;
+							});
+						}
+					}
+				}, onAnimationStart2 = function(event) {
+					if (event.target === node) prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+				};
+				let timeoutId;
+				const ownerWindow = node.ownerDocument.defaultView ?? window;
+				node.addEventListener("animationstart", onAnimationStart2);
+				node.addEventListener("animationcancel", onAnimationEnd2);
+				node.addEventListener("animationend", onAnimationEnd2);
+				return () => {
+					ownerWindow.clearTimeout(timeoutId);
+					node.removeEventListener("animationstart", onAnimationStart2);
+					node.removeEventListener("animationcancel", onAnimationEnd2);
+					node.removeEventListener("animationend", onAnimationEnd2);
+				};
+			}
+			send("ANIMATION_END");
+		}, [node, send]);
+		return {
+			isPresent: ["mounted", "unmountSuspended"].includes(state),
+			ref: React32__namespace.useCallback((node2) => {
+				if (node2) stylesRef.current = getComputedStyle(node2);
+				setNode(node2);
+			}, [])
+		};
+	}
+	function getAnimationName(styles) {
+		return styles?.animationName || "none";
+	}
+	exports.DATA_ITEM_ATTR = DATA_ITEM_ATTR;
+	exports.Presence = Presence;
+	exports.Primitive = Primitive;
+	exports.VisuallyHiddenInput = VisuallyHiddenInput;
+	exports.composeEventHandlers = composeEventHandlers;
+	exports.composeRefs = composeRefs;
+	exports.createContext = createContext3;
+	exports.useComposedRefs = useComposedRefs;
+	exports.useControllableState = useControllableState;
+	exports.useDirection = useDirection;
+	exports.useFormControl = useFormControl;
+	exports.useId = useId;
+	exports.useItemCollection = useItemCollection;
+}) });
+
+//#endregion
+export default require_dist();
+
+export { require_dist };