@wisdomgarden/torque 0.2.1 → 0.2.3

package/dist/components/overlay-layer/overlay-stack-debug.js

@@ -0,0 +1,151 @@
+"use client";
+const I = "data-torque-overlay-debug", $ = "torqueOverlayStack", k = "torque:overlay-stack-debug", _ = "2147483647", C = "2147483646";
+function A() {
+  try {
+    return JSON.parse(sessionStorage.getItem(k) ?? "");
+  } catch {
+    return { opened: !1 };
+  }
+}
+function m(d) {
+  try {
+    sessionStorage.setItem(k, JSON.stringify(d));
+  } catch {
+  }
+}
+function i(d, l, n) {
+  const r = document.createElement(d);
+  return r.style.cssText = l, n !== void 0 && (r.textContent = n), r;
+}
+function H(d) {
+  if (!d.closable) return "透明";
+  const l = [];
+  return d.closeOnEscape || l.push("吞 Esc"), d.closeOnClickOutside || l.push("点外不关"), l.join(" · ");
+}
+function M({
+  subscribe: d,
+  getSnapshot: l
+}) {
+  let n = null, r = null, v = null, p = { x: 0, y: 0 }, b = /* @__PURE__ */ new Map(), u = null, o = null, f = null, x = 0;
+  const g = () => {
+    x && cancelAnimationFrame(x), x = 0, u = null, o?.remove(), o = null, f = null;
+  }, E = () => {
+    const t = u ? b.get(u) : void 0, e = t?.getElement();
+    if (!t || !e?.isConnected || !o || !f)
+      o && (o.style.display = "none");
+    else {
+      const a = e.getBoundingClientRect();
+      o.style.display = "block", o.style.left = `${a.left}px`, o.style.top = `${a.top}px`, o.style.width = `${a.width}px`, o.style.height = `${a.height}px`, f.textContent = `${t.name ?? t.id} · ${t.zIndex}`;
+    }
+    x = requestAnimationFrame(E);
+  }, O = (t) => {
+    u !== t && (u = t, o || (o = i(
+      "div",
+      `position:fixed;z-index:${C};pointer-events:none;box-sizing:border-box;border:2px solid var(--t-brand-1,#00a1b0);background:rgba(0,161,176,.12);border-radius:4px;`
+    ), o.setAttribute(I, ""), o.setAttribute("aria-hidden", "true"), f = i(
+      "span",
+      "position:absolute;left:-2px;bottom:100%;padding:1px 6px;white-space:nowrap;border-radius:4px 4px 0 0;background:var(--t-brand-1,#00a1b0);color:#fff;font:12px/18px system-ui,sans-serif;"
+    ), o.append(f), document.body.append(o)), x || E());
+  }, y = (t, e) => {
+    if (!n) return;
+    const a = Math.max(8, window.innerWidth - n.offsetWidth - 8), s = Math.max(8, window.innerHeight - n.offsetHeight - 8);
+    p = {
+      x: Math.min(Math.max(8, t), a),
+      y: Math.min(Math.max(8, e), s)
+    }, n.style.left = `${p.x}px`, n.style.top = `${p.y}px`;
+  }, w = () => {
+    if (!r) return;
+    const t = [...l()].reverse();
+    if (b = new Map(t.map((e) => [e.id, e])), u && !b.has(u) && g(), r.replaceChildren(), t.length === 0) {
+      r.append(
+        i(
+          "div",
+          "color:var(--t-text-3,#999);padding:4px 0;",
+          "没有打开的浮层"
+        )
+      );
+      return;
+    }
+    t.forEach((e, a) => {
+      const s = i(
+        "div",
+        "display:grid;grid-template-columns:20px 1fr auto;gap:8px;align-items:baseline;padding:3px 0;border-top:1px solid var(--t-line-5,#eee);"
+      );
+      s.dataset.overlayId = e.id, e.getElement() && (s.style.cursor = "crosshair"), s.append(
+        i("span", "color:var(--t-text-3,#999);", String(t.length - a)),
+        i(
+          "span",
+          "min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--t-text-1,#141414);",
+          e.name ?? e.id
+        ),
+        i(
+          "span",
+          "font-variant-numeric:tabular-nums;color:var(--t-text-1,#141414);font-weight:500;",
+          String(e.zIndex)
+        )
+      );
+      const c = H(e);
+      c && s.append(
+        i("span", ""),
+        i(
+          "span",
+          "grid-column:span 2;color:var(--t-text-3,#999);font-size:11px;",
+          c
+        )
+      ), r?.append(s);
+    });
+  }, G = (t) => {
+    if (!n || t.button !== 0) return;
+    const e = t.currentTarget, a = t.clientX - p.x, s = t.clientY - p.y;
+    e.setPointerCapture?.(t.pointerId);
+    const c = (D) => y(D.clientX - a, D.clientY - s), h = () => {
+      e.removeEventListener("pointermove", c), e.removeEventListener("pointerup", h), e.removeEventListener("pointercancel", h), m({ opened: !0, ...p });
+    };
+    e.addEventListener("pointermove", c), e.addEventListener("pointerup", h), e.addEventListener("pointercancel", h), t.preventDefault();
+  }, S = () => {
+    if (n || typeof document > "u" || !document.body) return;
+    n = i(
+      "div",
+      `position:fixed;z-index:${_};width:280px;max-height:60vh;display:flex;flex-direction:column;background:var(--t-fill-8,#fff);color:var(--t-text-1,#141414);border:1px solid var(--t-line-4,#ddd);border-radius:8px;box-shadow:var(--t-shadow-2,0 4px 16px rgba(0,0,0,.15));font:12px/18px system-ui,sans-serif;`
+    ), n.setAttribute(I, ""), n.setAttribute("role", "complementary"), n.setAttribute("aria-label", "Overlay stack debugger");
+    const t = i(
+      "div",
+      "display:flex;align-items:center;gap:8px;padding:8px 10px;cursor:move;user-select:none;touch-action:none;border-bottom:1px solid var(--t-line-5,#eee);font-weight:500;"
+    );
+    t.append(i("span", "flex:1;", "层级栈（栈顶 → 栈底）"));
+    const e = i(
+      "button",
+      "border:0;background:none;cursor:pointer;color:var(--t-text-2,#666);font-size:16px;line-height:1;padding:0 2px;",
+      "×"
+    );
+    e.type = "button", e.setAttribute("aria-label", "Close overlay stack debugger"), e.addEventListener("pointerdown", (s) => s.stopPropagation()), e.addEventListener("click", () => L()), t.append(e), t.addEventListener("pointerdown", G), r = i("div", "overflow:auto;padding:4px 10px 8px;"), r.addEventListener("mouseover", (s) => {
+      const c = s.target.closest(
+        "[data-overlay-id]"
+      );
+      c?.dataset.overlayId ? O(c.dataset.overlayId) : g();
+    }), r.addEventListener("mouseleave", g), n.append(t, r), document.body.append(n);
+    const a = A();
+    y(
+      a.x ?? window.innerWidth - n.offsetWidth - 16,
+      a.y ?? 16
+    ), m({ opened: !0, ...p }), v = d(w), w();
+  }, L = () => {
+    g(), v?.(), v = null, n?.remove(), n = null, r = null, m({ opened: !1, ...p });
+  };
+  return { open: S, close: L };
+}
+function T(d) {
+  if (typeof window > "u") return;
+  const l = M(d);
+  Object.defineProperty(window, $, {
+    value: l,
+    configurable: !0,
+    writable: !0
+  }), A().opened && window.setTimeout(l.open, 0);
+}
+export {
+  I as OVERLAY_DEBUG_ATTRIBUTE,
+  $ as OVERLAY_DEBUG_GLOBAL,
+  M as createOverlayStackDebug,
+  T as installOverlayStackDebug
+};

