@wisdomgarden/torque 0.1.0

package/dist/components/tooltip/floating-arrow.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx as g } from "react/jsx-runtime";
+import { getArrowPositionStyles as u } from "./get-arrow-position-styles.js";
+const A = ({
+  arrowX: t,
+  arrowY: o,
+  arrowSize: r = 6,
+  arrowOffset: i = 5,
+  arrowRadius: e = 0,
+  arrowPosition: s = "center",
+  dir: n = "ltr",
+  className: l,
+  style: p,
+  ref: c,
+  placement: m,
+  ...y
+}) => {
+  const f = u({
+    position: m,
+    arrowSize: r,
+    arrowOffset: i,
+    arrowRadius: e,
+    arrowPosition: s,
+    arrowX: t,
+    arrowY: o,
+    dir: n
+  });
+  return /* @__PURE__ */ g(
+    "div",
+    {
+      ref: c,
+      className: l,
+      style: { ...f, ...p },
+      ...y
+    }
+  );
+};
+export {
+  A as FloatingArrow
+};

package/dist/components/tooltip/get-arrow-position-styles.d.ts

@@ -0,0 +1,11 @@
+import { FloatingPosition, ArrowPosition } from './types';
+export declare function getArrowPositionStyles({ position, arrowSize, arrowOffset, arrowRadius, arrowPosition, arrowX, arrowY, dir, }: {
+    position: FloatingPosition;
+    arrowSize: number;
+    arrowOffset: number;
+    arrowRadius: number;
+    arrowPosition: ArrowPosition;
+    arrowX: number | undefined;
+    arrowY: number | undefined;
+    dir: 'rtl' | 'ltr';
+}): {};

package/dist/components/tooltip/get-arrow-position-styles.js

@@ -0,0 +1,63 @@
+"use client";
+function b(r, o, t, n) {
+  return r === "center" || n === "center" ? { top: o } : r === "end" ? { bottom: t } : r === "start" ? { top: t } : {};
+}
+function g(r, o, t, n, e) {
+  return r === "center" || n === "center" ? { left: o } : r === "end" ? { [e === "ltr" ? "right" : "left"]: t } : r === "start" ? { [e === "ltr" ? "left" : "right"]: t } : {};
+}
+const h = {
+  bottom: "borderTopLeftRadius",
+  left: "borderTopRightRadius",
+  right: "borderBottomLeftRadius",
+  top: "borderBottomRightRadius"
+};
+function c({
+  position: r,
+  arrowSize: o,
+  arrowOffset: t,
+  arrowRadius: n,
+  arrowPosition: e,
+  arrowX: u,
+  arrowY: a,
+  dir: s
+}) {
+  const [i, l = "center"] = r.split("-"), p = {
+    width: o,
+    height: o,
+    transform: "rotate(45deg)",
+    position: "absolute",
+    [h[i]]: n
+  }, d = -o / 2;
+  return i === "left" ? {
+    ...p,
+    ...b(l, a, t, e),
+    right: d,
+    borderLeftColor: "transparent",
+    borderBottomColor: "transparent",
+    clipPath: "polygon(100% 0, 0 0, 100% 100%)"
+  } : i === "right" ? {
+    ...p,
+    ...b(l, a, t, e),
+    left: d,
+    borderRightColor: "transparent",
+    borderTopColor: "transparent",
+    clipPath: "polygon(0 100%, 0 0, 100% 100%)"
+  } : i === "top" ? {
+    ...p,
+    ...g(l, u, t, e, s),
+    bottom: d,
+    borderTopColor: "transparent",
+    borderLeftColor: "transparent",
+    clipPath: "polygon(0 100%, 100% 100%, 100% 0)"
+  } : i === "bottom" ? {
+    ...p,
+    ...g(l, u, t, e, s),
+    top: d,
+    borderBottomColor: "transparent",
+    borderRightColor: "transparent",
+    clipPath: "polygon(0 100%, 0 0, 100% 0)"
+  } : {};
+}
+export {
+  c as getArrowPositionStyles
+};

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

