@octanejs/base-ui 0.1.31 → 0.1.33

package/dist/cjs/utils/floating/FloatingPortal.cjs

@@ -0,0 +1,230 @@
+"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 FloatingPortal_exports = {};
+__export(FloatingPortal_exports, {
+  FloatingPortal: () => FloatingPortal,
+  useFloatingPortalNode: () => useFloatingPortalNode,
+  usePortalContext: () => usePortalContext
+});
+module.exports = __toCommonJS(FloatingPortal_exports);
+var import_octane = require("octane");
+var import_dom = require("@floating-ui/utils/dom");
+var import_internal = require("../../internal.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_addEventListener = require("../addEventListener.cjs");
+var import_mergeCleanups = require("../mergeCleanups.cjs");
+var import_empty = require("../empty.cjs");
+var import_useRenderElement = require("../useRenderElement.cjs");
+var import_createAttribute = require("./createAttribute.cjs");
+var import_FocusGuard = require("./FocusGuard.cjs");
+var import_tabbable = require("./tabbable.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+const ownerVisuallyHidden = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+};
+const PortalContext = (0, import_octane.createContext)(null);
+const usePortalContext = () => (0, import_octane.useContext)(PortalContext);
+const attr = (0, import_createAttribute.createAttribute)("portal");
+function useFloatingPortalNode(userProps, slot) {
+  const { ref, container: containerProp, componentProps = import_empty.EMPTY_OBJECT, elementProps } = userProps;
+  const uniqueId = (0, import_octane.useId)((0, import_internal.subSlot)(slot, "id"));
+  const portalContext = usePortalContext();
+  const parentPortalNode = portalContext?.portalNode;
+  const [containerElement, setContainerElement] = (0, import_octane.useState)(
+    null,
+    (0, import_internal.subSlot)(slot, "cel")
+  );
+  const [portalNode, setPortalNode] = (0, import_octane.useState)(null, (0, import_internal.subSlot)(slot, "pn"));
+  const setPortalNodeRef = (0, import_useStableCallback.useStableCallback)(
+    (node) => {
+      if (node !== null) {
+        setPortalNode(node);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "pnr")
+  );
+  const containerRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "cref"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (containerProp === null) {
+        if (containerRef.current) {
+          containerRef.current = null;
+          setPortalNode(null);
+          setContainerElement(null);
+        }
+        return;
+      }
+      if (uniqueId == null) {
+        return;
+      }
+      const resolvedContainer = (containerProp && ((0, import_dom.isNode)(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+      if (resolvedContainer == null) {
+        if (containerRef.current) {
+          containerRef.current = null;
+          setPortalNode(null);
+          setContainerElement(null);
+        }
+        return;
+      }
+      if (containerRef.current !== resolvedContainer) {
+        containerRef.current = resolvedContainer;
+        setPortalNode(null);
+        setContainerElement(resolvedContainer);
+      }
+    },
+    [containerProp, parentPortalNode, uniqueId],
+    (0, import_internal.subSlot)(slot, "e:container")
+  );
+  const portalElement = (0, import_useRenderElement.useRenderElement)(
+    "div",
+    componentProps,
+    {
+      ref: [ref, setPortalNodeRef],
+      props: [{ id: uniqueId, [attr]: "" }, elementProps]
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+  const portalSubtree = containerElement && portalElement ? (0, import_octane.createPortal)(portalElement, containerElement) : null;
+  return { portalNode, portalSubtree };
+}
+function FloatingPortal(componentProps) {
+  const slot = (0, import_internal.S)("FloatingPortal");
+  const { render, className, style, children, container, renderGuards, ref, ...elementProps } = componentProps;
+  const { portalNode, portalSubtree } = useFloatingPortalNode(
+    { container, ref, componentProps: { render, className, style }, elementProps },
+    (0, import_internal.subSlot)(slot, "node")
+  );
+  const beforeOutsideRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "bo"));
+  const afterOutsideRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ao"));
+  const beforeInsideRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "bi"));
+  const afterInsideRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ai"));
+  const [focusManagerState, setFocusManagerState] = (0, import_octane.useState)(
+    null,
+    (0, import_internal.subSlot)(slot, "fms")
+  );
+  const focusInsideDisabledRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "fid"));
+  const modal = focusManagerState?.modal;
+  const open = focusManagerState?.open;
+  const shouldRenderGuards = typeof renderGuards === "boolean" ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+  (0, import_octane.useEffect)(
+    () => {
+      if (!portalNode || modal) {
+        return void 0;
+      }
+      function onFocus(event) {
+        if (portalNode && event.relatedTarget && (0, import_tabbable.isOutsideEvent)(event)) {
+          if (event.type === "focusin") {
+            if (focusInsideDisabledRef.current) {
+              (0, import_tabbable.enableFocusInside)(portalNode);
+              focusInsideDisabledRef.current = false;
+            }
+          } else {
+            (0, import_tabbable.disableFocusInside)(portalNode);
+            focusInsideDisabledRef.current = true;
+          }
+        }
+      }
+      return (0, import_mergeCleanups.mergeCleanups)(
+        (0, import_addEventListener.addEventListener)(portalNode, "focusin", onFocus, true),
+        (0, import_addEventListener.addEventListener)(portalNode, "focusout", onFocus, true)
+      );
+    },
+    [portalNode, modal],
+    (0, import_internal.subSlot)(slot, "e:tab")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!portalNode || open !== true || !focusInsideDisabledRef.current) {
+        return;
+      }
+      (0, import_tabbable.enableFocusInside)(portalNode);
+      focusInsideDisabledRef.current = false;
+    },
+    [open, portalNode],
+    (0, import_internal.subSlot)(slot, "e:enable")
+  );
+  const portalContextValue = (0, import_octane.useMemo)(
+    () => ({
+      beforeOutsideRef,
+      afterOutsideRef,
+      beforeInsideRef,
+      afterInsideRef,
+      portalNode,
+      setFocusManagerState
+    }),
+    [portalNode],
+    (0, import_internal.subSlot)(slot, "ctx")
+  );
+  return [
+    (0, import_octane.createElement)(import_octane.Fragment, { key: "portal-subtree", children: portalSubtree }),
+    (0, import_octane.createElement)(PortalContext.Provider, {
+      key: "portal-context",
+      value: portalContextValue,
+      children: [
+        shouldRenderGuards && portalNode ? (0, import_octane.createElement)(import_FocusGuard.FocusGuard, {
+          key: "guard-before",
+          "data-type": "outside",
+          ref: beforeOutsideRef,
+          onFocus(event) {
+            if ((0, import_tabbable.isOutsideEvent)(event, portalNode)) {
+              beforeInsideRef.current?.focus();
+            } else {
+              const domReference = focusManagerState ? focusManagerState.domReference : null;
+              (0, import_tabbable.getPreviousTabbable)(domReference)?.focus();
+            }
+          }
+        }) : null,
+        shouldRenderGuards && portalNode ? (0, import_octane.createElement)("span", {
+          key: "aria-owns",
+          "aria-owns": portalNode.id,
+          style: ownerVisuallyHidden
+        }) : null,
+        portalNode ? (0, import_octane.createElement)(import_octane.Fragment, { key: "portal", children: (0, import_octane.createPortal)(children, portalNode) }) : null,
+        shouldRenderGuards && portalNode ? (0, import_octane.createElement)(import_FocusGuard.FocusGuard, {
+          key: "guard-after",
+          "data-type": "outside",
+          ref: afterOutsideRef,
+          onFocus(event) {
+            if ((0, import_tabbable.isOutsideEvent)(event, portalNode)) {
+              afterInsideRef.current?.focus();
+            } else {
+              const domReference = focusManagerState ? focusManagerState.domReference : null;
+              (0, import_tabbable.getNextTabbable)(domReference)?.focus();
+              if (focusManagerState?.closeOnFocusOut) {
+                focusManagerState?.onOpenChange(
+                  false,
+                  (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.focusOut, event)
+                );
+              }
+            }
+          }
+        }) : null
+      ]
+    })
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingPortal,
+  useFloatingPortalNode,
+  usePortalContext
+});

