@fangxinyan/lumina 0.6.18 → 0.7.0

package/dist/{chunk-T2O4DTDE.cjs → chunk-GTFP7HA3.cjs}

@@ -1,13 +1,16 @@
 'use strict';
 
 var chunk35RCCUGO_cjs = require('./chunk-35RCCUGO.cjs');
-var chunkYB3IWIOJ_cjs = require('./chunk-YB3IWIOJ.cjs');
-var chunkVS3I5OKA_cjs = require('./chunk-VS3I5OKA.cjs');
-var chunkSW2HMNCA_cjs = require('./chunk-SW2HMNCA.cjs');
-var chunk4KDABJSY_cjs = require('./chunk-4KDABJSY.cjs');
-require('./tokens-RYJ3DFTU.css');
+var chunkFJB3243S_cjs = require('./chunk-FJB3243S.cjs');
+var chunkSTQDKMS5_cjs = require('./chunk-STQDKMS5.cjs');
+var chunkHSDMJUB6_cjs = require('./chunk-HSDMJUB6.cjs');
+var chunkT4RR6NVU_cjs = require('./chunk-T4RR6NVU.cjs');
+var chunkQNQSNVCU_cjs = require('./chunk-QNQSNVCU.cjs');
+var chunkNRJXZPZR_cjs = require('./chunk-NRJXZPZR.cjs');
+var chunkEE5KXDRK_cjs = require('./chunk-EE5KXDRK.cjs');
+require('./tokens-CEJVVA3G.css');
 require('./shared-NJHRNLRH.css');
-require('./DatePicker-VDVSIARF.css');
+require('./DatePicker-ZSFDXAYD.css');
 var React = require('react');
 var reactDom = require('react-dom');
 var jsxRuntime = require('react/jsx-runtime');
@@ -59,12 +62,13 @@ var parseDateInput = (input) => {
   }
   return date;
 };