@@ -0,0 +1,54 @@
+import { FloatingPosition, FloatingStrategy } from './types';
+interface Inline {
+    inline?: boolean;
+    block?: never;
+}
+interface Block {
+    block?: boolean;
+    inline?: never;
+}
+type WrapperDisplay = Inline | Block;
+/**
+ * Tooltip 组件属性
+ */
+export type TooltipProps = React.HTMLAttributes<HTMLDivElement> & WrapperDisplay & {
+    /** 浮层弹出的位置。支持 'top' | 'right' | 'bottom' | 'left' 以及附带对齐方式的变体，如 'top-start' */
+    readonly position?: FloatingPosition;
+    /** 箭头属性配置 */
+    readonly arrowProps?: {
+        /** 箭头大小，默认 6px */
+        size?: number;
+        /** 箭头距边缘的偏移量（仅 start/end 对齐时生效），默认 5px */
+        offset?: number;
+        /** 箭头圆角半径，默认 0 */
+        radius?: number;
+    };
+    /** 浮层的 CSS 定位策略：'absolute' | 'fixed' */
+    readonly strategy?: FloatingStrategy;
+    /** 是否禁用 Tooltip 的显示 */
+    readonly disabled?: boolean;
+    /** 触发 Tooltip 的目标元素 */
+    readonly children: React.ReactNode;
+    /** Tooltip 内显示的提示内容 */
+    readonly label: React.ReactNode;
+    /** 浮层距离目标元素的偏移量，默认 5px */
+    readonly offset?: number;
+    /** 是否仅在目标文本被截断（溢出显示省略号）时才显示 Tooltip */
+    readonly showOnlyWhenTruncated?: boolean;
+    /** (仅当配合截断检测时) 限制目标元素的最大宽度，超出此宽度则截断 */
+    readonly truncateMaxWidth?: number | string;
+    /** (仅当配合截断检测时) 限制目标元素的最大行数，多行截断 */
+    readonly truncateMaxLines?: number;
+    /** 透传给浮层根节点的 ref */
+    readonly ref?: React.Ref<HTMLDivElement>;
+    /** 浮层的 z-index 层级，默认 300 */
+    readonly zIndex?: number;
+};
+/**
+ * Tooltip 组件
+ *
+ * 基于 `@floating-ui/react-dom` 封装的工具提示组件，支持智能定位、自动翻转、箭头指示，
+ * 以及独有的「仅文本截断时才显示 (showOnlyWhenTruncated)」功能。
+ */
+export declare const Tooltip: ({ position, strategy, arrowProps, offset: offsetProp, label, children, disabled, showOnlyWhenTruncated, truncateMaxWidth, truncateMaxLines, ref: externalRef, inline, block, zIndex, ...others }: TooltipProps) => import("react").JSX.Element;
+export type * from './types';

package/dist/components/tooltip/index.js

