@octanejs/radix 0.1.32 → 0.1.34

package/dist/cjs/collection.cjs

@@ -0,0 +1,95 @@
+"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 collection_exports = {};
+__export(collection_exports, {
+  createCollection: () => createCollection
+});
+module.exports = __toCommonJS(collection_exports);
+var import_octane = require("octane");
+var import_compose_refs = require("./compose-refs.cjs");
+var import_context = require("./context.cjs");
+var import_internal = require("./internal.cjs");
+var import_Slot = require("./Slot.cjs");
+const ITEM_DATA_ATTR = "data-radix-collection-item";
+function createCollection(name) {
+  const PROVIDER_NAME = name + "CollectionProvider";
+  const [createCollectionContext, createCollectionScope] = (0, import_context.createContextScope)(PROVIDER_NAME);
+  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME, {
+    collectionRef: { current: null },
+    itemMap: /* @__PURE__ */ new Map()
+  });
+  function CollectionProvider(props) {
+    const slot = (0, import_internal.S)(PROVIDER_NAME);
+    const { scope, children } = props;
+    const ref = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+    const itemMap = (0, import_octane.useRef)(/* @__PURE__ */ new Map(), (0, import_internal.subSlot)(slot, "map")).current;
+    return (0, import_octane.createElement)(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
+  }
+  function CollectionSlot(props) {
+    const slot = (0, import_internal.S)(name + "CollectionSlot");
+    const { scope, children, ref: forwardedRef } = props;
+    const context = useCollectionContext(name + "CollectionSlot", scope);
+    const composedRefs = (0, import_compose_refs.useComposedRefs)(
+      forwardedRef,
+      context.collectionRef,
+      (0, import_internal.subSlot)(slot, "refs")
+    );
+    return (0, import_octane.createElement)(import_Slot.Slot, { ref: composedRefs, children });
+  }
+  function CollectionItemSlot(props) {
+    const slot = (0, import_internal.S)(name + "CollectionItemSlot");
+    const { scope, children, ref: forwardedRef, ...itemData } = props;
+    const ref = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+    const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref, (0, import_internal.subSlot)(slot, "refs"));
+    const context = useCollectionContext(name + "CollectionItemSlot", scope);
+    (0, import_octane.useEffect)(
+      () => {
+        context.itemMap.set(ref, { ref, ...itemData });
+        return () => void context.itemMap.delete(ref);
+      },
+      void 0,
+      (0, import_internal.subSlot)(slot, "e:reg")
+    );
+    return (0, import_octane.createElement)(import_Slot.Slot, { [ITEM_DATA_ATTR]: "", ref: composedRefs, children });
+  }
+  function useCollection(...args) {
+    const [user, slotArg] = (0, import_internal.splitSlot)(args);
+    const scope = user[0];
+    void slotArg;
+    const context = useCollectionContext(name + "CollectionConsumer", scope);
+    return () => {
+      const collectionNode = context.collectionRef.current;
+      if (!collectionNode) return [];
+      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+      const items = Array.from(context.itemMap.values());
+      return items.sort(
+        (a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)
+      );
+    };
+  }
+  return [
+    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
+    useCollection,
+    createCollectionScope
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCollection
+});

package/dist/cjs/compose-event-handlers.cjs

@@ -0,0 +1,35 @@
+"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 compose_event_handlers_exports = {};
+__export(compose_event_handlers_exports, {
+  composeEventHandlers: () => composeEventHandlers
+});
+module.exports = __toCommonJS(compose_event_handlers_exports);
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler?.(event);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composeEventHandlers
+});

