@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/composite/keys.cjs

@@ -0,0 +1,174 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keys_exports = {};
+__export(keys_exports, {
+  ACTIVE_COMPOSITE_ITEM: () => ACTIVE_COMPOSITE_ITEM,
+  ALT: () => ALT,
+  ARROW_DOWN: () => ARROW_DOWN,
+  ARROW_KEYS: () => ARROW_KEYS,
+  ARROW_LEFT: () => ARROW_LEFT,
+  ARROW_RIGHT: () => ARROW_RIGHT,
+  ARROW_UP: () => ARROW_UP,
+  COMPOSITE_KEYS: () => COMPOSITE_KEYS,
+  CONTROL: () => CONTROL,
+  END: () => END,
+  HOME: () => HOME,
+  HORIZONTAL_KEYS: () => HORIZONTAL_KEYS,
+  HORIZONTAL_KEYS_WITH_EXTRA_KEYS: () => HORIZONTAL_KEYS_WITH_EXTRA_KEYS,
+  META: () => META,
+  MODIFIER_KEYS: () => MODIFIER_KEYS,
+  PAGE_DOWN: () => PAGE_DOWN,
+  PAGE_UP: () => PAGE_UP,
+  SHIFT: () => SHIFT,
+  VERTICAL_KEYS: () => VERTICAL_KEYS,
+  VERTICAL_KEYS_WITH_EXTRA_KEYS: () => VERTICAL_KEYS_WITH_EXTRA_KEYS,
+  isElementDisabled: () => isElementDisabled,
+  isNativeInput: () => isNativeInput,
+  scrollIntoViewIfNeeded: () => scrollIntoViewIfNeeded
+});
+module.exports = __toCommonJS(keys_exports);
+const ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
+const ARROW_UP = "ArrowUp";
+const ARROW_DOWN = "ArrowDown";
+const ARROW_LEFT = "ArrowLeft";
+const ARROW_RIGHT = "ArrowRight";
+const HOME = "Home";
+const END = "End";
+const PAGE_UP = "PageUp";
+const PAGE_DOWN = "PageDown";
+const HORIZONTAL_KEYS = /* @__PURE__ */ new Set([ARROW_LEFT, ARROW_RIGHT]);
+const HORIZONTAL_KEYS_WITH_EXTRA_KEYS = /* @__PURE__ */ new Set([ARROW_LEFT, ARROW_RIGHT, HOME, END]);
+const VERTICAL_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN]);
+const VERTICAL_KEYS_WITH_EXTRA_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN, HOME, END]);
+const ARROW_KEYS = /* @__PURE__ */ new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS]);
+const COMPOSITE_KEYS = /* @__PURE__ */ new Set([...ARROW_KEYS, HOME, END]);
+const SHIFT = "Shift";
+const CONTROL = "Control";
+const ALT = "Alt";
+const META = "Meta";
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([SHIFT, CONTROL, ALT, META]);
+function isHTMLElement(el) {
+  return el != null && el instanceof HTMLElement;
+}
+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 isElementDisabled(element) {
+  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+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.scrollMarginRight < 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;
+  let el = element;
+  while (el.offsetParent) {
+    result += el[propName];
+    if (el.offsetParent === ancestor) {
+      break;
+    }
+    el = el.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVE_COMPOSITE_ITEM,
+  ALT,
+  ARROW_DOWN,
+  ARROW_KEYS,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  COMPOSITE_KEYS,
+  CONTROL,
+  END,
+  HOME,
+  HORIZONTAL_KEYS,
+  HORIZONTAL_KEYS_WITH_EXTRA_KEYS,
+  META,
+  MODIFIER_KEYS,
+  PAGE_DOWN,
+  PAGE_UP,
+  SHIFT,
+  VERTICAL_KEYS,
+  VERTICAL_KEYS_WITH_EXTRA_KEYS,
+  isElementDisabled,
+  isNativeInput,
+  scrollIntoViewIfNeeded
+});