@@ -0,0 +1,150 @@
+"use client";
+import { jsxs as b, Fragment as oe, jsx as m } from "react/jsx-runtime";
+import { offset as ne, flip as se, shift as ie, arrow as ae, hide as le, useFloating as ce, autoUpdate as de } from "@floating-ui/react-dom";
+import { useDirection as ue, getFloatingPosition as fe, Portal as me, Transition as pe } from "@mantine/core";
+import { useMergedRef as H } from "@mantine/hooks";
+import { useRef as i, useState as ge, isValidElement as we, useMemo as p, useCallback as r } from "react";
+import { FloatingArrow as ve } from "./floating-arrow.js";
+import h from "./styles.module.css.js";
+import { useMergedEvents as Te } from "./use-merged-events.js";
+import { useTooltipTrigger as Ee } from "./use-tooltip-trigger.js";
+import { getTruncationTarget as Re, isTruncated as Fe } from "./utils.js";
+const g = 8, Le = ({
+  position: D = "top",
+  strategy: N = "absolute",
+  arrowProps: P,
+  offset: w = 5,
+  label: y,
+  children: a,
+  disabled: A,
+  showOnlyWhenTruncated: l = !1,
+  truncateMaxWidth: L,
+  truncateMaxLines: k = 1,
+  ref: I,
+  inline: c,
+  block: v = !0,
+  zIndex: S = 300,
+  ...j
+}) => {
+  const T = i(null), d = i(null), E = i(null), [R, o] = ge(!1), z = we(a), B = p(
+    () => c !== void 0 ? !c : v ?? !0,
+    [v, c]
+  ), {
+    size: C = 6,
+    offset: G = 5,
+    radius: V = 0
+  } = P ?? {}, { dir: F } = ue(), U = p(() => [
+    ne(w),
+    se({ padding: g }),
+    ie({ padding: g }),
+    // 同 popover.tsx：floating-ui 的 arrow 中间件收的就是 ref 对象本身。
+    // eslint-disable-next-line react-hooks/refs
+    ae({ element: E, padding: g }),
+    le()
+  ], [w]), {
+    x: X,
+    y: Y,
+    refs: M,
+    floatingStyles: _,
+    placement: q,
+    middlewareData: { arrow: { x: J, y: K } = {} },
+    middlewareData: x
+  } = ce({
+    open: R,
+    strategy: N,
+    placement: fe(F, D),
+    middleware: U,
+    whileElementsMounted: de
+  }), O = H(
+    T,
+    I,
+    M.setFloating
+  ), t = i(0), n = r(() => {
+    t.current && (clearTimeout(t.current), t.current = 0);
+  }, []), Q = H(d, M.setReference), s = r(() => {
+    if (n(), l) {
+      const e = Re(d.current);
+      if (!Fe(e)) return;
+    }
+    o(!0);
+  }, [n, l]), u = r((e) => {
+    const f = e.relatedTarget instanceof Node ? e.relatedTarget : null;
+    f && (d.current?.contains(f) || T.current?.contains(f)) || (t.current = window.setTimeout(() => {
+      o(!1);
+    }, 100));
+  }, []), Z = r(() => {
+    t.current = window.setTimeout(() => {
+      o(!1);
+    }, 100);
+  }, []), $ = r(() => {
+    n(), o(!1);
+  }, [n]), W = Te({
+    userProps: z ? a.props : {},
+    internalProps: {
+      onMouseEnter: s,
+      onMouseLeave: u,
+      onFocus: s,
+      onBlur: Z,
+      onClick: $
+    }
+  }), ee = p(
+    () => ({
+      onMouseEnter: s,
+      onMouseLeave: u
+    }),
+    [s, u]
+  ), { trigger: te, id: re } = Ee({
+    children: a,
+    showOnlyWhenTruncated: l,
+    truncateMaxWidth: L,
+    truncateMaxLines: k,
+    isBlock: B,
+    mergedReferenceRef: Q,
+    mergedEvents: W
+  });
+  return /* @__PURE__ */ b(oe, { children: [
+    /* @__PURE__ */ m(me, { children: /* @__PURE__ */ m(pe, { mounted: !A && R, children: (e) => /* @__PURE__ */ b(
+      "div",
+      {
+        id: re,
+        tabIndex: -1,
+        role: "tooltip",
+        ref: O,
+        className: h.wgTooltip,
+        ...j,
+        style: {
+          left: X,
+          top: Y,
+          ...e,
+          ..._,
+          zIndex: S,
+          visibility: x.hide?.referenceHidden ? "hidden" : void 0,
+          pointerEvents: x.hide?.referenceHidden ? "none" : void 0
+        },
+        ...ee,
+        children: [
+          y,
+          /* @__PURE__ */ m(
+            ve,
+            {
+              "aria-hidden": "true",
+              ref: E,
+              className: h.wgTooltipArrow,
+              arrowX: J,
+              arrowY: K,
+              arrowSize: C,
+              arrowOffset: G,
+              arrowRadius: V,
+              dir: F,
+              placement: q
+            }
+          )
+        ]
+      }
+    ) }) }),
+    te
+  ] });
+};
+export {
+  Le as Tooltip
+};

package/dist/components/tooltip/styles.module.css.js

@@ -0,0 +1,10 @@
+"use client";
+const o = "_wgTooltip_1ocgf_2", t = "_wgTooltipArrow_1ocgf_14", l = {
+  wgTooltip: o,
+  wgTooltipArrow: t
+};
+export {
+  l as default,
+  o as wgTooltip,
+  t as wgTooltipArrow
+};

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

