@zerodep-dev/vue-tsx-pro-ui 0.0.0-stage → 0.1.0

package/dist/utils/data/selection.js

@@ -0,0 +1,21 @@
+//#region src/utils/data/selection.ts
+/**
+* 单选的值或多选的值数组 → 已选值的数组（单选、多选共用一套渲染与列表状态时）。
+* 单选的空字符串算没有选中：表单的初始值常写 ''（同原生 select 的占位项），这时显示占位文字、不出清除按钮
+*/
+var selectedValues = (value) => typeof value === "string" ? value === "" ? [] : [value] : value ?? [];
+/** 点了 key 之后的选择；没有变化时返回原数组 */
+function toggleSelection(selected, key, { mode, required = false }) {
+	const isSelected = selected.includes(key);
+	if (mode === "single") {
+		if (!isSelected) return [key];
+		return required ? selected : [];
+	}
+	if (!isSelected) return [...selected, key];
+	if (required && selected.length === 1) return selected;
+	return selected.filter((item) => item !== key);
+}
+//#endregion
+export { selectedValues, toggleSelection };
+
+//# sourceMappingURL=selection.js.map

package/dist/utils/data/selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.js","names":[],"sources":["../../../src/utils/data/selection.ts"],"sourcesContent":["/**\n * 选择模型：单选、多选怎样响应“点了一项”（纯函数），以及单选 / 多选组件共用的 props。\n * ToggleGroup、Listbox、Select、Combobox、CheckboxGroup、DataTable 的行选择都用它。\n */\n\n/** 选择方式 */\nexport interface SelectionModes {\n  /** 单选：选中一项会取消其他项；再点已选的项取消选中（required 时不取消） */\n  single: unknown;\n  /** 多选：每项独立切换 */\n  multiple: unknown;\n}\n\n/** 单选：value 是选中项的值 */\nexport interface SingleSelectionProps {\n  /** 选择方式，默认 single */\n  selectionMode?: Extract<keyof SelectionModes, 'single'>;\n  /** 选中项：父级写 _value={x}；没有选中时是 null */\n  _value?: string | null;\n}\n\n/** 多选：value 是选中项的值的数组 */\nexport interface MultipleSelectionProps {\n  /** 选择方式 */\n  selectionMode: Extract<keyof SelectionModes, 'multiple'>;\n  /** 选中项：父级写 _value={list} */\n  _value?: string[];\n}\n\n/** 单选或多选：按 selectionMode 区分 value 是一个值还是数组（Listbox、Select、ToggleGroup） */\nexport type SelectionProps = SingleSelectionProps | MultipleSelectionProps;\n\n/** toggleSelection 的选项 */\nexport interface SelectionOptions {\n  /** 选择方式 */\n  mode: keyof SelectionModes;\n  /** 至少保留一项：最后一个已选项不能被取消 */\n  required?: boolean;\n}\n\n/**\n * 单选的值或多选的值数组 → 已选值的数组（单选、多选共用一套渲染与列表状态时）。\n * 单选的空字符串算没有选中：表单的初始值常写 ''（同原生 select 的占位项），这时显示占位文字、不出清除按钮\n */\nexport const selectedValues = (\n  value: string | readonly string[] | null | undefined,\n): readonly string[] => (typeof value === 'string' ? (value === '' ? [] : [value]) : (value ?? []));\n\n/** 点了 key 之后的选择；没有变化时返回原数组 */\nexport function toggleSelection<Key>(\n  selected: readonly Key[],\n  key: Key,\n  { mode, required = false }: SelectionOptions,\n): readonly Key[] {\n  const isSelected = selected.includes(key);\n  if (mode === 'single') {\n    if (!isSelected) return [key];\n    return required ? selected : [];\n  }\n  if (!isSelected) return [...selected, key];\n  if (required && selected.length === 1) return selected;\n  return selected.filter((item) => item !== key);\n}\n"],"mappings":";;;;;AA4CA,IAAa,kBACX,UACuB,OAAO,UAAU,WAAY,UAAU,KAAK,CAAA,IAAK,CAAC,KAAK,IAAM,SAAS,CAAA;;AAG/F,SAAgB,gBACd,UACA,KACA,EAAE,MAAM,WAAW,SACH;CAChB,MAAM,aAAa,SAAS,SAAS,GAAG;CACxC,IAAI,SAAS,UAAU;EACrB,IAAI,CAAC,YAAY,OAAO,CAAC,GAAG;EAC5B,OAAO,WAAW,WAAW,CAAA;CAC/B;CACA,IAAI,CAAC,YAAY,OAAO,CAAC,GAAG,UAAU,GAAG;CACzC,IAAI,YAAY,SAAS,WAAW,GAAG,OAAO;CAC9C,OAAO,SAAS,QAAQ,SAAS,SAAS,GAAG;AAC/C"}

package/dist/utils/data/status.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 状态映射：一处写好每种状态的名字、色调、图标与说明，标记（StatusBadge）、表格的状态列、筛选的选项、步骤、看板的列共用，
+ * 同一种状态在哪儿都是同一个颜色、同一个叫法。定义的顺序就是阶段的顺序（任务从“待启动”走到“关闭”）。
+ *
+ *   export const taskStatuses = createStatusMap({
+ *     pending: { label: '待启动', tone: 'neutral' },
+ *     designing: { label: '设计中', tone: 'info' },
+ *     closed: { label: '关闭', tone: 'success' },
+ *   });
+ *   <StatusBadge statuses={taskStatuses} value={task.status} />
+ *   <Select items={taskStatuses.options()} … />
+ */
+import type { IconData } from '../../base/Icon';
+import type { ListboxOption } from '../../input/list-state';
+import type { StatusTone } from '../style/tone-styles';
+/** 一种状态的外观与文案 */
+export interface StatusDefinition {
+    /** 显示的名字 */
+    label: string;
+    /** 色调 */
+    tone: StatusTone;
+    /** 名字前的图标；不写时 StatusBadge 画一个同色的圆点 */
+    icon?: IconData;
+    /** 说明：筛选项、提示里显示（“验证不达标时退回方案设计”） */
+    description?: string;
+}
+/** createStatusMap 的结果 */
+export interface StatusMap<K extends string = string> {
+    /** 全部状态的 key，按定义的顺序（阶段顺序） */
+    readonly keys: readonly K[];
+    /** 一种状态的定义；不认识的 key（接口多给了新状态）当成中性色、名字就是 key，不报错 */
+    get(key: K | (string & {})): StatusDefinition;
+    /** 名字 */
+    label(key: K | (string & {})): string;
+    /** 色调 */
+    tone(key: K | (string & {})): StatusTone;
+    /** 在阶段里的位置（从 0 起）；不认识的 key 是 -1 */
+    order(key: K | (string & {})): number;
+    /** 给 Select、Listbox、筛选用的选项：value 是 key，带名字与说明；只要一部分时传 keys */
+    options(keys?: readonly K[]): ListboxOption[];
+}
+/** 定义一组状态：名字、色调、图标、说明，按阶段顺序写 */
+export declare function createStatusMap<const K extends string>(definitions: Readonly<Record<K, StatusDefinition>>): StatusMap<K>;

package/dist/utils/data/status.js

