@neut/ui 0.0.8 → 0.0.10

package/dist/components/tooltip/TooltipContent/TooltipContent.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"TooltipContent.utils.js","names":[],"sources":["../../../../src/components/tooltip/TooltipContent/TooltipContent.utils.ts"],"sourcesContent":["export function computePosition(\n  trigger: HTMLElement,\n  content: HTMLElement,\n  side: \"top\" | \"bottom\" | \"left\" | \"right\",\n  align: \"start\" | \"center\" | \"end\",\n  alignOffset: number,\n  sideOffset: number,\n) {\n  const rect = trigger.getBoundingClientRect();\n  const contentWidth = content.offsetWidth;\n  const contentHeight = content.offsetHeight;\n  const vw = window.innerWidth;\n  const vh = window.innerHeight;\n  const MARGIN = 4;\n\n  let top = 0;\n  let left = 0;\n  let resolvedSide = side;\n  let resolvedAlign = align;\n\n  // --- Flip：优先检测对侧是否有足够空间，再决定最终 side ---\n  switch (side) {\n    case \"top\":\n      if (\n        rect.top < contentHeight + sideOffset &&\n        rect.bottom + sideOffset + contentHeight <= vh\n      ) {\n        resolvedSide = \"bottom\";\n      }\n      break;\n    case \"bottom\":\n      if (\n        rect.bottom + sideOffset + contentHeight > vh &&\n        rect.top - sideOffset - contentHeight >= 0\n      ) {\n        resolvedSide = \"top\";\n      }\n      break;\n    case \"left\":\n      if (\n        rect.left < contentWidth + sideOffset &&\n        rect.right + sideOffset + contentWidth <= vw\n      ) {\n        resolvedSide = \"right\";\n      }\n      break;\n    case \"right\":\n      if (\n        rect.right + sideOffset + contentWidth > vw &&\n        rect.left - sideOffset - contentWidth >= 0\n      ) {\n        resolvedSide = \"left\";\n      }\n      break;\n  }\n\n  // --- 主轴位置（基于 resolvedSide）---\n  switch (resolvedSide) {\n    case \"top\":\n      top = rect.top - contentHeight - sideOffset;\n      break;\n    case \"bottom\":\n      top = rect.bottom + sideOffset;\n      break;\n    case \"left\":\n      left = rect.left - contentWidth - sideOffset;\n      break;\n    case \"right\":\n      left = rect.right + sideOffset;\n      break;\n  }\n\n  // --- 交叉轴位置（align）---\n  if (resolvedSide === \"top\" || resolvedSide === \"bottom\") {\n    switch (align) {\n      case \"start\":\n        left = rect.left + alignOffset;\n        break;\n      case \"center\":\n        left = rect.left + rect.width / 2 - contentWidth / 2 + alignOffset;\n        break;\n      case \"end\":\n        left = rect.right - contentWidth - alignOffset;\n        break;\n    }\n  } else {\n    switch (align) {\n      case \"start\":\n        top = rect.top + alignOffset;\n        break;\n      case \"center\":\n        top = rect.top + rect.height / 2 - contentHeight / 2 + alignOffset;\n        break;\n      case \"end\":\n        top = rect.bottom - contentHeight - alignOffset;\n        break;\n    }\n  }\n\n  // --- Shift：贴边平移，并更新 resolvedAlign ---\n  if (resolvedSide === \"top\" || resolvedSide === \"bottom\") {\n    if (left < MARGIN) {\n      left = MARGIN;\n      resolvedAlign = \"start\";\n    } else if (left + contentWidth > vw - MARGIN) {\n      left = vw - contentWidth - MARGIN;\n      resolvedAlign = \"end\";\n    }\n  } else {\n    if (top < MARGIN) {\n      top = MARGIN;\n      resolvedAlign = \"start\";\n    } else if (top + contentHeight > vh - MARGIN) {\n      top = vh - contentHeight - MARGIN;\n      resolvedAlign = \"end\";\n    }\n  }\n\n  return { top, left, side: resolvedSide, align: resolvedAlign };\n}\n"],"mappings":";AAAA,SAAgB,EACd,GACA,GACA,GACA,GACA,GACA,GACA;CACA,IAAM,IAAO,EAAQ,uBAAuB,EACtC,IAAe,EAAQ,aACvB,IAAgB,EAAQ,cACxB,IAAK,OAAO,YACZ,IAAK,OAAO,aAGd,IAAM,GACN,IAAO,GACP,IAAe,GACf,IAAgB;AAGpB,SAAQ,GAAR;EACE,KAAK;AACH,GACE,EAAK,MAAM,IAAgB,KAC3B,EAAK,SAAS,IAAa,KAAiB,MAE5C,IAAe;AAEjB;EACF,KAAK;AACH,GACE,EAAK,SAAS,IAAa,IAAgB,KAC3C,EAAK,MAAM,IAAa,KAAiB,MAEzC,IAAe;AAEjB;EACF,KAAK;AACH,GACE,EAAK,OAAO,IAAe,KAC3B,EAAK,QAAQ,IAAa,KAAgB,MAE1C,IAAe;AAEjB;EACF,KAAK;AACH,GACE,EAAK,QAAQ,IAAa,IAAe,KACzC,EAAK,OAAO,IAAa,KAAgB,MAEzC,IAAe;AAEjB;;AAIJ,SAAQ,GAAR;EACE,KAAK;AACH,OAAM,EAAK,MAAM,IAAgB;AACjC;EACF,KAAK;AACH,OAAM,EAAK,SAAS;AACpB;EACF,KAAK;AACH,OAAO,EAAK,OAAO,IAAe;AAClC;EACF,KAAK;AACH,OAAO,EAAK,QAAQ;AACpB;;AAIJ,KAAI,MAAiB,SAAS,MAAiB,SAC7C,SAAQ,GAAR;EACE,KAAK;AACH,OAAO,EAAK,OAAO;AACnB;EACF,KAAK;AACH,OAAO,EAAK,OAAO,EAAK,QAAQ,IAAI,IAAe,IAAI;AACvD;EACF,KAAK;AACH,OAAO,EAAK,QAAQ,IAAe;AACnC;;KAGJ,SAAQ,GAAR;EACE,KAAK;AACH,OAAM,EAAK,MAAM;AACjB;EACF,KAAK;AACH,OAAM,EAAK,MAAM,EAAK,SAAS,IAAI,IAAgB,IAAI;AACvD;EACF,KAAK;AACH,OAAM,EAAK,SAAS,IAAgB;AACpC;;AAuBN,QAlBI,MAAiB,SAAS,MAAiB,WACzC,IAAO,KACT,IAAO,GACP,IAAgB,WACP,IAAO,IAAe,IAAK,MACpC,IAAO,IAAK,IAAe,GAC3B,IAAgB,SAGd,IAAM,KACR,IAAM,GACN,IAAgB,WACP,IAAM,IAAgB,IAAK,MACpC,IAAM,IAAK,IAAgB,GAC3B,IAAgB,QAIb;EAAE;EAAK;EAAM,MAAM;EAAc,OAAO;EAAe"}
+{"version":3,"file":"TooltipContent.utils.js","names":[],"sources":["../../../../src/components/tooltip/TooltipContent/TooltipContent.utils.ts"],"sourcesContent":["import {\n  offset,\n  flip,\n  shift,\n  arrow,\n  hide,\n  containingBlockOffset,\n  getSide,\n  getAlignment,\n  type Middleware,\n  type Placement,\n  type Side,\n  type Alignment,\n} from \"~/lib\";\n\n/**\n * 把 shadcn/Radix 风格的 side + align 拆分参数，转换成核心库统一用的\n * `Placement` 字符串（比如 side='top' + align='start' → 'top-start'）。\n * align 是 'center'（默认对齐、不偏移）时不带后缀，直接是 side 本身。\n */\nexport function toPlacement(\n  side: Side,\n  align: Alignment | \"center\",\n): Placement {\n  return align === \"center\" ? side : (`${side}-${align}` as Placement);\n}\n\n/**\n * 根据最终生效的 placement，算出缩放动画应该以哪个点为锚点（CSS transform-origin）。\n * 锚点应该落在\"贴近 trigger 的那条边\"上——比如 placement 是 'top'（content 在\n * trigger 上方），锚点就该是 content 自己的底边，缩放动画看起来才会像是\n * \"从 trigger 那里长出来\"，而不是原地放大缩小（默认的 transform-origin 是\n * 几何中心 50% 50%，视觉上和\"从哪个方向冒出来\"没有任何关联）。\n * 交叉轴（对齐方向）同理：align 是 start 就贴左/上边，end 就贴右/下边。\n */\nexport function getTransformOrigin(placement: Placement): string {\n  const side = getSide(placement);\n  const align = getAlignment(placement);\n  const crossAxisOrigin =\n    align === \"start\" ? \"0%\" : align === \"end\" ? \"100%\" : \"50%\";\n\n  switch (side) {\n    case \"top\":\n      return `${crossAxisOrigin} 100%`;\n    case \"bottom\":\n      return `${crossAxisOrigin} 0%`;\n    case \"left\":\n      return `100% ${crossAxisOrigin}`;\n    case \"right\":\n      return `0% ${crossAxisOrigin}`;\n  }\n}\n\nexport interface BuildTooltipMiddlewareOptions {\n  sideOffset: number;\n  /** 沿交叉轴（对齐方向）的偏移，对应 offset middleware 的 crossAxis */\n  alignOffset: number;\n  collisionPadding: number;\n  arrowElement: () => Element | undefined;\n}\n\n/**\n * Tooltip 定位管线的固定配方：\n *\n * 1. offset      — 沿主轴保持 sideOffset 间距，沿交叉轴偏移 alignOffset\n * 2. flip        — 主轴方向放不下就翻到对面（比如上方没空间就翻到下方）\n * 3. shift       — 翻转后仍溢出，就在不换边的前提下贴边平移\n * 4. arrow       — 算出箭头相对 content 的偏移，让它始终指向 trigger 中心\n * 5. hide        — trigger 被自己的滚动容器完全裁掉时标记隐藏\n * 6. containingBlockOffset — 修正祖先元素 transform 等属性导致的 position:fixed\n *    包含块偏移（demo 里通常不出现，放进有大量 transform 的真实项目后才会暴露，\n *    详见该 middleware 自身的注释）。放在最后一位，因为它修正的是\"最终要写进\n *    DOM 的坐标\"，前面几步都在统一的视口坐标系里计算，不受这个偏移影响。\n *\n * 特意没有用 size 中间件去动态限制 max-height、允许内容超长时滚动——\n * tooltip 不应该出现滚动条（这不是本库的一般性限制，是 tooltip 这个组件\n * 类型本身该有的样子，shadcn/Radix 的 Tooltip 也是这么做的）。宽度上限\n * 靠 TooltipContent.tsx 里静态的 `max-w-xs` class 兜底，让文字自然换行；\n * 高度完全不做限制，交给内容自身的实际高度决定。\n *\n * 这个决定还有一个技术上的原因：早先的实现里试过用 size 中间件动态算\n * max-height 配合 overflow:auto 实现\"超长内容可滚动\"，结果发现内层元素\n * 一旦同时具备 overflow:auto 和入场动画（zoom-in-95 会给它加一个 transform），\n * 动画播放期间 transform 会让这个元素变成箭头新的包含块（CSS 规范：非 none\n * 的 transform 会创建包含块），箭头戳出内层边缘的那部分又会被算进内层的\n * 可滚动溢出区域——于是出现了\"打开瞬间闪一下滚动条，箭头跟着被遮住，\n * 动画播完滚动条消失、箭头才重新出现\"这种诡异现象。去掉滚动能力后，\n * 这个耦合从根上就不存在了。\n *\n * 顺序不能随便换：arrow 必须在 shift/flip 之后（要用最终坐标才能算对偏移），\n * containingBlockOffset 必须在所有其他 middleware 之后。\n *\n * 单独抽成函数是为了让 useTooltipContent 保持简洁，也方便针对这套管线单独测试。\n */\nexport function createTooltipMiddleware(\n  options: BuildTooltipMiddlewareOptions,\n): Middleware[] {\n  return [\n    offset({ mainAxis: options.sideOffset, crossAxis: options.alignOffset }),\n    flip(),\n    shift({ padding: options.collisionPadding }),\n    arrow({ element: options.arrowElement, padding: 6 }),\n    hide(),\n    containingBlockOffset(),\n  ];\n}\n"],"mappings":";;;;;;;;AAoBA,SAAgB,EACd,GACA,GACW;CACX,OAAO,MAAU,WAAW,IAAQ,GAAG,EAAK,GAAG;AACjD;AAUA,SAAgB,EAAmB,GAA8B;CAC/D,IAAM,IAAO,EAAQ,CAAS,GACxB,IAAQ,EAAa,CAAS,GAC9B,IACJ,MAAU,UAAU,OAAO,MAAU,QAAQ,SAAS;CAExD,QAAQ,GAAR;EACE,KAAK,OACH,OAAO,GAAG,EAAgB;EAC5B,KAAK,UACH,OAAO,GAAG,EAAgB;EAC5B,KAAK,QACH,OAAO,QAAQ;EACjB,KAAK,SACH,OAAO,MAAM;CACjB;AACF;AA2CA,SAAgB,EACd,GACc;CACd,OAAO;EACL,EAAO;GAAE,UAAU,EAAQ;GAAY,WAAW,EAAQ;EAAY,CAAC;EACvE,EAAK;EACL,EAAM,EAAE,SAAS,EAAQ,iBAAiB,CAAC;EAC3C,EAAM;GAAE,SAAS,EAAQ;GAAc,SAAS;EAAE,CAAC;EACnD,EAAK;EACL,EAAsB;CACxB;AACF"}

