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

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

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

@@ -0,0 +1,67 @@
+/** 工作日历：哪天上班 */
+export interface WorkCalendar {
+    /** 这一天（ISO 日期）上不上班 */
+    isWorkday(iso: string): boolean;
+}
+/** createWorkCalendar 的选项 */
+export interface WorkCalendarOptions {
+    /** 休息的星期几（0 周日 … 6 周六），默认周六、周日 */
+    weekend?: readonly number[];
+    /** 放假的日子：ISO 日期，或 [开始, 结束]（含两端） */
+    holidays?: readonly (string | readonly [string, string])[];
+    /** 调休上班的日子（落在周末的补班） */
+    workdays?: readonly string[];
+}
+/** 按周末、节假日与调休生成工作日历 */
+export declare function createWorkCalendar({ weekend, holidays, workdays, }?: WorkCalendarOptions): WorkCalendar;
+/** 只按周末（周六、周日）算的工作日历：没配置 workCalendar 时用它 */
+export declare const weekdayCalendar: WorkCalendar;
+/**
+ * from 之后到 to（含）有几个工作日：周五到下周一是 1；to 在 from 之前时为负数（两端对调再取负，同 date-fns 的方向）
+ */
+export declare function workdaysBetween(from: string, to: string, calendar?: WorkCalendar): number;
+/** 从 from 起数 count 个工作日后的那一天（count 为负往前数，为 0 时原样） */
+export declare function addWorkdays(from: string, count: number, calendar?: WorkCalendar): string;
+/** 时限的状态 */
+export interface DeadlineStates {
+    /** 还早 */
+    pending: unknown;
+    /** 快到期：剩下的工作日不多于 soon */
+    soon: unknown;
+    /** 今天到期 */
+    due: unknown;
+    /** 超期 */
+    overdue: unknown;
+    /** 已完成（按完成那天算剩余或超期） */
+    done: unknown;
+}
+/** 时限：截止日直接给出，或开始日加几个工作日 */
+export type DeadlineInput = ({
+    due: string;
+    start?: never;
+    workdays?: never;
+} | {
+    start: string;
+    workdays: number;
+    due?: never;
+}) & {
+    /** 完成的日期；完成了状态是 done */
+    done?: string | null;
+    /** 今天，默认按浏览器时区的今天 */
+    today?: string;
+    /** 剩下几个工作日以内算快到期，默认 2 */
+    soon?: number;
+};
+/** 时限的结果 */
+export interface Deadline {
+    /** 截止日 */
+    due: string;
+    /** 离截止还有几个工作日：截止当天为 0，超期为负；完成了按完成那天算 */
+    remaining: number;
+    /** 状态 */
+    state: keyof DeadlineStates;
+}
+/** 算时限：截止日、还剩几个工作日、状态 */
+export declare function deadlineOf(input: DeadlineInput, calendar?: WorkCalendar): Deadline;
+/** 当前配置的工作日历（createUi / Provider 的 workCalendar；都没给时只按周末） */
+export declare function useWorkCalendar(): WorkCalendar;

package/dist/utils/data/workdays.js

