@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/popups/popupStoreUtils.cjs

@@ -0,0 +1,379 @@
+"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 popupStoreUtils_exports = {};
+__export(popupStoreUtils_exports, {
+  FOCUSABLE_POPUP_PROPS: () => FOCUSABLE_POPUP_PROPS,
+  applyPopupOpenChange: () => applyPopupOpenChange,
+  attachPreventUnmountOnClose: () => attachPreventUnmountOnClose,
+  createDefaultInitialFocus: () => createDefaultInitialFocus,
+  setPopupOpenState: () => setPopupOpenState,
+  useImplicitActiveTrigger: () => useImplicitActiveTrigger,
+  useInitialOpenSync: () => useInitialOpenSync,
+  useOpenStateTransitions: () => useOpenStateTransitions,
+  usePopupInteractionProps: () => usePopupInteractionProps,
+  usePopupRootSync: () => usePopupRootSync,
+  usePopupStore: () => usePopupStore,
+  useTriggerDataForwarding: () => useTriggerDataForwarding,
+  useTriggerRegistration: () => useTriggerRegistration
+});
+module.exports = __toCommonJS(popupStoreUtils_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useOnFirstRender = require("../useOnFirstRender.cjs");
+var import_useTransitionStatus = require("../useTransitionStatus.cjs");
+var import_useOpenChangeComplete = require("../useOpenChangeComplete.cjs");
+var import_empty = require("../empty.cjs");
+var import_constants = require("../floating/constants.cjs");
+var import_FloatingTree = require("../floating/FloatingTree.cjs");
+var import_useSyncedFloatingRootContext = require("../floating/useSyncedFloatingRootContext.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+const FOCUSABLE_POPUP_PROPS = {
+  tabIndex: -1,
+  [import_constants.FOCUSABLE_ATTRIBUTE]: ""
+};
+function createDefaultInitialFocus(popupRef) {
+  return (interactionType) => interactionType === "touch" ? popupRef.current : true;
+}
+function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement, slot) {
+  const floatingId = (0, import_octane.useId)((0, import_internal.subSlot)(slot, "fid"));
+  const nested = (0, import_FloatingTree.useFloatingParentNodeId)() != null;
+  const internalStoreRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "store"));
+  if (externalStore === void 0 && internalStoreRef.current === null) {
+    internalStoreRef.current = createStore(floatingId, nested);
+  }
+  const store = externalStore ?? internalStoreRef.current;
+  (0, import_useSyncedFloatingRootContext.useSyncedFloatingRootContext)(
+    {
+      popupStore: store,
+      treatPopupAsFloatingElement,
+      floatingRootContext: store.state.floatingRootContext,
+      floatingId,
+      nested,
+      onOpenChange: store.setOpen
+    },
+    (0, import_internal.subSlot)(slot, "synced")
+  );
+  return { store, internalStore: internalStoreRef.current };
+}
+function useTriggerRegistration(id, store, slot) {
+  const registeredElementIdRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "rid"));
+  const registeredElementRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "rel"));
+  return (0, import_octane.useCallback)(
+    (element) => {
+      if (id === void 0) {
+        return;
+      }
+      let shouldSyncTriggerCount = false;
+      if (registeredElementIdRef.current !== null) {
+        const registeredId = registeredElementIdRef.current;
+        const registeredElement = registeredElementRef.current;
+        const currentElement = store.context.triggerElements.getById(registeredId);
+        if (registeredElement && currentElement === registeredElement) {
+          store.context.triggerElements.delete(registeredId);
+          shouldSyncTriggerCount = true;
+        }
+        registeredElementIdRef.current = null;
+        registeredElementRef.current = null;
+      }
+      if (element !== null) {
+        registeredElementIdRef.current = id;
+        registeredElementRef.current = element;
+        store.context.triggerElements.add(id, element);
+        shouldSyncTriggerCount = true;
+      }
+      if (shouldSyncTriggerCount) {
+        const triggerCount = store.context.triggerElements.size;
+        if (store.select("open") && store.state.triggerCount !== triggerCount) {
+          store.set("triggerCount", triggerCount);
+        }
+      }
+    },
+    [store, id],
+    (0, import_internal.subSlot)(slot, "cb")
+  );
+}
+function setPopupOpenState(state, open, trigger, preventUnmountOnClose = false) {
+  if (open) {
+    state.preventUnmountingOnClose = false;
+  } else if (preventUnmountOnClose) {
+    state.preventUnmountingOnClose = true;
+  }
+  const triggerId = trigger?.id ?? null;
+  if (triggerId || open) {
+    state.activeTriggerId = triggerId;
+    state.activeTriggerElement = trigger ?? null;
+  }
+}
+function attachPreventUnmountOnClose(eventDetails) {
+  let preventUnmountOnClose = false;
+  eventDetails.preventUnmountOnClose = () => {
+    preventUnmountOnClose = true;
+  };
+  return () => preventUnmountOnClose;
+}
+function applyPopupOpenChange(store, nextOpen, eventDetails, options = {}) {
+  const reason = eventDetails.reason;
+  const isHover = reason === import_createChangeEventDetails.REASONS.triggerHover;
+  const isFocusOpen = nextOpen && reason === import_createChangeEventDetails.REASONS.triggerFocus;
+  const isDismissClose = !nextOpen && (reason === import_createChangeEventDetails.REASONS.triggerPress || reason === import_createChangeEventDetails.REASONS.escapeKey);
+  const shouldPreventUnmountOnClose = attachPreventUnmountOnClose(eventDetails);
+  store.context.onOpenChange?.(nextOpen, eventDetails);
+  if (eventDetails.isCanceled) {
+    return;
+  }
+  options.onBeforeDispatch?.();
+  store.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+  const changeState = () => {
+    const updatedState = { ...options.extraState, open: nextOpen };
+    if (isFocusOpen) {
+      updatedState.instantType = "focus";
+    } else if (isDismissClose) {
+      updatedState.instantType = "dismiss";
+    } else if (isHover) {
+      updatedState.instantType = void 0;
+    }
+    setPopupOpenState(updatedState, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
+    store.update(updatedState);
+  };
+  if (isHover) {
+    (0, import_octane.flushSync)(changeState);
+  } else {
+    changeState();
+  }
+}
+function useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerId, slot) {
+  (0, import_useOnFirstRender.useOnFirstRender)(
+    () => {
+      if (openProp === void 0 && store.state.open === false && defaultOpen) {
+        store.state = {
+          ...store.state,
+          open: true,
+          activeTriggerId: defaultTriggerId,
+          preventUnmountingOnClose: false
+        };
+      }
+    },
+    (0, import_internal.subSlot)(slot, "first")
+  );
+}
+function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates, slot) {
+  const isMountedByThisTrigger = store.useState(
+    "isMountedByTrigger",
+    (0, import_internal.subSlot)(slot, "mbt"),
+    triggerId
+  );
+  const baseRegisterTrigger = useTriggerRegistration(triggerId, store, (0, import_internal.subSlot)(slot, "reg"));
+  const registerTrigger = (0, import_useStableCallback.useStableCallback)(
+    (element) => {
+      baseRegisterTrigger(element);
+      if (!element) {
+        return;
+      }
+      const open = store.select("open");
+      const activeTriggerId = store.select("activeTriggerId");
+      if (activeTriggerId === triggerId) {
+        store.update({
+          activeTriggerElement: element,
+          ...open ? stateUpdates : null
+        });
+        return;
+      }
+      if (activeTriggerId == null && open) {
+        store.update({
+          activeTriggerId: triggerId,
+          activeTriggerElement: element,
+          ...stateUpdates
+        });
+      }
+    },
+    (0, import_internal.subSlot)(slot, "regcb")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (isMountedByThisTrigger) {
+        store.update({
+          activeTriggerElement: triggerElementRef.current,
+          ...stateUpdates
+        });
+      }
+    },
+    [isMountedByThisTrigger, store, triggerElementRef, ...Object.values(stateUpdates)],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return { registerTrigger, isMountedByThisTrigger };
+}
+function useImplicitActiveTrigger(store, options, slot) {
+  const { closeOnActiveTriggerUnmount = false } = options;
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const reactiveTriggerCount = store.useState("triggerCount", (0, import_internal.subSlot)(slot, "tc"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open) {
+        if (store.state.triggerCount !== 0) {
+          store.set("triggerCount", 0);
+        }
+        return;
+      }
+      const triggerCount = store.context.triggerElements.size;
+      const stateUpdates = {};
+      if (store.state.triggerCount !== triggerCount) {
+        stateUpdates.triggerCount = triggerCount;
+      }
+      const activeTriggerId = store.select("activeTriggerId");
+      let lostActiveTriggerId = null;
+      if (activeTriggerId) {
+        const activeTriggerElement = store.context.triggerElements.getById(activeTriggerId);
+        if (!activeTriggerElement) {
+          lostActiveTriggerId = activeTriggerId;
+        } else if (activeTriggerElement !== store.state.activeTriggerElement) {
+          stateUpdates.activeTriggerElement = activeTriggerElement;
+        }
+      }
+      if (!lostActiveTriggerId && !activeTriggerId && triggerCount === 1) {
+        const iteratorResult = store.context.triggerElements.entries().next();
+        if (!iteratorResult.done) {
+          const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
+          stateUpdates.activeTriggerId = implicitTriggerId;
+          stateUpdates.activeTriggerElement = implicitTriggerElement;
+        }
+      }
+      if (stateUpdates.triggerCount !== void 0 || stateUpdates.activeTriggerId !== void 0 || stateUpdates.activeTriggerElement !== void 0) {
+        store.update(stateUpdates);
+      }
+      if (lostActiveTriggerId) {
+        if (closeOnActiveTriggerUnmount) {
+          queueMicrotask(() => {
+            if (store.select("open") && store.select("activeTriggerId") === lostActiveTriggerId && !store.context.triggerElements.getById(lostActiveTriggerId)) {
+              const eventDetails = (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.none);
+              store.setOpen(false, eventDetails);
+              if (!eventDetails.isCanceled) {
+                store.update({
+                  activeTriggerId: null,
+                  activeTriggerElement: null
+                });
+              }
+            }
+          });
+        }
+      }
+    },
+    [open, store, reactiveTriggerCount, closeOnActiveTriggerUnmount],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+}
+function useOpenStateTransitions(open, store, onUnmount, slot) {
+  const { mounted, setMounted, transitionStatus } = (0, import_useTransitionStatus.useTransitionStatus)(
+    open,
+    void 0,
+    void 0,
+    (0, import_internal.subSlot)(slot, "ts")
+  );
+  const preventUnmountingOnClose = store.useState(
+    "preventUnmountingOnClose",
+    (0, import_internal.subSlot)(slot, "puoc")
+  );
+  const syncedPreventUnmountingOnClose = open ? false : preventUnmountingOnClose;
+  store.useSyncedValues(
+    {
+      mounted,
+      transitionStatus,
+      preventUnmountingOnClose: syncedPreventUnmountingOnClose
+    },
+    (0, import_internal.subSlot)(slot, "sync")
+  );
+  const forceUnmount = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      setMounted(false);
+      store.update({
+        activeTriggerId: null,
+        activeTriggerElement: null,
+        mounted: false,
+        preventUnmountingOnClose: false
+      });
+      onUnmount?.();
+      store.context.onOpenChangeComplete?.(false);
+    },
+    (0, import_internal.subSlot)(slot, "fu")
+  );
+  (0, import_useOpenChangeComplete.useOpenChangeComplete)(
+    {
+      enabled: mounted && !open && !syncedPreventUnmountingOnClose,
+      open,
+      ref: store.context.popupRef,
+      onComplete() {
+        if (!open) {
+          forceUnmount();
+        }
+      }
+    },
+    (0, import_internal.subSlot)(slot, "occ")
+  );
+  return { forceUnmount, transitionStatus };
+}
+function usePopupInteractionProps(store, statePart, slot) {
+  store.useSyncedValues(statePart, (0, import_internal.subSlot)(slot, "sync"));
+  (0, import_octane.useLayoutEffect)(
+    () => () => {
+      store.update({
+        activeTriggerProps: import_empty.EMPTY_OBJECT,
+        inactiveTriggerProps: import_empty.EMPTY_OBJECT,
+        popupProps: import_empty.EMPTY_OBJECT
+      });
+    },
+    [store],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+}
+function usePopupRootSync(store, open, slot) {
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open && store.state.openMethod !== null) {
+        store.set("openMethod", null);
+      }
+    },
+    [open, store],
+    (0, import_internal.subSlot)(slot, "e1")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => () => {
+      if (store.state.openMethod !== null) {
+        store.set("openMethod", null);
+      }
+    },
+    [store],
+    (0, import_internal.subSlot)(slot, "e2")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FOCUSABLE_POPUP_PROPS,
+  applyPopupOpenChange,
+  attachPreventUnmountOnClose,
+  createDefaultInitialFocus,
+  setPopupOpenState,
+  useImplicitActiveTrigger,
+  useInitialOpenSync,
+  useOpenStateTransitions,
+  usePopupInteractionProps,
+  usePopupRootSync,
+  usePopupStore,
+  useTriggerDataForwarding,
+  useTriggerRegistration
+});