package/dist/components/overlay-layer/overlay-stack.d.ts

@@ -0,0 +1,38 @@
+import type { OverlayCloseReason } from './types';
+/** 每次渲染都会刷新的部分，栈里按引用读最新值，不因为它们变化而重新登记。 */
+export interface OverlayHandlers {
+    close?: (reason: OverlayCloseReason) => void;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    getElement: () => HTMLElement | null;
+    getInsideElements: () => Array<HTMLElement | null>;
+    name?: string;
+}
+export interface OverlayRegistration {
+    id: string;
+    /** 外面包着的浮层 id，从外到内 */
+    ancestors: readonly string[];
+    explicitZIndex: number | undefined;
+    tier: number;
+    handlersRef: {
+        readonly current: OverlayHandlers;
+    };
+}
+/**
+ * 按最终数值归档：小于 10000 是普通层，10000 以上按千位分档。
+ * 所以直接传 `zIndex={15002}` 的引导气泡归 15000 档，不会把普通层顶高。
+ */
+export declare function toTierBucket(zIndex: number): number;
+export declare function warnIfInvalidTier(tier: number): void;
+/**
+ * 登记一个打开的浮层，返回只清理本次登记的注销函数。
+ *
+ * 新条目按"它下面的层"算层级；排在它后面的条目（同一次提交里先登记的子层）
+ * 重新计算，这样父子一起打开时子层仍在父层之上。
+ */
+export declare function registerOverlay(registration: OverlayRegistration): () => void;
+export declare function subscribeOverlayStack(listener: () => void): () => void;
+export declare function getOverlayZIndex(id: string): number | undefined;
+export declare function forgetOverlay(id: string): void;
+/** 仅供测试：当前栈里的条目数 */
+export declare function getOverlayStackSize(): number;