@@ -0,0 +1,27 @@
+//#region src/utils/data/status.ts
+/** 定义一组状态：名字、色调、图标、说明，按阶段顺序写 */
+function createStatusMap(definitions) {
+	const keys = Object.keys(definitions);
+	const index = new Map(keys.map((key, position) => [key, position]));
+	const get = (key) => index.has(key) ? definitions[key] : {
+		label: key,
+		tone: "neutral"
+	};
+	return {
+		keys,
+		get,
+		label: (key) => get(key).label,
+		tone: (key) => get(key).tone,
+		order: (key) => index.get(key) ?? -1,
+		options: (subset = keys) => subset.map((key) => ({
+			value: key,
+			label: definitions[key].label,
+			description: definitions[key].description,
+			icon: definitions[key].icon
+		}))
+	};
+}
+//#endregion
+export { createStatusMap };
+
+//# sourceMappingURL=status.js.map

package/dist/utils/data/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","names":[],"sources":["../../../src/utils/data/status.ts"],"sourcesContent":["/**\n * 状态映射：一处写好每种状态的名字、色调、图标与说明，标记（StatusBadge）、表格的状态列、筛选的选项、步骤、看板的列共用，\n * 同一种状态在哪儿都是同一个颜色、同一个叫法。定义的顺序就是阶段的顺序（任务从“待启动”走到“关闭”）。\n *\n *   export const taskStatuses = createStatusMap({\n *     pending: { label: '待启动', tone: 'neutral' },\n *     designing: { label: '设计中', tone: 'info' },\n *     closed: { label: '关闭', tone: 'success' },\n *   });\n *   <StatusBadge statuses={taskStatuses} value={task.status} />\n *   <Select items={taskStatuses.options()} … />\n */\nimport type { IconData } from '../../base/Icon';\nimport type { ListboxOption } from '../../input/list-state';\nimport type { StatusTone } from '../style/tone-styles';\n\n/** 一种状态的外观与文案 */\nexport interface StatusDefinition {\n  /** 显示的名字 */\n  label: string;\n  /** 色调 */\n  tone: StatusTone;\n  /** 名字前的图标；不写时 StatusBadge 画一个同色的圆点 */\n  icon?: IconData;\n  /** 说明：筛选项、提示里显示（“验证不达标时退回方案设计”） */\n  description?: string;\n}\n\n/** createStatusMap 的结果 */\nexport interface StatusMap<K extends string = string> {\n  /** 全部状态的 key，按定义的顺序（阶段顺序） */\n  readonly keys: readonly K[];\n  /** 一种状态的定义；不认识的 key（接口多给了新状态）当成中性色、名字就是 key，不报错 */\n  get(key: K | (string & {})): StatusDefinition;\n  /** 名字 */\n  label(key: K | (string & {})): string;\n  /** 色调 */\n  tone(key: K | (string & {})): StatusTone;\n  /** 在阶段里的位置（从 0 起）；不认识的 key 是 -1 */\n  order(key: K | (string & {})): number;\n  /** 给 Select、Listbox、筛选用的选项：value 是 key，带名字与说明；只要一部分时传 keys */\n  options(keys?: readonly K[]): ListboxOption[];\n}\n\n/** 定义一组状态：名字、色调、图标、说明，按阶段顺序写 */\nexport function createStatusMap<const K extends string>(\n  definitions: Readonly<Record<K, StatusDefinition>>,\n): StatusMap<K> {\n  const keys = Object.keys(definitions) as K[];\n  const index = new Map<string, number>(keys.map((key, position) => [key, position]));\n  const get = (key: string): StatusDefinition =>\n    index.has(key) ? definitions[key as K] : { label: key, tone: 'neutral' };\n  return {\n    keys,\n    get,\n    label: (key) => get(key).label,\n    tone: (key) => get(key).tone,\n    order: (key) => index.get(key) ?? -1,\n    options: (subset = keys) =>\n      subset.map((key) => ({\n        value: key,\n        label: definitions[key].label,\n        description: definitions[key].description,\n        icon: definitions[key].icon,\n      })),\n  };\n}\n"],"mappings":";;AA6CA,SAAgB,gBACd,aACc;CACd,MAAM,OAAO,OAAO,KAAK,WAAW;CACpC,MAAM,QAAQ,IAAI,IAAoB,KAAK,KAAK,KAAK,aAAa,CAAC,KAAK,QAAQ,CAAC,CAAC;CAClF,MAAM,OAAO,QACX,MAAM,IAAI,GAAG,IAAI,YAAY,OAAY;EAAE,OAAO;EAAK,MAAM;CAAU;CACzE,OAAO;EACL;EACA;EACA,QAAQ,QAAQ,IAAI,GAAG,CAAC,CAAC;EACzB,OAAO,QAAQ,IAAI,GAAG,CAAC,CAAC;EACxB,QAAQ,QAAQ,MAAM,IAAI,GAAG,KAAK;EAClC,UAAU,SAAS,SACjB,OAAO,KAAK,SAAS;GACnB,OAAO;GACP,OAAO,YAAY,IAAI,CAAC;GACxB,aAAa,YAAY,IAAI,CAAC;GAC9B,MAAM,YAAY,IAAI,CAAC;EACzB,EAAE;CACN;AACF"}

package/dist/utils/data/text.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 处理组件收到的内容（children 经插槽传来时是 VNode 数组，不是字符串）：
+ * plainText 取出纯文字，用于拼无障碍名称（如 Tag 的“移除 上海”）；childNodes 展开成一层 VNode 列表。
+ */
+import { type VNode, type VNodeChild } from 'vue';
+/** 内容只由文字组成时返回拼起来的文字，否则返回 undefined */
+export declare function plainText(content: VNodeChild): string | undefined;
+/**
+ * 把内容展开成一层 VNode 列表：数组、Fragment（<>…</>、v-for）都拆开，去掉 null、布尔与注释节点。
+ * 给按子元素个数排布的组件用（AvatarGroup 只显示前几个）。
+ */
+export declare function childNodes(content: VNodeChild): VNode[];

package/dist/utils/data/text.js

@@ -0,0 +1,30 @@
+import { Comment, Fragment, Text, createTextVNode, isVNode } from "vue";
+//#region src/utils/data/text.ts
+/**
+* 处理组件收到的内容（children 经插槽传来时是 VNode 数组，不是字符串）：
+* plainText 取出纯文字，用于拼无障碍名称（如 Tag 的“移除 上海”）；childNodes 展开成一层 VNode 列表。
+*/
+/** 内容只由文字组成时返回拼起来的文字，否则返回 undefined */
+function plainText(content) {
+	if (typeof content === "string" || typeof content === "number") return String(content);
+	if (Array.isArray(content)) {
+		const parts = content.map((part) => plainText(part));
+		return parts.every((part) => part !== void 0) ? parts.join("") : void 0;
+	}
+	if (isVNode(content) && content.type === Text && typeof content.children === "string") return content.children;
+}
+/**
+* 把内容展开成一层 VNode 列表：数组、Fragment（<>…</>、v-for）都拆开，去掉 null、布尔与注释节点。
+* 给按子元素个数排布的组件用（AvatarGroup 只显示前几个）。
+*/
+function childNodes(content) {
+	if (Array.isArray(content)) return content.flatMap((part) => childNodes(part));
+	if (!isVNode(content)) return typeof content === "string" || typeof content === "number" ? [createTextVNode(String(content))] : [];
+	if (content.type === Comment) return [];
+	if (content.type === Fragment) return childNodes(content.children);
+	return [content];
+}
+//#endregion
+export { childNodes, plainText };
+
+//# sourceMappingURL=text.js.map