package/dist/cjs/utils/popups/popupTriggerMap.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 popupTriggerMap_exports = {};
+__export(popupTriggerMap_exports, {
+  PopupTriggerMap: () => PopupTriggerMap
+});
+module.exports = __toCommonJS(popupTriggerMap_exports);
+class PopupTriggerMap {
+  elementsSet;
+  idMap;
+  constructor() {
+    this.elementsSet = /* @__PURE__ */ new Set();
+    this.idMap = /* @__PURE__ */ new Map();
+  }
+  add(id, element) {
+    const existingElement = this.idMap.get(id);
+    if (existingElement === element) {
+      return;
+    }
+    if (existingElement !== void 0) {
+      this.elementsSet.delete(existingElement);
+    }
+    this.elementsSet.add(element);
+    this.idMap.set(id, element);
+  }
+  delete(id) {
+    const element = this.idMap.get(id);
+    if (element) {
+      this.elementsSet.delete(element);
+      this.idMap.delete(id);
+    }
+  }
+  hasElement(element) {
+    return this.elementsSet.has(element);
+  }
+  hasMatchingElement(predicate) {
+    for (const element of this.elementsSet) {
+      if (predicate(element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getById(id) {
+    return this.idMap.get(id);
+  }
+  entries() {
+    return this.idMap.entries();
+  }
+  elements() {
+    return this.elementsSet.values();
+  }
+  get size() {
+    return this.idMap.size;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PopupTriggerMap
+});

package/dist/cjs/utils/popups/store.cjs

@@ -0,0 +1,118 @@
+"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 store_exports = {};
+__export(store_exports, {
+  createInitialPopupStoreState: () => createInitialPopupStoreState,
+  createPopupFloatingRootContext: () => createPopupFloatingRootContext,
+  popupStoreSelectors: () => popupStoreSelectors
+});
+module.exports = __toCommonJS(store_exports);
+var import_createSelector = require("../store/createSelector.cjs");
+var import_empty = require("../empty.cjs");
+var import_FloatingRootStore = require("../floating/FloatingRootStore.cjs");
+var import_getEmptyRootContext = require("../floating/getEmptyRootContext.cjs");
+function createInitialPopupStoreState() {
+  return {
+    open: false,
+    openProp: void 0,
+    mounted: false,
+    transitionStatus: void 0,
+    floatingRootContext: (0, import_getEmptyRootContext.getEmptyRootContext)(),
+    floatingId: void 0,
+    triggerCount: 0,
+    preventUnmountingOnClose: false,
+    payload: void 0,
+    activeTriggerId: null,
+    activeTriggerElement: null,
+    triggerIdProp: void 0,
+    popupElement: null,
+    positionerElement: null,
+    activeTriggerProps: import_empty.EMPTY_OBJECT,
+    inactiveTriggerProps: import_empty.EMPTY_OBJECT,
+    popupProps: import_empty.EMPTY_OBJECT
+  };
+}
+function createPopupFloatingRootContext(triggerElements, floatingId, nested = false) {
+  return new import_FloatingRootStore.FloatingRootStore({
+    open: false,
+    transitionStatus: void 0,
+    floatingElement: null,
+    referenceElement: null,
+    triggerElements,
+    floatingId,
+    syncOnly: true,
+    nested,
+    onOpenChange: void 0
+  });
+}
+const activeTriggerIdSelector = (0, import_createSelector.createSelector)(
+  (state) => state.triggerIdProp ?? state.activeTriggerId
+);
+const openSelector = (0, import_createSelector.createSelector)((state) => state.openProp ?? state.open);
+const popupIdSelector = (0, import_createSelector.createSelector)((state) => {
+  const popupId = state.popupElement?.id ?? state.floatingId;
+  return popupId || void 0;
+});
+function triggerOwnsOpenPopup(state, triggerId) {
+  return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
+}
+function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
+  if (triggerOwnsOpenPopup(state, triggerId)) {
+    return true;
+  }
+  return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) == null && state.triggerCount === 1;
+}
+const popupStoreSelectors = {
+  open: openSelector,
+  mounted: (0, import_createSelector.createSelector)((state) => state.mounted),
+  transitionStatus: (0, import_createSelector.createSelector)((state) => state.transitionStatus),
+  floatingRootContext: (0, import_createSelector.createSelector)((state) => state.floatingRootContext),
+  triggerCount: (0, import_createSelector.createSelector)((state) => state.triggerCount),
+  preventUnmountingOnClose: (0, import_createSelector.createSelector)((state) => state.preventUnmountingOnClose),
+  payload: (0, import_createSelector.createSelector)((state) => state.payload),
+  activeTriggerId: activeTriggerIdSelector,
+  activeTriggerElement: (0, import_createSelector.createSelector)(
+    (state) => state.mounted ? state.activeTriggerElement : null
+  ),
+  popupId: popupIdSelector,
+  isTriggerActive: (0, import_createSelector.createSelector)(
+    (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId
+  ),
+  isOpenedByTrigger: (0, import_createSelector.createSelector)(
+    (state, triggerId) => triggerOwnsOpenPopup(state, triggerId)
+  ),
+  isMountedByTrigger: (0, import_createSelector.createSelector)(
+    (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId && state.mounted
+  ),
+  triggerProps: (0, import_createSelector.createSelector)(
+    (state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps
+  ),
+  triggerPopupId: (0, import_createSelector.createSelector)(
+    (state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : void 0
+  ),
+  popupProps: (0, import_createSelector.createSelector)((state) => state.popupProps),
+  popupElement: (0, import_createSelector.createSelector)((state) => state.popupElement),
+  positionerElement: (0, import_createSelector.createSelector)((state) => state.positionerElement)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInitialPopupStoreState,
+  createPopupFloatingRootContext,
+  popupStoreSelectors
+});

package/dist/cjs/utils/popups/useTriggerFocusGuards.cjs

@@ -0,0 +1,72 @@
+"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 useTriggerFocusGuards_exports = {};
+__export(useTriggerFocusGuards_exports, {
+  useTriggerFocusGuards: () => useTriggerFocusGuards
+});
+module.exports = __toCommonJS(useTriggerFocusGuards_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_element = require("../floating/element.cjs");
+var import_tabbable = require("../floating/tabbable.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+function useTriggerFocusGuards(store, triggerElementRef, slot) {
+  const preFocusGuardRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "pre"));
+  function handlePreFocusGuardFocus(event) {
+    (0, import_octane.flushSync)(() => {
+      store.setOpen(
+        false,
+        (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.focusOut, event, event.currentTarget)
+      );
+    });
+    const previousTabbable = (0, import_tabbable.getTabbableBeforeElement)(
+      preFocusGuardRef.current
+    );
+    previousTabbable?.focus();
+  }
+  function handleFocusTargetFocus(event) {
+    const positionerElement = store.select("positionerElement");
+    if (positionerElement && (0, import_tabbable.isOutsideEvent)(event, positionerElement)) {
+      store.context.beforeContentFocusGuardRef.current?.focus();
+    } else {
+      (0, import_octane.flushSync)(() => {
+        store.setOpen(
+          false,
+          (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.focusOut, event, event.currentTarget)
+        );
+      });
+      let nextTabbable = (0, import_tabbable.getTabbableAfterElement)(
+        store.context.triggerFocusTargetRef.current || triggerElementRef.current
+      );
+      while (nextTabbable !== null && (0, import_element.contains)(positionerElement, nextTabbable)) {
+        const prevTabbable = nextTabbable;
+        nextTabbable = (0, import_tabbable.getNextTabbable)(nextTabbable);
+        if (nextTabbable === prevTabbable) {
+          break;
+        }
+      }
+      nextTabbable?.focus();
+    }
+  }
+  return { preFocusGuardRef, handlePreFocusGuardFocus, handleFocusTargetFocus };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useTriggerFocusGuards
+});

package/dist/cjs/utils/resolveAriaLabelledBy.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 resolveAriaLabelledBy_exports = {};
+__export(resolveAriaLabelledBy_exports, {
+  getDefaultLabelId: () => getDefaultLabelId,
+  resolveAriaLabelledBy: () => resolveAriaLabelledBy
+});
+module.exports = __toCommonJS(resolveAriaLabelledBy_exports);
+function getDefaultLabelId(id) {
+  return id == null ? void 0 : `${id}-label`;
+}
+function resolveAriaLabelledBy(fieldLabelId, localLabelId) {
+  return fieldLabelId ?? localLabelId;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultLabelId,
+  resolveAriaLabelledBy
+});