package/dist/cjs/compose-refs.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 compose_refs_exports = {};
+__export(compose_refs_exports, {
+  composeRefs: () => composeRefs,
+  useComposedRefs: () => useComposedRefs
+});
+module.exports = __toCommonJS(compose_refs_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/context.cjs

@@ -0,0 +1,96 @@
+"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 context_exports = {};
+__export(context_exports, {
+  createContextScope: () => createContextScope
+});
+module.exports = __toCommonJS(context_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext(rootComponentName, defaultContext) {
+    const BaseContext = (0, import_octane.createContext)(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      const { scope, children, ...context } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = (0, import_octane.useMemo)(() => context, Object.values(context), (0, import_internal.S)(scopeName + ":P" + index));
+      return (0, import_octane.createElement)(Context.Provider, { value, children });
+    }
+    function useContext(consumerName, scope) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = (0, import_octane.useContext)(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+    }
+    return [Provider, useContext];
+  }
+  const createScope = (() => {
+    const scopeContexts = defaultContexts.map(
+      (defaultContext) => (0, import_octane.createContext)(defaultContext)
+    );
+    return function useScope(...args) {
+      const [user, slotArg] = (0, import_internal.splitSlot)(args);
+      const slot = slotArg ?? (0, import_internal.S)(scopeName + ":useScope");
+      const scope = user[0];
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return (0, import_octane.useMemo)(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts],
+        (0, import_internal.subSlot)(slot, "m")
+      );
+    };
+  });
+  createScope.scopeName = scopeName;
+  return [createContext, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = (() => {
+    const scopeHooks = scopes.map((createScope2) => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(...args) {
+      const [user, slotArg] = (0, import_internal.splitSlot)(args);
+      const slot = slotArg ?? (0, import_internal.S)("composed:" + baseScope.scopeName);
+      const overrideScopes = user[0];
+      const nextScopes = scopeHooks.reduce((acc, { useScope, scopeName }, i) => {
+        const scopeProps = useScope(overrideScopes, (0, import_internal.subSlot)(slot, "s" + i));
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return { ...acc, ...currentScope };
+      }, {});
+      return (0, import_octane.useMemo)(
+        () => ({ [`__scope${baseScope.scopeName}`]: nextScopes }),
+        [nextScopes],
+        (0, import_internal.subSlot)(slot, "m")
+      );
+    };
+  });
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContextScope
+});

package/dist/cjs/direction.cjs

@@ -0,0 +1,41 @@
+"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 direction_exports = {};
+__export(direction_exports, {
+  DirectionProvider: () => DirectionProvider,
+  Provider: () => DirectionProvider,
+  useDirection: () => useDirection
+});
+module.exports = __toCommonJS(direction_exports);
+var import_octane = require("octane");
+const DirectionContext = (0, import_octane.createContext)(void 0);
+function DirectionProvider(props) {
+  const { dir, children } = props;
+  return (0, import_octane.createElement)(DirectionContext.Provider, { value: dir, children });
+}
+function useDirection(localDir) {
+  const globalDir = (0, import_octane.useContext)(DirectionContext);
+  return localDir || globalDir || "ltr";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectionProvider,
+  Provider,
+  useDirection
+});

package/dist/cjs/focus-guards.cjs