package/dist/components/tooltip/TooltipContent/index.d.ts

@@ -1 +1,8 @@
 export { TooltipContent } from './TooltipContent';
+export { TooltipContentContext, useTooltipContentContext, } from './TooltipContent.context';
+export type { TooltipContentContextValue } from './TooltipContent.context';
+export type { TooltipContentProps } from './TooltipContent.types';
+export { createTooltipMiddleware, getTransformOrigin, toPlacement, } from './TooltipContent.utils';
+export type { BuildTooltipMiddlewareOptions } from './TooltipContent.utils';
+export { useTooltipContent } from './useTooltipContent';
+export type { UseTooltipContentResult } from './useTooltipContent';

package/dist/components/tooltip/TooltipContent/useTooltipContent.d.ts

@@ -1,10 +1,47 @@
+import { Positioner } from '../../../lib';
+import { useTooltipContext } from '../Tooltip/Tooltip.context';
 import { TooltipContentProps } from './TooltipContent.types';
-export declare const useTooltipContent: (ref: () => HTMLDivElement | undefined, local: () => Required<Pick<TooltipContentProps, "side" | "align" | "alignOffset" | "sideOffset">>) => {
-    shouldRender: import('solid-js').Accessor<boolean>;
-    position: {
-        top: number;
-        left: number;
-        side: "left" | "right" | "bottom" | "top";
-        align: "center" | "start" | "end";
+export interface UseTooltipContentResult {
+    ctx: ReturnType<typeof useTooltipContext>;
+    pos: Positioner;
+    /** 综合了 open 状态 + hide 中间件的 referenceHidden 判断，代表"逻辑上应不应该打开" */
+    isVisible: () => boolean;
+    /**
+     * 代表"DOM 里要不要还留着这个节点"。isVisible 变 false 之后，mounted 不会立刻
+     * 跟着变 false，而是等退场动画播完（或者兜底超时）才变——展示层应该用它来控制
+     * <Show>，而不是直接用 isVisible，否则退场动画根本来不及播放就被卸载了。
+     */
+    mounted: () => boolean;
+    /**
+     * 真正用来驱动 data-state（进而驱动 CSS 进出场动画 class）的状态，
+     * 展示层应该用它，而不是直接用 isVisible。
+     *
+     * 和 isVisible 的区别只在"打开"这一侧：isVisible 变 true 的瞬间，
+     * animationState 不会立刻跟着变 "open"，而是等一帧（requestAnimationFrame）
+     * 之后才变——这一帧的间隙用来让箭头（TooltipArrow）完成挂载、把自己注册给
+     * arrow middleware、拿到正确的位置偏移。如果不等这一帧，动画会在箭头位置
+     * 还没算对的时候就开始播放，播到一半箭头才"跳"到正确位置，看起来就像是
+     * 箭头比内容慢一拍——这正是因为内容的淡入/缩放靠的是 CSS 动画（父元素的
+     * opacity/transform 会连带影响所有子元素，包括箭头，两者本该同步），而箭头
+     * 的具体位置靠的是 JS 算出来的 left/top，这是两套完全独立的机制，只有当
+     * "开始播放动画"这个时间点晚于"箭头位置算完"，才能保证两者观感一致。
+     * 关闭这一侧不需要这个延迟，isVisible 变 false 时 animationState 立刻跟着变。
+     */
+    animationState: () => "open" | "closed";
+    arrowElement: () => Element | undefined;
+    setArrowElement: (el: Element) => void;
+    /** 内层内容元素（真正播放进出场动画的那一层），TooltipContent 需要把它 ref 进来 */
+    contentElement: () => HTMLElement | undefined;
+    setContentElement: (el: HTMLElement) => void;
+    /**
+     * 加在"滑动层"（定位层和内容层之间的中间那层）上的 style。
+     * 命中 TooltipGroup 抢占时会有一个非零初始偏移，下一帧起会用 CSS transition
+     * 平滑归零，从而制造出"从旧 tooltip 位置滑到新位置"的效果；平时是空对象，
+     * 不产生任何影响。
+     */
+    slideStyle: () => {
+        transform?: string;
+        transition?: string;
     };
-};
+}
+export declare function useTooltipContent(props: () => TooltipContentProps): UseTooltipContentResult;

package/dist/components/tooltip/TooltipContent/useTooltipContent.js

@@ -1,48 +1,77 @@
 import { useTooltipContext as e } from "../Tooltip/Tooltip.context.js";
-import { computePosition as t } from "./TooltipContent.utils.js";
-import { createEffect as n, createSignal as r, onCleanup as i, onMount as a, untrack as o } from "solid-js";
-import { createStore as s } from "solid-js/store";
+import { createPositioner as t } from "../../../lib/positioner/create-positioner.js";
+import { createTooltipMiddleware as n, toPlacement as r } from "./TooltipContent.utils.js";
+import { createEffect as i, createMemo as a, createSignal as o, onCleanup as s } from "solid-js";
 //#region src/components/tooltip/TooltipContent/useTooltipContent.ts
-var c = (c, l) => {
-	let u = e(), [d, f] = s({
-		top: 0,
-		left: 0,
-		side: o(() => l().side),
-		align: o(() => l().align)
-	}), [p, m] = r(o(u.open)), h = (e) => {
-		if (!u.triggerRef || !e) return;
-		let { top: n, left: r, side: i, align: a } = t(u.triggerRef, e, l().side, l().align, l().alignOffset, l().sideOffset);
-		f({
-			top: n,
-			left: r,
-			side: i,
-			align: a
-		});
-	}, g = () => h(c());
-	return a(() => {
-		window.addEventListener("scroll", g, { passive: !0 }), window.addEventListener("resize", g, { passive: !0 });
-	}), i(() => {
-		window.removeEventListener("scroll", g), window.removeEventListener("resize", g);
-	}), n(() => {
-		if (u.open()) {
-			m(!0), requestAnimationFrame(() => {
-				requestAnimationFrame(() => h(c()));
-			});
-			return;
+var c = 300;
+function l(l) {
+	let u = e("TooltipContent"), [d, f] = o(), [p, m] = o(), h = t(u.reference, u.floating, {
+		placement: () => r(l().side ?? "top", l().align ?? "center"),
+		strategy: "fixed",
+		middleware: () => n({
+			sideOffset: l().sideOffset ?? 8,
+			alignOffset: l().alignOffset ?? 0,
+			collisionPadding: l().collisionPadding ?? 8,
+			arrowElement: d
+		})
+	}), g = a(() => u.open() && !h.middlewareData().hide?.referenceHidden), [_, v] = o("closed");
+	i(() => {
+		if (g()) {
+			let e = requestAnimationFrame(() => v("open"));
+			s(() => cancelAnimationFrame(e));
+		} else v("closed");
+	});
+	let [y, b] = o();
+	i(() => {
+		if (!S()) return;
+		let e = u.pendingSlideFrom();
+		if (!e || !h.isPositioned()) return;
+		let t = e.x - h.x(), n = e.y - h.y();
+		b({
+			x: t,
+			y: n
+		}), u.clearPendingSlideFrom(), requestAnimationFrame(() => b({
+			x: 0,
+			y: 0
+		}));
+	});
+	let x = a(() => {
+		let e = y();
+		if (!e) return {};
+		let t = e.x === 0 && e.y === 0;
+		return {
+			transform: `translate(${e.x}px, ${e.y}px)`,
+			transition: t ? "transform 150ms ease" : void 0
+		};
+	}), [S, C] = o(g());
+	return i((e) => {
+		let t = g(), n = p();
+		if (t) C(!0);
+		else if (e && n) if (u.consumeSuppressExitAnimation()) C(!1);
+		else {
+			let e = (e) => {
+				e.target === n && C(!1);
+			};
+			n.addEventListener("animationend", e), s(() => n.removeEventListener("animationend", e));
+			let t = window.setTimeout(() => C(!1), c);
+			s(() => window.clearTimeout(t));
 		}
-		let e = c();
-		if (!e) {
-			m(!1);
-			return;
-		}
-		let t = () => m(!1);
-		e.addEventListener("animationend", t, { once: !0 }), e.addEventListener("transitionend", t, { once: !0 });
-	}), {
-		shouldRender: p,
-		position: d
+		else t || C(!1);
+		return t;
+	}, g()), {
+		ctx: u,
+		pos: h,
+		isVisible: g,
+		mounted: S,
+		animationState: _,
+		arrowElement: d,
+		setArrowElement: f,
+		contentElement: p,
+		setContentElement: m,
+		slideStyle: x
 	};
-};
+}
 //#endregion
-export { c as useTooltipContent };
+export { l as useTooltipContent };
 
 //# sourceMappingURL=useTooltipContent.js.map

package/dist/components/tooltip/TooltipContent/useTooltipContent.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTooltipContent.js","names":[],"sources":["../../../../src/components/tooltip/TooltipContent/useTooltipContent.ts"],"sourcesContent":["import {\n  createEffect,\n  createSignal,\n  onCleanup,\n  onMount,\n  untrack,\n} from \"solid-js\";\nimport { computePosition } from \"./TooltipContent.utils\";\nimport { createStore } from \"solid-js/store\";\nimport { useTooltipContext } from \"../Tooltip/Tooltip.context\";\nimport type { TooltipContentProps } from \"./TooltipContent.types\";\n\nexport const useTooltipContent = (\n  ref: () => HTMLDivElement | undefined,\n  local: () => Required<\n    Pick<TooltipContentProps, \"side\" | \"align\" | \"alignOffset\" | \"sideOffset\">\n  >,\n) => {\n  const ctx = useTooltipContext();\n\n  const [position, setPosition] = createStore({\n    top: 0,\n    left: 0,\n    side: untrack(() => local().side),\n    align: untrack(() => local().align),\n  });\n  const [shouldRender, setShouldRender] = createSignal(untrack(ctx.open));\n\n  const updatePosition = (content: HTMLElement | undefined) => {\n    if (!ctx.triggerRef || !content) return;\n\n    const { top, left, side, align } = computePosition(\n      ctx.triggerRef,\n      content,\n      local().side,\n      local().align,\n      local().alignOffset,\n      local().sideOffset,\n    );\n    setPosition({ top, left, side, align });\n  };\n\n  const updatePositionWithContentRef = () => updatePosition(ref());\n\n  onMount(() => {\n    window.addEventListener(\"scroll\", updatePositionWithContentRef, {\n      passive: true,\n    });\n    window.addEventListener(\"resize\", updatePositionWithContentRef, {\n      passive: true,\n    });\n  });\n\n  onCleanup(() => {\n    window.removeEventListener(\"scroll\", updatePositionWithContentRef);\n    window.removeEventListener(\"resize\", updatePositionWithContentRef);\n  });\n\n  createEffect(() => {\n    const isOpen = ctx.open();\n\n    if (isOpen) {\n      setShouldRender(true);\n      // 等待 DOM 完成布局后再计算，双 rAF 确保内容节点已完成首次渲染\n      requestAnimationFrame(() => {\n        requestAnimationFrame(() => updatePosition(ref()));\n      });\n      return;\n    }\n\n    const el = ref();\n    if (!el) {\n      setShouldRender(false);\n      return;\n    }\n\n    const onFinish = () => setShouldRender(false);\n    el.addEventListener(\"animationend\", onFinish, { once: true });\n    el.addEventListener(\"transitionend\", onFinish, { once: true });\n  });\n\n  return { shouldRender, position };\n};\n"],"mappings":";;;;;AAYA,IAAa,KACX,GACA,MAGG;CACH,IAAM,IAAM,GAAmB,EAEzB,CAAC,GAAU,KAAe,EAAY;EAC1C,KAAK;EACL,MAAM;EACN,MAAM,QAAc,GAAO,CAAC,KAAK;EACjC,OAAO,QAAc,GAAO,CAAC,MAAM;EACpC,CAAC,EACI,CAAC,GAAc,KAAmB,EAAa,EAAQ,EAAI,KAAK,CAAC,EAEjE,KAAkB,MAAqC;AAC3D,MAAI,CAAC,EAAI,cAAc,CAAC,EAAS;EAEjC,IAAM,EAAE,QAAK,SAAM,SAAM,aAAU,EACjC,EAAI,YACJ,GACA,GAAO,CAAC,MACR,GAAO,CAAC,OACR,GAAO,CAAC,aACR,GAAO,CAAC,WACT;AACD,IAAY;GAAE;GAAK;GAAM;GAAM;GAAO,CAAC;IAGnC,UAAqC,EAAe,GAAK,CAAC;AAuChE,QArCA,QAAc;AAIZ,EAHA,OAAO,iBAAiB,UAAU,GAA8B,EAC9D,SAAS,IACV,CAAC,EACF,OAAO,iBAAiB,UAAU,GAA8B,EAC9D,SAAS,IACV,CAAC;GACF,EAEF,QAAgB;AAEd,EADA,OAAO,oBAAoB,UAAU,EAA6B,EAClE,OAAO,oBAAoB,UAAU,EAA6B;GAClE,EAEF,QAAmB;AAGjB,MAFe,EAAI,MAAM,EAEb;AAGV,GAFA,EAAgB,GAAK,EAErB,4BAA4B;AAC1B,gCAA4B,EAAe,GAAK,CAAC,CAAC;KAClD;AACF;;EAGF,IAAM,IAAK,GAAK;AAChB,MAAI,CAAC,GAAI;AACP,KAAgB,GAAM;AACtB;;EAGF,IAAM,UAAiB,EAAgB,GAAM;AAE7C,EADA,EAAG,iBAAiB,gBAAgB,GAAU,EAAE,MAAM,IAAM,CAAC,EAC7D,EAAG,iBAAiB,iBAAiB,GAAU,EAAE,MAAM,IAAM,CAAC;GAC9D,EAEK;EAAE;EAAc;EAAU"}
+{"version":3,"file":"useTooltipContent.js","names":[],"sources":["../../../../src/components/tooltip/TooltipContent/useTooltipContent.ts"],"sourcesContent":["import { createSignal, createMemo, createEffect, onCleanup } from \"solid-js\";\nimport { createPositioner, type Positioner } from \"~/lib\";\nimport { useTooltipContext } from \"../Tooltip/Tooltip.context\";\nimport { createTooltipMiddleware, toPlacement } from \"./TooltipContent.utils\";\nimport type { TooltipContentProps } from \"./TooltipContent.types\";\n\n/** 没有触发任何 CSS animation 时的兜底卸载延迟（ms）——比如没装 tailwindcss-animate、\n * 或者自定义样式只用了 transition 而不是 @keyframes，animationend 永远不会触发，\n * 避免元素卡在 DOM 里退不出去。 */\nconst EXIT_FALLBACK_MS = 300;\n\nexport interface UseTooltipContentResult {\n  ctx: ReturnType<typeof useTooltipContext>;\n  pos: Positioner;\n  /** 综合了 open 状态 + hide 中间件的 referenceHidden 判断，代表\"逻辑上应不应该打开\" */\n  isVisible: () => boolean;\n  /**\n   * 代表\"DOM 里要不要还留着这个节点\"。isVisible 变 false 之后，mounted 不会立刻\n   * 跟着变 false，而是等退场动画播完（或者兜底超时）才变——展示层应该用它来控制\n   * <Show>，而不是直接用 isVisible，否则退场动画根本来不及播放就被卸载了。\n   */\n  mounted: () => boolean;\n  /**\n   * 真正用来驱动 data-state（进而驱动 CSS 进出场动画 class）的状态，\n   * 展示层应该用它，而不是直接用 isVisible。\n   *\n   * 和 isVisible 的区别只在\"打开\"这一侧：isVisible 变 true 的瞬间，\n   * animationState 不会立刻跟着变 \"open\"，而是等一帧（requestAnimationFrame）\n   * 之后才变——这一帧的间隙用来让箭头（TooltipArrow）完成挂载、把自己注册给\n   * arrow middleware、拿到正确的位置偏移。如果不等这一帧，动画会在箭头位置\n   * 还没算对的时候就开始播放，播到一半箭头才\"跳\"到正确位置，看起来就像是\n   * 箭头比内容慢一拍——这正是因为内容的淡入/缩放靠的是 CSS 动画（父元素的\n   * opacity/transform 会连带影响所有子元素，包括箭头，两者本该同步），而箭头\n   * 的具体位置靠的是 JS 算出来的 left/top，这是两套完全独立的机制，只有当\n   * \"开始播放动画\"这个时间点晚于\"箭头位置算完\"，才能保证两者观感一致。\n   * 关闭这一侧不需要这个延迟，isVisible 变 false 时 animationState 立刻跟着变。\n   */\n  animationState: () => \"open\" | \"closed\";\n  arrowElement: () => Element | undefined;\n  setArrowElement: (el: Element) => void;\n  /** 内层内容元素（真正播放进出场动画的那一层），TooltipContent 需要把它 ref 进来 */\n  contentElement: () => HTMLElement | undefined;\n  setContentElement: (el: HTMLElement) => void;\n  /**\n   * 加在\"滑动层\"（定位层和内容层之间的中间那层）上的 style。\n   * 命中 TooltipGroup 抢占时会有一个非零初始偏移，下一帧起会用 CSS transition\n   * 平滑归零，从而制造出\"从旧 tooltip 位置滑到新位置\"的效果；平时是空对象，\n   * 不产生任何影响。\n   */\n  slideStyle: () => { transform?: string; transition?: string };\n}\n\nexport function useTooltipContent(\n  props: () => TooltipContentProps,\n): UseTooltipContentResult {\n  const ctx = useTooltipContext(\"TooltipContent\");\n  const [arrowElement, setArrowElement] = createSignal<Element>();\n  const [contentElement, setContentElement] = createSignal<HTMLElement>();\n\n  const pos = createPositioner(ctx.reference, ctx.floating, {\n    placement: () =>\n      toPlacement(props().side ?? \"top\", props().align ?? \"center\"),\n    strategy: \"fixed\",\n    middleware: () =>\n      createTooltipMiddleware({\n        sideOffset: props().sideOffset ?? 8,\n        alignOffset: props().alignOffset ?? 0,\n        collisionPadding: props().collisionPadding ?? 8,\n        arrowElement,\n      }),\n  });\n\n  // reference 完全滚出视口（比如所在容器被单独滚动）时，hide middleware 会标记\n  // referenceHidden，这里据此隐藏浮层，避免它悬空显示在一个已经看不到的触发器旁边。\n  const isVisible = createMemo(\n    () => ctx.open() && !pos.middlewareData().hide?.referenceHidden,\n  );\n\n  // --- 箭头和内容同步入场：延迟一帧再触发动画 class ---\n  // 见 UseTooltipContentResult.animationState 的注释：只有\"开始播放动画\"这个\n  // 时间点晚于\"箭头位置算完\"，才能保证箭头不会在动画播到一半时才跳到正确位置。\n  const [animationState, setAnimationState] = createSignal<\"open\" | \"closed\">(\n    \"closed\",\n  );\n\n  createEffect(() => {\n    if (isVisible()) {\n      const raf = requestAnimationFrame(() => setAnimationState(\"open\"));\n      onCleanup(() => cancelAnimationFrame(raf));\n    } else {\n      // 关闭不需要等——退场动画本来就是从\"当前已经落定的位置\"往外淡出/缩小，\n      // 不存在箭头位置还没算好这个问题，没理由延迟。\n      setAnimationState(\"closed\");\n    }\n  });\n\n  // --- TooltipGroup 抢占时的\"滑入\"过渡（FLIP 技术） ---\n  const [slideOffset, setSlideOffset] = createSignal<{\n    x: number;\n    y: number;\n  }>();\n\n  createEffect(() => {\n    if (!mounted()) return;\n    const from = ctx.pendingSlideFrom();\n    if (!from) return;\n    // 必须等真正定位完成（知道自己算出来的最终坐标）才能算出\"要从哪滑过来\"的差值。\n    if (!pos.isPositioned()) return;\n\n    const dx = from.x - pos.x();\n    const dy = from.y - pos.y();\n    // 第一步：把偏移设成非零值——这一步和 floatingStyles() 的最终坐标叠加后，\n    // 视觉上让新 tooltip 一出现就恰好在旧 tooltip 原来的位置，没有任何跳动。\n    setSlideOffset({ x: dx, y: dy });\n    // 消费一次立刻清空，避免后续 autoUpdate（滚动/resize 触发的重新定位）\n    // 又把这次的偏移重新套用一遍。\n    ctx.clearPendingSlideFrom();\n\n    // 第二步：下一帧再把偏移量归零。因为这次更新带上了 transition（见下面\n    // slideStyle 的实现），浏览器会把\"从非零偏移回到 0\"这个变化平滑动画出来，\n    // 效果就是从旧位置滑到新位置。用 requestAnimationFrame 而不是同步归零，\n    // 是为了确保浏览器先真正画出第一帧（非零偏移、无 transition），\n    // 下一帧的变化才有\"起点\"可以过渡，不会被浏览器合并成一次跳变。\n    requestAnimationFrame(() => setSlideOffset({ x: 0, y: 0 }));\n  });\n\n  const slideStyle = createMemo(() => {\n    const offset = slideOffset();\n    if (!offset) return {};\n    const atRest = offset.x === 0 && offset.y === 0;\n    return {\n      transform: `translate(${offset.x}px, ${offset.y}px)`,\n      // 只有\"归零\"这一步才带 transition：非零的那一帧要求瞬间落位、不能有动画，\n      // 否则会先看到它从视口原点飞过来，而不是从旧 tooltip 的位置飞过来。\n      transition: atRest ? \"transform 150ms ease\" : undefined,\n    };\n  });\n\n  // --- 退场动画支持（Presence）---\n  // isVisible 从 true 变 false 的瞬间，不立刻让 <Show> 卸载节点：先把 data-state\n  // 切到 closed（触发退场动画的 CSS class），等这个节点自己的 animationend 触发\n  // （或者兜底超时）之后，才真正把 mounted 设为 false，交给 <Show> 卸载。\n  const [mounted, setMounted] = createSignal(isVisible());\n\n  createEffect((wasVisible: boolean) => {\n    const visible = isVisible();\n    const el = contentElement();\n\n    if (visible) {\n      setMounted(true);\n    } else if (wasVisible && el) {\n      if (ctx.consumeSuppressExitAnimation()) {\n        // 被 TooltipGroup 抢占强制关闭：跳过退场动画，立即卸载，避免和正在\n        // 滑入的新 tooltip 同时出现在屏幕上（这是\"同时存在两个 tooltip\"这个\n        // bug 的根因——之前不管什么原因关闭，都统一走了退场动画那条路）。\n        setMounted(false);\n      } else {\n        const handleAnimationEnd = (e: AnimationEvent) => {\n          // 忽略从子元素冒泡上来的 animationend，只认内容元素自己播放的那个动画\n          if (e.target !== el) return;\n          setMounted(false);\n        };\n        el.addEventListener(\"animationend\", handleAnimationEnd);\n        onCleanup(() =>\n          el.removeEventListener(\"animationend\", handleAnimationEnd),\n        );\n\n        const fallback = window.setTimeout(\n          () => setMounted(false),\n          EXIT_FALLBACK_MS,\n        );\n        onCleanup(() => window.clearTimeout(fallback));\n      }\n    } else if (!visible) {\n      setMounted(false);\n    }\n\n    return visible;\n  }, isVisible());\n\n  return {\n    ctx,\n    pos,\n    isVisible,\n    mounted,\n    animationState,\n    arrowElement,\n    setArrowElement,\n    contentElement,\n    setContentElement,\n    slideStyle,\n  };\n}\n"],"mappings":";;;;;AASA,IAAM,IAAmB;AA2CzB,SAAgB,EACd,GACyB;CACzB,IAAM,IAAM,EAAkB,gBAAgB,GACxC,CAAC,GAAc,KAAmB,EAAsB,GACxD,CAAC,GAAgB,KAAqB,EAA0B,GAEhE,IAAM,EAAiB,EAAI,WAAW,EAAI,UAAU;EACxD,iBACE,EAAY,EAAM,CAAC,CAAC,QAAQ,OAAO,EAAM,CAAC,CAAC,SAAS,QAAQ;EAC9D,UAAU;EACV,kBACE,EAAwB;GACtB,YAAY,EAAM,CAAC,CAAC,cAAc;GAClC,aAAa,EAAM,CAAC,CAAC,eAAe;GACpC,kBAAkB,EAAM,CAAC,CAAC,oBAAoB;GAC9C;EACF,CAAC;CACL,CAAC,GAIK,IAAY,QACV,EAAI,KAAK,KAAK,CAAC,EAAI,eAAe,CAAC,CAAC,MAAM,eAClD,GAKM,CAAC,GAAgB,KAAqB,EAC1C,QACF;CAEA,QAAmB;EACjB,IAAI,EAAU,GAAG;GACf,IAAM,IAAM,4BAA4B,EAAkB,MAAM,CAAC;GACjE,QAAgB,qBAAqB,CAAG,CAAC;EAC3C,OAGE,EAAkB,QAAQ;CAE9B,CAAC;CAGD,IAAM,CAAC,GAAa,KAAkB,EAGnC;CAEH,QAAmB;EACjB,IAAI,CAAC,EAAQ,GAAG;EAChB,IAAM,IAAO,EAAI,iBAAiB;EAGlC,IAFI,CAAC,KAED,CAAC,EAAI,aAAa,GAAG;EAEzB,IAAM,IAAK,EAAK,IAAI,EAAI,EAAE,GACpB,IAAK,EAAK,IAAI,EAAI,EAAE;EAa1B,AAVA,EAAe;GAAE,GAAG;GAAI,GAAG;EAAG,CAAC,GAG/B,EAAI,sBAAsB,GAO1B,4BAA4B,EAAe;GAAE,GAAG;GAAG,GAAG;EAAE,CAAC,CAAC;CAC5D,CAAC;CAED,IAAM,IAAa,QAAiB;EAClC,IAAM,IAAS,EAAY;EAC3B,IAAI,CAAC,GAAQ,OAAO,CAAC;EACrB,IAAM,IAAS,EAAO,MAAM,KAAK,EAAO,MAAM;EAC9C,OAAO;GACL,WAAW,aAAa,EAAO,EAAE,MAAM,EAAO,EAAE;GAGhD,YAAY,IAAS,yBAAyB,KAAA;EAChD;CACF,CAAC,GAMK,CAAC,GAAS,KAAc,EAAa,EAAU,CAAC;CAsCtD,OApCA,GAAc,MAAwB;EACpC,IAAM,IAAU,EAAU,GACpB,IAAK,EAAe;EAE1B,IAAI,GACF,EAAW,EAAI;OACV,IAAI,KAAc,GACvB,IAAI,EAAI,6BAA6B,GAInC,EAAW,EAAK;OACX;GACL,IAAM,KAAsB,MAAsB;IAE5C,EAAE,WAAW,KACjB,EAAW,EAAK;GAClB;GAEA,AADA,EAAG,iBAAiB,gBAAgB,CAAkB,GACtD,QACE,EAAG,oBAAoB,gBAAgB,CAAkB,CAC3D;GAEA,IAAM,IAAW,OAAO,iBAChB,EAAW,EAAK,GACtB,CACF;GACA,QAAgB,OAAO,aAAa,CAAQ,CAAC;EAC/C;OACK,AAAK,KACV,EAAW,EAAK;EAGlB,OAAO;CACT,GAAG,EAAU,CAAC,GAEP;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/components/tooltip/TooltipGroup/TooltipGroup.context.d.ts

@@ -0,0 +1,29 @@
+import { Rect } from '../../../lib';
+export interface ActiveTooltipEntry {
+    /** 读取这个 tooltip 浮层此刻的实时矩形，供下一个抢占它的 tooltip 当"滑入起点"用 */
+    rect: () => Rect | undefined;
+    /** 立即关闭（跳过 closeDelay 和退场动画）——组内切换到别的 trigger 时调用 */
+    forceClose: () => void;
+}
+export interface TooltipGroupContextValue {
+    /** 打开时注册自己为"组内当前活跃的 tooltip"，返回取消注册函数（关闭/卸载时调用） */
+    registerActive: (entry: ActiveTooltipEntry) => () => void;
+    /**
+     * 组内某个 tooltip 即将打开时调用：
+     * 如果组里当前已经有一个活跃的 tooltip，立即强制关闭它、拿到它此刻的矩形
+     * 并返回（用作平移过渡的起点）；如果组内当前没有任何活跃 tooltip，返回
+     * undefined，调用方应该走正常的 openDelay 流程。
+     *
+     * 用"是否存在活跃 tooltip"而不是"上一个关闭后多久之内"这种时间窗口来判断，
+     * 是为了精确匹配"旧的还在退场倒计时里、这时候 hover 了别的 trigger"这个场景——
+     * 这种情况下旧的严格来说还没真正关闭（open() 依然是 true），基于时间窗口的
+     * 判断会因为"还没关闭、没触发通知"而错过这次协调，直接查"当前活跃"更可靠。
+     */
+    claim: () => Rect | undefined;
+}
+export declare const TooltipGroupContext: import('solid-js').Context<TooltipGroupContextValue | undefined>;
+/**
+ * 注意：和其他 useXxxContext 不同，这里缺失 context 时不抛错——
+ * <TooltipGroup> 是可选的，单独使用 <Tooltip> 不需要包一层。
+ */
+export declare function useTooltipGroupContext(): TooltipGroupContextValue | undefined;

package/dist/components/tooltip/TooltipGroup/TooltipGroup.context.js

@@ -0,0 +1,10 @@
+import { createContext as e, useContext as t } from "solid-js";
+//#region src/components/tooltip/TooltipGroup/TooltipGroup.context.ts
+var n = e();
+function r() {
+	return t(n);
+}
+//#endregion
+export { n as TooltipGroupContext, r as useTooltipGroupContext };
+
+//# sourceMappingURL=TooltipGroup.context.js.map

package/dist/components/tooltip/TooltipGroup/TooltipGroup.context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipGroup.context.js","names":[],"sources":["../../../../src/components/tooltip/TooltipGroup/TooltipGroup.context.ts"],"sourcesContent":["import { createContext, useContext } from \"solid-js\";\nimport type { Rect } from \"~/lib\";\n\nexport interface ActiveTooltipEntry {\n  /** 读取这个 tooltip 浮层此刻的实时矩形，供下一个抢占它的 tooltip 当\"滑入起点\"用 */\n  rect: () => Rect | undefined;\n  /** 立即关闭（跳过 closeDelay 和退场动画）——组内切换到别的 trigger 时调用 */\n  forceClose: () => void;\n}\n\nexport interface TooltipGroupContextValue {\n  /** 打开时注册自己为\"组内当前活跃的 tooltip\"，返回取消注册函数（关闭/卸载时调用） */\n  registerActive: (entry: ActiveTooltipEntry) => () => void;\n  /**\n   * 组内某个 tooltip 即将打开时调用：\n   * 如果组里当前已经有一个活跃的 tooltip，立即强制关闭它、拿到它此刻的矩形\n   * 并返回（用作平移过渡的起点）；如果组内当前没有任何活跃 tooltip，返回\n   * undefined，调用方应该走正常的 openDelay 流程。\n   *\n   * 用\"是否存在活跃 tooltip\"而不是\"上一个关闭后多久之内\"这种时间窗口来判断，\n   * 是为了精确匹配\"旧的还在退场倒计时里、这时候 hover 了别的 trigger\"这个场景——\n   * 这种情况下旧的严格来说还没真正关闭（open() 依然是 true），基于时间窗口的\n   * 判断会因为\"还没关闭、没触发通知\"而错过这次协调，直接查\"当前活跃\"更可靠。\n   */\n  claim: () => Rect | undefined;\n}\n\nexport const TooltipGroupContext = createContext<TooltipGroupContextValue>();\n\n/**\n * 注意：和其他 useXxxContext 不同，这里缺失 context 时不抛错——\n * <TooltipGroup> 是可选的，单独使用 <Tooltip> 不需要包一层。\n */\nexport function useTooltipGroupContext(): TooltipGroupContextValue | undefined {\n  return useContext(TooltipGroupContext);\n}\n"],"mappings":";;AA2BA,IAAa,IAAsB,EAAwC;AAM3E,SAAgB,IAA+D;CAC7E,OAAO,EAAW,CAAmB;AACvC"}