-var DatePicker = React__namespace.forwardRef(
+var DatePickerBase = React__namespace.forwardRef(
   ({
     value,
     defaultValue = null,
     onChange,
     format = "YYYY-MM-DD",
+    parse,
     placeholder = "\u8BF7\u9009\u62E9\u65E5\u671F",
     disabled,
     readOnly,
@@ -82,6 +86,12 @@ var DatePicker = React__namespace.forwardRef(
     dropdownClassName = "",
     className = "",
     onKeyDown,
+    id: fieldId,
+    "aria-invalid": ariaInvalid,
+    "aria-describedby": ariaDescribedBy,
+    "aria-labelledby": ariaLabelledBy,
+    "aria-required": ariaRequired,
+    "aria-label": ariaLabel,
     ...rest
   }, ref) => {
     const controlled = value !== void 0;
@@ -116,13 +126,23 @@ var DatePicker = React__namespace.forwardRef(
       setOpen
     });
     const rootRef = React__namespace.useRef(null);
-    const panelRef = React__namespace.useRef(null);
-    const { triggerRef, floatingStyle } = chunkYB3IWIOJ_cjs.useFloating({
+    const panelId = React__namespace.useId();
+    const portalContainer = chunkEE5KXDRK_cjs.usePortalContainer();
+    const portalTheme = chunkNRJXZPZR_cjs.useComponentPortalTheme("DatePicker");
+    const { triggerRef, floatingRef: panelRef, floatingStyle, zIndex: panelZIndex } = chunkFJB3243S_cjs.useFloating({
       open,
       placement,
       panelWidth: 344,
       panelHeight: 404
     });
+    chunkHSDMJUB6_cjs.useOverlayLayer({
+      open: open && !disabled && !readOnly && portalContainer != null,
+      containerRef: panelRef,
+      ownerRef: triggerRef,
+      zIndex: panelZIndex,
+      onEscape: () => setOpen(false),
+      restoreFocus: true
+    });
     const setRootRef = React__namespace.useCallback(
       (node) => {
         rootRef.current = node;
@@ -170,14 +190,9 @@ var DatePicker = React__namespace.forwardRef(
         if (panelRef.current?.contains(target)) return;
         setOpen(false);
       };
-      const onDocKey = (event) => {
-        if (event.key === "Escape") setOpen(false);
-      };
       document.addEventListener("mousedown", onDown);
-      document.addEventListener("keydown", onDocKey);
       return () => {
         document.removeEventListener("mousedown", onDown);
-        document.removeEventListener("keydown", onDocKey);
       };
     }, [open, setOpen]);
     const handleInputChange = (next) => {
@@ -189,12 +204,8 @@ var DatePicker = React__namespace.forwardRef(
         setDraft(formattedCurrent);
         return;
       }
-      if (typeof format === "function") {
-        setDraft(formattedCurrent);
-        return;
-      }
-      const parsed = parseDateInput(draft);
-      if (!parsed || isDisabledDate(parsed)) {
+      const parsed = parse ? parse(draft) : typeof format === "function" ? null : parseDateInput(draft);
+      if (!isValidDate(parsed) || isDisabledDate(parsed)) {
         setDraft(formattedCurrent);
         return;
       }
@@ -224,10 +235,16 @@ var DatePicker = React__namespace.forwardRef(
       invalid && "invalid",
       className
     ].filter(Boolean).join(" ");
-    return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: setRootRef, className: rootClassName, onKeyDown: handleRootKeyDown, ...rest, children: [
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: setRootRef, className: rootClassName, onKeyDown: handleRootKeyDown, ...rest, children: /* @__PURE__ */ jsxRuntime.jsxs(chunkNRJXZPZR_cjs.InternalComponentThemePart, { components: ["Input", "Calendar", "Button"], children: [
       /* @__PURE__ */ jsxRuntime.jsx(
-        chunkVS3I5OKA_cjs.Input,
+        chunkSTQDKMS5_cjs.Input,
         {
+          id: fieldId,
+          "aria-label": ariaLabel,
+          "aria-labelledby": ariaLabelledBy,
+          "aria-invalid": ariaInvalid,
+          "aria-required": ariaRequired,
+          "aria-describedby": ariaDescribedBy,
           value: draft,
           size,
           placeholder,
@@ -241,20 +258,24 @@ var DatePicker = React__namespace.forwardRef(
           onBlur: handleInputBlur,
           inputMode: "numeric",
           "aria-expanded": open,
-          "aria-haspopup": "dialog"
+          "aria-haspopup": "dialog",
+          "aria-controls": open ? panelId : void 0
         }
       ),
-      open && !disabled && !readOnly && typeof document !== "undefined" && reactDom.createPortal(
+      open && !disabled && !readOnly && portalContainer && reactDom.createPortal(
         /* @__PURE__ */ jsxRuntime.jsxs(
           "div",
           {
             ref: panelRef,
+            id: panelId,
             className: `date-picker-panel ${mergedPanelClassName}`,
             role: "dialog",
-            style: floatingStyle,
+            "aria-label": "\u9009\u62E9\u65E5\u671F",
+            ...portalTheme.dataAttributes,
+            style: { ...floatingStyle, ...portalTheme.style, ...portalTheme.styles.popup },
             children: [
               /* @__PURE__ */ jsxRuntime.jsx(
-                chunk4KDABJSY_cjs.Calendar,
+                chunkQNQSNVCU_cjs.Calendar,
                 {
                   value: calendarValue,
                   min: normalizedMin,
@@ -265,7 +286,7 @@ var DatePicker = React__namespace.forwardRef(
               ),
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "date-picker-footer", children: [
                 /* @__PURE__ */ jsxRuntime.jsx(
-                  chunkSW2HMNCA_cjs.Button,
+                  chunkT4RR6NVU_cjs.Button,
                   {
                     size: "sm",
                     variant: "ghost",
@@ -276,7 +297,7 @@ var DatePicker = React__namespace.forwardRef(
                 ),
                 /* @__PURE__ */ jsxRuntime.jsx("span", { className: "date-picker-footer-spacer" }),
                 allowClear && /* @__PURE__ */ jsxRuntime.jsx(
-                  chunkSW2HMNCA_cjs.Button,
+                  chunkT4RR6NVU_cjs.Button,
                   {
                     size: "sm",
                     variant: "ghost",
@@ -284,16 +305,21 @@ var DatePicker = React__namespace.forwardRef(
                     children: "\u6E05\u7A7A"
                   }
                 ),
-                /* @__PURE__ */ jsxRuntime.jsx(chunkSW2HMNCA_cjs.Button, { size: "sm", variant: "primary", onClick: () => setOpen(false), children: "\u786E\u5B9A" })
+                /* @__PURE__ */ jsxRuntime.jsx(chunkT4RR6NVU_cjs.Button, { size: "sm", variant: "primary", onClick: () => setOpen(false), children: "\u786E\u5B9A" })
               ] })
             ]
           }
         ),
-        document.body
+        portalContainer
       )
-    ] });
+    ] }) });
   }
 );
-DatePicker.displayName = "DatePicker";
+DatePickerBase.displayName = "DatePicker";
+var DatePicker = chunkNRJXZPZR_cjs.withComponentTheme(
+  DatePickerBase,
+  "DatePicker",
+  ["date-picker", "calendar", "input", "button"]
+);
 
 exports.DatePicker = DatePicker;

package/dist/chunk-HQFKXTX6.js

@@ -0,0 +1,60 @@
+import { withComponentTheme } from './chunk-DRDDQCDD.js';
+import './tokens-CEJVVA3G.css';
+import './shared-NJHRNLRH.css';
+import './Progress-33WE2NI7.css';
+import * as React from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var ProgressBase = React.forwardRef(({
+  value,
+  max = 100,
+  label,
+  showValue,
+  tone = "accent",
+  color,
+  size = "md",
+  indeterminate = false,
+  className = "",
+  style,
+  ...rest
+}, ref) => {
+  const safeMax = Number.isFinite(max) && max > 0 ? max : 100;
+  const safeValue = Number.isFinite(value) ? value : 0;
+  const normalizedValue = Math.max(0, Math.min(safeMax, safeValue));
+  const pct = normalizedValue / safeMax * 100;
+  const rootStyle = {
+    ...color ? {
+      ["--progress-fill"]: color,
+      ["--progress-fill-glow"]: `color-mix(in oklch, ${color} 35%, transparent)`
+    } : null,
+    ...style
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: `progress ${size} ${tone} ${indeterminate ? "indeterminate" : ""} ${className}`,
+      style: rootStyle,
+      role: "progressbar",
+      "aria-valuemin": 0,
+      "aria-valuemax": safeMax,
+      "aria-valuenow": indeterminate ? void 0 : normalizedValue,
+      "aria-valuetext": indeterminate ? "\u52A0\u8F7D\u4E2D" : void 0,
+      ...rest,
+      children: [
+        (label || showValue) && /* @__PURE__ */ jsxs("div", { className: "progress-label", children: [
+          label ? /* @__PURE__ */ jsx("span", { children: label }) : /* @__PURE__ */ jsx("span", {}),
+          showValue && !indeterminate && /* @__PURE__ */ jsxs("span", { className: "v", children: [
+            Math.round(pct),
+            "%"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "progress-track", children: /* @__PURE__ */ jsx("div", { className: "progress-bar", style: { width: indeterminate ? "35%" : `${pct}%` } }) })
+      ]
+    }
+  );
+});
+ProgressBase.displayName = "Progress";
+var Progress = withComponentTheme(ProgressBase, "Progress", "progress");
+
+export { Progress };

package/dist/chunk-HSDMJUB6.cjs

@@ -0,0 +1,319 @@
+'use strict';
+
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/utils/overlayStack.ts
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+  "[contenteditable='true']"
+].join(",");
+var layers = [];
+var listeningDocuments = /* @__PURE__ */ new Map();
+var scrollLocks = /* @__PURE__ */ new Map();
+var nextOverlayZIndex = 1e3;
+var nextLayerOrder = 0;
+var OverlayZIndexContext = React__namespace.createContext(void 0);
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+function OverlayZIndexProvider({ zIndex, children }) {
+  return React__namespace.createElement(OverlayZIndexContext.Provider, { value: zIndex }, children);
+}
+function useOverlayZIndex(open, explicitZIndex) {
+  const parentZIndex = React__namespace.useContext(OverlayZIndexContext);
+  const allocatedZIndexRef = React__namespace.useRef();
+  const wasOpenRef = React__namespace.useRef(false);
+  const hasValidExplicitZIndex = explicitZIndex != null && Number.isFinite(explicitZIndex);
+  if (hasValidExplicitZIndex) {
+    if (open) nextOverlayZIndex = Math.max(nextOverlayZIndex, explicitZIndex);
+    wasOpenRef.current = open;
+    return explicitZIndex;
+  }
+  if (!open) {
+    wasOpenRef.current = false;
+    return allocatedZIndexRef.current ?? Math.max(nextOverlayZIndex, parentZIndex ?? 0);
+  }
+  const floor = parentZIndex ?? 0;
+  if (!wasOpenRef.current || allocatedZIndexRef.current == null || allocatedZIndexRef.current <= floor) {
+    nextOverlayZIndex = Math.max(nextOverlayZIndex, floor) + 10;
+    allocatedZIndexRef.current = nextOverlayZIndex;
+  }
+  wasOpenRef.current = true;
+  return allocatedZIndexRef.current;
+}
+function isElementVisibleForFocus(element, container) {
+  const view = element.ownerDocument.defaultView;
+  if (!view) return true;
+  const elementStyle = view.getComputedStyle(element);
+  if (elementStyle.visibility === "hidden" || elementStyle.visibility === "collapse") return false;
+  let current = element;
+  while (current) {
+    const style = view.getComputedStyle(current);
+    if (style.display === "none" || style.contentVisibility === "hidden") return false;
+    if (current === container) break;
+    current = current.parentElement;
+  }
+  return true;
+}
+function getFocusableElements(container) {
+  return Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (element) => element.tabIndex >= 0 && element.getAttribute("aria-hidden") !== "true" && !element.hasAttribute("hidden") && !element.closest("[hidden],[inert]") && isElementVisibleForFocus(element, container)
+  );
+}
+function getLayerZIndex(layer) {
+  if (layer.zIndex != null && Number.isFinite(layer.zIndex)) return layer.zIndex;
+  const container = layer.containerRef.current;
+  if (!container) return 0;
+  const inlineValue = container.style.zIndex.trim();
+  const computedValue = inlineValue || container.ownerDocument.defaultView?.getComputedStyle(container).zIndex || "";
+  const parsed = Number.parseFloat(computedValue);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function isOwnedBy(child, parent, documentLayers, visited = /* @__PURE__ */ new Set()) {
+  if (child === parent || visited.has(child.id)) return false;
+  visited.add(child.id);
+  const owner = child.ownerRef?.current;
+  const parentContainer = parent.containerRef.current;
+  if (!owner || !parentContainer) return false;
+  if (parentContainer.contains(owner)) return true;
+  return documentLayers.some(
+    (candidate) => candidate !== child && candidate !== parent && candidate.containerRef.current?.contains(owner) && isOwnedBy(candidate, parent, documentLayers, visited)
+  );
+}
+function isLayerOwnedByElement(layer, owner, documentLayers, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(layer.id)) return false;
+  visited.add(layer.id);
+  const layerOwner = layer.ownerRef?.current;
+  if (!layerOwner) return false;
+  if (layerOwner === owner || owner.contains(layerOwner)) return true;
+  return documentLayers.some((candidate) => {
+    if (candidate === layer || !candidate.containerRef.current?.contains(layerOwner)) return false;
+    return isLayerOwnedByElement(candidate, owner, documentLayers, visited);
+  });
+}
+function isTargetWithinOverlayScope(owner, target) {
+  const NodeConstructor = owner.ownerDocument.defaultView?.Node;
+  if (!target || !NodeConstructor || !(target instanceof NodeConstructor)) return false;
+  if (owner.contains(target)) return true;
+  const documentLayers = layers.filter((layer) => layer.document === owner.ownerDocument);
+  return documentLayers.some(
+    (layer) => !!layer.containerRef.current?.contains(target) && isLayerOwnedByElement(layer, owner, documentLayers)
+  );
+}
+function orderDocumentLayers(documentLayers) {
+  return [...documentLayers].sort((left, right) => {
+    if (isOwnedBy(right, left, documentLayers)) return -1;
+    if (isOwnedBy(left, right, documentLayers)) return 1;
+    const zIndexDelta = getLayerZIndex(left) - getLayerZIndex(right);
+    return zIndexDelta || left.order - right.order;
+  });
+}
+function createFocusScope(trappingLayer, documentLayers) {
+  const container = trappingLayer.containerRef.current;
+  if (!container) return null;
+  const containers = [container];
+  const focusable = getFocusableElements(container);
+  const ownedLayers = orderDocumentLayers(documentLayers).filter((layer) => isOwnedBy(layer, trappingLayer, documentLayers));
+  ownedLayers.forEach((layer) => {
+    const childContainer = layer.containerRef.current;
+    if (!childContainer) return;
+    containers.push(childContainer);
+    const childFocusable = getFocusableElements(childContainer);
+    if (childFocusable.length === 0) return;
+    const owner = layer.ownerRef?.current;
+    const ownerIndex = owner ? focusable.findIndex((element) => element === owner || owner.contains(element) || element.contains(owner)) : -1;
+    focusable.splice(ownerIndex >= 0 ? ownerIndex + 1 : focusable.length, 0, ...childFocusable);
+  });
+  return { containers, focusable: [...new Set(focusable)] };
+}
+function trapTabKey(event, scope) {
+  const { containers, focusable } = scope;
+  const container = containers[0];
+  if (focusable.length === 0) {
+    event.preventDefault();
+    container.focus();
+    return;
+  }
+  const active = container.ownerDocument.activeElement;
+  const activeInsideScope = containers.some((scopeContainer) => scopeContainer.contains(active));
+  const activeIndex = focusable.indexOf(active);
+  if (!activeInsideScope || activeIndex < 0) {
+    event.preventDefault();
+    (event.shiftKey ? focusable[focusable.length - 1] : focusable[0]).focus();
+    return;
+  }
+  const direction = event.shiftKey ? -1 : 1;
+  const nextIndex = (activeIndex + direction + focusable.length) % focusable.length;
+  event.preventDefault();
+  focusable[nextIndex].focus();
+}
+function handleDocumentKeyDown(event) {
+  const documentLayers = layers.filter((layer) => layer.document === event.currentTarget);
+  const orderedLayers = orderDocumentLayers(documentLayers);
+  const top = orderedLayers[orderedLayers.length - 1];
+  if (!top) return;
+  if (event.key === "Escape" && top.onEscape) {
+    event.preventDefault();
+    event.stopPropagation();
+    top.onEscape();
+    return;
+  }
+  if (event.key === "Tab") {
+    const active = top.document.activeElement;
+    const trappingLayer = [...orderedLayers].reverse().find((layer) => {
+      if (!layer.trapFocus) return false;
+      const scope2 = createFocusScope(layer, documentLayers);
+      if (!scope2) return false;
+      const ownsTop = layer === top || isOwnedBy(top, layer, documentLayers);
+      const containsActive = scope2.containers.some((container) => container.contains(active));
+      return ownsTop || containsActive;
+    });
+    const scope = trappingLayer ? createFocusScope(trappingLayer, documentLayers) : null;
+    if (scope) trapTabKey(event, scope);
+  }
+}
+function retainDocumentListener(doc) {
+  const count = listeningDocuments.get(doc) ?? 0;
+  if (count === 0) doc.addEventListener("keydown", handleDocumentKeyDown, true);
+  listeningDocuments.set(doc, count + 1);
+}
+function releaseDocumentListener(doc) {
+  const count = listeningDocuments.get(doc) ?? 0;
+  if (count <= 1) {
+    doc.removeEventListener("keydown", handleDocumentKeyDown, true);
+    listeningDocuments.delete(doc);
+    return;
+  }
+  listeningDocuments.set(doc, count - 1);
+}
+function lockDocumentScroll(doc) {
+  const existing = scrollLocks.get(doc);
+  if (existing) {
+    existing.count += 1;
+    return;
+  }
+  const body = doc.body;
+  const scrollbarWidth = Math.max(0, doc.defaultView.innerWidth - doc.documentElement.clientWidth);
+  const computedPadding = Number.parseFloat(doc.defaultView.getComputedStyle(body).paddingRight) || 0;
+  scrollLocks.set(doc, {
+    count: 1,
+    overflow: body.style.overflow,
+    paddingRight: body.style.paddingRight
+  });
+  body.style.overflow = "hidden";
+  if (scrollbarWidth > 0) body.style.paddingRight = `${computedPadding + scrollbarWidth}px`;
+}
+function unlockDocumentScroll(doc) {
+  const state = scrollLocks.get(doc);
+  if (!state) return;
+  state.count -= 1;
+  if (state.count > 0) return;
+  doc.body.style.overflow = state.overflow;
+  doc.body.style.paddingRight = state.paddingRight;
+  scrollLocks.delete(doc);
+}
+function useOverlayLayer({
+  open,
+  containerRef,
+  ownerRef,
+  zIndex,
+  onEscape,
+  escapeEnabled = true,
+  trapFocus = false,
+  autoFocus = false,
+  restoreFocus = false,
+  lockScroll = false,
+  initialFocusRef
+}) {
+  const idRef = React__namespace.useRef(/* @__PURE__ */ Symbol("lumina-overlay"));
+  const entryRef = React__namespace.useRef(null);
+  const previousFocusRef = React__namespace.useRef(null);
+  const restoreFocusRef = React__namespace.useRef(restoreFocus);
+  restoreFocusRef.current = restoreFocus;
+  if (entryRef.current) {
+    entryRef.current.containerRef = containerRef;
+    entryRef.current.ownerRef = ownerRef;
+    entryRef.current.zIndex = zIndex;
+    entryRef.current.onEscape = escapeEnabled ? onEscape : void 0;
+    entryRef.current.trapFocus = trapFocus;
+  }
+  useIsomorphicLayoutEffect(() => {
+    if (!open || typeof document === "undefined") return;
+    const container = containerRef.current;
+    const doc = container?.ownerDocument ?? document;
+    previousFocusRef.current = doc.activeElement;
+    const entry = {
+      id: idRef.current,
+      containerRef,
+      ownerRef,
+      zIndex,
+      onEscape: escapeEnabled ? onEscape : void 0,
+      trapFocus,
+      document: doc,
+      order: ++nextLayerOrder
+    };
+    entryRef.current = entry;
+    layers.push(entry);
+    retainDocumentListener(doc);
+    const frame = autoFocus ? doc.defaultView?.requestAnimationFrame(() => {
+      const currentContainer = containerRef.current;
+      if (!currentContainer) return;
+      const target = initialFocusRef?.current ?? getFocusableElements(currentContainer)[0] ?? currentContainer;
+      target?.focus();
+    }) : void 0;
+    return () => {
+      if (frame != null) doc.defaultView?.cancelAnimationFrame(frame);
+      const index = layers.findIndex((layer) => layer.id === entry.id);
+      if (index >= 0) layers.splice(index, 1);
+      releaseDocumentListener(doc);
+      const currentEntry = entryRef.current ?? entry;
+      entryRef.current = null;
+      if (restoreFocusRef.current) {
+        const previous = previousFocusRef.current;
+        const owner = currentEntry.ownerRef?.current;
+        const ownerTarget = owner ? owner.tabIndex >= 0 ? owner : getFocusableElements(owner)[0] : void 0;
+        const closingContainer = currentEntry.containerRef.current ?? container;
+        doc.defaultView?.requestAnimationFrame(() => {
+          const active = doc.activeElement;
+          const focusWasReleased = active == null || active === doc.body || active === doc.documentElement || !active.isConnected || closingContainer?.contains(active);
+          const target = ownerTarget?.isConnected ? ownerTarget : previous;
+          if (target?.isConnected && focusWasReleased) target.focus();
+        });
+      }
+    };
+  }, [open]);
+  useIsomorphicLayoutEffect(() => {
+    if (!open || !lockScroll || typeof document === "undefined") return;
+    const doc = containerRef.current?.ownerDocument ?? document;
+    lockDocumentScroll(doc);
+    return () => unlockDocumentScroll(doc);
+  }, [open, lockScroll, containerRef]);
+}
+
+exports.OverlayZIndexProvider = OverlayZIndexProvider;
+exports.isTargetWithinOverlayScope = isTargetWithinOverlayScope;
+exports.useOverlayLayer = useOverlayLayer;
+exports.useOverlayZIndex = useOverlayZIndex;