@@ -0,0 +1,76 @@
+"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 focus_guards_exports = {};
+__export(focus_guards_exports, {
+  FocusGuards: () => FocusGuards,
+  useFocusGuards: () => useFocusGuards
+});
+module.exports = __toCommonJS(focus_guards_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+let count = 0;
+let guards = null;
+function useFocusGuards(...args) {
+  const [, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useFocusGuards");
+  (0, import_octane.useEffect)(
+    () => {
+      if (!guards) {
+        guards = { start: createFocusGuard(), end: createFocusGuard() };
+      }
+      const { start, end } = guards;
+      if (document.body.firstElementChild !== start) {
+        document.body.insertAdjacentElement("afterbegin", start);
+      }
+      if (document.body.lastElementChild !== end) {
+        document.body.insertAdjacentElement("beforeend", end);
+      }
+      count++;
+      return () => {
+        if (count === 1) {
+          guards?.start.remove();
+          guards?.end.remove();
+          guards = null;
+        }
+        count = Math.max(0, count - 1);
+      };
+    },
+    [],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+}
+function FocusGuards(props) {
+  useFocusGuards((0, import_internal.S)("FocusGuards"));
+  return props.children;
+}
+function createFocusGuard() {
+  const element = document.createElement("span");
+  element.setAttribute("data-radix-focus-guard", "");
+  element.tabIndex = 0;
+  element.style.outline = "none";
+  element.style.opacity = "0";
+  element.style.position = "fixed";
+  element.style.pointerEvents = "none";
+  return element;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusGuards,
+  useFocusGuards
+});

package/dist/cjs/index.cjs

@@ -0,0 +1,174 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  AccessibleIcon: () => AccessibleIcon,
+  Accordion: () => Accordion,
+  AlertDialog: () => AlertDialog,
+  Arrow: () => Arrow,
+  AspectRatio: () => AspectRatio,
+  Avatar: () => Avatar,
+  Checkbox: () => Checkbox,
+  Collapsible: () => Collapsible,
+  ContextMenu: () => ContextMenu,
+  Dialog: () => Dialog,
+  Direction: () => Direction,
+  DropdownMenu: () => DropdownMenu,
+  Form: () => Form,
+  HoverCard: () => HoverCard,
+  Label: () => Label,
+  Menu: () => Menu,
+  Menubar: () => Menubar,
+  NavigationMenu: () => NavigationMenu,
+  OneTimePasswordField: () => OneTimePasswordField,
+  PasswordToggleField: () => PasswordToggleField,
+  Popover: () => Popover,
+  Popper: () => Popper,
+  Portal: () => Portal,
+  Presence: () => import_Presence.Presence,
+  Primitive: () => import_Primitive.Primitive,
+  Progress: () => Progress,
+  RadioGroup: () => RadioGroup,
+  RovingFocus: () => RovingFocus,
+  ScrollArea: () => ScrollArea,
+  Select: () => Select,
+  Separator: () => Separator,
+  Slider: () => Slider,
+  Slot: () => import_Slot.Slot,
+  Slottable: () => import_Slot.Slottable,
+  Switch: () => Switch,
+  Tabs: () => Tabs,
+  Toast: () => Toast,
+  Toggle: () => Toggle,
+  ToggleGroup: () => ToggleGroup,
+  Toolbar: () => Toolbar,
+  Tooltip: () => Tooltip,
+  VisuallyHidden: () => VisuallyHidden,
+  composeEventHandlers: () => import_compose_event_handlers.composeEventHandlers,
+  composeRefs: () => import_compose_refs.composeRefs,
+  createContextScope: () => import_context.createContextScope,
+  useComposedRefs: () => import_compose_refs.useComposedRefs,
+  useControllableState: () => import_useControllableState.useControllableState
+});
+module.exports = __toCommonJS(index_exports);
+var import_Slot = require("./Slot.cjs");
+var import_Primitive = require("./Primitive.cjs");
+var import_compose_refs = require("./compose-refs.cjs");
+var import_compose_event_handlers = require("./compose-event-handlers.cjs");
+var import_context = require("./context.cjs");
+var import_useControllableState = require("./useControllableState.cjs");
+var import_Presence = require("./Presence.cjs");
+var Separator = __toESM(require("./Separator.cjs"), 1);
+var Label = __toESM(require("./Label.cjs"), 1);
+var Collapsible = __toESM(require("./Collapsible.cjs"), 1);
+var Accordion = __toESM(require("./Accordion.cjs"), 1);
+var Portal = __toESM(require("./Portal.cjs"), 1);
+var Dialog = __toESM(require("./Dialog.cjs"), 1);
+var AlertDialog = __toESM(require("./AlertDialog.cjs"), 1);
+var Toggle = __toESM(require("./Toggle.cjs"), 1);
+var ToggleGroup = __toESM(require("./ToggleGroup.cjs"), 1);
+var Tabs = __toESM(require("./Tabs.cjs"), 1);
+var RovingFocus = __toESM(require("./RovingFocusGroup.cjs"), 1);
+var AspectRatio = __toESM(require("./AspectRatio.cjs"), 1);
+var VisuallyHidden = __toESM(require("./VisuallyHidden.cjs"), 1);
+var Avatar = __toESM(require("./Avatar.cjs"), 1);
+var Progress = __toESM(require("./Progress.cjs"), 1);
+var Toolbar = __toESM(require("./Toolbar.cjs"), 1);
+var Arrow = __toESM(require("./Arrow.cjs"), 1);
+var Popper = __toESM(require("./Popper.cjs"), 1);
+var Tooltip = __toESM(require("./Tooltip.cjs"), 1);
+var Popover = __toESM(require("./Popover.cjs"), 1);
+var HoverCard = __toESM(require("./HoverCard.cjs"), 1);
+var Menu = __toESM(require("./Menu.cjs"), 1);
+var DropdownMenu = __toESM(require("./DropdownMenu.cjs"), 1);
+var ContextMenu = __toESM(require("./ContextMenu.cjs"), 1);
+var ScrollArea = __toESM(require("./ScrollArea.cjs"), 1);
+var Checkbox = __toESM(require("./Checkbox.cjs"), 1);
+var Switch = __toESM(require("./Switch.cjs"), 1);
+var RadioGroup = __toESM(require("./RadioGroup.cjs"), 1);
+var Slider = __toESM(require("./Slider.cjs"), 1);
+var Form = __toESM(require("./Form.cjs"), 1);
+var Menubar = __toESM(require("./Menubar.cjs"), 1);
+var Select = __toESM(require("./Select.cjs"), 1);
+var NavigationMenu = __toESM(require("./NavigationMenu.cjs"), 1);
+var Toast = __toESM(require("./Toast.cjs"), 1);
+var OneTimePasswordField = __toESM(require("./OneTimePasswordField.cjs"), 1);
+var PasswordToggleField = __toESM(require("./PasswordToggleField.cjs"), 1);
+var AccessibleIcon = __toESM(require("./AccessibleIcon.cjs"), 1);
+var Direction = __toESM(require("./direction.cjs"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessibleIcon,
+  Accordion,
+  AlertDialog,
+  Arrow,
+  AspectRatio,
+  Avatar,
+  Checkbox,
+  Collapsible,
+  ContextMenu,
+  Dialog,
+  Direction,
+  DropdownMenu,
+  Form,
+  HoverCard,
+  Label,
+  Menu,
+  Menubar,
+  NavigationMenu,
+  OneTimePasswordField,
+  PasswordToggleField,
+  Popover,
+  Popper,
+  Portal,
+  Presence,
+  Primitive,
+  Progress,
+  RadioGroup,
+  RovingFocus,
+  ScrollArea,
+  Select,
+  Separator,
+  Slider,
+  Slot,
+  Slottable,
+  Switch,
+  Tabs,
+  Toast,
+  Toggle,
+  ToggleGroup,
+  Toolbar,
+  Tooltip,
+  VisuallyHidden,
+  composeEventHandlers,
+  composeRefs,
+  createContextScope,
+  useComposedRefs,
+  useControllableState
+});