package/dist/components/overlay-layer/overlay-stack.js

@@ -0,0 +1,137 @@
+"use client";
+import { isDev as g } from "../../common/is-dev.js";
+import { OVERLAY_TIER_NOTIFICATION as E, OVERLAY_TOP_MIN as c, OVERLAY_TOP_MAX as f, OVERLAY_BASE as m } from "./constants.js";
+import { OVERLAY_DEBUG_ATTRIBUTE as x, installOverlayStackDebug as w } from "./overlay-stack-debug.js";
+const i = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Set();
+let k = 0;
+function u(e) {
+  return e < c ? m : Math.floor(e / 1e3) * 1e3;
+}
+function z(e) {
+  if (e === E) {
+    console.warn(
+      `[@wisdomgarden/torque] overlay tier ${e} is reserved for notifications. Pick another multiple of 1000 in [${c}, ${f}).`
+    );
+    return;
+  }
+  e === m || e >= c && e < f && e % 1e3 === 0 || console.warn(
+    `[@wisdomgarden/torque] overlay tier ${e} is invalid. Use OVERLAY_BASE (${m}) or a multiple of 1000 in [${c}, ${f}) other than ${E}.`
+  );
+}
+function d() {
+  const e = Array.from(i.values()), t = /* @__PURE__ */ new Map();
+  for (const n of e) {
+    let r = n.seq;
+    for (const o of e)
+      o.ancestors.includes(n.id) && (r = Math.min(r, o.seq));
+    t.set(n.id, r);
+  }
+  return e.sort(
+    (n, r) => t.get(n.id) - t.get(r.id) || n.ancestors.length - r.ancestors.length || n.seq - r.seq
+  );
+}
+function A(e, t) {
+  if (e.explicitZIndex !== void 0) return e.explicitZIndex;
+  const n = u(e.tier);
+  let r = -1 / 0;
+  for (const s of t)
+    s.bucket === n && (r = Math.max(r, s.zIndex));
+  const o = Math.max(e.tier, r + 1);
+  return g() && u(o) !== n && console.warn(
+    `[@wisdomgarden/torque] overlay "${e.handlersRef.current.name ?? e.id}" resolved z-index ${o}, which overflows its tier ${e.tier}. Too many overlays are open at once in this tier.`
+  ), o;
+}
+function O() {
+  h.forEach((e) => e());
+}
+function L() {
+  return d().map((e) => {
+    const t = e.handlersRef.current;
+    return {
+      id: e.id,
+      name: t.name,
+      zIndex: e.zIndex,
+      tierBucket: e.bucket,
+      closable: !!t.close,
+      closeOnEscape: t.closeOnEscape,
+      closeOnClickOutside: t.closeOnClickOutside,
+      getElement: t.getElement
+    };
+  });
+}
+function v(e) {
+  return e.composedPath().some(
+    (t) => t instanceof Element && t.hasAttribute(x)
+  );
+}
+function I(e) {
+  if (e.key !== "Escape" || e.isComposing || v(e)) return;
+  const t = e.target;
+  if (t instanceof Element && t.getAttribute("data-mantine-stop-propagation") === "true")
+    return;
+  const n = d().reverse().find((o) => o.handlersRef.current.close);
+  if (!n) return;
+  e.preventDefault(), e.stopImmediatePropagation();
+  const r = n.handlersRef.current;
+  r.closeOnEscape && r.close?.("escape");
+}
+function R(e, t) {
+  const n = t.getElement();
+  return n && e.includes(n) ? !0 : t.getInsideElements().some((r) => !!r && e.includes(r));
+}
+function a(e) {
+  if (v(e)) return;
+  const t = e.composedPath(), n = d().reverse().filter((r) => r.handlersRef.current.close);
+  for (const r of n) {
+    const o = r.handlersRef.current;
+    if (R(t, o) || !o.closeOnClickOutside) return;
+    o.close?.("outside");
+  }
+}
+function b() {
+  document.addEventListener("keydown", I), document.addEventListener("mousedown", a, !0), document.addEventListener("touchstart", a, !0);
+}
+function T() {
+  document.removeEventListener("keydown", I), document.removeEventListener("mousedown", a, !0), document.removeEventListener("touchstart", a, !0);
+}
+function M(e) {
+  i.size === 0 && b();
+  const t = {
+    ...e,
+    seq: k++,
+    zIndex: e.explicitZIndex ?? e.tier,
+    bucket: u(e.explicitZIndex ?? e.tier)
+  };
+  i.set(t.id, t);
+  const n = d(), r = n.indexOf(t);
+  for (let o = r; o < n.length; o++) {
+    const s = n[o], l = A(s, n.slice(0, o));
+    s.zIndex = l, s.bucket = u(l), p.set(s.id, l);
+  }
+  return O(), () => {
+    i.get(t.id) === t && (i.delete(t.id), i.size === 0 && T(), O());
+  };
+}
+function $(e) {
+  return h.add(e), () => {
+    h.delete(e);
+  };
+}
+function S(e) {
+  return p.get(e);
+}
+function D(e) {
+  p.delete(e);
+}
+g() && w({
+  subscribe: $,
+  getSnapshot: L
+});
+export {
+  D as forgetOverlay,
+  S as getOverlayZIndex,
+  M as registerOverlay,
+  $ as subscribeOverlayStack,
+  u as toTierBucket,
+  z as warnIfInvalidTier
+};

