@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/ToggleGroupContext.cjs

@@ -0,0 +1,40 @@
+"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 ToggleGroupContext_exports = {};
+__export(ToggleGroupContext_exports, {
+  ToggleGroupContext: () => ToggleGroupContext,
+  useToggleGroupContext: () => useToggleGroupContext
+});
+module.exports = __toCommonJS(ToggleGroupContext_exports);
+var import_octane = require("octane");
+const ToggleGroupContext = (0, import_octane.createContext)(void 0);
+function useToggleGroupContext(optional = true) {
+  const context = (0, import_octane.useContext)(ToggleGroupContext);
+  if (context === void 0 && !optional) {
+    throw new Error(
+      "Base UI: ToggleGroupContext is missing. ToggleGroup parts must be placed within <ToggleGroup>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToggleGroupContext,
+  useToggleGroupContext
+});

package/dist/cjs/utils/adaptiveOriginMiddleware.cjs

@@ -0,0 +1,94 @@
+"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 adaptiveOriginMiddleware_exports = {};
+__export(adaptiveOriginMiddleware_exports, {
+  DEFAULT_SIDES: () => DEFAULT_SIDES,
+  adaptiveOrigin: () => adaptiveOrigin
+});
+module.exports = __toCommonJS(adaptiveOriginMiddleware_exports);
+var import_utils = require("@floating-ui/utils");
+var import_owner = require("./owner.cjs");
+const DEFAULT_SIDES = {
+  sideX: "left",
+  sideY: "top"
+};
+const adaptiveOrigin = {
+  name: "adaptiveOrigin",
+  async fn(state) {
+    const {
+      x: rawX,
+      y: rawY,
+      rects: { floating: floatRect },
+      elements: { floating },
+      platform,
+      strategy,
+      placement
+    } = state;
+    const win = (0, import_owner.ownerWindow)(floating);
+    const styles = win.getComputedStyle(floating);
+    const hasTransition = styles.transitionDuration !== "0s" && styles.transitionDuration !== "";
+    if (!hasTransition) {
+      return {
+        x: rawX,
+        y: rawY,
+        data: DEFAULT_SIDES
+      };
+    }
+    const offsetParent = await platform.getOffsetParent?.(floating);
+    let offsetDimensions = { width: 0, height: 0 };
+    if (strategy === "fixed" && win?.visualViewport) {
+      offsetDimensions = {
+        width: win.visualViewport.width,
+        height: win.visualViewport.height
+      };
+    } else if (offsetParent === win) {
+      const doc = (0, import_owner.ownerDocument)(floating);
+      offsetDimensions = {
+        width: doc.documentElement.clientWidth,
+        height: doc.documentElement.clientHeight
+      };
+    } else if (await platform.isElement?.(offsetParent)) {
+      offsetDimensions = await platform.getDimensions(offsetParent);
+    }
+    const currentSide = (0, import_utils.getSide)(placement);
+    let x = rawX;
+    let y = rawY;
+    if (currentSide === "left") {
+      x = offsetDimensions.width - (rawX + floatRect.width);
+    }
+    if (currentSide === "top") {
+      y = offsetDimensions.height - (rawY + floatRect.height);
+    }
+    const sideX = currentSide === "left" ? "right" : DEFAULT_SIDES.sideX;
+    const sideY = currentSide === "top" ? "bottom" : DEFAULT_SIDES.sideY;
+    return {
+      x,
+      y,
+      data: {
+        sideX,
+        sideY
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SIDES,
+  adaptiveOrigin
+});

package/dist/cjs/utils/addEventListener.cjs

@@ -0,0 +1,33 @@
+"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 addEventListener_exports = {};
+__export(addEventListener_exports, {
+  addEventListener: () => addEventListener
+});
+module.exports = __toCommonJS(addEventListener_exports);
+function addEventListener(target, type, listener, options) {
+  target.addEventListener(type, listener, options);
+  return () => {
+    target.removeEventListener(type, listener, options);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addEventListener
+});

package/dist/cjs/utils/areArraysEqual.cjs

@@ -0,0 +1,30 @@
+"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 areArraysEqual_exports = {};
+__export(areArraysEqual_exports, {
+  areArraysEqual: () => areArraysEqual
+});
+module.exports = __toCommonJS(areArraysEqual_exports);
+function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {
+  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  areArraysEqual
+});

package/dist/cjs/utils/clamp.cjs

@@ -0,0 +1,30 @@
+"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 clamp_exports = {};
+__export(clamp_exports, {
+  clamp: () => clamp
+});
+module.exports = __toCommonJS(clamp_exports);
+function clamp(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  return Math.max(min, Math.min(val, max));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clamp
+});

package/dist/cjs/utils/closePart.cjs

@@ -0,0 +1,70 @@
+"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 closePart_exports = {};
+__export(closePart_exports, {
+  ClosePartProvider: () => ClosePartProvider,
+  useClosePartCount: () => useClosePartCount,
+  useClosePartRegistration: () => useClosePartRegistration
+});
+module.exports = __toCommonJS(closePart_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_useStableCallback = require("./useStableCallback.cjs");
+const ClosePartContext = (0, import_octane.createContext)(void 0);
+function useClosePartCount() {
+  const slot = (0, import_internal.S)("useClosePartCount");
+  const [closePartCount, setClosePartCount] = (0, import_octane.useState)(0, (0, import_internal.subSlot)(slot, "count"));
+  const register = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      setClosePartCount((count) => count + 1);
+      return () => {
+        setClosePartCount((count) => Math.max(0, count - 1));
+      };
+    },
+    (0, import_internal.subSlot)(slot, "reg")
+  );
+  const context = (0, import_octane.useMemo)(() => ({ register }), [register], (0, import_internal.subSlot)(slot, "ctx"));
+  return {
+    context,
+    hasClosePart: closePartCount > 0
+  };
+}
+function ClosePartProvider(props) {
+  return (0, import_octane.createElement)(ClosePartContext.Provider, {
+    value: props.value,
+    children: props.children
+  });
+}
+function useClosePartRegistration() {
+  const slot = (0, import_internal.S)("useClosePartRegistration");
+  const context = (0, import_octane.useContext)(ClosePartContext);
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      return context?.register();
+    },
+    [context],
+    (0, import_internal.subSlot)(slot, "eff")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClosePartProvider,
+  useClosePartCount,
+  useClosePartRegistration
+});