package/dist/cjs/utils/composite/list-utils.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var list_utils_exports = {};
+__export(list_utils_exports, {
+  findNonDisabledListIndex: () => findNonDisabledListIndex,
+  getMaxListIndex: () => getMaxListIndex,
+  getMinListIndex: () => getMinListIndex,
+  getTarget: () => getTarget,
+  isDifferentGridRow: () => isDifferentGridRow,
+  isIndexOutOfListBounds: () => isIndexOutOfListBounds,
+  isListIndexDisabled: () => isListIndexDisabled,
+  stopEvent: () => stopEvent
+});
+module.exports = __toCommonJS(list_utils_exports);
+var import_composite = require("../floating/composite.cjs");
+function getTarget(event) {
+  if ("composedPath" in event) {
+    return event.composedPath()[0];
+  }
+  return event.target;
+}
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+function isDifferentGridRow(index, cols, prevRow) {
+  return Math.floor(index / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(list, index) {
+  return index < 0 || index >= list.length;
+}
+function isListIndexDisabled(list, index, disabledIndices) {
+  const isExplicitlyDisabled = typeof disabledIndices === "function" ? disabledIndices(index) : disabledIndices?.includes(index) ?? false;
+  if (isExplicitlyDisabled) {
+    return true;
+  }
+  const element = list[index];
+  if (!element) {
+    return false;
+  }
+  if (!(0, import_composite.isElementVisible)(element)) {
+    return true;
+  }
+  return !disabledIndices && (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true");
+}
+function findNonDisabledListIndex(list, options = {}) {
+  const { startingIndex = -1, decrement = false, disabledIndices, amount = 1 } = options;
+  let index = startingIndex;
+  do {
+    index += decrement ? -amount : amount;
+  } while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
+  return index;
+}
+function getMinListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef.current, { disabledIndices });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef.current, {
+    decrement: true,
+    startingIndex: listRef.current.length,
+    disabledIndices
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findNonDisabledListIndex,
+  getMaxListIndex,
+  getMinListIndex,
+  getTarget,
+  isDifferentGridRow,
+  isIndexOutOfListBounds,
+  isListIndexDisabled,
+  stopEvent
+});

package/dist/cjs/utils/composite/useCompositeItem.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCompositeItem_exports = {};
+__export(useCompositeItem_exports, {
+  useCompositeItem: () => useCompositeItem
+});
+module.exports = __toCommonJS(useCompositeItem_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_composeRefs = require("../composeRefs.cjs");
+var import_CompositeRootContext = require("../CompositeRootContext.cjs");
+var import_useCompositeListItem = require("./useCompositeListItem.cjs");
+function useCompositeItem(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useCompositeItem");
+  const params = user[0] ?? {};
+  const { highlightItemOnHover, highlightedIndex, onHighlightedIndexChange } = (0, import_CompositeRootContext.useCompositeRootContext)();
+  const { ref, index } = (0, import_useCompositeListItem.useCompositeListItem)(params, (0, import_internal.subSlot)(slot, "li"));
+  const isHighlighted = highlightedIndex === index;
+  const itemRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "itemRef"));
+  const mergedRef = (0, import_composeRefs.useComposedRefs)(ref, itemRef, (0, import_internal.subSlot)(slot, "merged"));
+  const 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();
+      }
+    }
+  };
+  return {
+    compositeProps,
+    compositeRef: mergedRef,
+    index
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCompositeItem
+});