package/dist/utils/data/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/utils/data/text.ts"],"sourcesContent":["/**\n * 处理组件收到的内容（children 经插槽传来时是 VNode 数组，不是字符串）：\n * plainText 取出纯文字，用于拼无障碍名称（如 Tag 的“移除 上海”）；childNodes 展开成一层 VNode 列表。\n */\nimport {\n  Comment,\n  createTextVNode,\n  Fragment,\n  isVNode,\n  Text,\n  type VNode,\n  type VNodeChild,\n} from 'vue';\n\n/** 内容只由文字组成时返回拼起来的文字，否则返回 undefined */\nexport function plainText(content: VNodeChild): string | undefined {\n  if (typeof content === 'string' || typeof content === 'number') return String(content);\n  if (Array.isArray(content)) {\n    const parts = content.map((part) => plainText(part as VNodeChild));\n    return parts.every((part) => part !== undefined) ? parts.join('') : undefined;\n  }\n  if (isVNode(content) && content.type === Text && typeof content.children === 'string') {\n    return content.children;\n  }\n  return undefined;\n}\n\n/**\n * 把内容展开成一层 VNode 列表：数组、Fragment（<>…</>、v-for）都拆开，去掉 null、布尔与注释节点。\n * 给按子元素个数排布的组件用（AvatarGroup 只显示前几个）。\n */\nexport function childNodes(content: VNodeChild): VNode[] {\n  if (Array.isArray(content)) return content.flatMap((part) => childNodes(part as VNodeChild));\n  if (!isVNode(content)) {\n    return typeof content === 'string' || typeof content === 'number'\n      ? [createTextVNode(String(content))]\n      : [];\n  }\n  if (content.type === Comment) return [];\n  if (content.type === Fragment) return childNodes(content.children as VNodeChild);\n  return [content];\n}\n"],"mappings":";;;;;;;AAeA,SAAgB,UAAU,SAAyC;CACjE,IAAI,OAAO,YAAY,YAAY,OAAO,YAAY,UAAU,OAAO,OAAO,OAAO;CACrF,IAAI,MAAM,QAAQ,OAAO,GAAG;EAC1B,MAAM,QAAQ,QAAQ,KAAK,SAAS,UAAU,IAAkB,CAAC;EACjE,OAAO,MAAM,OAAO,SAAS,SAAS,KAAA,CAAS,IAAI,MAAM,KAAK,EAAE,IAAI,KAAA;CACtE;CACA,IAAI,QAAQ,OAAO,KAAK,QAAQ,SAAS,QAAQ,OAAO,QAAQ,aAAa,UAC3E,OAAO,QAAQ;AAGnB;;;;;AAMA,SAAgB,WAAW,SAA8B;CACvD,IAAI,MAAM,QAAQ,OAAO,GAAG,OAAO,QAAQ,SAAS,SAAS,WAAW,IAAkB,CAAC;CAC3F,IAAI,CAAC,QAAQ,OAAO,GAClB,OAAO,OAAO,YAAY,YAAY,OAAO,YAAY,WACrD,CAAC,gBAAgB,OAAO,OAAO,CAAC,CAAC,IACjC,CAAC;CAEP,IAAI,QAAQ,SAAS,SAAS,OAAO,CAAC;CACtC,IAAI,QAAQ,SAAS,UAAU,OAAO,WAAW,QAAQ,QAAsB;CAC/E,OAAO,CAAC,OAAO;AACjB"}

package/dist/utils/data/tree.d.ts

