@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/floating/useSyncedFloatingRootContext.cjs

@@ -0,0 +1,91 @@
+"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 useSyncedFloatingRootContext_exports = {};
+__export(useSyncedFloatingRootContext_exports, {
+  useSyncedFloatingRootContext: () => useSyncedFloatingRootContext
+});
+module.exports = __toCommonJS(useSyncedFloatingRootContext_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_dom = require("../dom.cjs");
+var import_FloatingRootStore = require("./FloatingRootStore.cjs");
+function useSyncedFloatingRootContext(options, slot) {
+  const {
+    popupStore,
+    treatPopupAsFloatingElement = false,
+    floatingRootContext: floatingRootContextProp,
+    floatingId,
+    nested,
+    onOpenChange
+  } = options;
+  const open = popupStore.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const referenceElement = popupStore.useState("activeTriggerElement", (0, import_internal.subSlot)(slot, "ref"));
+  const floatingElement = popupStore.useState(
+    treatPopupAsFloatingElement ? "popupElement" : "positionerElement",
+    (0, import_internal.subSlot)(slot, "floating")
+  );
+  const triggerElements = popupStore.context.triggerElements;
+  const handleOpenChange = onOpenChange;
+  const internalStoreRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "store"));
+  if (floatingRootContextProp === void 0 && internalStoreRef.current === null) {
+    internalStoreRef.current = new import_FloatingRootStore.FloatingRootStore({
+      open,
+      transitionStatus: void 0,
+      referenceElement,
+      floatingElement,
+      triggerElements,
+      onOpenChange: handleOpenChange,
+      floatingId,
+      syncOnly: true,
+      nested
+    });
+  }
+  const store = floatingRootContextProp ?? internalStoreRef.current;
+  popupStore.useSyncedValue(
+    "floatingId",
+    floatingId,
+    (0, import_internal.subSlot)(slot, "syncId")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      const valuesToSync = {
+        open,
+        floatingId,
+        referenceElement,
+        floatingElement
+      };
+      if ((0, import_dom.isElement)(referenceElement)) {
+        valuesToSync.domReferenceElement = referenceElement;
+      }
+      if (store.state.positionReference === store.state.referenceElement) {
+        valuesToSync.positionReference = referenceElement;
+      }
+      store.update(valuesToSync);
+    },
+    [open, floatingId, referenceElement, floatingElement, store],
+    (0, import_internal.subSlot)(slot, "e:sync")
+  );
+  store.context.onOpenChange = handleOpenChange;
+  store.context.nested = nested;
+  return store;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSyncedFloatingRootContext
+});

package/dist/cjs/utils/floating/useTypeahead.cjs