@@ -0,0 +1,67 @@
+import { useConfig } from "../../config/context.js";
+import { isoDayOfWeek, shiftIsoDate, todayIso } from "./date.js";
+//#region src/utils/data/workdays.ts
+/**
+* 工作日与时限（参考 date-fns 的 addBusinessDays、differenceInBusinessDays）：周末、法定节假日与调休补班。
+* 节假日每年发布一次，组件库不内置：应用把数据交给 createUi / Provider 的 workCalendar，组件经 useWorkCalendar 取用。
+*
+*   const workCalendar = createWorkCalendar({
+*     holidays: [['2026-10-01', '2026-10-08']],   // 放假（单日或区间）
+*     workdays: ['2026-09-27', '2026-10-10'],     // 调休上班的周末
+*   });
+*   createUi({ workCalendar });
+*
+*   const calendar = useWorkCalendar();
+*   deadlineOf({ start: verifiedOn, workdays: 10 }, calendar)   // → { due, remaining, state }
+*/
+/** 按周末、节假日与调休生成工作日历 */
+function createWorkCalendar({ weekend = [0, 6], holidays = [], workdays = [] } = {}) {
+	const off = /* @__PURE__ */ new Set();
+	for (const entry of holidays) if (typeof entry === "string") off.add(entry);
+	else for (let day = entry[0]; day <= entry[1]; day = shiftIsoDate(day, { days: 1 })) off.add(day);
+	const on = new Set(workdays);
+	return { isWorkday: (iso) => on.has(iso) || !off.has(iso) && !weekend.includes(isoDayOfWeek(iso)) };
+}
+/** 只按周末（周六、周日）算的工作日历：没配置 workCalendar 时用它 */
+var weekdayCalendar = createWorkCalendar();
+/**
+* from 之后到 to（含）有几个工作日：周五到下周一是 1；to 在 from 之前时为负数（两端对调再取负，同 date-fns 的方向）
+*/
+function workdaysBetween(from, to, calendar = weekdayCalendar) {
+	if (to < from) return 0 - workdaysBetween(to, from, calendar);
+	let count = 0;
+	for (let day = from; day < to;) {
+		day = shiftIsoDate(day, { days: 1 });
+		if (calendar.isWorkday(day)) count++;
+	}
+	return count;
+}
+/** 从 from 起数 count 个工作日后的那一天（count 为负往前数，为 0 时原样） */
+function addWorkdays(from, count, calendar = weekdayCalendar) {
+	const step = count >= 0 ? 1 : -1;
+	let day = from;
+	for (let left = Math.abs(count); left > 0;) {
+		day = shiftIsoDate(day, { days: step });
+		if (calendar.isWorkday(day)) left--;
+	}
+	return day;
+}
+/** 算时限：截止日、还剩几个工作日、状态 */
+function deadlineOf(input, calendar = weekdayCalendar) {
+	const due = input.due ?? addWorkdays(input.start, input.workdays, calendar);
+	const at = input.done ?? input.today ?? todayIso();
+	const remaining = workdaysBetween(at, due, calendar);
+	return {
+		due,
+		remaining,
+		state: input.done ? "done" : at > due ? "overdue" : at === due ? "due" : remaining <= (input.soon ?? 2) ? "soon" : "pending"
+	};
+}
+/** 当前配置的工作日历（createUi / Provider 的 workCalendar；都没给时只按周末） */
+function useWorkCalendar() {
+	return useConfig().workCalendar ?? weekdayCalendar;
+}
+//#endregion
+export { addWorkdays, createWorkCalendar, deadlineOf, useWorkCalendar, weekdayCalendar, workdaysBetween };
+
+//# sourceMappingURL=workdays.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workdays.js","names":[],"sources":["../../../src/utils/data/workdays.ts"],"sourcesContent":["/**\n * 工作日与时限（参考 date-fns 的 addBusinessDays、differenceInBusinessDays）：周末、法定节假日与调休补班。\n * 节假日每年发布一次，组件库不内置：应用把数据交给 createUi / Provider 的 workCalendar，组件经 useWorkCalendar 取用。\n *\n *   const workCalendar = createWorkCalendar({\n *     holidays: [['2026-10-01', '2026-10-08']],   // 放假（单日或区间）\n *     workdays: ['2026-09-27', '2026-10-10'],     // 调休上班的周末\n *   });\n *   createUi({ workCalendar });\n *\n *   const calendar = useWorkCalendar();\n *   deadlineOf({ start: verifiedOn, workdays: 10 }, calendar)   // → { due, remaining, state }\n */\nimport { useConfig } from '../../config/context';\nimport { isoDayOfWeek, shiftIsoDate, todayIso } from './date';\n\n/** 工作日历：哪天上班 */\nexport interface WorkCalendar {\n  /** 这一天（ISO 日期）上不上班 */\n  isWorkday(iso: string): boolean;\n}\n\n/** createWorkCalendar 的选项 */\nexport interface WorkCalendarOptions {\n  /** 休息的星期几（0 周日 … 6 周六），默认周六、周日 */\n  weekend?: readonly number[];\n  /** 放假的日子：ISO 日期，或 [开始, 结束]（含两端） */\n  holidays?: readonly (string | readonly [string, string])[];\n  /** 调休上班的日子（落在周末的补班） */\n  workdays?: readonly string[];\n}\n\n/** 按周末、节假日与调休生成工作日历 */\nexport function createWorkCalendar({\n  weekend = [0, 6],\n  holidays = [],\n  workdays = [],\n}: WorkCalendarOptions = {}): WorkCalendar {\n  const off = new Set<string>();\n  for (const entry of holidays) {\n    if (typeof entry === 'string') off.add(entry);\n    else\n      for (let day = entry[0]; day <= entry[1]; day = shiftIsoDate(day, { days: 1 })) off.add(day);\n  }\n  const on = new Set(workdays);\n  return {\n    isWorkday: (iso) => on.has(iso) || (!off.has(iso) && !weekend.includes(isoDayOfWeek(iso))),\n  };\n}\n\n/** 只按周末（周六、周日）算的工作日历：没配置 workCalendar 时用它 */\nexport const weekdayCalendar: WorkCalendar = createWorkCalendar();\n\n/**\n * from 之后到 to（含）有几个工作日：周五到下周一是 1；to 在 from 之前时为负数（两端对调再取负，同 date-fns 的方向）\n */\nexport function workdaysBetween(from: string, to: string, calendar = weekdayCalendar): number {\n  // 0 - x 而不是 -x：相差 0 个工作日时得 0，不是 -0\n  if (to < from) return 0 - workdaysBetween(to, from, calendar);\n  let count = 0;\n  for (let day = from; day < to;) {\n    day = shiftIsoDate(day, { days: 1 });\n    if (calendar.isWorkday(day)) count++;\n  }\n  return count;\n}\n\n/** 从 from 起数 count 个工作日后的那一天（count 为负往前数，为 0 时原样） */\nexport function addWorkdays(from: string, count: number, calendar = weekdayCalendar): string {\n  const step = count >= 0 ? 1 : -1;\n  let day = from;\n  for (let left = Math.abs(count); left > 0;) {\n    day = shiftIsoDate(day, { days: step });\n    if (calendar.isWorkday(day)) left--;\n  }\n  return day;\n}\n\n/** 时限的状态 */\nexport interface DeadlineStates {\n  /** 还早 */\n  pending: unknown;\n  /** 快到期：剩下的工作日不多于 soon */\n  soon: unknown;\n  /** 今天到期 */\n  due: unknown;\n  /** 超期 */\n  overdue: unknown;\n  /** 已完成（按完成那天算剩余或超期） */\n  done: unknown;\n}\n\n/** 时限：截止日直接给出，或开始日加几个工作日 */\nexport type DeadlineInput = (\n  | { due: string; start?: never; workdays?: never }\n  | { start: string; workdays: number; due?: never }\n) & {\n  /** 完成的日期；完成了状态是 done */\n  done?: string | null;\n  /** 今天，默认按浏览器时区的今天 */\n  today?: string;\n  /** 剩下几个工作日以内算快到期，默认 2 */\n  soon?: number;\n};\n\n/** 时限的结果 */\nexport interface Deadline {\n  /** 截止日 */\n  due: string;\n  /** 离截止还有几个工作日：截止当天为 0，超期为负；完成了按完成那天算 */\n  remaining: number;\n  /** 状态 */\n  state: keyof DeadlineStates;\n}\n\n/** 算时限：截止日、还剩几个工作日、状态 */\nexport function deadlineOf(input: DeadlineInput, calendar = weekdayCalendar): Deadline {\n  const due = input.due ?? addWorkdays(input.start, input.workdays, calendar);\n  const at = input.done ?? input.today ?? todayIso();\n  const remaining = workdaysBetween(at, due, calendar);\n  // 是否过期按日期比：周五截止、周六还没完成也算超期（虽然中间没有工作日）\n  const state: keyof DeadlineStates = input.done\n    ? 'done'\n    : at > due\n      ? 'overdue'\n      : at === due\n        ? 'due'\n        : remaining <= (input.soon ?? 2)\n          ? 'soon'\n          : 'pending';\n  return { due, remaining, state };\n}\n\n/** 当前配置的工作日历（createUi / Provider 的 workCalendar；都没给时只按周末） */\nexport function useWorkCalendar(): WorkCalendar {\n  return useConfig().workCalendar ?? weekdayCalendar;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiCA,SAAgB,mBAAmB,EACjC,UAAU,CAAC,GAAG,CAAC,GACf,WAAW,CAAC,GACZ,WAAW,CAAC,MACW,CAAC,GAAiB;CACzC,MAAM,sBAAM,IAAI,IAAY;CAC5B,KAAK,MAAM,SAAS,UAClB,IAAI,OAAO,UAAU,UAAU,IAAI,IAAI,KAAK;MAE1C,KAAK,IAAI,MAAM,MAAM,IAAI,OAAO,MAAM,IAAI,MAAM,aAAa,KAAK,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,IAAI,GAAG;CAE/F,MAAM,KAAK,IAAI,IAAI,QAAQ;CAC3B,OAAO,EACL,YAAY,QAAQ,GAAG,IAAI,GAAG,KAAM,CAAC,IAAI,IAAI,GAAG,KAAK,CAAC,QAAQ,SAAS,aAAa,GAAG,CAAC,EAC1F;AACF;;AAGA,IAAa,kBAAgC,mBAAmB;;;;AAKhE,SAAgB,gBAAgB,MAAc,IAAY,WAAW,iBAAyB;CAE5F,IAAI,KAAK,MAAM,OAAO,IAAI,gBAAgB,IAAI,MAAM,QAAQ;CAC5D,IAAI,QAAQ;CACZ,KAAK,IAAI,MAAM,MAAM,MAAM,KAAK;EAC9B,MAAM,aAAa,KAAK,EAAE,MAAM,EAAE,CAAC;EACnC,IAAI,SAAS,UAAU,GAAG,GAAG;CAC/B;CACA,OAAO;AACT;;AAGA,SAAgB,YAAY,MAAc,OAAe,WAAW,iBAAyB;CAC3F,MAAM,OAAO,SAAS,IAAI,IAAI;CAC9B,IAAI,MAAM;CACV,KAAK,IAAI,OAAO,KAAK,IAAI,KAAK,GAAG,OAAO,IAAI;EAC1C,MAAM,aAAa,KAAK,EAAE,MAAM,KAAK,CAAC;EACtC,IAAI,SAAS,UAAU,GAAG,GAAG;CAC/B;CACA,OAAO;AACT;;AAwCA,SAAgB,WAAW,OAAsB,WAAW,iBAA2B;CACrF,MAAM,MAAM,MAAM,OAAO,YAAY,MAAM,OAAO,MAAM,UAAU,QAAQ;CAC1E,MAAM,KAAK,MAAM,QAAQ,MAAM,SAAS,SAAS;CACjD,MAAM,YAAY,gBAAgB,IAAI,KAAK,QAAQ;CAWnD,OAAO;EAAE;EAAK;EAAW,OATW,MAAM,OACtC,SACA,KAAK,MACH,YACA,OAAO,MACL,QACA,cAAc,MAAM,QAAQ,KAC1B,SACA;CACqB;AACjC;;AAGA,SAAgB,kBAAgC;CAC9C,OAAO,UAAU,CAAC,CAAC,gBAAgB;AACrC"}