@@ -0,0 +1,140 @@
+/** 怎样从数据里读出树的结构 */
+export interface TreeAccessors<T> {
+    /** 节点的 key，整棵树里唯一；index 是它在同级里的位置 */
+    getKey: (node: T, index: number) => string;
+    /** 子节点；叶子或还没加载时返回 undefined / 空数组 */
+    getChildren: (node: T) => readonly T[] | undefined;
+    /** 有没有子节点（懒加载时子节点还没取回来也算有）；不写时看 getChildren 是否非空 */
+    hasChildren?: (node: T) => boolean;
+}
+/** 展开成一列的一行 */
+export interface FlatTreeNode<T> {
+    /** 原始数据 */
+    readonly node: T;
+    /** getKey 给出的 key */
+    readonly key: string;
+    /** 层级，第一层为 0 */
+    readonly depth: number;
+    /** 父节点的 key；第一层为 undefined */
+    readonly parent: string | undefined;
+    /** 能不能展开（有子节点，或懒加载时声明了有） */
+    readonly expandable: boolean;
+    /** 同级一共几个（aria-setsize） */
+    readonly setSize: number;
+    /** 在同级里排第几，从 1 开始（aria-posinset） */
+    readonly position: number;
+}
+/** 节点能不能展开 */
+export declare const isExpandable: <T>(node: T, { getChildren, hasChildren }: TreeAccessors<T>) => boolean;
+/** flattenTree 的选项 */
+export interface FlattenTreeOptions<T> {
+    /** 改写每一层的顺序（TreeDataTable 按当前排序），不写时按数据顺序 */
+    order?: (level: readonly T[]) => readonly T[];
+    /** 只要这些节点（搜索过滤：filterTree 的 include），不写时全要 */
+    include?: ReadonlySet<string>;
+}
+/** 按展开状态深度优先展开成一列：只有展开了的节点的子节点出现在结果里 */
+export declare function flattenTree<T>(roots: readonly T[], accessors: TreeAccessors<T>, expanded: ReadonlySet<string>, { order, include }?: FlattenTreeOptions<T>): FlatTreeNode<T>[];
+/** 整棵（已加载的）树的索引：勾选联动要看到折叠着的节点 */
+export interface TreeIndex {
+    /** 深度优先的顺序 */
+    readonly order: readonly string[];
+    /** key → 父节点的 key */
+    readonly parents: ReadonlyMap<string, string | undefined>;
+    /** key → 已加载的子节点的 key */
+    readonly children: ReadonlyMap<string, readonly string[]>;
+}
+/** 建立整棵已加载的树的索引 */
+export declare function indexTree<T>(roots: readonly T[], accessors: TreeAccessors<T>): TreeIndex;
+/** 勾选状态 */
+export type CheckState = 'checked' | 'indeterminate' | 'unchecked';
+/**
+ * 勾上或取消 key：子孙跟着变；祖先的子节点全勾上时祖先也勾上，否则取消。
+ * 返回勾上的全部节点（按树的顺序），可以直接写回 checked
+ */
+export declare function toggleChecked(index: TreeIndex, checked: readonly string[], key: string): string[];
+/** 勾选结果的取法（同 Ant Design 的 showCheckedStrategy） */
+export interface CheckStrategies {
+    /** 勾上的全部节点（默认） */
+    all: unknown;
+    /** 父节点全勾上时只要父节点，不再列出它的子孙（提交“整个部门”而不是逐个成员） */
+    parent: unknown;
+    /** 只要叶子（没有已加载的子节点的节点） */
+    child: unknown;
+}
+/** 按取法给出勾上的节点（按树的顺序）；checked 可以是 toggleChecked 的结果，也可以是外部给的部分节点 */
+export declare function checkedByStrategy(index: TreeIndex, checked: readonly string[], strategy: keyof CheckStrategies): string[];
+/** 从第一层到 key 的各节点的 key（含 key 自己）；key 不在树里时为空数组。Cascader 的路径、面包屑用它 */
+export declare function treePath(index: TreeIndex, key: string): string[];
+/** filterTree 的结果 */
+export interface TreeFilter {
+    /** 要显示的节点：匹配的节点与它们的祖先（交给 flattenTree 的 include） */
+    include: Set<string>;
+    /** 要展开的节点：匹配的节点的祖先，展开后才看得到匹配项 */
+    expand: Set<string>;
+    /** 匹配的节点（高亮用） */
+    matched: Set<string>;
+}
+/**
+ * 搜索过滤：留下匹配的节点与它们的祖先，并展开祖先（只看已加载的节点）。
+ * 匹配的节点的子孙不跟着留下（它们自己匹配才留下），同 Ant Design TreeSelect 的搜索
+ */
+export declare function filterTree<T>(roots: readonly T[], accessors: TreeAccessors<T>, match: (node: T) => boolean): TreeFilter;
+/** buildTree 怎样读平铺的行 */
+export interface TreeRows<T> {
+    /** 行的 key，这批行里唯一 */
+    getKey: (row: T) => string;
+    /** 父行的 key；根行是 null / undefined，父行不在这批行里的也当作根 */
+    getParent: (row: T) => string | null | undefined;
+    /** 用子节点生成一个节点（不改原行），同 TreeEditor；不写时是 `{ ...row, children }` */
+    withChildren?: (row: T, children: T[]) => T;
+}
+/**
+ * 平铺的行（每行带父 key）组装成树，返回第一层；同级保持 rows 里的顺序，叶子的 children 是空数组。
+ * 服务端搜索懒加载的树时回“匹配的节点和它们的祖先”（query 库的 withAncestors），组装后再用 filterTree 得到要展开、高亮的节点。
+ * key 重复或父子成环时报错（环上的行到不了第一层）
+ */
+export declare function buildTree<T>(rows: readonly T[], { getKey, getParent, withChildren }: TreeRows<T>): T[];
+/** moveNode 要的读写方法：在读取之外，能用新的子节点生成一个节点 */
+export interface TreeEditor<T> extends TreeAccessors<T> {
+    /** 换掉子节点后的新节点（不改原节点），如 `(node, children) => ({ ...node, children })` */
+    withChildren: (node: T, children: T[]) => T;
+}
+/** 移动的目标：放到哪个节点下（undefined 是第一层）的第几位 */
+export interface TreeMoveTarget {
+    /** 新的父节点的 key；第一层时为 undefined */
+    parent: string | undefined;
+    /** 在新的同级里的位置（按移走之后的同级算），超出时放到最后 */
+    index: number;
+}
+/**
+ * 把 key 移到 target（不改原数据，返回新的第一层；沿途的节点用 withChildren 重建，其余节点原样复用）。
+ * key 不存在、目标是它自己或它的子孙时返回 null（拖到自己里面不成立）
+ */
+export declare function moveNode<T>(roots: readonly T[], editor: TreeEditor<T>, key: string, target: TreeMoveTarget): T[] | null;
+/** 每个节点的勾选状态：子孙里有勾上的、但自己没有全勾上时是 indeterminate */
+export declare function checkStates(index: TreeIndex, checked: readonly string[]): Map<string, CheckState>;
+/** useTreeExpansion 的选项 */
+export interface TreeExpansionOptions<T> {
+    /** 读当前展开的 key */
+    expanded: () => readonly string[];
+    /** 写回展开的 key */
+    setExpanded: (keys: string[]) => void;
+    /** 节点已加载的子节点 */
+    getChildren: (node: T) => readonly T[] | undefined;
+    /** 展开一个还没有子节点的节点时调用：取回子节点并放进数据里；返回 Promise 时显示加载中 */
+    loadChildren?: (node: T) => Promise<unknown> | void;
+    /** 子节点加载失败：节点收回去，可以再展开重试；不写时在控制台报错 */
+    onLoadError?: (error: unknown, node: T) => void;
+}
+/** useTreeExpansion 的返回值 */
+export interface TreeExpansion<T> {
+    /** 是否展开 */
+    isExpanded: (key: string) => boolean;
+    /** 是否正在加载子节点 */
+    isLoading: (key: string) => boolean;
+    /** 展开或收起；展开一个还没有子节点的节点时懒加载 */
+    setOpen: (node: T, key: string, open: boolean) => Promise<void>;
+}
+/** 展开状态与懒加载（在 setup 里调用） */
+export declare function useTreeExpansion<T>({ expanded, setExpanded, getChildren, loadChildren, onLoadError, }: TreeExpansionOptions<T>): TreeExpansion<T>;

package/dist/utils/data/tree.js