package/dist/components/tooltip/TooltipGroup/TooltipGroup.d.ts

@@ -0,0 +1,2 @@
+import { TooltipGroupProps } from './TooltipGroup.types';
+export declare function TooltipGroup(props: TooltipGroupProps): import("solid-js").JSX.Element;

package/dist/components/tooltip/TooltipGroup/TooltipGroup.js

@@ -0,0 +1,25 @@
+import { TooltipGroupContext as e } from "./TooltipGroup.context.js";
+import { createComponent as t } from "solid-js/web";
+//#region src/components/tooltip/TooltipGroup/TooltipGroup.tsx
+function n(n) {
+	let r;
+	return t(e.Provider, {
+		value: {
+			registerActive: (e) => (r = e, () => {
+				r === e && (r = void 0);
+			}),
+			claim: () => {
+				if (!r) return;
+				let e = r.rect();
+				if (r.forceClose(), r = void 0, !(!e || e.width === 0 && e.height === 0)) return e;
+			}
+		},
+		get children() {
+			return n.children;
+		}
+	});
+}
+//#endregion
+export { n as TooltipGroup };
+
+//# sourceMappingURL=TooltipGroup.js.map

package/dist/components/tooltip/TooltipGroup/TooltipGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipGroup.js","names":["TooltipGroupContext","ActiveTooltipEntry","TooltipGroupContextValue","TooltipGroupProps","TooltipGroup","props","activeEntry","registerActive","entry","undefined","claim","rect","forceClose","width","height","ctx","_$createComponent","Provider","value","children"],"sources":["../../../../src/components/tooltip/TooltipGroup/TooltipGroup.tsx"],"sourcesContent":["import { TooltipGroupContext } from \"./TooltipGroup.context\";\nimport type {\n  ActiveTooltipEntry,\n  TooltipGroupContextValue,\n} from \"./TooltipGroup.context\";\nimport type { TooltipGroupProps } from \"./TooltipGroup.types\";\n\nexport function TooltipGroup(props: TooltipGroupProps) {\n  // 用一个模块外可变量而不是 Solid signal 存\"当前活跃条目\"是有意的：\n  // 这纯粹是组件间协调用的内部状态，不需要驱动任何渲染，用 signal 反而会\n  // 引入不必要的响应式开销和多余的重渲染触发。\n  let activeEntry: ActiveTooltipEntry | undefined;\n\n  const registerActive: TooltipGroupContextValue[\"registerActive\"] = (\n    entry,\n  ) => {\n    activeEntry = entry;\n    return () => {\n      // 只清自己注册的那条，避免\"A 还没来得及 unregister，B 已经抢注册\"时，\n      // A 的 cleanup 误把 B 刚设置的 activeEntry 清掉。\n      if (activeEntry === entry) activeEntry = undefined;\n    };\n  };\n\n  const claim: TooltipGroupContextValue[\"claim\"] = () => {\n    if (!activeEntry) return undefined;\n    const rect = activeEntry.rect();\n    activeEntry.forceClose();\n    activeEntry = undefined;\n\n    // 防御性检查：一个真实可见的 tooltip 不可能宽高都是 0——如果读到的是\n    // 这种全 0 矩形，大概率是读到了一个已经从 DOM 里摘除的 detached 元素\n    // （getBoundingClientRect 规范规定这种情况下就是全 0）。这种情况下\n    // 宁可放弃这次平移过渡（新 tooltip 走正常的 openDelay 流程），也不要\n    // 把 (0,0) 当成合法的滑入起点，出现\"从左上角滑入\"这种明显错误的观感。\n    if (!rect || (rect.width === 0 && rect.height === 0)) return undefined;\n    return rect;\n  };\n\n  const ctx: TooltipGroupContextValue = { registerActive, claim };\n\n  return (\n    <TooltipGroupContext.Provider value={ctx}>\n      {props.children}\n    </TooltipGroupContext.Provider>\n  );\n}\n"],"mappings":";;;AAOA,SAAgBI,EAAaC,GAA0B;CAIrD,IAAIC;CA8BJ,OAAAU,EACGhB,EAAoBiB,UAAQ;EAACC,OAAOH;GAHCR,iBAzBtCC,OAEAF,IAAcE,SACD;IAGX,AAAIF,MAAgBE,MAAOF,IAAcG,KAAAA;GAC3C;GAkBsDC,aAfD;IACrD,IAAI,CAACJ,GAAa;IAClB,IAAMK,IAAOL,EAAYK,KAAK;IAC9BL,MAAYM,WAAW,GACvBN,IAAcG,KAAAA,GAOV,GAACE,KAASA,EAAKE,UAAU,KAAKF,EAAKG,WAAW,IAClD,OAAOH;GACT;EAKuCI;EAAG,IAAAI,WAAA;GAAA,OACrCd,EAAMc;EAAQ;CAAA,CAAA;AAGrB"}

