@neut/ui 0.0.9 → 0.0.11

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"}

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

@@ -1,4 +1,10 @@
 export { Tooltip } from './Tooltip';
+export type { TooltipProps, TooltipContextValue } from './Tooltip';
 export { TooltipTrigger } from './TooltipTrigger';
+export type { TooltipTriggerProps } from './TooltipTrigger';
 export { TooltipContent } from './TooltipContent';
+export type { TooltipContentProps } from './TooltipContent';
 export { TooltipArrow } from './TooltipArrow';
+export type { TooltipArrowProps } from './TooltipArrow';
+export { TooltipGroup } from './TooltipGroup';
+export type { TooltipGroupProps, TooltipGroupContextValue, ActiveTooltipEntry, } from './TooltipGroup';

package/dist/components/tooltip/index.js

@@ -2,4 +2,5 @@ import { Tooltip as e } from "./Tooltip/Tooltip.js";
 import { TooltipTrigger as t } from "./TooltipTrigger/TooltipTrigger.js";
 import { TooltipContent as n } from "./TooltipContent/TooltipContent.js";
 import { TooltipArrow as r } from "./TooltipArrow/TooltipArrow.js";
-export { e as Tooltip, r as TooltipArrow, n as TooltipContent, t as TooltipTrigger };
+import { TooltipGroup as i } from "./TooltipGroup/TooltipGroup.js";
+export { e as Tooltip, r as TooltipArrow, n as TooltipContent, i as TooltipGroup, t as TooltipTrigger };

package/dist/hooks/useFontLoader.js