@@ -0,0 +1,13 @@
+/** Tooltip 浮动方向：结束对齐或开始对齐 */
+export type FloatingPlacement = 'end' | 'start';
+/** Tooltip 浮动侧：上、右、下、左 */
+export type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Tooltip 完整浮动位置
+ * 可以是单侧（如 'top'），也可以是单侧+对齐方式（如 'top-start'）
+ */
+export type FloatingPosition = FloatingSide | `${FloatingSide}-${FloatingPlacement}`;
+/** 箭头位置：居中或偏向一侧 */
+export type ArrowPosition = 'center' | 'side';
+/** 浮动元素的 CSS 定位策略 */
+export type FloatingStrategy = 'absolute' | 'fixed';

package/dist/components/tooltip/use-merged-events.d.ts

@@ -0,0 +1,18 @@
+interface EventsProps {
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseMove?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseDown?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseUp?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseOver?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseOut?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+}
+interface UseMergedEventsProps {
+    userProps: EventsProps;
+    internalProps: EventsProps;
+}
+export declare const useMergedEvents: ({ userProps, internalProps, }: UseMergedEventsProps) => EventsProps;
+export {};

package/dist/components/tooltip/use-merged-events.js

@@ -0,0 +1,22 @@
+"use client";
+import { useMemo as c } from "react";
+const v = ({
+  userProps: t,
+  internalProps: r
+}) => c(() => Object.entries(r).reduce((s, [e, u]) => {
+  const n = t[e];
+  return n ? {
+    ...s,
+    [e]: (o) => {
+      n(
+        o
+      ), u(o);
+    }
+  } : {
+    ...s,
+    [e]: u
+  };
+}, {}), [t, r]);
+export {
+  v as useMergedEvents
+};

package/dist/components/tooltip/use-tooltip-trigger.d.ts

@@ -0,0 +1,13 @@
+export interface UseTooltipTriggerProps {
+    children: React.ReactNode;
+    showOnlyWhenTruncated: boolean;
+    truncateMaxWidth?: number | string;
+    truncateMaxLines: number;
+    isBlock: boolean;
+    mergedReferenceRef: React.Ref<HTMLDivElement>;
+    mergedEvents: React.HTMLAttributes<HTMLElement>;
+}
+export declare function useTooltipTrigger({ children, showOnlyWhenTruncated, truncateMaxWidth, truncateMaxLines, isBlock, mergedReferenceRef, mergedEvents, }: UseTooltipTriggerProps): {
+    trigger: import("react").JSX.Element;
+    id: string;
+};

package/dist/components/tooltip/use-tooltip-trigger.js

@@ -0,0 +1,59 @@
+"use client";
+import { jsx as g } from "react/jsx-runtime";
+import { useId as b } from "@mantine/hooks";
+import { isValidElement as u, useMemo as d, cloneElement as y } from "react";
+import { getTruncationContentStyle as E, toPlainStyle as S } from "./utils.js";
+function x({
+  children: o,
+  showOnlyWhenTruncated: t,
+  truncateMaxWidth: e,
+  truncateMaxLines: l,
+  isBlock: n,
+  mergedReferenceRef: s,
+  mergedEvents: p
+}) {
+  const r = b(), i = u(o) ? o : null, a = d(
+    () => t ? {
+      display: n ? "block" : "inline-block",
+      maxWidth: e ?? "100%",
+      minWidth: 0,
+      overflow: "hidden",
+      verticalAlign: "middle"
+    } : void 0,
+    [t, e, n]
+  ), m = d(
+    () => t ? E(l) : void 0,
+    [t, l]
+  ), c = {
+    ...!t && { ...p, ref: s },
+    ...m && {
+      style: {
+        ...i ? S(i.props.style) : {},
+        ...m
+      }
+    },
+    "aria-describedby": r
+  }, f = i ? (
+    // 把合并后的 ref 注入使用者传进来的子元素，是 Tooltip 触发器的核心机制。
+    // eslint-disable-next-line react-hooks/refs
+    y(i, {
+      ...i.props,
+      ...c
+    })
+  ) : /* @__PURE__ */ g("span", { ...c, children: o });
+  return t ? {
+    trigger: /* @__PURE__ */ g(
+      "span",
+      {
+        ref: s,
+        style: a,
+        ...p,
+        children: f
+      }
+    ),
+    id: r
+  } : { trigger: f, id: r };
+}
+export {
+  x as useTooltipTrigger
+};

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