package/dist/components/overlay-layer/overlay-tier-scope.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface OverlayTierScopeProps {
+    /** 里面不传档位的浮层默认进这一档。 */
+    readonly tier: number;
+    readonly children?: React.ReactNode;
+}
+/**
+ * 只告诉里面的 `useOverlayLayer` "默认用哪一档"。
+ * 不算数值、不进栈、不渲染任何 DOM；内层 scope 覆盖外层，显式传 `tier` 的浮层不受影响。
+ */
+export declare function OverlayTierScope({ tier, children }: OverlayTierScopeProps): React.JSX.Element;
+export declare function useOverlayScopeTier(): number | null;

package/dist/components/overlay-layer/overlay-tier-scope.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx as t } from "react/jsx-runtime";
+import { useContext as i, createContext as n } from "react";
+import { isDev as u } from "../../common/is-dev.js";
+import { warnIfInvalidTier as f } from "./overlay-stack.js";
+const r = n(null);
+function p({ tier: e, children: o }) {
+  return u() && f(e), /* @__PURE__ */ t(r.Provider, { value: e, children: o });
+}
+function v() {
+  return i(r);
+}
+export {
+  p as OverlayTierScope,
+  v as useOverlayScopeTier
+};

package/dist/components/overlay-layer/types.d.ts

@@ -0,0 +1,63 @@
+import type { RefObject } from 'react';
+/** 浮层被关闭的原因：按了 Escape，或点在了浮层外面。 */
+export type OverlayCloseReason = 'escape' | 'outside';
+export interface OverlayLayerOptions {
+    /** 是否打开。`true` 入栈、`false` 立刻出栈（不等关闭动画）。常驻元素传 `true`。 */
+    opened: boolean;
+    /**
+     * 显式层级。传了就直接用、不参与计算，但仍登记进栈，并按数值归档
+     * （小于 10000 归普通层，10000 以上按千位归档）。
+     */
+    zIndex?: number;
+    /**
+     * 档位基准。不传取外层 `OverlayTierScope`，再没有就是普通层 `OVERLAY_BASE`。
+     * 业务顶层档位只能是 `[10000, 16000)` 之间 1000 的整数倍，14000 保留给通知。
+     */
+    tier?: number;
+    /**
+     * 关闭函数。传了才参与 Escape 关和点外面关；不传 = 透明，只占层级，
+     * Escape 和点外面都当它不存在（Tooltip、悬浮按钮、AI 侧边栏）。
+     */
+    close?: (reason: OverlayCloseReason) => void;
+    /**
+     * 本层是参与关闭的最上层时，按 Escape 是否关闭它。
+     * `false` 时既不关它、也不关下面的层（吞掉这次按键）。
+     * @default true
+     */
+    closeOnEscape?: boolean;
+    /**
+     * 点在本层外面时是否关闭它。`false` 时它和它下面的层都不关。
+     * @default true
+     */
+    closeOnClickOutside?: boolean;
+    /** 额外算作"本层里面"的节点，例如 Popover 的触发按钮。 */
+    insideRefs?: ReadonlyArray<RefObject<HTMLElement | null>>;
+    /** 调试用名字。 */
+    name?: string;
+}
+export interface OverlayLayerResult {
+    /** 算好的层级，贴到浮层真正浮起来的那个节点上。 */
+    zIndex: number;
+    /**
+     * 贴到浮层面板上，用于判断点击是否在浮层里面。
+     * 传了 `close` 就必须贴；弹窗要贴在面板上，不能贴在含遮罩的根节点上。
+     */
+    ref: (element: HTMLElement | null) => void;
+}
+/** 调试快照里的一条：栈中一个打开着的浮层。只在开发环境有内容。 */
+export interface OverlayStackDebugEntry {
+    /** hook 内部 id */
+    id: string;
+    /** 登记时传的 `name`，没传为 `undefined` */
+    name: string | undefined;
+    /** 当前层级 */
+    zIndex: number;
+    /** 归档的档位基准（普通层 200，顶层按千位） */
+    tierBucket: number;
+    /** 是否传了 `close`：`false` 即透明层，不参与 Escape 与点外面 */
+    closable: boolean;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    /** 取浮层面板节点（没贴 ref 的返回 null），调试面板用来高亮 */
+    getElement: () => HTMLElement | null;
+}