package/dist/utils/dom/announcer.d.ts

@@ -0,0 +1,11 @@
+/** 播报的紧迫程度 */
+export interface Politenesses {
+    /** 等读屏念完当前的内容再念（默认）：选中条数、搜索结果、已复制 */
+    polite: unknown;
+    /** 打断当前的朗读：出错、操作失败 */
+    assertive: unknown;
+}
+/** 播报的紧迫程度 */
+export type Politeness = keyof Politenesses;
+/** 让读屏念出一句话；同一句话连说两次也会念（先清空，稍后再写入）。没有 document（服务端）时什么也不做 */
+export declare function announce(message: string, politeness?: Politeness): void;

package/dist/utils/dom/announcer.js

@@ -0,0 +1,53 @@
+import { topModal } from "./overlay.js";
+//#region src/utils/dom/announcer.ts
+/**
+* 读屏播报（参考 React Aria 的 LiveAnnouncer）：整页共用两个常驻的 aria-live 区域（polite 与 assertive），
+* 组件不再各自挂播报区。读屏只念已经存在的区域里的变化，随内容一起插入的 aria-live 区域常常不念，第一句就丢了。
+*
+*   announce(lang.tableSelectedCount(3));
+*   announce('保存失败', 'assertive');
+*
+* 有模态对话框打开时区域挂进最上层的对话框：showModal 让对话框外面的内容对读屏失效。
+*/
+/** 只给读屏的区域：视觉上隐藏（同 VisuallyHidden；这里是命令式创建的元素，直接写行内样式） */
+var SR_ONLY = {
+	position: "absolute",
+	width: "1px",
+	height: "1px",
+	margin: "-1px",
+	padding: "0",
+	overflow: "hidden",
+	clipPath: "inset(50%)",
+	whiteSpace: "nowrap",
+	border: "0"
+};
+/** 清空与写入之间隔多久（毫秒）：同一帧里改两次，读屏只看到最后的结果，重复的话就不念了 */
+var REPEAT_DELAY = 100;
+var regions = /* @__PURE__ */ new Map();
+var timers = /* @__PURE__ */ new Map();
+function region(politeness) {
+	let element = regions.get(politeness);
+	if (!element) {
+		element = document.createElement("div");
+		element.setAttribute("aria-live", politeness);
+		element.setAttribute("aria-atomic", "true");
+		element.dataset.liveAnnouncer = politeness;
+		Object.assign(element.style, SR_ONLY);
+		regions.set(politeness, element);
+	}
+	const host = topModal() ?? document.body;
+	if (element.parentElement !== host) host.append(element);
+	return element;
+}
+/** 让读屏念出一句话；同一句话连说两次也会念（先清空，稍后再写入）。没有 document（服务端）时什么也不做 */
+function announce(message, politeness = "polite") {
+	if (typeof document === "undefined" || !message) return;
+	const element = region(politeness);
+	element.textContent = "";
+	clearTimeout(timers.get(politeness));
+	timers.set(politeness, setTimeout(() => element.textContent = message, REPEAT_DELAY));
+}
+//#endregion
+export { announce };
+
+//# sourceMappingURL=announcer.js.map