package/dist/cjs/utils/collapsibleOpenStateMapping.cjs

@@ -0,0 +1,42 @@
+"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 collapsibleOpenStateMapping_exports = {};
+__export(collapsibleOpenStateMapping_exports, {
+  collapsibleOpenStateMapping: () => collapsibleOpenStateMapping,
+  collapsibleTriggerOpenStateMapping: () => collapsibleTriggerOpenStateMapping
+});
+module.exports = __toCommonJS(collapsibleOpenStateMapping_exports);
+const PANEL_OPEN_HOOK = { "data-open": "" };
+const PANEL_CLOSED_HOOK = { "data-closed": "" };
+const TRIGGER_PANEL_OPEN_HOOK = { "data-panel-open": "" };
+const collapsibleOpenStateMapping = {
+  open(value) {
+    return value ? PANEL_OPEN_HOOK : PANEL_CLOSED_HOOK;
+  }
+};
+const collapsibleTriggerOpenStateMapping = {
+  open(value) {
+    return value ? TRIGGER_PANEL_OPEN_HOOK : null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collapsibleOpenStateMapping,
+  collapsibleTriggerOpenStateMapping
+});

package/dist/cjs/utils/composeRefs.cjs

@@ -0,0 +1,68 @@
+"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 composeRefs_exports = {};
+__export(composeRefs_exports, {
+  composeRefs: () => composeRefs,
+  useComposedRefs: () => useComposedRefs
+});
+module.exports = __toCommonJS(composeRefs_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else 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(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useComposedRefs");
+  const refs = user;
+  return (0, import_octane.useCallback)(composeRefs(...refs), refs, (0, import_internal.subSlot)(slot, "cb"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composeRefs,
+  useComposedRefs
+});

package/dist/cjs/utils/composite/CompositeItem.cjs

@@ -0,0 +1,59 @@
+"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 CompositeItem_exports = {};
+__export(CompositeItem_exports, {
+  CompositeItem: () => CompositeItem
+});
+module.exports = __toCommonJS(CompositeItem_exports);
+var import_internal = require("../../internal.cjs");
+var import_useRenderElement = require("../useRenderElement.cjs");
+var import_useCompositeItem = require("./useCompositeItem.cjs");
+const EMPTY_ARRAY = [];
+const EMPTY_OBJECT = {};
+function CompositeItem(componentProps) {
+  const slot = (0, import_internal.S)("CompositeItem");
+  const {
+    render,
+    className,
+    style,
+    state = EMPTY_OBJECT,
+    props = EMPTY_ARRAY,
+    refs = EMPTY_ARRAY,
+    metadata,
+    stateAttributesMapping,
+    tag = "div",
+    ...elementProps
+  } = componentProps;
+  const { compositeProps, compositeRef } = (0, import_useCompositeItem.useCompositeItem)({ metadata }, (0, import_internal.subSlot)(slot, "item"));
+  return (0, import_useRenderElement.useRenderElement)(
+    tag,
+    { render, className, style },
+    {
+      state,
+      ref: [...refs, compositeRef],
+      props: [compositeProps, ...props, elementProps],
+      stateAttributesMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeItem
+});

package/dist/cjs/utils/composite/CompositeList.cjs

@@ -0,0 +1,177 @@
+"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 CompositeList_exports = {};
+__export(CompositeList_exports, {
+  CompositeList: () => CompositeList
+});
+module.exports = __toCommonJS(CompositeList_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_CompositeListContext = require("./CompositeListContext.cjs");
+function createMap() {
+  return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+  return /* @__PURE__ */ new Set();
+}
+function sortByDocumentPosition(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 CompositeList(props) {
+  const slot = (0, import_internal.S)("CompositeList");
+  const { children, elementsRef, labelsRef, onMapChange: onMapChangeProp } = props;
+  const onMapChange = (0, import_useStableCallback.useStableCallback)(onMapChangeProp, (0, import_internal.subSlot)(slot, "omc"));
+  const nextIndexRef = (0, import_octane.useRef)(0, (0, import_internal.subSlot)(slot, "nextIdx"));
+  const listeners = (0, import_useRefWithInit.useRefWithInit)(
+    createListeners,
+    (0, import_internal.subSlot)(slot, "listeners")
+  ).current;
+  const map = (0, import_useRefWithInit.useRefWithInit)(
+    createMap,
+    (0, import_internal.subSlot)(slot, "map")
+  ).current;
+  const [mapTick, setMapTick] = (0, import_octane.useState)(0, (0, import_internal.subSlot)(slot, "tick"));
+  const lastTickRef = (0, import_octane.useRef)(mapTick, (0, import_internal.subSlot)(slot, "lastTick"));
+  const register = (0, import_useStableCallback.useStableCallback)(
+    (node, metadata) => {
+      map.set(node, metadata ?? null);
+      lastTickRef.current += 1;
+      setMapTick(lastTickRef.current);
+    },
+    (0, import_internal.subSlot)(slot, "reg")
+  );
+  const unregister = (0, import_useStableCallback.useStableCallback)(
+    (node) => {
+      map.delete(node);
+      lastTickRef.current += 1;
+      setMapTick(lastTickRef.current);
+    },
+    (0, import_internal.subSlot)(slot, "unreg")
+  );
+  const sortedMap = (0, import_octane.useMemo)(
+    () => {
+      const newMap = /* @__PURE__ */ new Map();
+      const sortedNodes = Array.from(map.keys()).filter((node) => node.isConnected).sort(sortByDocumentPosition);
+      sortedNodes.forEach((node, index) => {
+        const metadata = map.get(node) ?? {};
+        newMap.set(node, { ...metadata, index });
+      });
+      return newMap;
+    },
+    [map, mapTick],
+    (0, import_internal.subSlot)(slot, "sorted")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (typeof MutationObserver !== "function" || sortedMap.size === 0) {
+        return void 0;
+      }
+      const mutationObserver = new MutationObserver((entries) => {
+        const diff = /* @__PURE__ */ new Set();
+        const updateDiff = (node) => diff.has(node) ? diff.delete(node) : diff.add(node);
+        entries.forEach((entry) => {
+          entry.removedNodes.forEach(updateDiff);
+          entry.addedNodes.forEach(updateDiff);
+        });
+        if (diff.size === 0) {
+          lastTickRef.current += 1;
+          setMapTick(lastTickRef.current);
+        }
+      });
+      sortedMap.forEach((_, node) => {
+        if (node.parentElement) {
+          mutationObserver.observe(node.parentElement, { childList: true });
+        }
+      });
+      return () => {
+        mutationObserver.disconnect();
+      };
+    },
+    [sortedMap],
+    (0, import_internal.subSlot)(slot, "e:mo")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      const shouldUpdateLengths = lastTickRef.current === mapTick;
+      if (shouldUpdateLengths) {
+        if (elementsRef.current.length !== sortedMap.size) {
+          elementsRef.current.length = sortedMap.size;
+        }
+        if (labelsRef && labelsRef.current.length !== sortedMap.size) {
+          labelsRef.current.length = sortedMap.size;
+        }
+        nextIndexRef.current = sortedMap.size;
+      }
+      onMapChange(sortedMap);
+    },
+    [onMapChange, sortedMap, elementsRef, labelsRef, mapTick],
+    (0, import_internal.subSlot)(slot, "e:len")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => () => {
+      elementsRef.current = [];
+    },
+    [elementsRef],
+    (0, import_internal.subSlot)(slot, "e:cleanEl")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => () => {
+      if (labelsRef) {
+        labelsRef.current = [];
+      }
+    },
+    [labelsRef],
+    (0, import_internal.subSlot)(slot, "e:cleanLbl")
+  );
+  const subscribeMapChange = (0, import_useStableCallback.useStableCallback)(
+    (fn) => {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    (0, import_internal.subSlot)(slot, "sub")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      listeners.forEach((l) => l(sortedMap));
+    },
+    [listeners, sortedMap],
+    (0, import_internal.subSlot)(slot, "e:notify")
+  );
+  const contextValue = (0, import_octane.useMemo)(
+    () => ({ register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef }),
+    [register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef],
+    (0, import_internal.subSlot)(slot, "ctx")
+  );
+  return (0, import_octane.createElement)(import_CompositeListContext.CompositeListContext.Provider, { value: contextValue, children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeList
+});