package/dist/cjs/utils/floating/FloatingRootStore.cjs

@@ -0,0 +1,87 @@
+"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 FloatingRootStore_exports = {};
+__export(FloatingRootStore_exports, {
+  FloatingRootStore: () => FloatingRootStore
+});
+module.exports = __toCommonJS(FloatingRootStore_exports);
+var import_createSelector = require("../store/createSelector.cjs");
+var import_ReactStore = require("../store/ReactStore.cjs");
+var import_createEventEmitter = require("./createEventEmitter.cjs");
+var import_event = require("./event.cjs");
+const selectors = {
+  open: (0, import_createSelector.createSelector)((state) => state.open),
+  transitionStatus: (0, import_createSelector.createSelector)((state) => state.transitionStatus),
+  domReferenceElement: (0, import_createSelector.createSelector)((state) => state.domReferenceElement),
+  referenceElement: (0, import_createSelector.createSelector)(
+    (state) => state.positionReference ?? state.referenceElement
+  ),
+  floatingElement: (0, import_createSelector.createSelector)((state) => state.floatingElement),
+  floatingId: (0, import_createSelector.createSelector)((state) => state.floatingId)
+};
+class FloatingRootStore extends import_ReactStore.ReactStore {
+  syncOnly;
+  constructor(options) {
+    const { syncOnly, nested, onOpenChange, triggerElements, ...initialState } = options;
+    super(
+      {
+        ...initialState,
+        positionReference: initialState.referenceElement,
+        domReferenceElement: initialState.referenceElement
+      },
+      {
+        onOpenChange,
+        dataRef: { current: {} },
+        events: (0, import_createEventEmitter.createEventEmitter)(),
+        nested,
+        triggerElements
+      },
+      selectors
+    );
+    this.syncOnly = syncOnly;
+  }
+  syncOpenEvent = (newOpen, event) => {
+    if (!newOpen || !this.state.open || event != null && (0, import_event.isClickLikeEvent)(event)) {
+      this.context.dataRef.current.openEvent = newOpen ? event : void 0;
+    }
+  };
+  dispatchOpenChange = (newOpen, eventDetails) => {
+    this.syncOpenEvent(newOpen, eventDetails.event);
+    const details = {
+      open: newOpen,
+      reason: eventDetails.reason,
+      nativeEvent: eventDetails.event,
+      nested: this.context.nested,
+      triggerElement: eventDetails.trigger
+    };
+    this.context.events.emit("openchange", details);
+  };
+  setOpen = (newOpen, eventDetails) => {
+    if (this.syncOnly) {
+      this.context.onOpenChange?.(newOpen, eventDetails);
+      return;
+    }
+    this.dispatchOpenChange(newOpen, eventDetails);
+    this.context.onOpenChange?.(newOpen, eventDetails);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingRootStore
+});