@@ -0,0 +1,187 @@
+"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 useTypeahead_exports = {};
+__export(useTypeahead_exports, {
+  useTypeahead: () => useTypeahead
+});
+module.exports = __toCommonJS(useTypeahead_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_empty = require("../empty.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_list_utils = require("../composite/list-utils.cjs");
+var import_composite = require("./composite.cjs");
+var import_element = require("./element.cjs");
+function useTypeahead(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useTypeahead");
+  const context = user[0];
+  const props = user[1];
+  const {
+    listRef,
+    elementsRef,
+    activeIndex,
+    onMatch: onMatchProp,
+    disabledIndices,
+    onTyping,
+    enabled = true,
+    resetMs = 750,
+    selectedIndex = null
+  } = props;
+  const store = context && "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const timeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "to"));
+  const stringRef = (0, import_octane.useRef)("", (0, import_internal.subSlot)(slot, "str"));
+  const prevIndexRef = (0, import_octane.useRef)(
+    selectedIndex ?? activeIndex ?? -1,
+    (0, import_internal.subSlot)(slot, "prev")
+  );
+  const matchIndexRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "match"));
+  const onKeyDown = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      function isVisible(index2) {
+        const element = elementsRef?.current[index2];
+        return !element || (0, import_composite.isElementVisible)(element);
+      }
+      function isItemAvailable(index2) {
+        if (!isVisible(index2)) {
+          return false;
+        }
+        return disabledIndices == null || !(0, import_list_utils.isListIndexDisabled)(import_empty.EMPTY_ARRAY, index2, disabledIndices);
+      }
+      function getMatchingIndex(list, string, startIndex2 = 0) {
+        if (list.length === 0) {
+          return -1;
+        }
+        const normalizedStartIndex = (startIndex2 % list.length + list.length) % list.length;
+        const lowerString = string.toLowerCase();
+        for (let offset = 0; offset < list.length; offset += 1) {
+          const index2 = (normalizedStartIndex + offset) % list.length;
+          const text = list[index2];
+          if (!text?.toLowerCase().startsWith(lowerString) || !isItemAvailable(index2)) {
+            continue;
+          }
+          return index2;
+        }
+        return -1;
+      }
+      const listContent = listRef.current;
+      if (stringRef.current.length > 0 && event.key === " ") {
+        (0, import_list_utils.stopEvent)(event);
+        onTyping?.(true);
+      }
+      if (stringRef.current.length > 0 && stringRef.current[0] !== " ") {
+        if (getMatchingIndex(listContent, stringRef.current) === -1 && event.key !== " ") {
+          onTyping?.(false);
+        }
+      }
+      if (listContent == null || // Character key.
+      event.key.length !== 1 || // Modifier key.
+      event.ctrlKey || event.metaKey || event.altKey) {
+        return;
+      }
+      if (open && event.key !== " ") {
+        (0, import_list_utils.stopEvent)(event);
+        onTyping?.(true);
+      }
+      const isNewSession = stringRef.current === "";
+      if (isNewSession) {
+        prevIndexRef.current = selectedIndex ?? activeIndex ?? -1;
+      }
+      const allowRapidSuccessionOfFirstLetter = listContent.every(
+        (text, index2) => text && isItemAvailable(index2) ? text[0]?.toLowerCase() !== text[1]?.toLowerCase() : true
+      );
+      if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {
+        stringRef.current = "";
+        prevIndexRef.current = matchIndexRef.current;
+      }
+      stringRef.current += event.key;
+      timeout.start(resetMs, () => {
+        stringRef.current = "";
+        prevIndexRef.current = matchIndexRef.current;
+        onTyping?.(false);
+      });
+      const prevIndex = isNewSession ? selectedIndex ?? activeIndex ?? -1 : prevIndexRef.current;
+      const startIndex = (prevIndex ?? 0) + 1;
+      const index = getMatchingIndex(listContent, stringRef.current, startIndex);
+      if (index !== -1) {
+        onMatchProp?.(index);
+        matchIndexRef.current = index;
+      } else if (event.key !== " ") {
+        stringRef.current = "";
+        onTyping?.(false);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "okd")
+  );
+  const onBlur = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      const next = event.relatedTarget;
+      const currentDomReferenceElement = store.select("domReferenceElement");
+      const currentFloatingElement = store.select("floatingElement");
+      const withinComposite = (0, import_element.contains)(currentDomReferenceElement, next) || (0, import_element.contains)(currentFloatingElement, next);
+      if (withinComposite) {
+        return;
+      }
+      timeout.clear();
+      stringRef.current = "";
+      prevIndexRef.current = matchIndexRef.current;
+      onTyping?.(false);
+    },
+    (0, import_internal.subSlot)(slot, "ob")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open && selectedIndex !== null) {
+        return;
+      }
+      timeout.clear();
+      matchIndexRef.current = null;
+      if (stringRef.current !== "") {
+        stringRef.current = "";
+      }
+    },
+    [open, selectedIndex, timeout],
+    (0, import_internal.subSlot)(slot, "e:reset")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (open && stringRef.current === "") {
+        prevIndexRef.current = selectedIndex ?? activeIndex ?? -1;
+      }
+    },
+    [open, selectedIndex, activeIndex],
+    (0, import_internal.subSlot)(slot, "e:sync")
+  );
+  const sharedProps = (0, import_octane.useMemo)(
+    () => ({ onKeyDown, onBlur }),
+    [onKeyDown, onBlur],
+    (0, import_internal.subSlot)(slot, "shared")
+  );
+  return (0, import_octane.useMemo)(
+    () => enabled ? { reference: sharedProps, floating: sharedProps } : {},
+    [enabled, sharedProps],
+    (0, import_internal.subSlot)(slot, "out")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useTypeahead
+});