package/dist/cjs/utils/composite/useCompositeListItem.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCompositeListItem_exports = {};
+__export(useCompositeListItem_exports, {
+  IndexGuessBehavior: () => IndexGuessBehavior,
+  useCompositeListItem: () => useCompositeListItem
+});
+module.exports = __toCommonJS(useCompositeListItem_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_CompositeListContext = require("./CompositeListContext.cjs");
+var IndexGuessBehavior = /* @__PURE__ */ ((IndexGuessBehavior2) => {
+  IndexGuessBehavior2[IndexGuessBehavior2["None"] = 0] = "None";
+  IndexGuessBehavior2[IndexGuessBehavior2["GuessFromOrder"] = 1] = "GuessFromOrder";
+  return IndexGuessBehavior2;
+})(IndexGuessBehavior || {});
+function useCompositeListItem(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useCompositeListItem");
+  const params = user[0] ?? {};
+  const { label, metadata, textRef, indexGuessBehavior, index: externalIndex } = params;
+  const { register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef } = (0, import_CompositeListContext.useCompositeListContext)();
+  const indexRef = (0, import_octane.useRef)(-1, (0, import_internal.subSlot)(slot, "idxRef"));
+  const [index, setIndex] = (0, import_octane.useState)(
+    externalIndex ?? (indexGuessBehavior === 1 /* GuessFromOrder */ ? () => {
+      if (indexRef.current === -1) {
+        const newIndex = nextIndexRef.current;
+        nextIndexRef.current += 1;
+        indexRef.current = newIndex;
+      }
+      return indexRef.current;
+    } : -1),
+    (0, import_internal.subSlot)(slot, "idx")
+  );
+  const componentRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "node"));
+  const ref = (0, import_octane.useCallback)(
+    (node) => {
+      componentRef.current = node;
+      if (index !== -1 && node !== null) {
+        elementsRef.current[index] = node;
+        if (labelsRef) {
+          const isLabelDefined = label !== void 0;
+          labelsRef.current[index] = isLabelDefined ? label : textRef?.current?.textContent ?? node.textContent;
+        }
+      }
+    },
+    [index, elementsRef, labelsRef, label, textRef],
+    (0, import_internal.subSlot)(slot, "ref")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (externalIndex != null) {
+        return void 0;
+      }
+      const node = componentRef.current;
+      if (node) {
+        register(node, metadata);
+        return () => {
+          unregister(node);
+        };
+      }
+      return void 0;
+    },
+    [externalIndex, register, unregister, metadata],
+    (0, import_internal.subSlot)(slot, "e:reg")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (externalIndex != null) {
+        return void 0;
+      }
+      return subscribeMapChange((map) => {
+        const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+        if (i != null) {
+          setIndex(i);
+        }
+      });
+    },
+    [externalIndex, subscribeMapChange, setIndex],
+    (0, import_internal.subSlot)(slot, "e:sub")
+  );
+  return { ref, index };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexGuessBehavior,
+  useCompositeListItem
+});

package/dist/cjs/utils/composite/useCompositeRoot.cjs