package/dist/cjs/utils/floating/FloatingTree.cjs

@@ -0,0 +1,86 @@
+"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 FloatingTree_exports = {};
+__export(FloatingTree_exports, {
+  FloatingNode: () => FloatingNode,
+  FloatingTree: () => FloatingTree,
+  FloatingTreeStore: () => import_FloatingTreeStore.FloatingTreeStore,
+  useFloatingNodeId: () => useFloatingNodeId,
+  useFloatingParentNodeId: () => useFloatingParentNodeId,
+  useFloatingTree: () => useFloatingTree
+});
+module.exports = __toCommonJS(FloatingTree_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useBaseUiId = require("../useBaseUiId.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_octane2 = require("octane");
+var import_FloatingTreeStore = require("./FloatingTreeStore.cjs");
+const FloatingNodeContext = (0, import_octane.createContext)(null);
+const FloatingTreeContext = (0, import_octane.createContext)(null);
+const useFloatingParentNodeId = () => (0, import_octane.useContext)(FloatingNodeContext)?.id || null;
+const useFloatingTree = (externalTree) => {
+  const contextTree = (0, import_octane.useContext)(FloatingTreeContext);
+  return externalTree ?? contextTree;
+};
+function useFloatingNodeId(externalTree, slot) {
+  const id = (0, import_useBaseUiId.useBaseUiId)(void 0, (0, import_internal.subSlot)(slot, "id"));
+  const tree = useFloatingTree(externalTree);
+  const parentId = useFloatingParentNodeId();
+  (0, import_octane2.useLayoutEffect)(
+    () => {
+      if (!id) {
+        return void 0;
+      }
+      const node = { id, parentId };
+      tree?.addNode(node);
+      return () => {
+        tree?.removeNode(node);
+      };
+    },
+    [tree, id, parentId],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return id;
+}
+function FloatingNode(props) {
+  const slot = (0, import_internal.S)("FloatingNode");
+  const { children, id } = props;
+  const parentId = useFloatingParentNodeId();
+  const value = (0, import_octane.useMemo)(() => ({ id, parentId }), [id, parentId], (0, import_internal.subSlot)(slot, "v"));
+  return (0, import_octane.createElement)(FloatingNodeContext.Provider, { value, children });
+}
+function FloatingTree(props) {
+  const slot = (0, import_internal.S)("FloatingTree");
+  const { children, externalTree } = props;
+  const tree = (0, import_useRefWithInit.useRefWithInit)(
+    () => externalTree ?? new import_FloatingTreeStore.FloatingTreeStore(),
+    (0, import_internal.subSlot)(slot, "tree")
+  ).current;
+  return (0, import_octane.createElement)(FloatingTreeContext.Provider, { value: tree, children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingNode,
+  FloatingTree,
+  FloatingTreeStore,
+  useFloatingNodeId,
+  useFloatingParentNodeId,
+  useFloatingTree
+});

package/dist/cjs/utils/floating/FloatingTreeStore.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 FloatingTreeStore_exports = {};
+__export(FloatingTreeStore_exports, {
+  FloatingTreeStore: () => FloatingTreeStore
+});
+module.exports = __toCommonJS(FloatingTreeStore_exports);
+var import_createEventEmitter = require("./createEventEmitter.cjs");
+class FloatingTreeStore {
+  nodesRef = { current: [] };
+  events = (0, import_createEventEmitter.createEventEmitter)();
+  addNode(node) {
+    this.nodesRef.current.push(node);
+  }
+  removeNode(node) {
+    const index = this.nodesRef.current.findIndex((n) => n === node);
+    if (index !== -1) {
+      this.nodesRef.current.splice(index, 1);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingTreeStore
+});

package/dist/cjs/utils/floating/FocusGuard.cjs

@@ -0,0 +1,54 @@
+"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 FocusGuard_exports = {};
+__export(FocusGuard_exports, {
+  FocusGuard: () => FocusGuard
+});
+module.exports = __toCommonJS(FocusGuard_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_platform = require("../platform.cjs");
+var import_visuallyHidden = require("../visuallyHidden.cjs");
+function FocusGuard(props) {
+  const slot = (0, import_internal.S)("FocusGuard");
+  const { ref, ...rest } = props;
+  const [role, setRole] = (0, import_octane.useState)(void 0, (0, import_internal.subSlot)(slot, "role"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (import_platform.platform.screenReader.voiceOver && import_platform.platform.engine.webkit) {
+        setRole("button");
+      }
+    },
+    [],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return (0, import_octane.createElement)("span", {
+    ...rest,
+    ref,
+    style: import_visuallyHidden.visuallyHidden,
+    "aria-hidden": role ? void 0 : true,
+    tabIndex: 0,
+    role,
+    ["data-base-ui-focus-guard"]: ""
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusGuard
+});

package/dist/cjs/utils/floating/composite.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 composite_exports = {};
+__export(composite_exports, {
+  isElementVisible: () => isElementVisible,
+  isHiddenByStyles: () => isHiddenByStyles
+});
+module.exports = __toCommonJS(composite_exports);
+var import_dom = require("@floating-ui/utils/dom");
+function isHiddenByStyles(styles) {
+  return styles.visibility === "hidden" || styles.visibility === "collapse";
+}
+function isElementVisible(element, styles = element ? (0, import_dom.getComputedStyle)(element) : null) {
+  if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
+    return false;
+  }
+  if (typeof element.checkVisibility === "function") {
+    return element.checkVisibility();
+  }
+  return styles.display !== "none" && styles.display !== "contents";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isElementVisible,
+  isHiddenByStyles
+});

package/dist/cjs/utils/floating/constants.cjs

@@ -0,0 +1,34 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  CLICK_TRIGGER_IDENTIFIER: () => CLICK_TRIGGER_IDENTIFIER,
+  FOCUSABLE_ATTRIBUTE: () => FOCUSABLE_ATTRIBUTE,
+  TYPEABLE_SELECTOR: () => TYPEABLE_SELECTOR
+});
+module.exports = __toCommonJS(constants_exports);
+const FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+const CLICK_TRIGGER_IDENTIFIER = "data-base-ui-click-trigger";
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLICK_TRIGGER_IDENTIFIER,
+  FOCUSABLE_ATTRIBUTE,
+  TYPEABLE_SELECTOR
+});

package/dist/cjs/utils/floating/createAttribute.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 createAttribute_exports = {};
+__export(createAttribute_exports, {
+  createAttribute: () => createAttribute
+});
+module.exports = __toCommonJS(createAttribute_exports);
+function createAttribute(name) {
+  return `data-base-ui-${name}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAttribute
+});

package/dist/cjs/utils/floating/createEventEmitter.cjs

@@ -0,0 +1,44 @@
+"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 createEventEmitter_exports = {};
+__export(createEventEmitter_exports, {
+  createEventEmitter: () => createEventEmitter
+});
+module.exports = __toCommonJS(createEventEmitter_exports);
+function createEventEmitter() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    emit(event, data) {
+      map.get(event)?.forEach((listener) => listener(data));
+    },
+    on(event, listener) {
+      if (!map.has(event)) {
+        map.set(event, /* @__PURE__ */ new Set());
+      }
+      map.get(event).add(listener);
+    },
+    off(event, listener) {
+      map.get(event)?.delete(listener);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEventEmitter
+});