package/dist/components/overlay-layer/use-mantine-overlay-layer.d.ts

@@ -0,0 +1,21 @@
+interface MantineOverlayProps {
+    opened: boolean;
+    onClose: () => void;
+    zIndex?: string | number;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+}
+/**
+ * 组件库内部用：让 Mantine 薄封装（ModalDeprecated / Drawer / BaseBottomDrawer）接入层级模块。
+ *
+ * 调用方要把 `rootRef` 贴到 Mantine 组件上、把 `zIndex` 传进去，并给 Mantine 传
+ * `closeOnEscape={false}` `closeOnClickOutside={false}`：Escape 与点遮罩统一由层级模块处理，
+ * 否则一次操作会被处理两遍。Mantine 不暴露面板节点，只能从根节点里找；遮罩也在根节点里，
+ * 所以不能直接拿根节点判断"点在里面"。
+ */
+export declare function useMantineOverlayLayer(component: 'Modal' | 'Drawer', props: MantineOverlayProps, name: string): {
+    rootRef: import("react").RefObject<HTMLDivElement | null>;
+    zIndex: number;
+    id: string;
+};
+export {};

package/dist/components/overlay-layer/use-mantine-overlay-layer.js

@@ -0,0 +1,24 @@
+"use client";
+import { useProps as s } from "@mantine/core";
+import { useRef as u } from "react";
+import { useOverlayLayerInternal as i } from "./use-overlay-layer.js";
+const d = { closeOnClickOutside: !0, closeOnEscape: !0 };
+function f(t, e, l) {
+  const { closeOnClickOutside: r, closeOnEscape: c } = s(
+    t,
+    d,
+    e
+  ), n = u(null), o = i({
+    opened: e.opened,
+    zIndex: e.zIndex === void 0 ? void 0 : Number(e.zIndex),
+    close: () => e.onClose(),
+    closeOnEscape: c,
+    closeOnClickOutside: r,
+    getElement: () => n.current?.querySelector('[role="dialog"]') ?? null,
+    name: l
+  });
+  return { rootRef: n, zIndex: o.zIndex, id: o.id };
+}
+export {
+  f as useMantineOverlayLayer
+};

package/dist/components/overlay-layer/use-overlay-layer.d.ts

@@ -0,0 +1,26 @@
+import type { OverlayLayerOptions, OverlayLayerResult } from './types';
+interface InternalOverlayLayerOptions extends OverlayLayerOptions {
+    /**
+     * 拿不到面板节点、没法贴 `ref` 时（Mantine 薄封装）按需查找面板。
+     * 不对外：业务浮层一律贴 `ref`。
+     */
+    getElement?: () => HTMLElement | null;
+}
+/** 组件库内部版本：额外返回 id，供 `OverlayParentProvider` 记录祖先链。 */
+export declare function useOverlayLayerInternal(options: InternalOverlayLayerOptions): OverlayLayerResult & {
+    id: string;
+};
+/**
+ * 浮层层级 hook：算 z-index 并登记进全局栈，让之后打开的浮层排在上面；
+ * 传了 `close` 就参与 Escape 关（只关栈顶）和点外面关（从栈顶往下逐层）。
+ *
+ * 不需要被任何 Provider 包住，业务自定义浮层和组件库浮层遵守同一套规则。
+ *
+ * @example
+ * ```tsx
+ * const { zIndex, ref } = useOverlayLayer({ opened, close: () => setOpened(false) });
+ * return <div ref={ref} style={{ zIndex }} className="fixed inset-x-0 bottom-0">…</div>;
+ * ```
+ */
+export declare function useOverlayLayer(options: OverlayLayerOptions): OverlayLayerResult;
+export {};