package/dist/utils/dom/announcer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"announcer.js","names":[],"sources":["../../../src/utils/dom/announcer.ts"],"sourcesContent":["/**\n * 读屏播报（参考 React Aria 的 LiveAnnouncer）：整页共用两个常驻的 aria-live 区域（polite 与 assertive），\n * 组件不再各自挂播报区。读屏只念已经存在的区域里的变化，随内容一起插入的 aria-live 区域常常不念，第一句就丢了。\n *\n *   announce(lang.tableSelectedCount(3));\n *   announce('保存失败', 'assertive');\n *\n * 有模态对话框打开时区域挂进最上层的对话框：showModal 让对话框外面的内容对读屏失效。\n */\nimport { topModal } from './overlay';\n\n/** 播报的紧迫程度 */\nexport interface Politenesses {\n  /** 等读屏念完当前的内容再念（默认）：选中条数、搜索结果、已复制 */\n  polite: unknown;\n  /** 打断当前的朗读：出错、操作失败 */\n  assertive: unknown;\n}\n\n/** 播报的紧迫程度 */\nexport type Politeness = keyof Politenesses;\n\n/** 只给读屏的区域：视觉上隐藏（同 VisuallyHidden；这里是命令式创建的元素，直接写行内样式） */\nconst SR_ONLY: Partial<CSSStyleDeclaration> = {\n  position: 'absolute',\n  width: '1px',\n  height: '1px',\n  margin: '-1px',\n  padding: '0',\n  overflow: 'hidden',\n  clipPath: 'inset(50%)',\n  whiteSpace: 'nowrap',\n  border: '0',\n};\n\n/** 清空与写入之间隔多久（毫秒）：同一帧里改两次，读屏只看到最后的结果，重复的话就不念了 */\nconst REPEAT_DELAY = 100;\n\nconst regions = new Map<Politeness, HTMLElement>();\nconst timers = new Map<Politeness, ReturnType<typeof setTimeout>>();\n\nfunction region(politeness: Politeness): HTMLElement {\n  let element = regions.get(politeness);\n  if (!element) {\n    element = document.createElement('div');\n    element.setAttribute('aria-live', politeness);\n    element.setAttribute('aria-atomic', 'true');\n    element.dataset.liveAnnouncer = politeness;\n    Object.assign(element.style, SR_ONLY);\n    regions.set(politeness, element);\n  }\n  const host = topModal() ?? document.body;\n  if (element.parentElement !== host) host.append(element);\n  return element;\n}\n\n/** 让读屏念出一句话；同一句话连说两次也会念（先清空，稍后再写入）。没有 document（服务端）时什么也不做 */\nexport function announce(message: string, politeness: Politeness = 'polite'): void {\n  if (typeof document === 'undefined' || !message) return;\n  const element = region(politeness);\n  element.textContent = '';\n  clearTimeout(timers.get(politeness));\n  timers.set(\n    politeness,\n    setTimeout(() => (element.textContent = message), REPEAT_DELAY),\n  );\n}\n"],"mappings":";;;;;;;;;;;;AAuBA,IAAM,UAAwC;CAC5C,UAAU;CACV,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,UAAU;CACV,YAAY;CACZ,QAAQ;AACV;;AAGA,IAAM,eAAe;AAErB,IAAM,0BAAU,IAAI,IAA6B;AACjD,IAAM,yBAAS,IAAI,IAA+C;AAElE,SAAS,OAAO,YAAqC;CACnD,IAAI,UAAU,QAAQ,IAAI,UAAU;CACpC,IAAI,CAAC,SAAS;EACZ,UAAU,SAAS,cAAc,KAAK;EACtC,QAAQ,aAAa,aAAa,UAAU;EAC5C,QAAQ,aAAa,eAAe,MAAM;EAC1C,QAAQ,QAAQ,gBAAgB;EAChC,OAAO,OAAO,QAAQ,OAAO,OAAO;EACpC,QAAQ,IAAI,YAAY,OAAO;CACjC;CACA,MAAM,OAAO,SAAS,KAAK,SAAS;CACpC,IAAI,QAAQ,kBAAkB,MAAM,KAAK,OAAO,OAAO;CACvD,OAAO;AACT;;AAGA,SAAgB,SAAS,SAAiB,aAAyB,UAAgB;CACjF,IAAI,OAAO,aAAa,eAAe,CAAC,SAAS;CACjD,MAAM,UAAU,OAAO,UAAU;CACjC,QAAQ,cAAc;CACtB,aAAa,OAAO,IAAI,UAAU,CAAC;CACnC,OAAO,IACL,YACA,iBAAkB,QAAQ,cAAc,SAAU,YAAY,CAChE;AACF"}