@@ -0,0 +1,4 @@
+export declare function getTruncationContentStyle(maxLines: number): React.CSSProperties;
+export declare function toPlainStyle(style: unknown): React.CSSProperties;
+export declare function isTruncated(el: HTMLElement | null): boolean;
+export declare function getTruncationTarget(ref: HTMLElement | null, useFirstChild: boolean): HTMLElement | null;

package/dist/components/tooltip/utils.js

@@ -0,0 +1,35 @@
+"use client";
+function e(t) {
+  const i = {
+    overflow: "hidden",
+    maxWidth: "100%",
+    minWidth: 0
+  };
+  return t > 1 ? {
+    ...i,
+    display: "-webkit-box",
+    WebkitBoxOrient: "vertical",
+    WebkitLineClamp: t
+  } : {
+    ...i,
+    display: "block",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  };
+}
+function r(t) {
+  return t && typeof t == "object" && !Array.isArray(t) ? t : {};
+}
+const n = 1;
+function o(t) {
+  return t ? t.scrollWidth - t.clientWidth > n || t.scrollHeight - t.clientHeight > n : !1;
+}
+function l(t, i) {
+  return t ? t.firstElementChild instanceof HTMLElement ? t.firstElementChild : t : null;
+}
+export {
+  e as getTruncationContentStyle,
+  l as getTruncationTarget,
+  o as isTruncated,
+  r as toPlainStyle
+};

package/dist/components/tree/hooks/use-custom-click-behavior-feature.d.ts

@@ -0,0 +1,16 @@
+import { FeatureImplementation } from '@headless-tree/core';
+interface CustomClickBehaviorOptions<T> {
+    selectableFolders: boolean;
+    selectOnLabelClick: boolean;
+    selectionMode: 'single' | 'multi';
+    expandFolderOnSelect: boolean;
+    isItemDisabled?: (item: T) => boolean;
+}
+/**
+ * 创建自定义节点交互特性，统一处理禁用、文件夹可选性和文字区域点击选择。
+ *
+ * itemInstance 中的方法会接入 @headless-tree 的特性链：
+ * `prev` 是前一个特性提供的默认实现，本特性只在需要拦截或改写行为时包裹它。
+ */
+export declare function useCustomClickBehaviorFeature<T>({ selectableFolders, selectOnLabelClick, selectionMode, expandFolderOnSelect, isItemDisabled, }: CustomClickBehaviorOptions<T>): FeatureImplementation<T>;
+export {};

package/dist/components/tree/hooks/use-custom-click-behavior-feature.js