package/dist/cjs/utils/formatNumber.cjs

@@ -0,0 +1,60 @@
+"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 formatNumber_exports = {};
+__export(formatNumber_exports, {
+  cache: () => cache,
+  formatNumber: () => formatNumber,
+  formatNumberValue: () => formatNumberValue,
+  getFormatter: () => getFormatter
+});
+module.exports = __toCommonJS(formatNumber_exports);
+var import_stringifyLocale = require("./stringifyLocale.cjs");
+const cache = /* @__PURE__ */ new Map();
+function getFormatter(locale, options) {
+  const optionsString = JSON.stringify({ locale: (0, import_stringifyLocale.stringifyLocale)(locale), options });
+  const cachedFormatter = cache.get(optionsString);
+  if (cachedFormatter) {
+    return cachedFormatter;
+  }
+  const formatter = new Intl.NumberFormat(locale, options);
+  cache.set(optionsString, formatter);
+  return formatter;
+}
+function formatNumber(value, locale, options) {
+  if (value == null) {
+    return "";
+  }
+  return getFormatter(locale, options).format(value);
+}
+function formatNumberValue(value, locale, format) {
+  if (value == null) {
+    return "";
+  }
+  if (!format) {
+    return formatNumber(value / 100, locale, { style: "percent" });
+  }
+  return formatNumber(value, locale, format);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cache,
+  formatNumber,
+  formatNumberValue,
+  getFormatter
+});

package/dist/cjs/utils/generateId.cjs