@@ -0,0 +1,263 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCompositeRoot_exports = {};
+__export(useCompositeRoot_exports, {
+  useCompositeRoot: () => useCompositeRoot
+});
+module.exports = __toCommonJS(useCompositeRoot_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_composeRefs = require("../composeRefs.cjs");
+var import_keys = require("./keys.cjs");
+var import_list_utils = require("./list-utils.cjs");
+const EMPTY_ARRAY = [];
+function isModifierKeySet(event, ignoredModifierKeys) {
+  for (const key of import_keys.MODIFIER_KEYS.values()) {
+    if (ignoredModifierKeys.includes(key)) {
+      continue;
+    }
+    if (event.getModifierState(key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function useCompositeRoot(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useCompositeRoot");
+  const params = user[0];
+  const {
+    loopFocus = true,
+    orientation = "both",
+    grid,
+    onLoop,
+    direction,
+    highlightedIndex: externalHighlightedIndex,
+    onHighlightedIndexChange: externalSetHighlightedIndex,
+    rootRef: externalRef,
+    enableHomeAndEndKeys = false,
+    stopEventPropagation = false,
+    disabledIndices,
+    modifierKeys = EMPTY_ARRAY
+  } = params;
+  const [internalHighlightedIndex, internalSetHighlightedIndex] = (0, import_octane.useState)(0, (0, import_internal.subSlot)(slot, "hi"));
+  const isGrid = grid != null;
+  const rootRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "root"));
+  const mergedRef = (0, import_composeRefs.useComposedRefs)(rootRef, externalRef, (0, import_internal.subSlot)(slot, "merged"));
+  const elementsRef = (0, import_octane.useRef)([], (0, import_internal.subSlot)(slot, "els"));
+  const hasSetDefaultIndexRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "hasSet"));
+  const highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex;
+  const onHighlightedIndexChange = (0, import_useStableCallback.useStableCallback)(
+    (index, shouldScrollIntoView = false) => {
+      (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index);
+      if (shouldScrollIntoView) {
+        const newActiveItem = elementsRef.current[index];
+        (0, import_keys.scrollIntoViewIfNeeded)(rootRef.current, newActiveItem, direction, orientation);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "ohic")
+  );
+  const onMapChange = (0, import_useStableCallback.useStableCallback)(
+    (map) => {
+      if (map.size === 0 || hasSetDefaultIndexRef.current) {
+        return;
+      }
+      hasSetDefaultIndexRef.current = true;
+      const sortedElements = Array.from(map.keys());
+      const activeItem = sortedElements.find(
+        (compositeElement) => compositeElement?.hasAttribute(import_keys.ACTIVE_COMPOSITE_ITEM)
+      ) ?? null;
+      const activeIndex = activeItem ? sortedElements.indexOf(activeItem) : -1;
+      if (activeIndex !== -1) {
+        onHighlightedIndexChange(activeIndex);
+      } else if ((0, import_list_utils.isListIndexDisabled)(sortedElements, highlightedIndex, disabledIndices)) {
+        const firstEnabledIndex = (0, import_list_utils.findNonDisabledListIndex)(sortedElements, { disabledIndices });
+        if (!(0, import_list_utils.isIndexOutOfListBounds)(sortedElements, firstEnabledIndex)) {
+          onHighlightedIndexChange(firstEnabledIndex);
+        }
+      }
+      (0, import_keys.scrollIntoViewIfNeeded)(rootRef.current, activeItem, direction, orientation);
+    },
+    (0, import_internal.subSlot)(slot, "omc")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (disabledIndices == null || externalHighlightedIndex != null || !hasSetDefaultIndexRef.current) {
+        return;
+      }
+      const elements = elementsRef.current;
+      if ((0, import_list_utils.isListIndexDisabled)(elements, highlightedIndex, disabledIndices)) {
+        const firstEnabledIndex = (0, import_list_utils.findNonDisabledListIndex)(elements, { disabledIndices });
+        if (!(0, import_list_utils.isIndexOutOfListBounds)(elements, firstEnabledIndex)) {
+          onHighlightedIndexChange(firstEnabledIndex);
+        }
+      }
+    },
+    [
+      disabledIndices,
+      externalHighlightedIndex,
+      highlightedIndex,
+      elementsRef,
+      onHighlightedIndexChange
+    ],
+    (0, import_internal.subSlot)(slot, "e:validate")
+  );
+  const onKeyDown = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      const RELEVANT_KEYS = enableHomeAndEndKeys ? import_keys.COMPOSITE_KEYS : import_keys.ARROW_KEYS;
+      if (!RELEVANT_KEYS.has(event.key)) {
+        return;
+      }
+      if (isModifierKeySet(event, modifierKeys)) {
+        return;
+      }
+      const element = rootRef.current;
+      if (!element) {
+        return;
+      }
+      const isRtl = direction === "rtl";
+      const horizontalForwardKey = isRtl ? import_keys.ARROW_LEFT : import_keys.ARROW_RIGHT;
+      const forwardKey = {
+        horizontal: horizontalForwardKey,
+        vertical: import_keys.ARROW_DOWN,
+        both: horizontalForwardKey
+      }[orientation];
+      const horizontalBackwardKey = isRtl ? import_keys.ARROW_RIGHT : import_keys.ARROW_LEFT;
+      const backwardKey = {
+        horizontal: horizontalBackwardKey,
+        vertical: import_keys.ARROW_UP,
+        both: horizontalBackwardKey
+      }[orientation];
+      const target = (0, import_list_utils.getTarget)(event);
+      if (target != null && (0, import_keys.isNativeInput)(target) && !(0, import_keys.isElementDisabled)(target)) {
+        const input = target;
+        const selectionStart = input.selectionStart;
+        const selectionEnd = input.selectionEnd;
+        const textContent = input.value ?? "";
+        if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd) {
+          return;
+        }
+        if (event.key !== backwardKey && selectionStart < textContent.length) {
+          return;
+        }
+        if (event.key !== forwardKey && selectionStart > 0) {
+          return;
+        }
+      }
+      let nextIndex = highlightedIndex;
+      const minIndex = (0, import_list_utils.getMinListIndex)(elementsRef, disabledIndices);
+      const maxIndex = (0, import_list_utils.getMaxListIndex)(elementsRef, disabledIndices);
+      if (grid != null) {
+        nextIndex = grid({
+          disabledIndices,
+          elementsRef,
+          event,
+          highlightedIndex,
+          loopFocus,
+          maxIndex,
+          minIndex,
+          onLoop: (e, prev, next) => onLoop ? onLoop(e, prev, next, elementsRef) : next,
+          orientation,
+          rtl: isRtl
+        });
+      }
+      const forwardKeys = {
+        horizontal: [horizontalForwardKey],
+        vertical: [import_keys.ARROW_DOWN],
+        both: [horizontalForwardKey, import_keys.ARROW_DOWN]
+      }[orientation];
+      const backwardKeys = {
+        horizontal: [horizontalBackwardKey],
+        vertical: [import_keys.ARROW_UP],
+        both: [horizontalBackwardKey, import_keys.ARROW_UP]
+      }[orientation];
+      const preventedKeys = isGrid ? RELEVANT_KEYS : {
+        horizontal: enableHomeAndEndKeys ? import_keys.HORIZONTAL_KEYS_WITH_EXTRA_KEYS : import_keys.HORIZONTAL_KEYS,
+        vertical: enableHomeAndEndKeys ? import_keys.VERTICAL_KEYS_WITH_EXTRA_KEYS : import_keys.VERTICAL_KEYS,
+        both: RELEVANT_KEYS
+      }[orientation];
+      if (enableHomeAndEndKeys) {
+        if (event.key === import_keys.HOME) {
+          nextIndex = minIndex;
+        } else if (event.key === import_keys.END) {
+          nextIndex = maxIndex;
+        }
+      }
+      if (nextIndex === highlightedIndex && (forwardKeys.includes(event.key) || backwardKeys.includes(event.key))) {
+        if (loopFocus && nextIndex === maxIndex && forwardKeys.includes(event.key)) {
+          nextIndex = minIndex;
+          if (onLoop) {
+            nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+          }
+        } else if (loopFocus && nextIndex === minIndex && backwardKeys.includes(event.key)) {
+          nextIndex = maxIndex;
+          if (onLoop) {
+            nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+          }
+        } else {
+          nextIndex = (0, import_list_utils.findNonDisabledListIndex)(elementsRef.current, {
+            startingIndex: nextIndex,
+            decrement: backwardKeys.includes(event.key),
+            disabledIndices
+          });
+        }
+      }
+      if (nextIndex !== highlightedIndex && !(0, import_list_utils.isIndexOutOfListBounds)(elementsRef.current, nextIndex)) {
+        if (stopEventPropagation) {
+          event.stopPropagation();
+        }
+        if (preventedKeys.has(event.key)) {
+          event.preventDefault();
+        }
+        onHighlightedIndexChange(nextIndex, true);
+        queueMicrotask(() => {
+          elementsRef.current[nextIndex]?.focus();
+        });
+      }
+    },
+    (0, import_internal.subSlot)(slot, "okd")
+  );
+  const props = {
+    ref: mergedRef,
+    onFocus(event) {
+      const element = rootRef.current;
+      const target = (0, import_list_utils.getTarget)(event);
+      if (!element || target == null || !(0, import_keys.isNativeInput)(target)) {
+        return;
+      }
+      const input = target;
+      input.setSelectionRange(0, input.value.length ?? 0);
+    },
+    onKeyDown
+  };
+  return {
+    props,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    disabledIndices,
+    onMapChange,
+    relayKeyboardEvent: onKeyDown
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCompositeRoot
+});