@monimesl/dot-renderer-react 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/vendor/@base-ui/react/floating-ui-react/utils/event.js

@@ -0,0 +1,25 @@
+import { android } from "../../../utils/platform/os.js";
+import { jsdom } from "../../../utils/platform/env.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/event.mjs
+function stopEvent(event) {
+	event.preventDefault();
+	event.stopPropagation();
+}
+function isReactEvent(event) {
+	return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+	if (event.pointerType === "" && event.isTrusted) return true;
+	if (android && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+	if (jsdom) return false;
+	return !android && event.width === 0 && event.height === 0 || android && 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 isClickLikeEvent(event) {
+	const type = event.type;
+	return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
+}
+//#endregion
+export { isClickLikeEvent, isReactEvent, isVirtualClick, isVirtualPointerEvent, stopEvent };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/markOthers.js

@@ -0,0 +1,116 @@
+import { getNodeName, isShadowRoot } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { ownerDocument } from "../../../utils/owner.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/markOthers.mjs
+const counters = {
+	inert: /* @__PURE__ */ new WeakMap(),
+	"aria-hidden": /* @__PURE__ */ new WeakMap()
+};
+const markerName = "data-base-ui-inert";
+const uncontrolledElementsSets = {
+	inert: /* @__PURE__ */ new WeakSet(),
+	"aria-hidden": /* @__PURE__ */ new WeakSet()
+};
+let markerCounterMap = /* @__PURE__ */ new WeakMap();
+let lockCount = 0;
+function getUncontrolledElementsSet(controlAttribute) {
+	return uncontrolledElementsSets[controlAttribute];
+}
+function unwrapHost(node) {
+	if (!node) return null;
+	return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
+}
+const correctElements = (parent, targets) => targets.map((target) => {
+	if (parent.contains(target)) return target;
+	const correctedTarget = unwrapHost(target);
+	if (parent.contains(correctedTarget)) return correctedTarget;
+	return null;
+}).filter((x) => x != null);
+const buildKeepSet = (targets) => {
+	const keep = /* @__PURE__ */ new Set();
+	targets.forEach((target) => {
+		let node = target;
+		while (node && !keep.has(node)) {
+			keep.add(node);
+			node = node.parentNode;
+		}
+	});
+	return keep;
+};
+const collectOutsideElements = (root, keepElements, stopElements) => {
+	const outside = [];
+	const walk = (parent) => {
+		if (!parent || stopElements.has(parent)) return;
+		Array.from(parent.children).forEach((node) => {
+			if (getNodeName(node) === "script") return;
+			if (keepElements.has(node)) walk(node);
+			else outside.push(node);
+		});
+	};
+	walk(root);
+	return outside;
+};
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, { mark = true }) {
+	let controlAttribute = null;
+	if (inert) controlAttribute = "inert";
+	else if (ariaHidden) controlAttribute = "aria-hidden";
+	let counterMap = null;
+	let uncontrolledElementsSet = null;
+	const avoidElements = correctElements(body, uncorrectedAvoidElements);
+	const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)) : [];
+	const hiddenElements = [];
+	const markedElements = [];
+	if (controlAttribute) {
+		const map = counters[controlAttribute];
+		const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
+		uncontrolledElementsSet = currentUncontrolledElementsSet;
+		counterMap = map;
+		const ariaLiveElements = correctElements(body, Array.from(body.querySelectorAll("[aria-live]")));
+		const controlElements = avoidElements.concat(ariaLiveElements);
+		collectOutsideElements(body, buildKeepSet(controlElements), new Set(controlElements)).forEach((node) => {
+			const attr = node.getAttribute(controlAttribute);
+			const alreadyHidden = attr !== null && attr !== "false";
+			const counterValue = (map.get(node) || 0) + 1;
+			map.set(node, counterValue);
+			hiddenElements.push(node);
+			if (counterValue === 1 && alreadyHidden) currentUncontrolledElementsSet.add(node);
+			if (!alreadyHidden) node.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+		});
+	}
+	if (mark) markerTargets.forEach((node) => {
+		const markerValue = (markerCounterMap.get(node) || 0) + 1;
+		markerCounterMap.set(node, markerValue);
+		markedElements.push(node);
+		if (markerValue === 1) node.setAttribute(markerName, "");
+	});
+	lockCount += 1;
+	return () => {
+		if (counterMap) hiddenElements.forEach((element) => {
+			const counterValue = (counterMap.get(element) || 0) - 1;
+			counterMap.set(element, counterValue);
+			if (!counterValue) {
+				if (!uncontrolledElementsSet?.has(element) && controlAttribute) element.removeAttribute(controlAttribute);
+				uncontrolledElementsSet?.delete(element);
+			}
+		});
+		if (mark) markedElements.forEach((element) => {
+			const markerValue = (markerCounterMap.get(element) || 0) - 1;
+			markerCounterMap.set(element, markerValue);
+			if (!markerValue) element.removeAttribute(markerName);
+		});
+		lockCount -= 1;
+		if (!lockCount) {
+			counters.inert = /* @__PURE__ */ new WeakMap();
+			counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
+			uncontrolledElementsSets.inert = /* @__PURE__ */ new WeakSet();
+			uncontrolledElementsSets["aria-hidden"] = /* @__PURE__ */ new WeakSet();
+			markerCounterMap = /* @__PURE__ */ new WeakMap();
+		}
+	};
+}
+function markOthers(avoidElements, options = {}) {
+	const { ariaHidden = false, inert = false, mark = true } = options;
+	const body = ownerDocument(avoidElements[0]).body;
+	return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, { mark });
+}
+//#endregion
+export { markOthers };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/nodes.js