package/dist/components/tooltip/TooltipGroup/TooltipGroup.types.d.ts

@@ -0,0 +1,10 @@
+import { ParentProps } from 'solid-js';
+/**
+ * <TooltipGroup> 是可选的：把多个 <Tooltip> 包在一起，组内相邻 trigger 之间
+ * 切换 hover 时，会跳过 openDelay 并触发"从旧位置滑到新位置"的过渡效果，
+ * 而不是旧的先走完退场动画、新的再等 openDelay 出现。
+ *
+ * 不需要这个效果的话，<Tooltip> 完全可以脱离 <TooltipGroup> 单独使用，
+ * 行为不受影响（内部用 useTooltipGroupContext 判断是否存在，缺失时静默降级）。
+ */
+export type TooltipGroupProps = ParentProps;

package/dist/components/tooltip/TooltipGroup/index.d.ts

@@ -0,0 +1,4 @@
+export { TooltipGroup } from './TooltipGroup';
+export { TooltipGroupContext, useTooltipGroupContext, } from './TooltipGroup.context';
+export type { TooltipGroupContextValue, ActiveTooltipEntry, } from './TooltipGroup.context';
+export type { TooltipGroupProps } from './TooltipGroup.types';

package/dist/components/tooltip/TooltipTrigger/TooltipTrigger.d.ts