@@ -59,7 +59,7 @@ var n = {
 	}
 }, r = /* @__PURE__ */ new Set();
 function i(e) {
-	return e.filter((e) => e in n ? !0 : (process.env.NODE_ENV !== "production" && console.warn(`[useFontLoader] unsupported lang: "${e}". Supported values: ${Object.keys(n).join(", ")}`), !1));
+	return e.filter((e) => e in n);
 }
 function a(e) {
 	let t = e.filter((e) => !r.has(n[e].family));

package/dist/hooks/useFontLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFontLoader.js","names":[],"sources":["../../src/hooks/useFontLoader.ts"],"sourcesContent":["import { createEffect, onCleanup } from \"solid-js\";\n\n// ─── 字体配置表 ────────────────────────────────────────────────\nconst FONT_MAP = {\n  en: { family: \"Inter\", weights: \"400;500;700\" },\n  fr: { family: \"Inter\", weights: \"400;500;700\" },\n  de: { family: \"Inter\", weights: \"400;500;700\" },\n  ru: { family: \"Noto+Sans\", weights: \"400;500;700\" },\n  \"zh-hans\": { family: \"Noto+Sans+SC\", weights: \"400;500;700\" },\n  \"zh-hant\": { family: \"Noto+Sans+TC\", weights: \"400;500;700\" },\n  ja: { family: \"Noto+Sans+JP\", weights: \"400;500;700\" },\n  ko: { family: \"Noto+Sans+KR\", weights: \"400;500;700\" },\n  hi: { family: \"Noto+Sans+Devanagari\", weights: \"400;500;700\" },\n  th: { family: \"Noto+Sans+Thai\", weights: \"400;500;700\" },\n  bn: { family: \"Noto+Sans+Bengali\", weights: \"400;500;700\" },\n  ar: { family: \"Noto+Sans+Arabic\", weights: \"400;500;700\" },\n  he: { family: \"Noto+Sans+Hebrew\", weights: \"400;500;700\" },\n  fa: { family: \"Noto+Sans+Arabic\", weights: \"400;500;700\" },\n} as const satisfies Record<string, { family: string; weights: string }>;\n\nexport type Lang = keyof typeof FONT_MAP;\n\n// ─── 已加载字体缓存（模块级单例，避免重复插入） ──────────────\nconst loaded = new Set<string>();\n\nfunction filterValidLangs(langs: string[]): Lang[] {\n  return langs.filter((lang): lang is Lang => {\n    if (lang in FONT_MAP) return true;\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\n        `[useFontLoader] unsupported lang: \"${lang}\". ` +\n          `Supported values: ${Object.keys(FONT_MAP).join(\", \")}`,\n      );\n    }\n    return false;\n  });\n}\n\nexport interface UseFontLoaderOptions {\n  /**\n   * 要加载的字体对应的语言\n   *\n   * 默认为`en`\n   */\n  langs?: Lang | Lang[];\n\n  /**\n   * 指定 data-lang 写入的目标元素。\n   * - 传入 ref：仅在该元素上生效，适合局部语言切换。\n   * - 不传（undefined）：写入 ，全局生效。\n   * 卸载时自动恢复目标元素的原始 data-lang 值。\n   *\n   * apply 为 false 时此选项无效。\n   */\n  targetRef?: HTMLElement;\n\n  /**\n   * 是否将 data-lang 写入目标元素以应用字体样式。\n   * - true（默认）：写入 data-lang，字体立即生效。\n   * - false：仅预加载字体资源，不修改任何 DOM，\n   *   适合提前预热用户可能切换到的语言字体。\n   * @default\n   */\n  apply?: boolean;\n}\n\n/* ----------------------------------------------------------------\n   工具：插入 Google Fonts\n   ---------------------------------------------------------------- */\nfunction loadGoogleFonts(langs: Lang[]): void {\n  const toLoad = langs.filter((lang) => !loaded.has(FONT_MAP[lang].family));\n  if (toLoad.length === 0) return;\n\n  const families = [\n    ...new Set(\n      toLoad.map((lang) => {\n        const { family, weights } = FONT_MAP[lang];\n        return `family=${family}:wght@${weights}`;\n      }),\n    ),\n  ];\n\n  const link = document.createElement(\"link\");\n  link.rel = \"stylesheet\";\n  link.href = `https://fonts.googleapis.com/css2?${families.join(\"&\")}&display=swap`;\n\n  document.head.appendChild(link);\n  for (const lang of toLoad) {\n    loaded.add(FONT_MAP[lang].family);\n  }\n}\n\n// ─── Hook ─────────────────────────────────────────────────────\nexport function useFontLoader(options?: UseFontLoaderOptions) {\n  const {\n    langs = \"en\",\n    targetRef = document.documentElement,\n    apply = true,\n  } = options ?? {};\n\n  const langList = Array.isArray(langs) ? langs : [langs];\n  const validLangs = filterValidLangs(langList);\n\n  // --- 加载字体资源 ---\n  createEffect(() => {\n    loadGoogleFonts(validLangs);\n  });\n\n  // --- 将 data-lang 写入目标元素 ---\n  createEffect(() => {\n    if (!apply || validLangs.length === 0) return;\n\n    // targetRef 未传或 ref.current 尚未挂载时，回退到\n    const el = targetRef ?? document.documentElement;\n    const lang = validLangs[0];\n    const prev = el.getAttribute(\"data-lang\");\n\n    el.setAttribute(\"data-lang\", lang);\n\n    onCleanup(() => {\n      // 卸载时恢复：原本有值则还原，原本无则移除\n      if (prev === null) {\n        el.removeAttribute(\"data-lang\");\n      } else {\n        el.setAttribute(\"data-lang\", prev);\n      }\n    });\n  });\n}\n"],"mappings":";;AAGA,IAAM,IAAW;CACf,IAAI;EAAE,QAAQ;EAAS,SAAS;EAAe;CAC/C,IAAI;EAAE,QAAQ;EAAS,SAAS;EAAe;CAC/C,IAAI;EAAE,QAAQ;EAAS,SAAS;EAAe;CAC/C,IAAI;EAAE,QAAQ;EAAa,SAAS;EAAe;CACnD,WAAW;EAAE,QAAQ;EAAgB,SAAS;EAAe;CAC7D,WAAW;EAAE,QAAQ;EAAgB,SAAS;EAAe;CAC7D,IAAI;EAAE,QAAQ;EAAgB,SAAS;EAAe;CACtD,IAAI;EAAE,QAAQ;EAAgB,SAAS;EAAe;CACtD,IAAI;EAAE,QAAQ;EAAwB,SAAS;EAAe;CAC9D,IAAI;EAAE,QAAQ;EAAkB,SAAS;EAAe;CACxD,IAAI;EAAE,QAAQ;EAAqB,SAAS;EAAe;CAC3D,IAAI;EAAE,QAAQ;EAAoB,SAAS;EAAe;CAC1D,IAAI;EAAE,QAAQ;EAAoB,SAAS;EAAe;CAC1D,IAAI;EAAE,QAAQ;EAAoB,SAAS;EAAe;CAC3D,EAKK,oBAAS,IAAI,KAAa;AAEhC,SAAS,EAAiB,GAAyB;AACjD,QAAO,EAAM,QAAQ,MACf,KAAQ,IAAiB,MAC7B,QAAA,IAAA,aAA6B,gBAC3B,QAAQ,KACN,sCAAsC,EAAK,uBACpB,OAAO,KAAK,EAAS,CAAC,KAAK,KAAK,GACxD,EAEI,IACP;;AAkCJ,SAAS,EAAgB,GAAqB;CAC5C,IAAM,IAAS,EAAM,QAAQ,MAAS,CAAC,EAAO,IAAI,EAAS,GAAM,OAAO,CAAC;AACzE,KAAI,EAAO,WAAW,EAAG;CAEzB,IAAM,IAAW,CACf,GAAG,IAAI,IACL,EAAO,KAAK,MAAS;EACnB,IAAM,EAAE,WAAQ,eAAY,EAAS;AACrC,SAAO,UAAU,EAAO,QAAQ;GAChC,CACH,CACF,EAEK,IAAO,SAAS,cAAc,OAAO;AAI3C,CAHA,EAAK,MAAM,cACX,EAAK,OAAO,qCAAqC,EAAS,KAAK,IAAI,CAAC,gBAEpE,SAAS,KAAK,YAAY,EAAK;AAC/B,MAAK,IAAM,KAAQ,EACjB,GAAO,IAAI,EAAS,GAAM,OAAO;;AAKrC,SAAgB,EAAc,GAAgC;CAC5D,IAAM,EACJ,WAAQ,MACR,eAAY,SAAS,iBACrB,WAAQ,OACN,KAAW,EAAE,EAGX,IAAa,EADF,MAAM,QAAQ,EAAM,GAAG,IAAQ,CAAC,EAAM,CACV;AAQ7C,CALA,QAAmB;AACjB,IAAgB,EAAW;GAC3B,EAGF,QAAmB;AACjB,MAAI,CAAC,KAAS,EAAW,WAAW,EAAG;EAGvC,IAAM,IAAK,KAAa,SAAS,iBAC3B,IAAO,EAAW,IAClB,IAAO,EAAG,aAAa,YAAY;AAIzC,EAFA,EAAG,aAAa,aAAa,EAAK,EAElC,QAAgB;AAEd,GAAI,MAAS,OACX,EAAG,gBAAgB,YAAY,GAE/B,EAAG,aAAa,aAAa,EAAK;IAEpC;GACF"}
+{"version":3,"file":"useFontLoader.js","names":[],"sources":["../../src/hooks/useFontLoader.ts"],"sourcesContent":["import { createEffect, onCleanup } from \"solid-js\";\n\n// ─── 字体配置表 ────────────────────────────────────────────────\nconst FONT_MAP = {\n  en: { family: \"Inter\", weights: \"400;500;700\" },\n  fr: { family: \"Inter\", weights: \"400;500;700\" },\n  de: { family: \"Inter\", weights: \"400;500;700\" },\n  ru: { family: \"Noto+Sans\", weights: \"400;500;700\" },\n  \"zh-hans\": { family: \"Noto+Sans+SC\", weights: \"400;500;700\" },\n  \"zh-hant\": { family: \"Noto+Sans+TC\", weights: \"400;500;700\" },\n  ja: { family: \"Noto+Sans+JP\", weights: \"400;500;700\" },\n  ko: { family: \"Noto+Sans+KR\", weights: \"400;500;700\" },\n  hi: { family: \"Noto+Sans+Devanagari\", weights: \"400;500;700\" },\n  th: { family: \"Noto+Sans+Thai\", weights: \"400;500;700\" },\n  bn: { family: \"Noto+Sans+Bengali\", weights: \"400;500;700\" },\n  ar: { family: \"Noto+Sans+Arabic\", weights: \"400;500;700\" },\n  he: { family: \"Noto+Sans+Hebrew\", weights: \"400;500;700\" },\n  fa: { family: \"Noto+Sans+Arabic\", weights: \"400;500;700\" },\n} as const satisfies Record<string, { family: string; weights: string }>;\n\nexport type Lang = keyof typeof FONT_MAP;\n\n// ─── 已加载字体缓存（模块级单例，避免重复插入） ──────────────\nconst loaded = new Set<string>();\n\nfunction filterValidLangs(langs: string[]): Lang[] {\n  return langs.filter((lang): lang is Lang => {\n    if (lang in FONT_MAP) return true;\n    if (!import.meta.env.PROD) {\n      console.warn(\n        `[useFontLoader] unsupported lang: \"${lang}\". ` +\n          `Supported values: ${Object.keys(FONT_MAP).join(\", \")}`,\n      );\n    }\n    return false;\n  });\n}\n\nexport interface UseFontLoaderOptions {\n  /**\n   * 要加载的字体对应的语言\n   *\n   * 默认为`en`\n   */\n  langs?: Lang | Lang[];\n\n  /**\n   * 指定 data-lang 写入的目标元素。\n   * - 传入 ref：仅在该元素上生效，适合局部语言切换。\n   * - 不传（undefined）：写入 ，全局生效。\n   * 卸载时自动恢复目标元素的原始 data-lang 值。\n   *\n   * apply 为 false 时此选项无效。\n   */\n  targetRef?: HTMLElement;\n\n  /**\n   * 是否将 data-lang 写入目标元素以应用字体样式。\n   * - true（默认）：写入 data-lang，字体立即生效。\n   * - false：仅预加载字体资源，不修改任何 DOM，\n   *   适合提前预热用户可能切换到的语言字体。\n   * @default\n   */\n  apply?: boolean;\n}\n\n/* ----------------------------------------------------------------\n   工具：插入 Google Fonts\n   ---------------------------------------------------------------- */\nfunction loadGoogleFonts(langs: Lang[]): void {\n  const toLoad = langs.filter((lang) => !loaded.has(FONT_MAP[lang].family));\n  if (toLoad.length === 0) return;\n\n  const families = [\n    ...new Set(\n      toLoad.map((lang) => {\n        const { family, weights } = FONT_MAP[lang];\n        return `family=${family}:wght@${weights}`;\n      }),\n    ),\n  ];\n\n  const link = document.createElement(\"link\");\n  link.rel = \"stylesheet\";\n  link.href = `https://fonts.googleapis.com/css2?${families.join(\"&\")}&display=swap`;\n\n  document.head.appendChild(link);\n  for (const lang of toLoad) {\n    loaded.add(FONT_MAP[lang].family);\n  }\n}\n\n// ─── Hook ─────────────────────────────────────────────────────\nexport function useFontLoader(options?: UseFontLoaderOptions) {\n  const {\n    langs = \"en\",\n    targetRef = document.documentElement,\n    apply = true,\n  } = options ?? {};\n\n  const langList = Array.isArray(langs) ? langs : [langs];\n  const validLangs = filterValidLangs(langList);\n\n  // --- 加载字体资源 ---\n  createEffect(() => {\n    loadGoogleFonts(validLangs);\n  });\n\n  // --- 将 data-lang 写入目标元素 ---\n  createEffect(() => {\n    if (!apply || validLangs.length === 0) return;\n\n    // targetRef 未传或 ref.current 尚未挂载时，回退到\n    const el = targetRef ?? document.documentElement;\n    const lang = validLangs[0];\n    const prev = el.getAttribute(\"data-lang\");\n\n    el.setAttribute(\"data-lang\", lang);\n\n    onCleanup(() => {\n      // 卸载时恢复：原本有值则还原，原本无则移除\n      if (prev === null) {\n        el.removeAttribute(\"data-lang\");\n      } else {\n        el.setAttribute(\"data-lang\", prev);\n      }\n    });\n  });\n}\n"],"mappings":";;AAGA,IAAM,IAAW;CACf,IAAI;EAAE,QAAQ;EAAS,SAAS;CAAc;CAC9C,IAAI;EAAE,QAAQ;EAAS,SAAS;CAAc;CAC9C,IAAI;EAAE,QAAQ;EAAS,SAAS;CAAc;CAC9C,IAAI;EAAE,QAAQ;EAAa,SAAS;CAAc;CAClD,WAAW;EAAE,QAAQ;EAAgB,SAAS;CAAc;CAC5D,WAAW;EAAE,QAAQ;EAAgB,SAAS;CAAc;CAC5D,IAAI;EAAE,QAAQ;EAAgB,SAAS;CAAc;CACrD,IAAI;EAAE,QAAQ;EAAgB,SAAS;CAAc;CACrD,IAAI;EAAE,QAAQ;EAAwB,SAAS;CAAc;CAC7D,IAAI;EAAE,QAAQ;EAAkB,SAAS;CAAc;CACvD,IAAI;EAAE,QAAQ;EAAqB,SAAS;CAAc;CAC1D,IAAI;EAAE,QAAQ;EAAoB,SAAS;CAAc;CACzD,IAAI;EAAE,QAAQ;EAAoB,SAAS;CAAc;CACzD,IAAI;EAAE,QAAQ;EAAoB,SAAS;CAAc;AAC3D,GAKM,oBAAS,IAAI,IAAY;AAE/B,SAAS,EAAiB,GAAyB;CACjD,OAAO,EAAM,QAAQ,MACf,KAAQ,CAQb;AACH;AAiCA,SAAS,EAAgB,GAAqB;CAC5C,IAAM,IAAS,EAAM,QAAQ,MAAS,CAAC,EAAO,IAAI,EAAS,EAAK,CAAC,MAAM,CAAC;CACxE,IAAI,EAAO,WAAW,GAAG;CAEzB,IAAM,IAAW,CACf,GAAG,IAAI,IACL,EAAO,KAAK,MAAS;EACnB,IAAM,EAAE,WAAQ,eAAY,EAAS;EACrC,OAAO,UAAU,EAAO,QAAQ;CAClC,CAAC,CACH,CACF,GAEM,IAAO,SAAS,cAAc,MAAM;CAI1C,AAHA,EAAK,MAAM,cACX,EAAK,OAAO,qCAAqC,EAAS,KAAK,GAAG,EAAE,gBAEpE,SAAS,KAAK,YAAY,CAAI;CAC9B,KAAK,IAAM,KAAQ,GACjB,EAAO,IAAI,EAAS,EAAK,CAAC,MAAM;AAEpC;AAGA,SAAgB,EAAc,GAAgC;CAC5D,IAAM,EACJ,WAAQ,MACR,eAAY,SAAS,iBACrB,WAAQ,OACN,KAAW,CAAC,GAGV,IAAa,EADF,MAAM,QAAQ,CAAK,IAAI,IAAQ,CAAC,CAAK,CACV;CAQ5C,AALA,QAAmB;EACjB,EAAgB,CAAU;CAC5B,CAAC,GAGD,QAAmB;EACjB,IAAI,CAAC,KAAS,EAAW,WAAW,GAAG;EAGvC,IAAM,IAAK,KAAa,SAAS,iBAC3B,IAAO,EAAW,IAClB,IAAO,EAAG,aAAa,WAAW;EAIxC,AAFA,EAAG,aAAa,aAAa,CAAI,GAEjC,QAAgB;GAEd,AAAI,MAAS,OACX,EAAG,gBAAgB,WAAW,IAE9B,EAAG,aAAa,aAAa,CAAI;EAErC,CAAC;CACH,CAAC;AACH"}

package/dist/index.d.ts

@@ -28,6 +28,7 @@ export * from './components/skeleton';
 export * from './components/slider';
 export * from './components/spinner';
 export * from './components/switch';
+export * from './components/tabs';
 export * from './components/textarea';
 export * from './components/toast';
 export * from './components/tooltip';