package/dist/components/overlay-layer/use-overlay-layer.js

@@ -0,0 +1,77 @@
+"use client";
+import { useIsomorphicEffect as v } from "@mantine/hooks";
+import { useId as w, useRef as y, useEffect as m, useSyncExternalStore as A, useCallback as R } from "react";
+import { isDev as I } from "../../common/is-dev.js";
+import { OVERLAY_BASE as T } from "./constants.js";
+import { useOverlayAncestors as b } from "./overlay-parent-context.js";
+import { warnIfInvalidTier as k, subscribeOverlayStack as L, getOverlayZIndex as _, registerOverlay as z, forgetOverlay as C } from "./overlay-stack.js";
+import { useOverlayScopeTier as N } from "./overlay-tier-scope.js";
+const Z = 1e3, D = () => {
+};
+function M(s) {
+  const {
+    opened: t,
+    zIndex: r,
+    tier: o,
+    close: d,
+    closeOnEscape: f = !0,
+    closeOnClickOutside: p = !0,
+    insideRefs: O,
+    name: c,
+    getElement: g
+  } = s, x = N(), i = o ?? x ?? T, a = b().join("|"), e = w(), l = y(null), u = y({
+    closeOnEscape: f,
+    closeOnClickOutside: p,
+    getElement: () => l.current,
+    getInsideElements: () => []
+  });
+  v(() => {
+    u.current = {
+      close: d,
+      closeOnEscape: f,
+      closeOnClickOutside: p,
+      getElement: g ?? (() => l.current),
+      getInsideElements: () => (O ?? []).map((n) => n.current),
+      name: c
+    };
+  }), m(() => {
+    I() && o !== void 0 && k(o);
+  }, [o]);
+  const S = A(
+    L,
+    () => _(e),
+    D
+  );
+  v(() => {
+    if (t)
+      return z({
+        id: e,
+        ancestors: a ? a.split("|") : [],
+        explicitZIndex: r,
+        tier: i,
+        handlersRef: u
+      });
+  }, [t, r, i, e, a]), m(() => () => C(e), [e]);
+  const E = !!d;
+  m(() => {
+    if (!I() || !t || !E) return;
+    const n = window.setTimeout(() => {
+      u.current.getElement() || console.warn(
+        `[@wisdomgarden/torque] overlay "${c ?? e}" is open and closable but its \`ref\` is not attached to any element, so every click inside it counts as a click outside. Attach the returned \`ref\` to the panel.`
+      );
+    }, Z);
+    return () => window.clearTimeout(n);
+  }, [t, E, c, e]);
+  const h = R((n) => {
+    l.current = n;
+  }, []);
+  return { zIndex: r ?? S ?? i, ref: h, id: e };
+}
+function W(s) {
+  const { zIndex: t, ref: r } = M(s);
+  return { zIndex: t, ref: r };
+}
+export {
+  W as useOverlayLayer,
+  M as useOverlayLayerInternal
+};

package/dist/components/popover/hooks.d.ts

@@ -7,7 +7,6 @@ export declare function useAnimatedMount(opened: boolean, keepMounted?: boolean)
 };
 export declare function usePopoverFocus(trigger: PopoverTrigger, opened: boolean, animState: 'open' | 'closing', mounted: boolean, floatingRef: React.RefObject<HTMLDivElement | null>, getFloatingScopeElements: () => HTMLElement[], initialFocusRef?: React.RefObject<HTMLElement | null>, preventAutoFocus?: boolean): void;
 export declare function getFocusableElements(containers: Array<HTMLElement | null>): HTMLElement[];
-export declare function useEscapeClose(closeOnEscape: boolean, opened: boolean, close: () => void, referenceRef: React.RefObject<HTMLElement | null>, id: string, depth: number, restoreFocus?: () => void): void;
 export declare function useArrowStyle(withArrow: boolean, arrowData: {
     x?: number;
     y?: number;