package/dist/cjs/internal.cjs

@@ -0,0 +1,51 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  S: () => S,
+  splitSlot: () => splitSlot,
+  subSlot: () => subSlot
+});
+module.exports = __toCommonJS(internal_exports);
+const subSlotCache = /* @__PURE__ */ new Map();
+function subSlot(slot, tag) {
+  if (slot === void 0) return void 0;
+  let byTag = subSlotCache.get(slot);
+  if (byTag === void 0) subSlotCache.set(slot, byTag = /* @__PURE__ */ new Map());
+  let sym = byTag.get(tag);
+  if (sym === void 0) byTag.set(tag, sym = /* @__PURE__ */ Symbol.for((slot.description ?? "") + ":" + tag));
+  return sym;
+}
+function splitSlot(args) {
+  const tail = args[args.length - 1];
+  const slot = typeof tail === "symbol" ? tail : void 0;
+  return [slot !== void 0 ? args.slice(0, -1) : args, slot];
+}
+const sCache = /* @__PURE__ */ new Map();
+function S(tag) {
+  let sym = sCache.get(tag);
+  if (sym === void 0) sCache.set(tag, sym = /* @__PURE__ */ Symbol.for("@octanejs/radix:" + tag));
+  return sym;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  S,
+  splitSlot,
+  subSlot
+});