@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/floating/element.cjs

@@ -0,0 +1,103 @@
+"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 element_exports = {};
+__export(element_exports, {
+  activeElement: () => activeElement,
+  contains: () => import_contains.contains,
+  getFloatingFocusElement: () => getFloatingFocusElement,
+  getTarget: () => import_list_utils.getTarget,
+  isEventTargetWithin: () => isEventTargetWithin,
+  isInteractiveElement: () => isInteractiveElement,
+  isRootElement: () => isRootElement,
+  isTargetInsideEnabledTrigger: () => isTargetInsideEnabledTrigger,
+  isTypeableCombobox: () => isTypeableCombobox,
+  isTypeableElement: () => isTypeableElement
+});
+module.exports = __toCommonJS(element_exports);
+var import_dom = require("../dom.cjs");
+var import_constants = require("./constants.cjs");
+var import_contains = require("../contains.cjs");
+var import_list_utils = require("../composite/list-utils.cjs");
+function isTargetInsideEnabledTrigger(target, triggerElements) {
+  if (!(0, import_dom.isElement)(target)) {
+    return false;
+  }
+  const targetElement = target;
+  if (triggerElements.hasElement(targetElement)) {
+    return !targetElement.hasAttribute("data-trigger-disabled");
+  }
+  for (const [, trigger] of triggerElements.entries()) {
+    if ((0, import_contains.contains)(trigger, targetElement)) {
+      return !trigger.hasAttribute("data-trigger-disabled");
+    }
+  }
+  return false;
+}
+function isInteractiveElement(element) {
+  return element?.closest(
+    `button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${import_constants.TYPEABLE_SELECTOR}`
+  ) != null;
+}
+function activeElement(doc) {
+  let element = doc.activeElement;
+  while (element?.shadowRoot?.activeElement != null) {
+    element = element.shadowRoot.activeElement;
+  }
+  return element;
+}
+function isTypeableElement(element) {
+  return (0, import_dom.isHTMLElement)(element) && element.matches(import_constants.TYPEABLE_SELECTOR);
+}
+function isTypeableCombobox(element) {
+  if (!element) {
+    return false;
+  }
+  return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  return floatingElement.hasAttribute(import_constants.FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${import_constants.FOCUSABLE_ATTRIBUTE}]`) ?? floatingElement;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ("composedPath" in event) {
+    return event.composedPath().includes(node);
+  }
+  return event.target != null && node.contains(event.target);
+}
+function isRootElement(element) {
+  return element.matches("html,body");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activeElement,
+  contains,
+  getFloatingFocusElement,
+  getTarget,
+  isEventTargetWithin,
+  isInteractiveElement,
+  isRootElement,
+  isTargetInsideEnabledTrigger,
+  isTypeableCombobox,
+  isTypeableElement
+});

package/dist/cjs/utils/floating/enqueueFocus.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 enqueueFocus_exports = {};
+__export(enqueueFocus_exports, {
+  enqueueFocus: () => enqueueFocus
+});
+module.exports = __toCommonJS(enqueueFocus_exports);
+var import_empty = require("../empty.cjs");
+let rafId = 0;
+function enqueueFocus(el, options = {}) {
+  const { preventScroll = false, sync = false, shouldFocus } = options;
+  cancelAnimationFrame(rafId);
+  function exec() {
+    if (shouldFocus && !shouldFocus()) {
+      return;
+    }
+    el?.focus({ preventScroll });
+  }
+  if (sync) {
+    exec();
+    return import_empty.NOOP;
+  }
+  const currentRafId = requestAnimationFrame(exec);
+  rafId = currentRafId;
+  return () => {
+    if (rafId === currentRafId) {
+      cancelAnimationFrame(currentRafId);
+      rafId = 0;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enqueueFocus
+});

package/dist/cjs/utils/floating/event.cjs

@@ -0,0 +1,65 @@
+"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 event_exports = {};
+__export(event_exports, {
+  isClickLikeEvent: () => isClickLikeEvent,
+  isMouseLikePointerType: () => isMouseLikePointerType,
+  isReactEvent: () => isReactEvent,
+  isVirtualClick: () => isVirtualClick,
+  isVirtualPointerEvent: () => isVirtualPointerEvent
+});
+module.exports = __toCommonJS(event_exports);
+var import_platform = require("../platform.cjs");
+function isClickLikeEvent(event) {
+  const type = event.type;
+  return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
+}
+function isMouseLikePointerType(pointerType, strict) {
+  const values = ["mouse", "pen"];
+  if (!strict) {
+    values.push("", void 0);
+  }
+  return values.includes(pointerType);
+}
+function isReactEvent(event) {
+  return event != null && "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+  if (event.pointerType === "" && event.isTrusted) {
+    return true;
+  }
+  if (import_platform.platform.os.android && event.pointerType) {
+    return event.type === "click" && event.buttons === 1;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  if (import_platform.platform.env.jsdom) {
+    return false;
+  }
+  return !import_platform.platform.os.android && event.width === 0 && event.height === 0 || import_platform.platform.os.android && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isClickLikeEvent,
+  isMouseLikePointerType,
+  isReactEvent,
+  isVirtualClick,
+  isVirtualPointerEvent
+});

package/dist/cjs/utils/floating/getEmptyRootContext.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 getEmptyRootContext_exports = {};
+__export(getEmptyRootContext_exports, {
+  getEmptyRootContext: () => getEmptyRootContext
+});
+module.exports = __toCommonJS(getEmptyRootContext_exports);
+var import_popupTriggerMap = require("../popups/popupTriggerMap.cjs");
+var import_FloatingRootStore = require("./FloatingRootStore.cjs");
+function getEmptyRootContext() {
+  return new import_FloatingRootStore.FloatingRootStore({
+    open: false,
+    transitionStatus: void 0,
+    floatingElement: null,
+    referenceElement: null,
+    triggerElements: new import_popupTriggerMap.PopupTriggerMap(),
+    floatingId: void 0,
+    syncOnly: false,
+    nested: false,
+    onOpenChange: void 0
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEmptyRootContext
+});

package/dist/cjs/utils/floating/gridNavigation.cjs

@@ -0,0 +1,45 @@
+"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 gridNavigation_exports = {};
+__export(gridNavigation_exports, {
+  gridNavigation: () => gridNavigation
+});
+module.exports = __toCommonJS(gridNavigation_exports);
+var import_grid_utils = require("../composite/grid-utils.cjs");
+var import_list_utils = require("../composite/list-utils.cjs");
+function gridNavigation(event, prevIndex, listRef, orientation, loopFocus, rtl, disabledIndices, minIndex, maxIndex, cols = 2) {
+  const nextIndex = (0, import_grid_utils.getGridNavigatedIndex)(listRef.current, {
+    event,
+    orientation,
+    loopFocus,
+    rtl,
+    cols,
+    disabledIndices,
+    minIndex,
+    maxIndex,
+    // An out-of-range previous index falls back to the first enabled item.
+    prevIndex: prevIndex > maxIndex ? minIndex : prevIndex,
+    stopEvent: true
+  });
+  return (0, import_list_utils.isIndexOutOfListBounds)(listRef.current, nextIndex) ? void 0 : nextIndex;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gridNavigation
+});

package/dist/cjs/utils/floating/markOthers.cjs

@@ -0,0 +1,181 @@
+"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 markOthers_exports = {};
+__export(markOthers_exports, {
+  markOthers: () => markOthers
+});
+module.exports = __toCommonJS(markOthers_exports);
+var import_dom = require("@floating-ui/utils/dom");
+var import_owner = require("../owner.cjs");
+const counters = {
+  inert: /* @__PURE__ */ new WeakMap(),
+  "aria-hidden": /* @__PURE__ */ new WeakMap()
+};
+const markerName = "data-base-ui-inert";
+const uncontrolledElementsSets = {
+  inert: /* @__PURE__ */ new WeakSet(),
+  "aria-hidden": /* @__PURE__ */ new WeakSet()
+};
+let markerCounterMap = /* @__PURE__ */ new WeakMap();
+let lockCount = 0;
+function getUncontrolledElementsSet(controlAttribute) {
+  return uncontrolledElementsSets[controlAttribute];
+}
+function unwrapHost(node) {
+  if (!node) {
+    return null;
+  }
+  return (0, import_dom.isShadowRoot)(node) ? node.host : unwrapHost(node.parentNode);
+}
+const correctElements = (parent, targets) => targets.map((target) => {
+  if (parent.contains(target)) {
+    return target;
+  }
+  const correctedTarget = unwrapHost(target);
+  if (correctedTarget && parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  return null;
+}).filter((x) => x != null);
+const buildKeepSet = (targets) => {
+  const keep = /* @__PURE__ */ new Set();
+  targets.forEach((target) => {
+    let node = target;
+    while (node && !keep.has(node)) {
+      keep.add(node);
+      node = node.parentNode;
+    }
+  });
+  return keep;
+};
+const collectOutsideElements = (root, keepElements, stopElements) => {
+  const outside = [];
+  const walk = (parent) => {
+    if (!parent || stopElements.has(parent)) {
+      return;
+    }
+    Array.from(parent.children).forEach((node) => {
+      if ((0, import_dom.getNodeName)(node) === "script") {
+        return;
+      }
+      if (keepElements.has(node)) {
+        walk(node);
+      } else {
+        outside.push(node);
+      }
+    });
+  };
+  walk(root);
+  return outside;
+};
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert, { mark = true }) {
+  let controlAttribute = null;
+  if (inert) {
+    controlAttribute = "inert";
+  } else if (ariaHidden) {
+    controlAttribute = "aria-hidden";
+  }
+  let counterMap = null;
+  let uncontrolledElementsSet = null;
+  const avoidElements = correctElements(body, uncorrectedAvoidElements);
+  const markerTargets = mark ? collectOutsideElements(body, buildKeepSet(avoidElements), new Set(avoidElements)) : [];
+  const hiddenElements = [];
+  const markedElements = [];
+  if (controlAttribute) {
+    const map = counters[controlAttribute];
+    const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
+    uncontrolledElementsSet = currentUncontrolledElementsSet;
+    counterMap = map;
+    const ariaLiveElements = correctElements(
+      body,
+      Array.from(body.querySelectorAll("[aria-live]"))
+    );
+    const controlElements = avoidElements.concat(ariaLiveElements);
+    const controlTargets = collectOutsideElements(
+      body,
+      buildKeepSet(controlElements),
+      new Set(controlElements)
+    );
+    controlTargets.forEach((node) => {
+      const attribute = node.getAttribute(controlAttribute);
+      const alreadyHidden = attribute !== null && attribute !== "false";
+      const counterValue = (map.get(node) || 0) + 1;
+      map.set(node, counterValue);
+      hiddenElements.push(node);
+      if (counterValue === 1 && alreadyHidden) {
+        currentUncontrolledElementsSet.add(node);
+      }
+      if (!alreadyHidden) {
+        node.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+      }
+    });
+  }
+  if (mark) {
+    markerTargets.forEach((node) => {
+      const markerValue = (markerCounterMap.get(node) || 0) + 1;
+      markerCounterMap.set(node, markerValue);
+      markedElements.push(node);
+      if (markerValue === 1) {
+        node.setAttribute(markerName, "");
+      }
+    });
+  }
+  lockCount += 1;
+  return () => {
+    if (counterMap) {
+      hiddenElements.forEach((element) => {
+        const currentCounterValue = counterMap.get(element) || 0;
+        const counterValue = currentCounterValue - 1;
+        counterMap.set(element, counterValue);
+        if (!counterValue) {
+          if (!uncontrolledElementsSet?.has(element) && controlAttribute) {
+            element.removeAttribute(controlAttribute);
+          }
+          uncontrolledElementsSet?.delete(element);
+        }
+      });
+    }
+    if (mark) {
+      markedElements.forEach((element) => {
+        const markerValue = (markerCounterMap.get(element) || 0) - 1;
+        markerCounterMap.set(element, markerValue);
+        if (!markerValue) {
+          element.removeAttribute(markerName);
+        }
+      });
+    }
+    lockCount -= 1;
+    if (!lockCount) {
+      counters.inert = /* @__PURE__ */ new WeakMap();
+      counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
+      uncontrolledElementsSets.inert = /* @__PURE__ */ new WeakSet();
+      uncontrolledElementsSets["aria-hidden"] = /* @__PURE__ */ new WeakSet();
+      markerCounterMap = /* @__PURE__ */ new WeakMap();
+    }
+  };
+}
+function markOthers(avoidElements, options = {}) {
+  const { ariaHidden = false, inert = false, mark = true } = options;
+  const body = (0, import_owner.ownerDocument)(avoidElements[0]).body;
+  return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, { mark });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  markOthers
+});

package/dist/cjs/utils/floating/nodes.cjs

@@ -0,0 +1,48 @@
+"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 nodes_exports = {};
+__export(nodes_exports, {
+  getNodeAncestors: () => getNodeAncestors,
+  getNodeChildren: () => getNodeChildren
+});
+module.exports = __toCommonJS(nodes_exports);
+function getNodeChildren(nodes, id, onlyOpenChildren = true) {
+  const directChildren = nodes.filter((node) => node.parentId === id);
+  return directChildren.flatMap((child) => [
+    ...!onlyOpenChildren || child.context?.open ? [child] : [],
+    ...getNodeChildren(nodes, child.id, onlyOpenChildren)
+  ]);
+}
+function getNodeAncestors(nodes, id) {
+  let allAncestors = [];
+  let currentParentId = nodes.find((node) => node.id === id)?.parentId;
+  while (currentParentId) {
+    const currentNode = nodes.find((node) => node.id === currentParentId);
+    currentParentId = currentNode?.parentId;
+    if (currentNode) {
+      allAncestors = allAncestors.concat(currentNode);
+    }
+  }
+  return allAncestors;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeAncestors,
+  getNodeChildren
+});