package/dist/utils/dom/caret.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 文本框里某个字符位置在视口中的坐标：@ 提及、斜杠命令这类跟着光标弹出的列表用它定位。
+ *
+ *   const anchor = caretAnchor(textarea, () => textarea.selectionStart);
+ *   anchorFloating(anchor, panel, { placement: 'bottom-start' });
+ *
+ * 做法同 textarea-caret-position（component/textarea-caret）：在页面外放一个镜像 div，复制影响排版的样式，
+ * 写入位置之前的文字和一个标记 span，量标记的位置，再减去文本框的滚动。input 不换行，textarea 按 pre-wrap 换行。
+ */
+import type { VirtualElement } from '@floating-ui/dom';
+/** 文本框里第 index 个字符之前（光标在那里时）的位置：视口坐标，宽 0、高一行 */
+export declare function caretRect(element: HTMLTextAreaElement | HTMLInputElement, index: number): DOMRect;
+/** 跟着光标的锚点（给 anchorFloating / useAnchoredPopover）：每次定位时按 index() 重新测量，文本框滚动时跟着更新 */
+export declare function caretAnchor(element: HTMLTextAreaElement | HTMLInputElement, index: () => number): VirtualElement;

package/dist/utils/dom/caret.js

@@ -0,0 +1,72 @@
+//#region src/utils/dom/caret.ts
+/** 影响文字排版的样式：镜像 div 照抄 */
+var MIRRORED = [
+	"direction",
+	"boxSizing",
+	"width",
+	"height",
+	"overflowX",
+	"overflowY",
+	"borderTopWidth",
+	"borderRightWidth",
+	"borderBottomWidth",
+	"borderLeftWidth",
+	"borderStyle",
+	"paddingTop",
+	"paddingRight",
+	"paddingBottom",
+	"paddingLeft",
+	"fontStyle",
+	"fontVariant",
+	"fontWeight",
+	"fontStretch",
+	"fontSize",
+	"fontSizeAdjust",
+	"lineHeight",
+	"fontFamily",
+	"fontFeatureSettings",
+	"textAlign",
+	"textTransform",
+	"textIndent",
+	"textDecoration",
+	"letterSpacing",
+	"wordSpacing",
+	"tabSize"
+];
+/** 文本框里第 index 个字符之前（光标在那里时）的位置：视口坐标，宽 0、高一行 */
+function caretRect(element, index) {
+	const style = getComputedStyle(element);
+	const mirror = document.createElement("div");
+	for (const property of MIRRORED) mirror.style[property] = style[property];
+	Object.assign(mirror.style, {
+		position: "absolute",
+		visibility: "hidden",
+		top: "0",
+		left: "-9999px",
+		overflow: "hidden",
+		whiteSpace: element instanceof HTMLTextAreaElement ? "pre-wrap" : "pre",
+		overflowWrap: "break-word"
+	});
+	mirror.textContent = element.value.slice(0, index);
+	const marker = document.createElement("span");
+	marker.textContent = element.value.slice(index) || ".";
+	mirror.append(marker);
+	document.body.append(mirror);
+	const lineHeight = parseFloat(style.lineHeight) || parseFloat(style.fontSize) * 1.2;
+	const top = marker.offsetTop + parseFloat(style.borderTopWidth) - element.scrollTop;
+	const left = marker.offsetLeft + parseFloat(style.borderLeftWidth) - element.scrollLeft;
+	mirror.remove();
+	const box = element.getBoundingClientRect();
+	return new DOMRect(box.left + left, box.top + top, 0, lineHeight);
+}
+/** 跟着光标的锚点（给 anchorFloating / useAnchoredPopover）：每次定位时按 index() 重新测量，文本框滚动时跟着更新 */
+function caretAnchor(element, index) {
+	return {
+		getBoundingClientRect: () => caretRect(element, index()),
+		contextElement: element
+	};
+}
+//#endregion
+export { caretAnchor, caretRect };
+
+//# sourceMappingURL=caret.js.map