@@ -0,0 +1,16 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/nodes.mjs
+function getNodeChildren(nodes, id, onlyOpenChildren = true) {
+	return nodes.filter((node) => node.parentId === id).flatMap((child) => [...!onlyOpenChildren || child.context?.open ? [child] : [], ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getNodeAncestors(nodes, id) {
+	let allAncestors = [];
+	let currentParentId = nodes.find((node) => node.id === id)?.parentId;
+	while (currentParentId) {
+		const currentNode = nodes.find((node) => node.id === currentParentId);
+		currentParentId = currentNode?.parentId;
+		if (currentNode) allAncestors = allAncestors.concat(currentNode);
+	}
+	return allAncestors;
+}
+//#endregion
+export { getNodeAncestors, getNodeChildren };

package/dist/vendor/@base-ui/react/floating-ui-react/utils/tabbable.js

@@ -0,0 +1,135 @@
+import { getComputedStyle, getNodeName, isHTMLElement, isShadowRoot } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { ownerDocument } from "../../../utils/owner.js";
+import { activeElement, contains } from "../../../utils/shadowDom.js";
+import { isElementVisible } from "./composite.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/floating-ui-react/utils/tabbable.mjs
+const CANDIDATE_SELECTOR = "a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable=\"false\"]),audio[controls],video[controls]";
+function getParentElement(element) {
+	const assignedSlot = element.assignedSlot;
+	if (assignedSlot) return assignedSlot;
+	if (element.parentElement) return element.parentElement;
+	const rootNode = element.getRootNode();
+	return isShadowRoot(rootNode) ? rootNode.host : null;
+}
+function getDetailsSummary(details) {
+	for (const child of Array.from(details.children)) if (getNodeName(child) === "summary") return child;
+	return null;
+}
+function isWithinOpenDetailsSummary(element, details) {
+	const summary = getDetailsSummary(details);
+	return !!summary && (element === summary || contains(summary, element));
+}
+function isFocusableCandidate(element) {
+	const nodeName = element ? getNodeName(element) : "";
+	return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== "summary" || element.parentElement != null && getNodeName(element.parentElement) === "details" && getDetailsSummary(element.parentElement) === element) && (nodeName !== "details" || getDetailsSummary(element) == null) && (nodeName !== "input" || element.type !== "hidden");
+}
+function isFocusableElement(element) {
+	if (!isFocusableCandidate(element) || !element.isConnected || element.matches(":disabled")) return false;
+	for (let current = element; current; current = getParentElement(current)) {
+		const isAncestor = current !== element;
+		const isSlot = getNodeName(current) === "slot";
+		if (current.hasAttribute("inert")) return false;
+		if (isAncestor && getNodeName(current) === "details" && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute("hidden") || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) return false;
+	}
+	return true;
+}
+function isVisibleInTabbableTree(element, isAncestor) {
+	const styles = getComputedStyle(element);
+	if (!isAncestor) return isElementVisible(element, styles);
+	return styles.display !== "none";
+}
+function getTabIndex(element) {
+	const tabIndex = element.tabIndex;
+	if (tabIndex < 0) {
+		const nodeName = getNodeName(element);
+		if (nodeName === "details" || nodeName === "audio" || nodeName === "video" || isHTMLElement(element) && element.isContentEditable) return 0;
+	}
+	return tabIndex;
+}
+function getNamedRadioInput(element) {
+	if (getNodeName(element) !== "input") return null;
+	const input = element;
+	return input.type === "radio" && input.name !== "" ? input : null;
+}
+function isTabbableRadio(element, candidates) {
+	const input = getNamedRadioInput(element);
+	if (!input) return true;
+	const checkedRadio = candidates.find((candidate) => {
+		const radio = getNamedRadioInput(candidate);
+		return radio?.name === input.name && radio.form === input.form && radio.checked;
+	});
+	if (checkedRadio) return checkedRadio === input;
+	return candidates.find((candidate) => {
+		const radio = getNamedRadioInput(candidate);
+		return radio?.name === input.name && radio.form === input.form;
+	}) === input;
+}
+function getComposedChildren(container) {
+	if (isHTMLElement(container) && getNodeName(container) === "slot") {
+		const assignedElements = container.assignedElements({ flatten: true });
+		if (assignedElements.length > 0) return assignedElements;
+	}
+	if (isHTMLElement(container) && container.shadowRoot) return Array.from(container.shadowRoot.children);
+	return Array.from(container.children);
+}
+function appendCandidates(container, list) {
+	getComposedChildren(container).forEach((child) => {
+		if (isFocusableCandidate(child)) list.push(child);
+		appendCandidates(child, list);
+	});
+}
+function appendMatchingElements(container, selector, list) {
+	getComposedChildren(container).forEach((child) => {
+		if (isHTMLElement(child) && child.matches(selector)) list.push(child);
+		appendMatchingElements(child, selector, list);
+	});
+}
+function isTabbable(element) {
+	return isFocusableElement(element) && getTabIndex(element) >= 0;
+}
+function focusable(container) {
+	const candidates = [];
+	appendCandidates(container, candidates);
+	return candidates.filter(isFocusableElement);
+}
+function tabbable(container) {
+	const candidates = focusable(container);
+	return candidates.filter((element) => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
+}
+function getTabbableIn(container, dir) {
+	const list = tabbable(container);
+	const len = list.length;
+	if (len === 0) return;
+	const active = activeElement(ownerDocument(container));
+	const index = list.indexOf(active);
+	return list[index === -1 ? dir === 1 ? 0 : len - 1 : index + dir];
+}
+function getNextTabbable(referenceElement) {
+	return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+	return getTabbableIn(ownerDocument(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) {
+	tabbable(container).forEach((element) => {
+		element.dataset.tabindex = element.getAttribute("tabindex") || "";
+		element.setAttribute("tabindex", "-1");
+	});
+}
+function enableFocusInside(container) {
+	const elements = [];
+	appendMatchingElements(container, "[data-tabindex]", elements);
+	elements.forEach((element) => {
+		const tabindex = element.dataset.tabindex;
+		delete element.dataset.tabindex;
+		if (tabindex) element.setAttribute("tabindex", tabindex);
+		else element.removeAttribute("tabindex");
+	});
+}
+//#endregion
+export { disableFocusInside, enableFocusInside, focusable, getNextTabbable, getPreviousTabbable, isOutsideEvent, isTabbable, tabbable };

package/dist/vendor/@base-ui/react/internals/TransitionStatusDataAttributes.js

@@ -0,0 +1,11 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/TransitionStatusDataAttributes.mjs
+/**
+* Present when the component begins animating in.
+*/
+const startingStyle = "data-starting-style";
+/**
+* Present when the component is animating out.
+*/
+const endingStyle = "data-ending-style";
+//#endregion
+export { endingStyle, startingStyle };

package/dist/vendor/@base-ui/react/internals/composite/composite.js

@@ -0,0 +1,89 @@
+import { isHTMLElement } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import "../../floating-ui-react/utils/event.js";
+import { findNonDisabledListIndex, getMaxListIndex, getMinListIndex, isIndexOutOfListBounds, isListIndexDisabled } from "../../floating-ui-react/utils/composite.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/composite.mjs
+const ARROW_UP = "ArrowUp";
+const ARROW_DOWN = "ArrowDown";
+const ARROW_LEFT = "ArrowLeft";
+const ARROW_RIGHT = "ArrowRight";
+const HOME = "Home";
+const COMPOSITE_KEYS = /* @__PURE__ */ new Set([
+	ARROW_UP,
+	ARROW_DOWN,
+	ARROW_LEFT,
+	ARROW_RIGHT,
+	HOME,
+	"End"
+]);
+const SHIFT = "Shift";
+const MODIFIER_KEYS = [
+	SHIFT,
+	"Control",
+	"Alt",
+	"Meta"
+];
+function isInputElement(element) {
+	return isHTMLElement(element) && element.tagName === "INPUT";
+}
+function isNativeInput(element) {
+	if (isInputElement(element) && element.selectionStart != null) return true;
+	if (isHTMLElement(element) && element.tagName === "TEXTAREA") return true;
+	return false;
+}
+function scrollIntoViewIfNeeded(scrollContainer, element, direction, orientation) {
+	if (!scrollContainer || !element || !element.scrollTo) return;
+	let targetX = scrollContainer.scrollLeft;
+	let targetY = scrollContainer.scrollTop;
+	const isOverflowingX = scrollContainer.clientWidth < scrollContainer.scrollWidth;
+	const isOverflowingY = scrollContainer.clientHeight < scrollContainer.scrollHeight;
+	if (isOverflowingX && orientation !== "vertical") {
+		const elementOffsetLeft = getOffset(scrollContainer, element, "left");
+		const containerStyles = getStyles(scrollContainer);
+		const elementStyles = getStyles(element);
+		if (direction === "ltr") {
+			if (elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight) targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight;
+			else if (elementOffsetLeft - elementStyles.scrollMarginLeft < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft) targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft;
+		}
+		if (direction === "rtl") {
+			if (elementOffsetLeft - elementStyles.scrollMarginLeft < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft) targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft;
+			else if (elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight) targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight;
+		}
+	}
+	if (isOverflowingY && orientation !== "horizontal") {
+		const elementOffsetTop = getOffset(scrollContainer, element, "top");
+		const containerStyles = getStyles(scrollContainer);
+		const elementStyles = getStyles(element);
+		if (elementOffsetTop - elementStyles.scrollMarginTop < scrollContainer.scrollTop + containerStyles.scrollPaddingTop) targetY = elementOffsetTop - elementStyles.scrollMarginTop - containerStyles.scrollPaddingTop;
+		else if (elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom > scrollContainer.scrollTop + scrollContainer.clientHeight - containerStyles.scrollPaddingBottom) targetY = elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom - scrollContainer.clientHeight + containerStyles.scrollPaddingBottom;
+	}
+	scrollContainer.scrollTo({
+		left: targetX,
+		top: targetY,
+		behavior: "auto"
+	});
+}
+function getOffset(ancestor, element, side) {
+	const propName = side === "left" ? "offsetLeft" : "offsetTop";
+	let result = 0;
+	while (element.offsetParent) {
+		result += element[propName];
+		if (element.offsetParent === ancestor) break;
+		element = element.offsetParent;
+	}
+	return result;
+}
+function getStyles(element) {
+	const styles = getComputedStyle(element);
+	return {
+		scrollMarginTop: parseFloat(styles.scrollMarginTop) || 0,
+		scrollMarginRight: parseFloat(styles.scrollMarginRight) || 0,
+		scrollMarginBottom: parseFloat(styles.scrollMarginBottom) || 0,
+		scrollMarginLeft: parseFloat(styles.scrollMarginLeft) || 0,
+		scrollPaddingTop: parseFloat(styles.scrollPaddingTop) || 0,
+		scrollPaddingRight: parseFloat(styles.scrollPaddingRight) || 0,
+		scrollPaddingBottom: parseFloat(styles.scrollPaddingBottom) || 0,
+		scrollPaddingLeft: parseFloat(styles.scrollPaddingLeft) || 0
+	};
+}
+//#endregion
+export { ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, COMPOSITE_KEYS, HOME, MODIFIER_KEYS, SHIFT, findNonDisabledListIndex, getMaxListIndex, getMinListIndex, isIndexOutOfListBounds, isListIndexDisabled, isNativeInput, scrollIntoViewIfNeeded };

package/dist/vendor/@base-ui/react/internals/composite/constants.js

@@ -0,0 +1,4 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/constants.mjs
+const ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
+//#endregion
+export { ACTIVE_COMPOSITE_ITEM };

package/dist/vendor/@base-ui/react/internals/composite/item/CompositeItem.js

@@ -0,0 +1,21 @@
+"use client";
+import { EMPTY_ARRAY, EMPTY_OBJECT } from "../../../../utils/empty.js";
+import { useRenderElement } from "../../useRenderElement.js";
+import { useCompositeItem } from "./useCompositeItem.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/item/CompositeItem.mjs
+function CompositeItem(componentProps) {
+	const { render, className, style, state = EMPTY_OBJECT, props = EMPTY_ARRAY, refs = EMPTY_ARRAY, metadata, stateAttributesMapping, tag = "div", ...elementProps } = componentProps;
+	const { compositeProps, compositeRef } = useCompositeItem({ metadata });
+	return useRenderElement(tag, componentProps, {
+		state,
+		ref: [compositeRef, ...refs],
+		props: [
+			compositeProps,
+			...props,
+			elementProps
+		],
+		stateAttributesMapping
+	});
+}
+//#endregion
+export { CompositeItem };

package/dist/vendor/@base-ui/react/internals/composite/item/useCompositeItem.js

@@ -0,0 +1,31 @@
+"use client";
+import { useMergedRefs } from "../../../../utils/useMergedRefs.js";
+import { useCompositeRootContext } from "../root/CompositeRootContext.js";
+import { useCompositeListItem } from "../list/useCompositeListItem.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/item/useCompositeItem.mjs
+function useCompositeItem(params = {}) {
+	const { highlightItemOnHover, highlightedIndex, onHighlightedIndexChange } = useCompositeRootContext();
+	const { ref, index } = useCompositeListItem(params);
+	const isHighlighted = highlightedIndex === index;
+	const itemRef = React.useRef(null);
+	const mergedRef = useMergedRefs(ref, itemRef);
+	return {
+		compositeProps: {
+			tabIndex: isHighlighted ? 0 : -1,
+			onFocus() {
+				onHighlightedIndexChange(index);
+			},
+			onMouseMove() {
+				const item = itemRef.current;
+				if (!highlightItemOnHover || !item) return;
+				const disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+				if (!isHighlighted && !disabled) item.focus();
+			}
+		},
+		compositeRef: mergedRef,
+		index
+	};
+}
+//#endregion
+export { useCompositeItem };

package/dist/vendor/@base-ui/react/internals/composite/list/CompositeList.js

@@ -0,0 +1,180 @@
+"use client";
+import { useRefWithInit } from "../../../../utils/useRefWithInit.js";
+import { useStableCallback } from "../../../../utils/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../utils/useIsoLayoutEffect.js";
+import { CompositeListContext } from "./CompositeListContext.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/list/CompositeList.mjs
+/**
+* Provides context for a list of items in a composite component.
+*/
+function CompositeList(props) {
+	const { children, elementsRef, labelsRef, onMapChange: onMapChangeProp } = props;
+	const onMapChange = useStableCallback(onMapChangeProp);
+	const [, setMapTick] = React.useState(false);
+	const listeners = useRefWithInit(createListeners).current;
+	const map = useRefWithInit(createMap).current;
+	const nextIndexRef = React.useRef(0);
+	const isDirtyRef = React.useRef(true);
+	const itemsRef = React.useRef(null);
+	const mutationObserverRef = React.useRef(null);
+	const scheduleMapUpdate = useStableCallback(() => {
+		if (isDirtyRef.current) return;
+		isDirtyRef.current = true;
+		setMapTick((tick) => !tick);
+	});
+	const register = useStableCallback((node, registration) => {
+		map.set(node, registration);
+		scheduleMapUpdate();
+	});
+	const unregister = useStableCallback((node) => {
+		map.delete(node);
+		scheduleMapUpdate();
+	});
+	const syncRefs = useStableCallback((items) => {
+		const nextMap = /* @__PURE__ */ new Map();
+		elementsRef.current.length = 0;
+		if (labelsRef) labelsRef.current.length = 0;
+		items.forEach((item) => {
+			nextMap.set(item.element, {
+				...item.registration.metadata ?? {},
+				index: item.index
+			});
+			elementsRef.current[item.index] = item.element;
+			if (labelsRef) labelsRef.current[item.index] = item.registration.label !== void 0 ? item.registration.label : item.registration.textRef?.current?.textContent ?? item.element.textContent;
+		});
+		nextIndexRef.current = elementsRef.current.length;
+		return nextMap;
+	});
+	function observe(sortedNodes) {
+		mutationObserverRef.current?.disconnect();
+		mutationObserverRef.current = null;
+		if (typeof MutationObserver !== "function" || sortedNodes.length < 2) return;
+		const mutationObserver = new MutationObserver((entries) => {
+			if (!hasMovedNode(entries)) return;
+			let previousConnectedNode = null;
+			for (const node of sortedNodes) {
+				if (!node.isConnected) continue;
+				if (previousConnectedNode && sortByDocumentPosition(previousConnectedNode, node) > 0) {
+					mutationObserver.disconnect();
+					scheduleMapUpdate();
+					return;
+				}
+				previousConnectedNode = node;
+			}
+		});
+		mutationObserverRef.current = mutationObserver;
+		const roots = /* @__PURE__ */ new Set();
+		for (let i = 1; i < sortedNodes.length; i += 1) {
+			const root = getCommonAncestor(sortedNodes[i - 1], sortedNodes[i]);
+			if (root) roots.add(root);
+		}
+		roots.forEach((root) => mutationObserver.observe(root, { childList: true }));
+	}
+	const flush = useStableCallback(() => {
+		const [items, automaticNodes] = getCompositeListSnapshot(map);
+		const nextMap = syncRefs(items);
+		const previousItems = itemsRef.current;
+		const changed = !previousItems || previousItems.length !== items.length || items.some((item, index) => {
+			const previousItem = previousItems[index];
+			return item.index !== previousItem.index || item.element !== previousItem.element || item.registration.index !== previousItem.registration.index || item.registration.metadata !== previousItem.registration.metadata;
+		});
+		observe(automaticNodes);
+		itemsRef.current = items;
+		isDirtyRef.current = false;
+		if (!changed) return;
+		listeners.forEach((listener) => listener(nextMap));
+		onMapChange(nextMap);
+	});
+	useIsoLayoutEffect(() => {
+		if (!isDirtyRef.current && itemsRef.current) syncRefs(itemsRef.current);
+		return () => {
+			elementsRef.current = [];
+			if (labelsRef) labelsRef.current = [];
+		};
+	}, [
+		elementsRef,
+		labelsRef,
+		syncRefs
+	]);
+	useIsoLayoutEffect(() => {
+		if (isDirtyRef.current) flush();
+	});
+	useIsoLayoutEffect(() => {
+		return () => {
+			mutationObserverRef.current?.disconnect();
+			isDirtyRef.current = true;
+		};
+	}, []);
+	const subscribeMapChange = useStableCallback((fn) => {
+		listeners.add(fn);
+		return () => {
+			listeners.delete(fn);
+		};
+	});
+	const contextValue = React.useMemo(() => ({
+		register,
+		unregister,
+		subscribeMapChange,
+		nextIndexRef
+	}), [
+		register,
+		unregister,
+		subscribeMapChange,
+		nextIndexRef
+	]);
+	return /*#__PURE__*/ jsx(CompositeListContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function createMap() {
+	return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+	return /* @__PURE__ */ new Set();
+}
+function getCompositeListSnapshot(map) {
+	const reservedIndices = /* @__PURE__ */ new Set();
+	const items = [];
+	const automaticItems = [];
+	map.forEach((registration, node) => {
+		if (!node.isConnected) return;
+		const index = registration.index;
+		const item = {
+			index: index ?? -1,
+			element: node,
+			registration
+		};
+		if (index === null) automaticItems.push(item);
+		else if (index >= 0) {
+			reservedIndices.add(index);
+			items.push(item);
+		}
+	});
+	let nextAutomaticIndex = 0;
+	automaticItems.sort((a, b) => sortByDocumentPosition(a.element, b.element));
+	automaticItems.forEach((item) => {
+		while (reservedIndices.has(nextAutomaticIndex)) nextAutomaticIndex += 1;
+		item.index = nextAutomaticIndex;
+		items.push(item);
+		nextAutomaticIndex += 1;
+	});
+	if (reservedIndices.size > 0) items.sort((a, b) => a.index - b.index);
+	return [items, automaticItems.map((item) => item.element)];
+}
+function getCommonAncestor(firstNode, lastNode) {
+	let ancestor = firstNode.parentElement;
+	while (ancestor && !ancestor.contains(lastNode)) ancestor = ancestor.parentElement;
+	return ancestor;
+}
+function hasMovedNode(entries) {
+	for (const entry of entries) for (let i = 0; i < entry.removedNodes.length; i += 1) if (entry.removedNodes[i].isConnected) return true;
+	return false;
+}
+function sortByDocumentPosition(a, b) {
+	return a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+//#endregion
+export { CompositeList };

package/dist/vendor/@base-ui/react/internals/composite/list/CompositeListContext.js

@@ -0,0 +1,15 @@
+"use client";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/internals/composite/list/CompositeListContext.mjs
+const CompositeListContext = /*#__PURE__*/ React.createContext({
+	register: () => {},
+	unregister: () => {},
+	subscribeMapChange: () => () => {},
+	nextIndexRef: { current: 0 }
+});
+if (process.env.NODE_ENV !== "production") CompositeListContext.displayName = "CompositeListContext";
+function useCompositeListContext() {
+	return React.useContext(CompositeListContext);
+}
+//#endregion
+export { CompositeListContext, useCompositeListContext };