@@ -1,2 +1,4 @@
-import { JSXElement, ParentProps } from 'solid-js';
-export declare const TooltipTrigger: (props: ParentProps) => JSXElement;
+import { ValidComponent } from 'solid-js';
+import { TooltipTriggerProps } from './TooltipTrigger.types';
+import { Button } from '../../button';
+export declare const TooltipTrigger: <T extends ValidComponent = typeof Button<"button">>(props: TooltipTriggerProps<T>) => import("solid-js").JSX.Element;

package/dist/components/tooltip/TooltipTrigger/TooltipTrigger.js

@@ -1,11 +1,31 @@
-import { useTooltipTrigger as e } from "./useTooltipTrigger.js";
-import { children as t, untrack as n } from "solid-js";
+import { Button as e } from "../../button/Button.js";
+import { useTooltipTrigger as t } from "./useTooltipTrigger.js";
+import { Dynamic as n, createComponent as r, memo as i, mergeProps as a } from "solid-js/web";
 //#region src/components/tooltip/TooltipTrigger/TooltipTrigger.tsx
-var r = (r) => {
-	let i = t(() => n(() => r.children));
-	return e(i), i;
+function o(...e) {
+	return (t) => {
+		for (let n of e) typeof n == "function" && n(t);
+	};
+}
+var s = (s) => {
+	let { ctx: c, attachListeners: l } = t();
+	return r(n, a(s, {
+		get component() {
+			return s.component ?? e;
+		},
+		ref(e) {
+			var t = o(c.setReference, s.ref, l);
+			typeof t == "function" && t(e);
+		},
+		get "aria-describedby"() {
+			return i(() => !!c.open())() ? c.contentId : void 0;
+		},
+		get "data-state"() {
+			return c.open() ? "open" : "closed";
+		}
+	}));
 };
 //#endregion
-export { r as TooltipTrigger };
+export { s as TooltipTrigger };
 
 //# sourceMappingURL=TooltipTrigger.js.map

package/dist/components/tooltip/TooltipTrigger/TooltipTrigger.js.map

@@ -1 +1 @@
-{"version":3,"file":"TooltipTrigger.js","names":["children","untrack","JSXElement","ParentProps","useTooltipTrigger","TooltipTrigger","props","resolved"],"sources":["../../../../src/components/tooltip/TooltipTrigger/TooltipTrigger.tsx"],"sourcesContent":["import { children, untrack, type JSXElement, type ParentProps } from \"solid-js\";\nimport { useTooltipTrigger } from \"./useTooltipTrigger\";\n\nexport const TooltipTrigger = (props: ParentProps) => {\n  const resolved = children(() => untrack(() => props.children));\n  useTooltipTrigger(resolved);\n\n  return resolved as unknown as JSXElement;\n};\n"],"mappings":";;;AAGA,IAAaK,KAAkBC,MAAuB;CACpD,IAAMC,IAAWP,QAAeC,QAAcK,EAAMN,SAAS,CAAC;AAG9D,QAFAI,EAAkBG,EAAS,EAEpBA"}
+{"version":3,"file":"TooltipTrigger.js","names":["ValidComponent","Dynamic","useTooltipTrigger","TooltipTriggerProps","Button","mergeRefs","refs","Array","Element","el","ref","TooltipTrigger","props","T","ctx","attachListeners","_$createComponent","_$mergeProps","component","r$","_ref$","setReference","aria-describedby","_$memo","open","contentId","undefined","data-state"],"sources":["../../../../src/components/tooltip/TooltipTrigger/TooltipTrigger.tsx"],"sourcesContent":["import type { ValidComponent } from \"solid-js\";\nimport { Dynamic } from \"solid-js/web\";\n\nimport { useTooltipTrigger } from \"./useTooltipTrigger\";\nimport type { TooltipTriggerProps } from \"./TooltipTrigger.types\";\n\nimport { Button } from \"~/components/button\";\n\n/**\n * 合并多个 ref，依次调用，谁都不会覆盖谁。\n *\n * 类型上写成 `Element | ((el: Element) => void)`，是为了匹配 Solid 的 ref\n * 类型约定（调用方在 JSX 里可以写 `ref={myVar}` 也可以写 `ref={(el) => ...}`）。\n * 但组件内部实际拿到的 props.ref，无论调用方是哪种写法，Solid 编译器都会\n * 统一规整成回调函数再转发进来（这是官方文档明确说明的行为：\n * https://docs.solidjs.com/concepts/refs#forwarding-refs），所以这里直接\n * 当函数调用即可，不需要再判断类型。\n */\nfunction mergeRefs(\n  ...refs: Array<Element | ((el: Element) => void) | undefined>\n) {\n  return (el: Element) => {\n    for (const ref of refs) {\n      if (typeof ref === \"function\") ref(el);\n    }\n  };\n}\n\nexport const TooltipTrigger = <\n  T extends ValidComponent = typeof Button<\"button\">,\n>(\n  props: TooltipTriggerProps<T>,\n) => {\n  const { ctx, attachListeners } = useTooltipTrigger();\n\n  return (\n    <Dynamic\n      {...props}\n      component={(props.component as ValidComponent) ?? Button<\"button\">}\n      ref={mergeRefs(ctx.setReference, props.ref, attachListeners)}\n      aria-describedby={ctx.open() ? ctx.contentId : undefined}\n      data-state={ctx.open() ? \"open\" : \"closed\"}\n      // data-disabled={props.disabled ? \"\" : undefined}\n    />\n  );\n};\n"],"mappings":";;;;AAkBA,SAASK,EACP,GAAGC,GACH;CACA,QAAQG,MAAgB;EACtB,KAAK,IAAMC,KAAOJ,GAChB,AAAI,OAAOI,KAAQ,cAAYA,EAAID,CAAE;CAEzC;AACF;AAEA,IAAaE,KAGXC,MACG;CACH,IAAM,EAAEE,QAAKC,uBAAoBb,EAAkB;CAEnD,OAAAc,EACGf,GAAOgB,EACFL,GAAK;EAAA,IACTM,YAAS;GAAA,OAAGN,EAAMM,aAAgCd;EAAgB;EAAAM,IAAAS,GAAA;GAAA,IAAAC,IAC7Df,EAAUS,EAAIO,cAAcT,EAAMF,KAAKK,CAAe;GAAC,OAAAK,KAAA,cAAAA,EAAAD,CAAA;EAAA;EAAA,IAAA,qBAAA;GAAA,OAC1CI,QAAA,CAAA,CAAAT,EAAIU,KAAK,CAAC,CAAA,CAAA,IAAGV,EAAIW,YAAYC,KAAAA;EAAS;EAAA,IAAA,eAAA;GAAA,OAC5CZ,EAAIU,KAAK,IAAI,SAAS;EAAQ;CAAA,CAAA,CAAA;AAIhD"}

package/dist/components/tooltip/TooltipTrigger/TooltipTrigger.types.d.ts

@@ -0,0 +1,3 @@
+import { ValidComponent } from 'solid-js';
+import { PolymorphicProps } from '../../../types';
+export type TooltipTriggerProps<T extends ValidComponent> = PolymorphicProps<T>;

package/dist/components/tooltip/TooltipTrigger/index.d.ts

@@ -1 +1,4 @@
 export { TooltipTrigger } from './TooltipTrigger';
+export type { TooltipTriggerProps } from './TooltipTrigger.types';
+export { useTooltipTrigger } from './useTooltipTrigger';
+export type { UseTooltipTriggerResult } from './useTooltipTrigger';

package/dist/components/tooltip/TooltipTrigger/useTooltipTrigger.d.ts

@@ -1,2 +1,29 @@
-import { ChildrenReturn } from 'solid-js';
-export declare const useTooltipTrigger: (resolved: ChildrenReturn) => void;
+import { useTooltipContext } from '../Tooltip/Tooltip.context';
+export interface UseTooltipTriggerResult {
+    ctx: ReturnType<typeof useTooltipContext>;
+    /**
+     * 把打开/关闭相关的原生事件监听器绑定到真正的 DOM 元素上（通过 ref 调用）。
+     * 用 addEventListener 而不是 JSX 的 onXxx prop，是为了不占用这些 prop 名——
+     * 调用方可以在 <TooltipTrigger onClick={...} onMouseEnter={...}> 上自由传
+     * 自己的原生事件处理，两者是完全独立的两套机制（一个走 Solid 的事件系统，
+     * 一个是原生 addEventListener），互不覆盖、都会正常触发。
+     */
+    attachListeners: (el: Element) => void;
+}
+/**
+ * 封装 TooltipTrigger 需要绑定的所有事件逻辑：
+ * - pointerenter/pointerleave（悬停进入/离开）走 openDelay/closeDelay
+ * - focus/blur（键盘导航）跳过延迟，立即开关——这是无障碍要求，键盘用户不该被迫等待
+ * - Escape 立即关闭，并阻止冒泡（避免被外层其他也监听 Escape 的逻辑重复处理）
+ * - mousedown 立即关闭——贴近 shadcn/Radix 的行为：用户开始点击这个元素，
+ *   就意味着要跟它交互了，tooltip 这时候还杵在那儿会挡视线，应该立刻让路，
+ *   不用等 pointerleave 或者走 closeDelay。
+ *
+ * mousedown 和 focus 之间有一个容易踩的坑：原生事件顺序是
+ * mousedown → focus → mouseup → click——点击一个可聚焦元素（比如 <button>），
+ * 浏览器会在 mousedown 之后自动给它 focus。如果不做处理，mousedown 刚关掉
+ * tooltip，紧跟着浏览器自动触发的 focus 又会把它立刻重新打开，两条逻辑打架。
+ * 用 isPointerDown 标记"这次 focus 是不是紧跟在点击后面被动触发的"，是的话
+ * 就跳过重新打开，只有真正的键盘 Tab 导航触发的 focus 才会打开 tooltip。
+ */
+export declare function useTooltipTrigger(): UseTooltipTriggerResult;

package/dist/components/tooltip/TooltipTrigger/useTooltipTrigger.js

@@ -1,34 +1,34 @@
 import { useTooltipContext as e } from "../Tooltip/Tooltip.context.js";
-import { onCleanup as t, onMount as n } from "solid-js";
+import { onCleanup as t } from "solid-js";
 //#region src/components/tooltip/TooltipTrigger/useTooltipTrigger.ts
-var r = (r) => {
-	let { setOpen: i, openDelay: a, closeDelay: o, setTriggerRef: s } = e(), c, l, u = () => {
-		clearTimeout(l), c = setTimeout(() => i(!0), a);
-	}, d = () => {
-		clearTimeout(c), l = setTimeout(() => i(!1), o);
-	}, f = (e) => {
-		console.log("鼠标移入", e.type), u();
-	}, p = (e) => {
-		console.log("鼠标移出", e.type), d();
-	}, m = (e) => {
-		console.log("鼠标按下", e.type), d();
-	};
-	n(() => {
-		let e = r.toArray();
-		e.length !== 1 && console.warn("[Tooltip] TooltipTrigger should have exactly one child");
-		let n = e[0];
-		if (n) {
-			if (!(n instanceof HTMLElement)) {
-				console.error("[Tooltip] TooltipTrigger child should be an HTMLElement");
-				return;
-			}
-			s(n), n.addEventListener("pointerenter", f), n.addEventListener("pointerleave", p), n.addEventListener("mousedown", m), n.addEventListener("blur", p), t(() => {
-				clearTimeout(c), clearTimeout(l), n && (n.removeEventListener("pointerenter", f), n.removeEventListener("pointerleave", p), n.removeEventListener("mousedown", m), n.removeEventListener("blur", p));
+function n() {
+	let n = e("TooltipTrigger");
+	return {
+		ctx: n,
+		attachListeners: (e) => {
+			let r = !1, i = () => {
+				n.disabled() || n.requestOpen();
+			}, a = () => {
+				n.requestClose();
+			}, o = () => {
+				r || n.disabled() || n.openImmediate();
+			}, s = () => {
+				n.closeImmediate();
+			}, c = (e) => {
+				let t = e;
+				t.key === "Escape" && n.open() && (t.stopPropagation(), n.closeImmediate());
+			}, l = () => {
+				r = !0, !n.disabled() && n.open() && n.closeImmediate();
+			}, u = () => {
+				r = !1;
+			};
+			e.addEventListener("pointerenter", i), e.addEventListener("pointerleave", a), e.addEventListener("focus", o), e.addEventListener("blur", s), e.addEventListener("keydown", c), e.addEventListener("mousedown", l), document.addEventListener("mouseup", u), t(() => {
+				e.removeEventListener("pointerenter", i), e.removeEventListener("pointerleave", a), e.removeEventListener("focus", o), e.removeEventListener("blur", s), e.removeEventListener("keydown", c), e.removeEventListener("mousedown", l), document.removeEventListener("mouseup", u);
 			});
 		}
-	});
-};
+	};
+}
 //#endregion
-export { r as useTooltipTrigger };
+export { n as useTooltipTrigger };
 
 //# sourceMappingURL=useTooltipTrigger.js.map

package/dist/components/tooltip/TooltipTrigger/useTooltipTrigger.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTooltipTrigger.js","names":[],"sources":["../../../../src/components/tooltip/TooltipTrigger/useTooltipTrigger.ts"],"sourcesContent":["import { onCleanup, onMount, type ChildrenReturn } from \"solid-js\";\nimport type { TimeoutID } from \"~/types\";\nimport { useTooltipContext } from \"../Tooltip/Tooltip.context\";\n\nexport const useTooltipTrigger = (resolved: ChildrenReturn) => {\n  const { setOpen, openDelay, closeDelay, setTriggerRef } = useTooltipContext();\n\n  let openTimer: TimeoutID;\n  let closeTimer: TimeoutID;\n\n  const open = () => {\n    clearTimeout(closeTimer);\n    openTimer = setTimeout(() => setOpen(true), openDelay);\n  };\n\n  const close = () => {\n    clearTimeout(openTimer);\n    closeTimer = setTimeout(() => setOpen(false), closeDelay);\n  };\n\n  const handleMouseEnter = (ev: PointerEvent) => {\n    console.log(\"鼠标移入\", ev.type);\n    open();\n  };\n  const handleMouseLeave = (ev: PointerEvent | FocusEvent) => {\n    console.log(\"鼠标移出\", ev.type);\n    close();\n  };\n  const handleMouseDown = (ev: Event) => {\n    console.log(\"鼠标按下\", ev.type);\n    close();\n  };\n\n  onMount(() => {\n    const trigger = resolved.toArray();\n    if (trigger.length !== 1) {\n      console.warn(\"[Tooltip] TooltipTrigger should have exactly one child\");\n    }\n\n    const el = trigger[0] as HTMLElement | undefined;\n\n    if (!el) return;\n\n    if (!(el instanceof HTMLElement)) {\n      console.error(\"[Tooltip] TooltipTrigger child should be an HTMLElement\");\n      return;\n    }\n\n    setTriggerRef(el);\n    el.addEventListener(\"pointerenter\", handleMouseEnter);\n    el.addEventListener(\"pointerleave\", handleMouseLeave);\n    el.addEventListener(\"mousedown\", handleMouseDown);\n    el.addEventListener(\"blur\", handleMouseLeave);\n\n    onCleanup(() => {\n      clearTimeout(openTimer);\n      clearTimeout(closeTimer);\n\n      if (!el) return;\n      el.removeEventListener(\"pointerenter\", handleMouseEnter);\n      el.removeEventListener(\"pointerleave\", handleMouseLeave);\n      el.removeEventListener(\"mousedown\", handleMouseDown);\n      el.removeEventListener(\"blur\", handleMouseLeave);\n    });\n  });\n\n  // createEffect(() => {\n  //   el = resolved() as HTMLElement | undefined;\n  //   if (!el) return;\n\n  //   const handleMouseEnter = () => {\n  //     open();\n  //   };\n  //   const handleMouseLeave = () => {\n  //     close();\n  //   };\n  //   const handleMouseDown = () => close();\n\n  //   untrack(() => setTriggerRef(el!));\n  //   el.addEventListener(\"mouseenter\", handleMouseEnter);\n  //   el.addEventListener(\"mouseleave\", handleMouseLeave);\n  //   el.addEventListener(\"mousedown\", handleMouseDown);\n  //   el.addEventListener(\"blur\", handleMouseLeave);\n\n  //   onCleanup(() => {\n  //     el!.removeEventListener(\"mouseenter\", handleMouseEnter);\n  //     el!.removeEventListener(\"mouseleave\", handleMouseLeave);\n  //     el!.removeEventListener(\"mousedown\", handleMouseDown);\n  //     el!.removeEventListener(\"blur\", handleMouseLeave);\n  //   });\n  // });\n\n  // onCleanup(() => {\n  //   clearTimeout(openTimer);\n  //   clearTimeout(closeTimer);\n  // });\n};\n"],"mappings":";;;AAIA,IAAa,KAAqB,MAA6B;CAC7D,IAAM,EAAE,YAAS,cAAW,eAAY,qBAAkB,GAAmB,EAEzE,GACA,GAEE,UAAa;AAEjB,EADA,aAAa,EAAW,EACxB,IAAY,iBAAiB,EAAQ,GAAK,EAAE,EAAU;IAGlD,UAAc;AAElB,EADA,aAAa,EAAU,EACvB,IAAa,iBAAiB,EAAQ,GAAM,EAAE,EAAW;IAGrD,KAAoB,MAAqB;AAE7C,EADA,QAAQ,IAAI,QAAQ,EAAG,KAAK,EAC5B,GAAM;IAEF,KAAoB,MAAkC;AAE1D,EADA,QAAQ,IAAI,QAAQ,EAAG,KAAK,EAC5B,GAAO;IAEH,KAAmB,MAAc;AAErC,EADA,QAAQ,IAAI,QAAQ,EAAG,KAAK,EAC5B,GAAO;;AAGT,SAAc;EACZ,IAAM,IAAU,EAAS,SAAS;AAClC,EAAI,EAAQ,WAAW,KACrB,QAAQ,KAAK,yDAAyD;EAGxE,IAAM,IAAK,EAAQ;AAEd,SAEL;OAAI,EAAE,aAAc,cAAc;AAChC,YAAQ,MAAM,0DAA0D;AACxE;;AASF,GANA,EAAc,EAAG,EACjB,EAAG,iBAAiB,gBAAgB,EAAiB,EACrD,EAAG,iBAAiB,gBAAgB,EAAiB,EACrD,EAAG,iBAAiB,aAAa,EAAgB,EACjD,EAAG,iBAAiB,QAAQ,EAAiB,EAE7C,QAAgB;AACd,iBAAa,EAAU,EACvB,aAAa,EAAW,EAEnB,MACL,EAAG,oBAAoB,gBAAgB,EAAiB,EACxD,EAAG,oBAAoB,gBAAgB,EAAiB,EACxD,EAAG,oBAAoB,aAAa,EAAgB,EACpD,EAAG,oBAAoB,QAAQ,EAAiB;KAChD;;GACF"}
+{"version":3,"file":"useTooltipTrigger.js","names":[],"sources":["../../../../src/components/tooltip/TooltipTrigger/useTooltipTrigger.ts"],"sourcesContent":["import { onCleanup } from \"solid-js\";\nimport { useTooltipContext } from \"../Tooltip/Tooltip.context\";\n\nexport interface UseTooltipTriggerResult {\n  ctx: ReturnType<typeof useTooltipContext>;\n  /**\n   * 把打开/关闭相关的原生事件监听器绑定到真正的 DOM 元素上（通过 ref 调用）。\n   * 用 addEventListener 而不是 JSX 的 onXxx prop，是为了不占用这些 prop 名——\n   * 调用方可以在 <TooltipTrigger onClick={...} onMouseEnter={...}> 上自由传\n   * 自己的原生事件处理，两者是完全独立的两套机制（一个走 Solid 的事件系统，\n   * 一个是原生 addEventListener），互不覆盖、都会正常触发。\n   */\n  attachListeners: (el: Element) => void;\n}\n\n/**\n * 封装 TooltipTrigger 需要绑定的所有事件逻辑：\n * - pointerenter/pointerleave（悬停进入/离开）走 openDelay/closeDelay\n * - focus/blur（键盘导航）跳过延迟，立即开关——这是无障碍要求，键盘用户不该被迫等待\n * - Escape 立即关闭，并阻止冒泡（避免被外层其他也监听 Escape 的逻辑重复处理）\n * - mousedown 立即关闭——贴近 shadcn/Radix 的行为：用户开始点击这个元素，\n *   就意味着要跟它交互了，tooltip 这时候还杵在那儿会挡视线，应该立刻让路，\n *   不用等 pointerleave 或者走 closeDelay。\n *\n * mousedown 和 focus 之间有一个容易踩的坑：原生事件顺序是\n * mousedown → focus → mouseup → click——点击一个可聚焦元素（比如 <button>），\n * 浏览器会在 mousedown 之后自动给它 focus。如果不做处理，mousedown 刚关掉\n * tooltip，紧跟着浏览器自动触发的 focus 又会把它立刻重新打开，两条逻辑打架。\n * 用 isPointerDown 标记\"这次 focus 是不是紧跟在点击后面被动触发的\"，是的话\n * 就跳过重新打开，只有真正的键盘 Tab 导航触发的 focus 才会打开 tooltip。\n */\nexport function useTooltipTrigger(): UseTooltipTriggerResult {\n  const ctx = useTooltipContext(\"TooltipTrigger\");\n\n  const attachListeners = (el: Element) => {\n    let isPointerDown = false;\n\n    const onPointerEnter = () => {\n      if (!ctx.disabled()) ctx.requestOpen();\n    };\n    const onPointerLeave = () => {\n      ctx.requestClose();\n    };\n    const onFocus = () => {\n      // 紧跟在 mousedown 后面的这次 focus 是浏览器自动带出来的副作用，\n      // 不代表用户在用键盘导航，不应该重新打开刚被 mousedown 关掉的 tooltip。\n      if (isPointerDown) return;\n      if (!ctx.disabled()) ctx.openImmediate();\n    };\n    const onBlur = () => {\n      ctx.closeImmediate();\n    };\n    const onKeyDown = (e: Event) => {\n      const keyboardEvent = e as KeyboardEvent;\n      if (keyboardEvent.key === \"Escape\" && ctx.open()) {\n        keyboardEvent.stopPropagation();\n        ctx.closeImmediate();\n      }\n    };\n    const onMouseDown = () => {\n      isPointerDown = true;\n      if (ctx.disabled()) return;\n      if (ctx.open()) ctx.closeImmediate();\n    };\n    // 标记要在 mouseup 时清掉，而且特意监听 document 而不是元素自己的\n    // mouseup——如果鼠标按下后拖动到元素外面再松开，元素自己收不到 mouseup，\n    // 标记会一直卡在 true，导致后续真正的键盘 focus 也被误伤跳过。\n    const onDocumentMouseUp = () => {\n      isPointerDown = false;\n    };\n\n    el.addEventListener(\"pointerenter\", onPointerEnter);\n    el.addEventListener(\"pointerleave\", onPointerLeave);\n    el.addEventListener(\"focus\", onFocus);\n    el.addEventListener(\"blur\", onBlur);\n    el.addEventListener(\"keydown\", onKeyDown);\n    el.addEventListener(\"mousedown\", onMouseDown);\n    document.addEventListener(\"mouseup\", onDocumentMouseUp);\n\n    onCleanup(() => {\n      el.removeEventListener(\"pointerenter\", onPointerEnter);\n      el.removeEventListener(\"pointerleave\", onPointerLeave);\n      el.removeEventListener(\"focus\", onFocus);\n      el.removeEventListener(\"blur\", onBlur);\n      el.removeEventListener(\"keydown\", onKeyDown);\n      el.removeEventListener(\"mousedown\", onMouseDown);\n      document.removeEventListener(\"mouseup\", onDocumentMouseUp);\n    });\n  };\n\n  return { ctx, attachListeners };\n}\n"],"mappings":";;;AA+BA,SAAgB,IAA6C;CAC3D,IAAM,IAAM,EAAkB,gBAAgB;CA0D9C,OAAO;EAAE;EAAK,kBAxDW,MAAgB;GACvC,IAAI,IAAgB,IAEd,UAAuB;IAC3B,AAAK,EAAI,SAAS,KAAG,EAAI,YAAY;GACvC,GACM,UAAuB;IAC3B,EAAI,aAAa;GACnB,GACM,UAAgB;IAGhB,KACC,EAAI,SAAS,KAAG,EAAI,cAAc;GACzC,GACM,UAAe;IACnB,EAAI,eAAe;GACrB,GACM,KAAa,MAAa;IAC9B,IAAM,IAAgB;IACtB,AAAI,EAAc,QAAQ,YAAY,EAAI,KAAK,MAC7C,EAAc,gBAAgB,GAC9B,EAAI,eAAe;GAEvB,GACM,UAAoB;IACxB,IAAgB,IACZ,GAAI,SAAS,KACb,EAAI,KAAK,KAAG,EAAI,eAAe;GACrC,GAIM,UAA0B;IAC9B,IAAgB;GAClB;GAUA,AARA,EAAG,iBAAiB,gBAAgB,CAAc,GAClD,EAAG,iBAAiB,gBAAgB,CAAc,GAClD,EAAG,iBAAiB,SAAS,CAAO,GACpC,EAAG,iBAAiB,QAAQ,CAAM,GAClC,EAAG,iBAAiB,WAAW,CAAS,GACxC,EAAG,iBAAiB,aAAa,CAAW,GAC5C,SAAS,iBAAiB,WAAW,CAAiB,GAEtD,QAAgB;IAOd,AANA,EAAG,oBAAoB,gBAAgB,CAAc,GACrD,EAAG,oBAAoB,gBAAgB,CAAc,GACrD,EAAG,oBAAoB,SAAS,CAAO,GACvC,EAAG,oBAAoB,QAAQ,CAAM,GACrC,EAAG,oBAAoB,WAAW,CAAS,GAC3C,EAAG,oBAAoB,aAAa,CAAW,GAC/C,SAAS,oBAAoB,WAAW,CAAiB;GAC3D,CAAC;EACH;CAE8B;AAChC"}