@@ -0,0 +1,125 @@
+"use client";
+import { CheckedState as c } from "@headless-tree/core";
+import { useRef as C, useMemo as I } from "react";
+function S({
+  selectableFolders: i,
+  selectOnLabelClick: f,
+  selectionMode: g,
+  expandFolderOnSelect: k,
+  isItemDisabled: h
+}) {
+  const s = C({
+    selectableFolders: i,
+    selectOnLabelClick: f,
+    selectionMode: g,
+    expandFolderOnSelect: k,
+    isItemDisabled: h
+  });
+  return s.current = {
+    selectableFolders: i,
+    selectOnLabelClick: f,
+    selectionMode: g,
+    expandFolderOnSelect: k,
+    isItemDisabled: h
+  }, I(() => {
+    const l = (e) => {
+      const t = e.getItemData();
+      return t != null && !!s.current.isItemDisabled?.(t);
+    }, a = (e) => {
+      e.isFolder() && (e.isExpanded() ? e.collapse() : e.expand());
+    }, p = (e) => e.isFolder() ? e.getChildren().flatMap(p) : l(e) ? [] : [e.getId()], r = (e, t, ...n) => {
+      if (!l(e))
+        return t?.(...n);
+    };
+    return {
+      key: "custom-click-behavior",
+      itemInstance: {
+        /** 选择节点；禁用节点不响应。 */
+        select: ({ item: e, prev: t }) => r(e, t),
+        /** 取消选择节点；禁用节点保持原选择状态。 */
+        deselect: ({ item: e, prev: t }) => r(e, t),
+        /** 切换节点选择状态；禁用节点不响应。 */
+        toggleSelect: ({ item: e, prev: t }) => r(e, t),
+        /** 执行范围选择；起始节点禁用时不继续默认范围选择。 */
+        selectUpTo: ({ item: e, prev: t }, n) => r(e, t, n),
+        /** 勾选节点；禁用节点不响应。 */
+        setChecked: ({ item: e, prev: t }) => r(e, t),
+        /** 取消勾选节点；禁用节点保持原勾选状态。 */
+        setUnchecked: ({ item: e, prev: t }) => r(e, t),
+        /** 切换节点勾选状态；禁用节点不响应。 */
+        toggleCheckedState: ({ item: e, prev: t }) => r(e, t),
+        /**
+         * 获取节点勾选状态。
+         *
+         * 非级联模式沿用默认实现；级联模式下，文件夹只根据未禁用叶子节点推导
+         * Checked / Indeterminate / Unchecked，禁用后代不参与计算。
+         */
+        getCheckedState: ({ item: e, tree: t, prev: n }) => {
+          if (!t.getConfig().propagateCheckedState)
+            return n?.() ?? c.Unchecked;
+          if (!e.isFolder()) return n?.() ?? c.Unchecked;
+          const d = t.getState().checkedItems;
+          if (d.includes(e.getId())) return c.Checked;
+          const o = p(e);
+          return o.length === 0 ? c.Unchecked : o.every((u) => d.includes(u)) ? c.Checked : o.some((u) => d.includes(u)) ? c.Indeterminate : c.Unchecked;
+        },
+        /** 展开文件夹；禁用节点不响应。 */
+        expand: ({ item: e, prev: t }) => r(e, t),
+        /** 收起文件夹；禁用节点不响应。 */
+        collapse: ({ item: e, prev: t }) => r(e, t),
+        /** 合并默认复选框属性，并同步节点的禁用状态。 */
+        getCheckboxProps: ({ item: e, prev: t }) => ({
+          ...t?.(),
+          disabled: l(e)
+        }),
+        /**
+         * 合并节点根元素属性，并根据当前配置改写文字区域的点击行为。
+         */
+        getProps: ({ item: e, tree: t, prev: n }) => {
+          const d = n?.() || {}, o = l(e);
+          return {
+            ...d,
+            "aria-disabled": o || void 0,
+            /**
+             * 处理节点文字区域点击：
+             * 1. 禁用节点阻止交互；
+             * 2. 不可选文件夹只切换展开；
+             * 3. 关闭文字选择时只维护焦点并切换展开；
+             * 4. 多选模式切换勾选并同步文件夹展开；
+             * 5. 单选模式沿用 @headless-tree 的默认点击行为；
+             *    但当 expandFolderOnSelect 为 false 时，点击可选文件夹只选中不展开，
+             *    展开留给箭头控制。
+             */
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onClick: (u) => {
+              if (o) {
+                u.preventDefault();
+                return;
+              }
+              if (e.isFolder() && !s.current.selectableFolders) {
+                e.setFocused(), e.primaryAction(), a(e);
+                return;
+              }
+              if (!s.current.selectOnLabelClick) {
+                e.setFocused(), e.primaryAction(), a(e);
+                return;
+              }
+              if (s.current.selectionMode === "multi") {
+                e.setFocused(), e.primaryAction(), e.toggleCheckedState(), a(e);
+                return;
+              }
+              if (e.isFolder() && !s.current.expandFolderOnSelect) {
+                e.setFocused(), t.setSelectedItems([e.getId()]);
+                return;
+              }
+              d.onClick?.(u);
+            }
+          };
+        }
+      }
+    };
+  }, []);
+}
+export {
+  S as useCustomClickBehaviorFeature
+};

package/dist/components/tree/hooks/use-tree-animation.d.ts

@@ -0,0 +1,12 @@
+import { TreeInstance } from '@headless-tree/core';
+export declare const ANIMATION_EXPAND_DELAY = 20;
+export declare const ANIMATION_COLLAPSE_DURATION = 200;
+/**
+ * 提供树节点展开和折叠动画相关的逻辑与状态
+ */
+export declare function useTreeAnimation<T>(defaultExpandedIds?: string[], expandedIds?: string[], onExpandedIdsChange?: (ids: string[]) => void, lazyMode?: boolean): {
+    expandedItems: string[];
+    setExpandedItems: (updater: string[] | ((old: string[]) => string[])) => void;
+    animatingNodes: Map<string, "expanding" | "collapsing">;
+    treeRef: import("react").RefObject<TreeInstance<T> | null>;
+};