@@ -0,0 +1,273 @@
+import { shallowRef } from "vue";
+//#region src/utils/data/tree.ts
+/**
+* 树状数据的共用逻辑：按展开状态展开成一列行、勾选的父子联动（含半选）、展开时懒加载子项，
+* 以及搜索过滤、勾选结果的取法（只要父 / 只要子 / 全部）、到某个节点的路径、移动节点。
+* TreeDataTable（层级行）、Tree、TreeSelect、Cascader、Transfer 共用；数据形状不限，由 getKey / getChildren 读取。
+*
+*   const rows = flattenTree(roots, { getKey, getChildren }, new Set(expanded));
+*   const index = indexTree(roots, { getKey, getChildren });
+*   checked = toggleChecked(index, checked, key);        // 勾上 / 取消一项，子孙与祖先跟着变
+*   const states = checkStates(index, checked);           // key → checked / indeterminate / unchecked
+*   const value = checkedByStrategy(index, checked, 'parent'); // 父节点全勾上时只要父节点
+*   const { include, expand } = filterTree(roots, accessors, (node) => node.name.includes(query));
+*   flattenTree(roots, accessors, new Set([...expanded, ...expand]), { include });
+*   roots = moveNode(roots, { ...accessors, withChildren }, key, { parent: 'b', index: 0 });
+*   roots = buildTree(flatRows, { getKey: (r) => r.id, getParent: (r) => r.parentId }); // 平铺的行（服务端搜索的结果）组装成树
+*/
+/** 节点能不能展开 */
+var isExpandable = (node, { getChildren, hasChildren }) => hasChildren?.(node) ?? (getChildren(node)?.length ?? 0) > 0;
+/** 按展开状态深度优先展开成一列：只有展开了的节点的子节点出现在结果里 */
+function flattenTree(roots, accessors, expanded, { order = (level) => level, include } = {}) {
+	const result = [];
+	const visit = (level, depth, parent) => {
+		const keyOf = new Map(level.map((node, index) => [node, accessors.getKey(node, index)]));
+		const sorted = order(level).filter((node) => !include || include.has(keyOf.get(node)));
+		sorted.forEach((node, index) => {
+			const key = keyOf.get(node);
+			const expandable = isExpandable(node, accessors);
+			result.push({
+				node,
+				key,
+				depth,
+				parent,
+				expandable,
+				setSize: sorted.length,
+				position: index + 1
+			});
+			if (expandable && expanded.has(key)) visit(accessors.getChildren(node) ?? [], depth + 1, key);
+		});
+	};
+	visit(roots, 0, void 0);
+	return result;
+}
+/** 建立整棵已加载的树的索引 */
+function indexTree(roots, accessors) {
+	const order = [];
+	const parents = /* @__PURE__ */ new Map();
+	const children = /* @__PURE__ */ new Map();
+	const visit = (level, parent) => {
+		const keys = level.map((node, index) => accessors.getKey(node, index));
+		if (parent !== void 0) children.set(parent, keys);
+		level.forEach((node, index) => {
+			const key = keys[index];
+			order.push(key);
+			parents.set(key, parent);
+			visit(accessors.getChildren(node) ?? [], key);
+		});
+	};
+	visit(roots, void 0);
+	return {
+		order,
+		parents,
+		children
+	};
+}
+/**
+* 实际勾上的节点：自己或任何祖先在 checked 里（父节点勾上之后才懒加载出来的子节点因此也算勾上），
+* 或者已加载的子节点全勾上了（checked 由外部给出、没有写全父节点时）
+*/
+function effectiveChecked(index, checked) {
+	const listed = new Set(checked);
+	const result = /* @__PURE__ */ new Set();
+	for (const key of index.order) {
+		const parent = index.parents.get(key);
+		if (listed.has(key) || parent !== void 0 && result.has(parent)) result.add(key);
+	}
+	for (let i = index.order.length - 1; i >= 0; i--) {
+		const children = index.children.get(index.order[i]);
+		if (children?.length && children.every((child) => result.has(child))) result.add(index.order[i]);
+	}
+	return result;
+}
+/**
+* 勾上或取消 key：子孙跟着变；祖先的子节点全勾上时祖先也勾上，否则取消。
+* 返回勾上的全部节点（按树的顺序），可以直接写回 checked
+*/
+function toggleChecked(index, checked, key) {
+	const result = effectiveChecked(index, checked);
+	const next = !result.has(key);
+	const visit = (current) => {
+		if (next) result.add(current);
+		else result.delete(current);
+		index.children.get(current)?.forEach(visit);
+	};
+	visit(key);
+	for (let parent = index.parents.get(key); parent !== void 0;) {
+		if (index.children.get(parent).every((child) => result.has(child))) result.add(parent);
+		else result.delete(parent);
+		parent = index.parents.get(parent);
+	}
+	return index.order.filter((item) => result.has(item));
+}
+/** 按取法给出勾上的节点（按树的顺序）；checked 可以是 toggleChecked 的结果，也可以是外部给的部分节点 */
+function checkedByStrategy(index, checked, strategy) {
+	const effective = effectiveChecked(index, checked);
+	return index.order.filter((key) => {
+		if (!effective.has(key)) return false;
+		if (strategy === "child") return !index.children.get(key)?.length;
+		if (strategy === "parent") {
+			const parent = index.parents.get(key);
+			return parent === void 0 || !effective.has(parent);
+		}
+		return true;
+	});
+}
+/** 从第一层到 key 的各节点的 key（含 key 自己）；key 不在树里时为空数组。Cascader 的路径、面包屑用它 */
+function treePath(index, key) {
+	if (!index.parents.has(key)) return [];
+	const path = [];
+	for (let current = key; current !== void 0;) {
+		path.unshift(current);
+		current = index.parents.get(current);
+	}
+	return path;
+}
+/**
+* 搜索过滤：留下匹配的节点与它们的祖先，并展开祖先（只看已加载的节点）。
+* 匹配的节点的子孙不跟着留下（它们自己匹配才留下），同 Ant Design TreeSelect 的搜索
+*/
+function filterTree(roots, accessors, match) {
+	const result = {
+		include: /* @__PURE__ */ new Set(),
+		expand: /* @__PURE__ */ new Set(),
+		matched: /* @__PURE__ */ new Set()
+	};
+	const visit = (level) => {
+		let any = false;
+		level.forEach((node, index) => {
+			const key = accessors.getKey(node, index);
+			const self = match(node);
+			const below = visit(accessors.getChildren(node) ?? []);
+			if (self) result.matched.add(key);
+			if (below) result.expand.add(key);
+			if (self || below) {
+				result.include.add(key);
+				any = true;
+			}
+		});
+		return any;
+	};
+	visit(roots);
+	return result;
+}
+/**
+* 平铺的行（每行带父 key）组装成树，返回第一层；同级保持 rows 里的顺序，叶子的 children 是空数组。
+* 服务端搜索懒加载的树时回“匹配的节点和它们的祖先”（query 库的 withAncestors），组装后再用 filterTree 得到要展开、高亮的节点。
+* key 重复或父子成环时报错（环上的行到不了第一层）
+*/
+function buildTree(rows, { getKey, getParent, withChildren }) {
+	const make = withChildren ?? ((row, children) => ({
+		...row,
+		children
+	}));
+	const keys = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const key = getKey(row);
+		if (keys.has(key)) throw new Error(`buildTree：key ${key} 出现了两次`);
+		keys.add(key);
+	}
+	const roots = [];
+	const childrenOf = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const parent = getParent(row);
+		if (parent == null || parent === getKey(row) || !keys.has(parent)) roots.push(row);
+		else childrenOf.set(parent, [...childrenOf.get(parent) ?? [], row]);
+	}
+	let built = 0;
+	const node = (row) => {
+		built++;
+		return make(row, (childrenOf.get(getKey(row)) ?? []).map(node));
+	};
+	const tree = roots.map(node);
+	if (built < rows.length) throw new Error("buildTree：有的行的父子关系成了环，到不了第一层");
+	return tree;
+}
+/**
+* 把 key 移到 target（不改原数据，返回新的第一层；沿途的节点用 withChildren 重建，其余节点原样复用）。
+* key 不存在、目标是它自己或它的子孙时返回 null（拖到自己里面不成立）
+*/
+function moveNode(roots, editor, key, target) {
+	const index = indexTree(roots, editor);
+	if (!index.parents.has(key)) return null;
+	if (target.parent !== void 0) {
+		if (!index.parents.has(target.parent)) return null;
+		if (treePath(index, target.parent).includes(key)) return null;
+	}
+	let moving;
+	const removePath = new Set(treePath(index, key).slice(0, -1));
+	const remove = (level) => level.flatMap((node, position) => {
+		const nodeKey = editor.getKey(node, position);
+		if (nodeKey === key) {
+			moving = node;
+			return [];
+		}
+		if (!removePath.has(nodeKey)) return [node];
+		return [editor.withChildren(node, remove(editor.getChildren(node) ?? []))];
+	});
+	const without = remove(roots);
+	const insert = (level) => {
+		const next = [...level];
+		next.splice(Math.min(Math.max(target.index, 0), next.length), 0, moving);
+		return next;
+	};
+	if (target.parent === void 0) return insert(without);
+	const insertPath = new Set(treePath(indexTree(without, editor), target.parent));
+	const add = (level) => level.map((node, position) => {
+		const nodeKey = editor.getKey(node, position);
+		if (!insertPath.has(nodeKey)) return node;
+		const children = editor.getChildren(node) ?? [];
+		return editor.withChildren(node, nodeKey === target.parent ? insert(children) : add(children));
+	});
+	return add(without);
+}
+/** 每个节点的勾选状态：子孙里有勾上的、但自己没有全勾上时是 indeterminate */
+function checkStates(index, checked) {
+	const effective = effectiveChecked(index, checked);
+	const states = /* @__PURE__ */ new Map();
+	for (let i = index.order.length - 1; i >= 0; i--) {
+		const key = index.order[i];
+		if (effective.has(key)) {
+			states.set(key, "checked");
+			continue;
+		}
+		const some = index.children.get(key)?.some((child) => states.get(child) !== "unchecked");
+		states.set(key, some ? "indeterminate" : "unchecked");
+	}
+	return states;
+}
+/** 展开状态与懒加载（在 setup 里调用） */
+function useTreeExpansion({ expanded, setExpanded, getChildren, loadChildren, onLoadError }) {
+	const loading = shallowRef(/* @__PURE__ */ new Set());
+	const isExpanded = (key) => expanded().includes(key);
+	const collapse = (key) => setExpanded(expanded().filter((item) => item !== key));
+	async function setOpen(node, key, open) {
+		if (isExpanded(key) === open) return;
+		if (!open) return collapse(key);
+		setExpanded([...expanded(), key]);
+		if (!loadChildren || loading.value.has(key) || (getChildren(node)?.length ?? 0) > 0) return;
+		const pending = loadChildren(node);
+		if (!(pending instanceof Promise)) return;
+		loading.value = /* @__PURE__ */ new Set([...loading.value, key]);
+		try {
+			await pending;
+		} catch (error) {
+			collapse(key);
+			if (onLoadError) onLoadError(error, node);
+			else console.error("树的子节点加载失败", error);
+		} finally {
+			const next = new Set(loading.value);
+			next.delete(key);
+			loading.value = next;
+		}
+	}
+	return {
+		isExpanded,
+		isLoading: (key) => loading.value.has(key),
+		setOpen
+	};
+}
+//#endregion
+export { buildTree, checkStates, checkedByStrategy, filterTree, flattenTree, indexTree, isExpandable, moveNode, toggleChecked, treePath, useTreeExpansion };
+
+//# sourceMappingURL=tree.js.map