@@ -0,0 +1,32 @@
+"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 generateId_exports = {};
+__export(generateId_exports, {
+  generateId: () => generateId
+});
+module.exports = __toCommonJS(generateId_exports);
+let counter = 0;
+function generateId(prefix) {
+  counter += 1;
+  return `${prefix}-${Math.random().toString(36).slice(2, 6)}-${counter}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateId
+});

package/dist/cjs/utils/getCssDimensions.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 getCssDimensions_exports = {};
+__export(getCssDimensions_exports, {
+  getCssDimensions: () => getCssDimensions
+});
+module.exports = __toCommonJS(getCssDimensions_exports);
+var import_dom = require("./dom.cjs");
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = (0, import_dom.isHTMLElement)(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = Math.round(width * 2) / 2 !== offsetWidth || Math.round(height * 2) / 2 !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return { width, height };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCssDimensions
+});

package/dist/cjs/utils/getDefaultFormSubmitter.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 getDefaultFormSubmitter_exports = {};
+__export(getDefaultFormSubmitter_exports, {
+  getDefaultFormSubmitter: () => getDefaultFormSubmitter
+});
+module.exports = __toCommonJS(getDefaultFormSubmitter_exports);
+function getDefaultFormSubmitter(form) {
+  if (!form) {
+    return null;
+  }
+  for (const candidate of Array.from(form.elements)) {
+    const tagName = candidate.tagName;
+    if (tagName === "BUTTON" || tagName === "INPUT") {
+      const button = candidate;
+      if (button.type === "submit") {
+        return button;
+      }
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultFormSubmitter
+});

package/dist/cjs/utils/getDisabledMountTransitionStyles.cjs

@@ -0,0 +1,32 @@
+"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 getDisabledMountTransitionStyles_exports = {};
+__export(getDisabledMountTransitionStyles_exports, {
+  getDisabledMountTransitionStyles: () => getDisabledMountTransitionStyles
+});
+module.exports = __toCommonJS(getDisabledMountTransitionStyles_exports);
+var import_empty = require("./empty.cjs");
+var import_constants = require("./constants.cjs");
+function getDisabledMountTransitionStyles(transitionStatus) {
+  return transitionStatus === "starting" ? import_constants.DISABLED_TRANSITIONS_STYLE : import_empty.EMPTY_OBJECT;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDisabledMountTransitionStyles
+});

package/dist/cjs/utils/getElementRef.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 getElementRef_exports = {};
+__export(getElementRef_exports, {
+  getElementRef: () => getElementRef
+});
+module.exports = __toCommonJS(getElementRef_exports);
+var import_octane = require("octane");
+function getElementRef(element) {
+  if (!(0, import_octane.isValidElement)(element)) {
+    return null;
+  }
+  const props = element.props;
+  return props?.ref ?? null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getElementRef
+});

package/dist/cjs/utils/getPseudoElementBounds.cjs

@@ -0,0 +1,56 @@
+"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 getPseudoElementBounds_exports = {};
+__export(getPseudoElementBounds_exports, {
+  getPseudoElementBounds: () => getPseudoElementBounds
+});
+module.exports = __toCommonJS(getPseudoElementBounds_exports);
+var import_owner = require("./owner.cjs");
+var import_platform = require("./platform.cjs");
+function getPseudoElementBounds(element) {
+  const elementRect = element.getBoundingClientRect();
+  const win = (0, import_owner.ownerWindow)(element);
+  if (import_platform.platform.env.jsdom) {
+    return elementRect;
+  }
+  const beforeStyles = win.getComputedStyle(element, "::before");
+  const afterStyles = win.getComputedStyle(element, "::after");
+  const hasPseudoElements = beforeStyles.content !== "none" || afterStyles.content !== "none";
+  if (!hasPseudoElements) {
+    return elementRect;
+  }
+  const beforeWidth = parseFloat(beforeStyles.width) || 0;
+  const beforeHeight = parseFloat(beforeStyles.height) || 0;
+  const afterWidth = parseFloat(afterStyles.width) || 0;
+  const afterHeight = parseFloat(afterStyles.height) || 0;
+  const totalWidth = Math.max(elementRect.width, beforeWidth, afterWidth);
+  const totalHeight = Math.max(elementRect.height, beforeHeight, afterHeight);
+  const widthDiff = totalWidth - elementRect.width;
+  const heightDiff = totalHeight - elementRect.height;
+  return {
+    left: elementRect.left - widthDiff / 2,
+    right: elementRect.right + widthDiff / 2,
+    top: elementRect.top - heightDiff / 2,
+    bottom: elementRect.bottom + heightDiff / 2
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPseudoElementBounds
+});

package/dist/cjs/utils/getStateAttributesProps.cjs

@@ -0,0 +1,46 @@
+"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 getStateAttributesProps_exports = {};
+__export(getStateAttributesProps_exports, {
+  getStateAttributesProps: () => getStateAttributesProps
+});
+module.exports = __toCommonJS(getStateAttributesProps_exports);
+function getStateAttributesProps(state, customMapping) {
+  const props = {};
+  for (const key in state) {
+    const value = state[key];
+    if (customMapping?.hasOwnProperty(key)) {
+      const customProps = customMapping[key](value);
+      if (customProps != null) {
+        Object.assign(props, customProps);
+      }
+      continue;
+    }
+    if (value === true) {
+      props[`data-${key.toLowerCase()}`] = "";
+    } else if (value) {
+      props[`data-${key.toLowerCase()}`] = value.toString();
+    }
+  }
+  return props;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStateAttributesProps
+});

package/dist/cjs/utils/hideMiddleware.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 hideMiddleware_exports = {};
+__export(hideMiddleware_exports, {
+  hide: () => hide
+});
+module.exports = __toCommonJS(hideMiddleware_exports);
+var import_floating_ui = require("@octanejs/floating-ui");
+const nativeHideFn = (0, import_floating_ui.hide)().fn;
+const hide = {
+  name: "hide",
+  async fn(state) {
+    const { width, height, x, y } = state.rects.reference;
+    const anchorHidden = width === 0 && height === 0 && x === 0 && y === 0;
+    const nativeHideResult = await nativeHideFn(state);
+    return {
+      data: {
+        referenceHidden: nativeHideResult.data?.referenceHidden || anchorHidden
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hide
+});