@pixpilot/shadcn-ui 0.1.0 → 0.4.1

package/dist/node_modules/.pnpm/@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.utils.cjs

@@ -0,0 +1,426 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
+const require_floating_ui_utils = require('../../../../../@floating-ui_utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.cjs');
+const require_floating_ui_utils_dom = require('../../../../../@floating-ui_utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.cjs');
+const require_index = require('../../../../../tabbable@6.3.0/node_modules/tabbable/dist/index.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region ../../node_modules/.pnpm/@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.utils.mjs
+function getPlatform() {
+	const uaData = navigator.userAgentData;
+	if (uaData != null && uaData.platform) return uaData.platform;
+	return navigator.platform;
+}
+function getUserAgent() {
+	const uaData = navigator.userAgentData;
+	if (uaData && Array.isArray(uaData.brands)) return uaData.brands.map((_ref) => {
+		let { brand, version } = _ref;
+		return brand + "/" + version;
+	}).join(" ");
+	return navigator.userAgent;
+}
+function isSafari() {
+	return /apple/i.test(navigator.vendor);
+}
+function isAndroid() {
+	const re = /android/i;
+	return re.test(getPlatform()) || re.test(getUserAgent());
+}
+function isMac() {
+	return getPlatform().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function isJSDOM() {
+	return getUserAgent().includes("jsdom/");
+}
+function activeElement(doc) {
+	let activeElement$1 = doc.activeElement;
+	while (((_activeElement = activeElement$1) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
+		var _activeElement;
+		activeElement$1 = activeElement$1.shadowRoot.activeElement;
+	}
+	return activeElement$1;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+	if (parent.contains(child)) return true;
+	if (rootNode && require_floating_ui_utils_dom.isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getTarget(event) {
+	if ("composedPath" in event) return event.composedPath()[0];
+	return event.target;
+}
+function isEventTargetWithin(event, node) {
+	if (node == null) return false;
+	if ("composedPath" in event) return event.composedPath().includes(node);
+	const e = event;
+	return e.target != null && node.contains(e.target);
+}
+function isRootElement(element) {
+	return element.matches("html,body");
+}
+function getDocument(node) {
+	return (node == null ? void 0 : node.ownerDocument) || document;
+}
+function isTypeableElement(element) {
+	return require_floating_ui_utils_dom.isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function isTypeableCombobox(element) {
+	if (!element) return false;
+	return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+	if (!element || isJSDOM()) return true;
+	try {
+		return element.matches(":focus-visible");
+	} catch (_e) {
+		return true;
+	}
+}
+function getFloatingFocusElement(floatingElement) {
+	if (!floatingElement) return null;
+	return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector("[" + FOCUSABLE_ATTRIBUTE + "]") || floatingElement;
+}
+function getNodeChildren(nodes, id, onlyOpenChildren) {
+	if (onlyOpenChildren === void 0) onlyOpenChildren = true;
+	return nodes.filter((node) => {
+		var _node$context;
+		return node.parentId === id && (!onlyOpenChildren || ((_node$context = node.context) == null ? void 0 : _node$context.open));
+	}).flatMap((child) => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getDeepestNode(nodes, id) {
+	let deepestNodeId;
+	let maxDepth = -1;
+	function findDeepest(nodeId, depth) {
+		if (depth > maxDepth) {
+			deepestNodeId = nodeId;
+			maxDepth = depth;
+		}
+		getNodeChildren(nodes, nodeId).forEach((child) => {
+			findDeepest(child.id, depth + 1);
+		});
+	}
+	findDeepest(id, 0);
+	return nodes.find((node) => node.id === deepestNodeId);
+}
+function getNodeAncestors(nodes, id) {
+	var _nodes$find;
+	let allAncestors = [];
+	let currentParentId = (_nodes$find = nodes.find((node) => node.id === id)) == null ? void 0 : _nodes$find.parentId;
+	while (currentParentId) {
+		const currentNode = nodes.find((node) => node.id === currentParentId);
+		currentParentId = currentNode == null ? void 0 : currentNode.parentId;
+		if (currentNode) allAncestors = allAncestors.concat(currentNode);
+	}
+	return allAncestors;
+}
+function stopEvent(event) {
+	event.preventDefault();
+	event.stopPropagation();
+}
+function isReactEvent(event) {
+	return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+	if (event.mozInputSource === 0 && event.isTrusted) return true;
+	if (isAndroid() && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+	if (isJSDOM()) return false;
+	return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isMouseLikePointerType(pointerType, strict) {
+	const values = ["mouse", "pen"];
+	if (!strict) values.push("", void 0);
+	return values.includes(pointerType);
+}
+function useLatestRef(value) {
+	const ref = react.useRef(value);
+	index(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+function useEffectEvent(callback) {
+	const ref = react.useRef(() => {
+		if (process.env.NODE_ENV !== "production") throw new Error("Cannot call an event handler while rendering.");
+	});
+	useSafeInsertionEffect(() => {
+		ref.current = callback;
+	});
+	return react.useCallback(function() {
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+		return ref.current == null ? void 0 : ref.current(...args);
+	}, []);
+}
+function isDifferentGridRow(index$1, cols, prevRow) {
+	return Math.floor(index$1 / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(listRef, index$1) {
+	return index$1 < 0 || index$1 >= listRef.current.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef, { disabledIndices });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef, {
+		decrement: true,
+		startingIndex: listRef.current.length,
+		disabledIndices
+	});
+}
+function findNonDisabledListIndex(listRef, _temp) {
+	let { startingIndex = -1, decrement = false, disabledIndices, amount = 1 } = _temp === void 0 ? {} : _temp;
+	let index$1 = startingIndex;
+	do
+		index$1 += decrement ? -amount : amount;
+	while (index$1 >= 0 && index$1 <= listRef.current.length - 1 && isListIndexDisabled(listRef, index$1, disabledIndices));
+	return index$1;
+}
+function getGridNavigatedIndex(listRef, _ref) {
+	let { event, orientation, loop, rtl, cols, disabledIndices, minIndex, maxIndex, prevIndex, stopEvent: stop = false } = _ref;
+	let nextIndex = prevIndex;
+	if (event.key === ARROW_UP) {
+		stop && stopEvent(event);
+		if (prevIndex === -1) nextIndex = maxIndex;
+		else {
+			nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: nextIndex,
+				amount: cols,
+				decrement: true,
+				disabledIndices
+			});
+			if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {
+				const col = prevIndex % cols;
+				const maxCol = maxIndex % cols;
+				const offset = maxIndex - (maxCol - col);
+				if (maxCol === col) nextIndex = maxIndex;
+				else nextIndex = maxCol > col ? offset : offset - cols;
+			}
+		}
+		if (isIndexOutOfListBounds(listRef, nextIndex)) nextIndex = prevIndex;
+	}
+	if (event.key === ARROW_DOWN) {
+		stop && stopEvent(event);
+		if (prevIndex === -1) nextIndex = minIndex;
+		else {
+			nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex,
+				amount: cols,
+				disabledIndices
+			});
+			if (loop && prevIndex + cols > maxIndex) nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex % cols - cols,
+				amount: cols,
+				disabledIndices
+			});
+		}
+		if (isIndexOutOfListBounds(listRef, nextIndex)) nextIndex = prevIndex;
+	}
+	if (orientation === "both") {
+		const prevRow = require_floating_ui_utils.floor(prevIndex / cols);
+		if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
+			stop && stopEvent(event);
+			if (prevIndex % cols !== cols - 1) {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex,
+					disabledIndices
+				});
+				if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex - prevIndex % cols - 1,
+					disabledIndices
+				});
+			} else if (loop) nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex - prevIndex % cols - 1,
+				disabledIndices
+			});
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {
+			stop && stopEvent(event);
+			if (prevIndex % cols !== 0) {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex,
+					decrement: true,
+					disabledIndices
+				});
+				if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex + (cols - prevIndex % cols),
+					decrement: true,
+					disabledIndices
+				});
+			} else if (loop) nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex + (cols - prevIndex % cols),
+				decrement: true,
+				disabledIndices
+			});
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		const lastRow = require_floating_ui_utils.floor(maxIndex / cols) === prevRow;
+		if (isIndexOutOfListBounds(listRef, nextIndex)) if (loop && lastRow) nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
+			startingIndex: prevIndex - prevIndex % cols - 1,
+			disabledIndices
+		});
+		else nextIndex = prevIndex;
+	}
+	return nextIndex;
+}
+/** For each cell index, gets the item index that occupies that cell */
+function createGridCellMap(sizes, cols, dense) {
+	const cellMap = [];
+	let startIndex = 0;
+	sizes.forEach((_ref2, index$1) => {
+		let { width, height } = _ref2;
+		if (width > cols) {
+			if (process.env.NODE_ENV !== "production") throw new Error("[Floating UI]: Invalid grid - item width at index " + index$1 + " is greater than grid columns");
+		}
+		let itemPlaced = false;
+		if (dense) startIndex = 0;
+		while (!itemPlaced) {
+			const targetCells = [];
+			for (let i = 0; i < width; i++) for (let j = 0; j < height; j++) targetCells.push(startIndex + i + j * cols);
+			if (startIndex % cols + width <= cols && targetCells.every((cell) => cellMap[cell] == null)) {
+				targetCells.forEach((cell) => {
+					cellMap[cell] = index$1;
+				});
+				itemPlaced = true;
+			} else startIndex++;
+		}
+	});
+	return [...cellMap];
+}
+/** Gets cell index of an item's corner or -1 when index is -1. */
+function getGridCellIndexOfCorner(index$1, sizes, cellMap, cols, corner) {
+	if (index$1 === -1) return -1;
+	const firstCellIndex = cellMap.indexOf(index$1);
+	const sizeItem = sizes[index$1];
+	switch (corner) {
+		case "tl": return firstCellIndex;
+		case "tr":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + sizeItem.width - 1;
+		case "bl":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + (sizeItem.height - 1) * cols;
+		case "br": return cellMap.lastIndexOf(index$1);
+	}
+}
+/** Gets all cell indices that correspond to the specified indices */
+function getGridCellIndices(indices, cellMap) {
+	return cellMap.flatMap((index$1, cellIndex) => indices.includes(index$1) ? [cellIndex] : []);
+}
+function isListIndexDisabled(listRef, index$1, disabledIndices) {
+	if (typeof disabledIndices === "function") return disabledIndices(index$1);
+	else if (disabledIndices) return disabledIndices.includes(index$1);
+	const element = listRef.current[index$1];
+	return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+function getTabbableIn(container, dir) {
+	const list = (0, import_dist.tabbable)(container, getTabbableOptions());
+	const len = list.length;
+	if (len === 0) return;
+	const active = activeElement(getDocument(container));
+	const index$1 = list.indexOf(active);
+	return list[index$1 === -1 ? dir === 1 ? 0 : len - 1 : index$1 + dir];
+}
+function getNextTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, -1) || referenceElement;
+}
+function isOutsideEvent(event, container) {
+	const containerElement = container || event.currentTarget;
+	const relatedTarget = event.relatedTarget;
+	return !relatedTarget || !contains(containerElement, relatedTarget);
+}
+function disableFocusInside(container) {
+	(0, import_dist.tabbable)(container, getTabbableOptions()).forEach((element) => {
+		element.dataset.tabindex = element.getAttribute("tabindex") || "";
+		element.setAttribute("tabindex", "-1");
+	});
+}
+function enableFocusInside(container) {
+	container.querySelectorAll("[data-tabindex]").forEach((element) => {
+		const tabindex = element.dataset.tabindex;
+		delete element.dataset.tabindex;
+		if (tabindex) element.setAttribute("tabindex", tabindex);
+		else element.removeAttribute("tabindex");
+	});
+}
+var import_dist, FOCUSABLE_ATTRIBUTE, TYPEABLE_SELECTOR, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ARROW_DOWN, index, SafeReact, useSafeInsertionEffect, getTabbableOptions;
+var init_floating_ui_react_utils = require_rolldown_runtime.__esm({ "../../node_modules/.pnpm/@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.utils.mjs": (() => {
+	require_floating_ui_utils_dom.init_floating_ui_utils_dom();
+	require_floating_ui_utils.init_floating_ui_utils();
+	import_dist = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_index.require_dist(), 1);
+	FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
+	TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+	ARROW_LEFT = "ArrowLeft";
+	ARROW_RIGHT = "ArrowRight";
+	ARROW_UP = "ArrowUp";
+	ARROW_DOWN = "ArrowDown";
+	index = typeof document !== "undefined" ? react.useLayoutEffect : function noop() {};
+	SafeReact = { ...react };
+	useSafeInsertionEffect = SafeReact.useInsertionEffect || ((fn) => fn());
+	getTabbableOptions = () => ({
+		getShadowRoot: true,
+		displayCheck: typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+	});
+}) });
+
+//#endregion
+init_floating_ui_react_utils();
+exports.activeElement = activeElement;
+exports.contains = contains;
+exports.createGridCellMap = createGridCellMap;
+exports.disableFocusInside = disableFocusInside;
+exports.enableFocusInside = enableFocusInside;
+exports.findNonDisabledListIndex = findNonDisabledListIndex;
+exports.getDeepestNode = getDeepestNode;
+exports.getDocument = getDocument;
+exports.getFloatingFocusElement = getFloatingFocusElement;
+exports.getGridCellIndexOfCorner = getGridCellIndexOfCorner;
+exports.getGridCellIndices = getGridCellIndices;
+exports.getGridNavigatedIndex = getGridNavigatedIndex;
+exports.getMaxListIndex = getMaxListIndex;
+exports.getMinListIndex = getMinListIndex;
+exports.getNextTabbable = getNextTabbable;
+exports.getNodeAncestors = getNodeAncestors;
+exports.getNodeChildren = getNodeChildren;
+exports.getPlatform = getPlatform;
+exports.getPreviousTabbable = getPreviousTabbable;
+exports.getTabbableOptions = getTabbableOptions;
+exports.getTarget = getTarget;
+exports.getUserAgent = getUserAgent;
+exports.index = index;
+Object.defineProperty(exports, 'init_floating_ui_react_utils', {
+  enumerable: true,
+  get: function () {
+    return init_floating_ui_react_utils;
+  }
+});
+exports.isEventTargetWithin = isEventTargetWithin;
+exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
+exports.isListIndexDisabled = isListIndexDisabled;
+exports.isMac = isMac;
+exports.isMouseLikePointerType = isMouseLikePointerType;
+exports.isOutsideEvent = isOutsideEvent;
+exports.isReactEvent = isReactEvent;
+exports.isRootElement = isRootElement;
+exports.isSafari = isSafari;
+exports.isTypeableCombobox = isTypeableCombobox;
+exports.isTypeableElement = isTypeableElement;
+exports.isVirtualClick = isVirtualClick;
+exports.isVirtualPointerEvent = isVirtualPointerEvent;
+exports.matchesFocusVisible = matchesFocusVisible;
+exports.stopEvent = stopEvent;
+exports.useEffectEvent = useEffectEvent;
+exports.useLatestRef = useLatestRef;