package/dist/utils/data/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","names":[],"sources":["../../../src/utils/data/tree.ts"],"sourcesContent":["/**\n * 树状数据的共用逻辑：按展开状态展开成一列行、勾选的父子联动（含半选）、展开时懒加载子项，\n * 以及搜索过滤、勾选结果的取法（只要父 / 只要子 / 全部）、到某个节点的路径、移动节点。\n * TreeDataTable（层级行）、Tree、TreeSelect、Cascader、Transfer 共用；数据形状不限，由 getKey / getChildren 读取。\n *\n *   const rows = flattenTree(roots, { getKey, getChildren }, new Set(expanded));\n *   const index = indexTree(roots, { getKey, getChildren });\n *   checked = toggleChecked(index, checked, key);        // 勾上 / 取消一项，子孙与祖先跟着变\n *   const states = checkStates(index, checked);           // key → checked / indeterminate / unchecked\n *   const value = checkedByStrategy(index, checked, 'parent'); // 父节点全勾上时只要父节点\n *   const { include, expand } = filterTree(roots, accessors, (node) => node.name.includes(query));\n *   flattenTree(roots, accessors, new Set([...expanded, ...expand]), { include });\n *   roots = moveNode(roots, { ...accessors, withChildren }, key, { parent: 'b', index: 0 });\n *   roots = buildTree(flatRows, { getKey: (r) => r.id, getParent: (r) => r.parentId }); // 平铺的行（服务端搜索的结果）组装成树\n */\nimport { shallowRef } from 'vue';\n\n/** 怎样从数据里读出树的结构 */\nexport interface TreeAccessors<T> {\n  /** 节点的 key，整棵树里唯一；index 是它在同级里的位置 */\n  getKey: (node: T, index: number) => string;\n  /** 子节点；叶子或还没加载时返回 undefined / 空数组 */\n  getChildren: (node: T) => readonly T[] | undefined;\n  /** 有没有子节点（懒加载时子节点还没取回来也算有）；不写时看 getChildren 是否非空 */\n  hasChildren?: (node: T) => boolean;\n}\n\n/** 展开成一列的一行 */\nexport interface FlatTreeNode<T> {\n  /** 原始数据 */\n  readonly node: T;\n  /** getKey 给出的 key */\n  readonly key: string;\n  /** 层级，第一层为 0 */\n  readonly depth: number;\n  /** 父节点的 key；第一层为 undefined */\n  readonly parent: string | undefined;\n  /** 能不能展开（有子节点，或懒加载时声明了有） */\n  readonly expandable: boolean;\n  /** 同级一共几个（aria-setsize） */\n  readonly setSize: number;\n  /** 在同级里排第几，从 1 开始（aria-posinset） */\n  readonly position: number;\n}\n\n/** 节点能不能展开 */\nexport const isExpandable = <T>(node: T, { getChildren, hasChildren }: TreeAccessors<T>): boolean =>\n  hasChildren?.(node) ?? (getChildren(node)?.length ?? 0) > 0;\n\n/** flattenTree 的选项 */\nexport interface FlattenTreeOptions<T> {\n  /** 改写每一层的顺序（TreeDataTable 按当前排序），不写时按数据顺序 */\n  order?: (level: readonly T[]) => readonly T[];\n  /** 只要这些节点（搜索过滤：filterTree 的 include），不写时全要 */\n  include?: ReadonlySet<string>;\n}\n\n/** 按展开状态深度优先展开成一列：只有展开了的节点的子节点出现在结果里 */\nexport function flattenTree<T>(\n  roots: readonly T[],\n  accessors: TreeAccessors<T>,\n  expanded: ReadonlySet<string>,\n  { order = (level) => level, include }: FlattenTreeOptions<T> = {},\n): FlatTreeNode<T>[] {\n  const result: FlatTreeNode<T>[] = [];\n  const visit = (level: readonly T[], depth: number, parent: string | undefined) => {\n    // 先按原位置取 key（getKey 的 index 是数据里的位置），再排序、过滤\n    const keyOf = new Map(level.map((node, index) => [node, accessors.getKey(node, index)]));\n    const sorted = order(level).filter((node) => !include || include.has(keyOf.get(node)!));\n    sorted.forEach((node, index) => {\n      const key = keyOf.get(node)!;\n      const expandable = isExpandable(node, accessors);\n      result.push({\n        node,\n        key,\n        depth,\n        parent,\n        expandable,\n        setSize: sorted.length,\n        position: index + 1,\n      });\n      if (expandable && expanded.has(key)) visit(accessors.getChildren(node) ?? [], depth + 1, key);\n    });\n  };\n  visit(roots, 0, undefined);\n  return result;\n}\n\n/** 整棵（已加载的）树的索引：勾选联动要看到折叠着的节点 */\nexport interface TreeIndex {\n  /** 深度优先的顺序 */\n  readonly order: readonly string[];\n  /** key → 父节点的 key */\n  readonly parents: ReadonlyMap<string, string | undefined>;\n  /** key → 已加载的子节点的 key */\n  readonly children: ReadonlyMap<string, readonly string[]>;\n}\n\n/** 建立整棵已加载的树的索引 */\nexport function indexTree<T>(roots: readonly T[], accessors: TreeAccessors<T>): TreeIndex {\n  const order: string[] = [];\n  const parents = new Map<string, string | undefined>();\n  const children = new Map<string, string[]>();\n  const visit = (level: readonly T[], parent: string | undefined) => {\n    const keys = level.map((node, index) => accessors.getKey(node, index));\n    if (parent !== undefined) children.set(parent, keys);\n    level.forEach((node, index) => {\n      const key = keys[index]!;\n      order.push(key);\n      parents.set(key, parent);\n      visit(accessors.getChildren(node) ?? [], key);\n    });\n  };\n  visit(roots, undefined);\n  return { order, parents, children };\n}\n\n/** 勾选状态 */\nexport type CheckState = 'checked' | 'indeterminate' | 'unchecked';\n\n/**\n * 实际勾上的节点：自己或任何祖先在 checked 里（父节点勾上之后才懒加载出来的子节点因此也算勾上），\n * 或者已加载的子节点全勾上了（checked 由外部给出、没有写全父节点时）\n */\nfunction effectiveChecked(index: TreeIndex, checked: readonly string[]): Set<string> {\n  const listed = new Set(checked);\n  const result = new Set<string>();\n  // order 是深度优先：正序时父节点先于子节点，倒序时子节点先于父节点\n  for (const key of index.order) {\n    const parent = index.parents.get(key);\n    if (listed.has(key) || (parent !== undefined && result.has(parent))) result.add(key);\n  }\n  for (let i = index.order.length - 1; i >= 0; i--) {\n    const children = index.children.get(index.order[i]!);\n    if (children?.length && children.every((child) => result.has(child)))\n      result.add(index.order[i]!);\n  }\n  return result;\n}\n\n/**\n * 勾上或取消 key：子孙跟着变；祖先的子节点全勾上时祖先也勾上，否则取消。\n * 返回勾上的全部节点（按树的顺序），可以直接写回 checked\n */\nexport function toggleChecked(index: TreeIndex, checked: readonly string[], key: string): string[] {\n  const result = effectiveChecked(index, checked);\n  const next = !result.has(key);\n  const visit = (current: string) => {\n    if (next) result.add(current);\n    else result.delete(current);\n    index.children.get(current)?.forEach(visit);\n  };\n  visit(key);\n  for (let parent = index.parents.get(key); parent !== undefined;) {\n    const all = index.children.get(parent)!.every((child) => result.has(child));\n    if (all) result.add(parent);\n    else result.delete(parent);\n    parent = index.parents.get(parent);\n  }\n  return index.order.filter((item) => result.has(item));\n}\n\n/** 勾选结果的取法（同 Ant Design 的 showCheckedStrategy） */\nexport interface CheckStrategies {\n  /** 勾上的全部节点（默认） */\n  all: unknown;\n  /** 父节点全勾上时只要父节点，不再列出它的子孙（提交“整个部门”而不是逐个成员） */\n  parent: unknown;\n  /** 只要叶子（没有已加载的子节点的节点） */\n  child: unknown;\n}\n\n/** 按取法给出勾上的节点（按树的顺序）；checked 可以是 toggleChecked 的结果，也可以是外部给的部分节点 */\nexport function checkedByStrategy(\n  index: TreeIndex,\n  checked: readonly string[],\n  strategy: keyof CheckStrategies,\n): string[] {\n  const effective = effectiveChecked(index, checked);\n  return index.order.filter((key) => {\n    if (!effective.has(key)) return false;\n    if (strategy === 'child') return !index.children.get(key)?.length;\n    if (strategy === 'parent') {\n      const parent = index.parents.get(key);\n      return parent === undefined || !effective.has(parent);\n    }\n    return true;\n  });\n}\n\n/** 从第一层到 key 的各节点的 key（含 key 自己）；key 不在树里时为空数组。Cascader 的路径、面包屑用它 */\nexport function treePath(index: TreeIndex, key: string): string[] {\n  if (!index.parents.has(key)) return [];\n  const path: string[] = [];\n  for (let current: string | undefined = key; current !== undefined;) {\n    path.unshift(current);\n    current = index.parents.get(current);\n  }\n  return path;\n}\n\n/** filterTree 的结果 */\nexport interface TreeFilter {\n  /** 要显示的节点：匹配的节点与它们的祖先（交给 flattenTree 的 include） */\n  include: Set<string>;\n  /** 要展开的节点：匹配的节点的祖先，展开后才看得到匹配项 */\n  expand: Set<string>;\n  /** 匹配的节点（高亮用） */\n  matched: Set<string>;\n}\n\n/**\n * 搜索过滤：留下匹配的节点与它们的祖先，并展开祖先（只看已加载的节点）。\n * 匹配的节点的子孙不跟着留下（它们自己匹配才留下），同 Ant Design TreeSelect 的搜索\n */\nexport function filterTree<T>(\n  roots: readonly T[],\n  accessors: TreeAccessors<T>,\n  match: (node: T) => boolean,\n): TreeFilter {\n  const result: TreeFilter = { include: new Set(), expand: new Set(), matched: new Set() };\n  // 返回子树里有没有匹配的节点\n  const visit = (level: readonly T[]): boolean => {\n    let any = false;\n    level.forEach((node, index) => {\n      const key = accessors.getKey(node, index);\n      const self = match(node);\n      const below = visit(accessors.getChildren(node) ?? []);\n      if (self) result.matched.add(key);\n      if (below) result.expand.add(key);\n      if (self || below) {\n        result.include.add(key);\n        any = true;\n      }\n    });\n    return any;\n  };\n  visit(roots);\n  return result;\n}\n\n/** buildTree 怎样读平铺的行 */\nexport interface TreeRows<T> {\n  /** 行的 key，这批行里唯一 */\n  getKey: (row: T) => string;\n  /** 父行的 key；根行是 null / undefined，父行不在这批行里的也当作根 */\n  getParent: (row: T) => string | null | undefined;\n  /** 用子节点生成一个节点（不改原行），同 TreeEditor；不写时是 `{ ...row, children }` */\n  withChildren?: (row: T, children: T[]) => T;\n}\n\n/**\n * 平铺的行（每行带父 key）组装成树，返回第一层；同级保持 rows 里的顺序，叶子的 children 是空数组。\n * 服务端搜索懒加载的树时回“匹配的节点和它们的祖先”（query 库的 withAncestors），组装后再用 filterTree 得到要展开、高亮的节点。\n * key 重复或父子成环时报错（环上的行到不了第一层）\n */\nexport function buildTree<T>(\n  rows: readonly T[],\n  { getKey, getParent, withChildren }: TreeRows<T>,\n): T[] {\n  const make = withChildren ?? ((row: T, children: T[]) => ({ ...row, children }) as T);\n  const keys = new Set<string>();\n  for (const row of rows) {\n    const key = getKey(row);\n    if (keys.has(key)) throw new Error(`buildTree：key ${key} 出现了两次`);\n    keys.add(key);\n  }\n  const roots: T[] = [];\n  const childrenOf = new Map<string, T[]>();\n  for (const row of rows) {\n    const parent = getParent(row);\n    if (parent == null || parent === getKey(row) || !keys.has(parent)) roots.push(row);\n    else childrenOf.set(parent, [...(childrenOf.get(parent) ?? []), row]);\n  }\n  let built = 0;\n  const node = (row: T): T => {\n    built++;\n    return make(row, (childrenOf.get(getKey(row)) ?? []).map(node));\n  };\n  const tree = roots.map(node);\n  if (built < rows.length) throw new Error('buildTree：有的行的父子关系成了环，到不了第一层');\n  return tree;\n}\n\n/** moveNode 要的读写方法：在读取之外，能用新的子节点生成一个节点 */\nexport interface TreeEditor<T> extends TreeAccessors<T> {\n  /** 换掉子节点后的新节点（不改原节点），如 `(node, children) => ({ ...node, children })` */\n  withChildren: (node: T, children: T[]) => T;\n}\n\n/** 移动的目标：放到哪个节点下（undefined 是第一层）的第几位 */\nexport interface TreeMoveTarget {\n  /** 新的父节点的 key；第一层时为 undefined */\n  parent: string | undefined;\n  /** 在新的同级里的位置（按移走之后的同级算），超出时放到最后 */\n  index: number;\n}\n\n/**\n * 把 key 移到 target（不改原数据，返回新的第一层；沿途的节点用 withChildren 重建，其余节点原样复用）。\n * key 不存在、目标是它自己或它的子孙时返回 null（拖到自己里面不成立）\n */\nexport function moveNode<T>(\n  roots: readonly T[],\n  editor: TreeEditor<T>,\n  key: string,\n  target: TreeMoveTarget,\n): T[] | null {\n  const index = indexTree(roots, editor);\n  if (!index.parents.has(key)) return null;\n  if (target.parent !== undefined) {\n    if (!index.parents.has(target.parent)) return null;\n    if (treePath(index, target.parent).includes(key)) return null;\n  }\n  let moving: T | undefined;\n  // 先摘下来：只重建 key 的祖先\n  const removePath = new Set(treePath(index, key).slice(0, -1));\n  const remove = (level: readonly T[]): T[] =>\n    level.flatMap((node, position) => {\n      const nodeKey = editor.getKey(node, position);\n      if (nodeKey === key) {\n        moving = node;\n        return [];\n      }\n      if (!removePath.has(nodeKey)) return [node];\n      return [editor.withChildren(node, remove(editor.getChildren(node) ?? []))];\n    });\n  const without = remove(roots);\n  const insert = (level: readonly T[]) => {\n    const next = [...level];\n    next.splice(Math.min(Math.max(target.index, 0), next.length), 0, moving!);\n    return next;\n  };\n  if (target.parent === undefined) return insert(without);\n  // 再插进去：只重建目标父节点的祖先（含它自己）\n  const insertPath = new Set(treePath(indexTree(without, editor), target.parent));\n  const add = (level: readonly T[]): T[] =>\n    level.map((node, position) => {\n      const nodeKey = editor.getKey(node, position);\n      if (!insertPath.has(nodeKey)) return node;\n      const children = editor.getChildren(node) ?? [];\n      return editor.withChildren(\n        node,\n        nodeKey === target.parent ? insert(children) : add(children),\n      );\n    });\n  return add(without);\n}\n\n/** 每个节点的勾选状态：子孙里有勾上的、但自己没有全勾上时是 indeterminate */\nexport function checkStates(index: TreeIndex, checked: readonly string[]): Map<string, CheckState> {\n  const effective = effectiveChecked(index, checked);\n  const states = new Map<string, CheckState>();\n  // 倒序：子节点先于父节点算好\n  for (let i = index.order.length - 1; i >= 0; i--) {\n    const key = index.order[i]!;\n    if (effective.has(key)) {\n      states.set(key, 'checked');\n      continue;\n    }\n    const some = index.children.get(key)?.some((child) => states.get(child) !== 'unchecked');\n    states.set(key, some ? 'indeterminate' : 'unchecked');\n  }\n  return states;\n}\n\n/** useTreeExpansion 的选项 */\nexport interface TreeExpansionOptions<T> {\n  /** 读当前展开的 key */\n  expanded: () => readonly string[];\n  /** 写回展开的 key */\n  setExpanded: (keys: string[]) => void;\n  /** 节点已加载的子节点 */\n  getChildren: (node: T) => readonly T[] | undefined;\n  /** 展开一个还没有子节点的节点时调用：取回子节点并放进数据里；返回 Promise 时显示加载中 */\n  loadChildren?: (node: T) => Promise<unknown> | void;\n  /** 子节点加载失败：节点收回去，可以再展开重试；不写时在控制台报错 */\n  onLoadError?: (error: unknown, node: T) => void;\n}\n\n/** useTreeExpansion 的返回值 */\nexport interface TreeExpansion<T> {\n  /** 是否展开 */\n  isExpanded: (key: string) => boolean;\n  /** 是否正在加载子节点 */\n  isLoading: (key: string) => boolean;\n  /** 展开或收起；展开一个还没有子节点的节点时懒加载 */\n  setOpen: (node: T, key: string, open: boolean) => Promise<void>;\n}\n\n/** 展开状态与懒加载（在 setup 里调用） */\nexport function useTreeExpansion<T>({\n  expanded,\n  setExpanded,\n  getChildren,\n  loadChildren,\n  onLoadError,\n}: TreeExpansionOptions<T>): TreeExpansion<T> {\n  const loading = shallowRef<ReadonlySet<string>>(new Set());\n  const isExpanded = (key: string) => expanded().includes(key);\n\n  const collapse = (key: string) => setExpanded(expanded().filter((item) => item !== key));\n\n  async function setOpen(node: T, key: string, open: boolean) {\n    if (isExpanded(key) === open) return;\n    if (!open) return collapse(key);\n    setExpanded([...expanded(), key]);\n    // 正在加载（收起后又展开）：等那一次，不重复请求\n    if (!loadChildren || loading.value.has(key) || (getChildren(node)?.length ?? 0) > 0) return;\n    const pending = loadChildren(node);\n    if (!(pending instanceof Promise)) return;\n    loading.value = new Set([...loading.value, key]);\n    try {\n      await pending;\n    } catch (error) {\n      // 失败时收回去：留着展开却没有子节点，看起来像是本来就没有；再展开会重试\n      collapse(key);\n      if (onLoadError) onLoadError(error, node);\n      else console.error('树的子节点加载失败', error);\n    } finally {\n      const next = new Set(loading.value);\n      next.delete(key);\n      loading.value = next;\n    }\n  }\n\n  return { isExpanded, isLoading: (key) => loading.value.has(key), setOpen };\n}\n"],"mappings":"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"}