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

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

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.js","names":[],"sources":["../../../src/utils/data/numeric.ts"],"sourcesContent":["/**\n * 内置支持的数值类型：number、bigint 与 decimal.js 的 Decimal（金额、精确运算）。\n * 组件的数值属性都接受它们（NumericValue），排序、格式化、表单提交不丢精度。\n *\n *   compareNumeric(new Decimal('1.5'), 1.25)   // 1：不同类型也按大小比\n *   numericText(new Decimal('1e21'))           // '1000000000000000000000'：提交给服务端的十进制文本\n *\n * 这里不在运行时导入 decimal.js：按实例自己的构造函数识别与运算（使用方可能用 Decimal.clone 配了精度），\n * 没用到 Decimal 的应用不会因此打包它。\n */\nimport type Decimal from 'decimal.js';\nimport { snapToStep } from './number';\n\n/** 组件接受的数值 */\nexport type NumericValue = number | bigint | Decimal;\n\ntype DecimalConstructor = typeof Decimal;\n\n/** 是不是 decimal.js 的 Decimal（含 Decimal.clone 出来的构造函数的实例） */\nexport function isDecimal(value: unknown): value is Decimal {\n  if (typeof value !== 'object' || value === null) return false;\n  const constructor = (value as { constructor?: Partial<DecimalConstructor> }).constructor;\n  return typeof constructor?.isDecimal === 'function' && constructor.isDecimal(value);\n}\n\n/** 能读成数字的文字：接口常把金额给成十进制字符串（'19.90'）；空白、Infinity、不是数字的都不算 */\nexport function isNumericText(value: unknown): value is string {\n  return typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value));\n}\n\n/** 是不是组件接受的数值（NaN 也算 number，由使用方决定怎么处理） */\nexport function isNumeric(value: unknown): value is NumericValue {\n  return typeof value === 'number' || typeof value === 'bigint' || isDecimal(value);\n}\n\n/** 转成 number：只给需要浮点数的地方用（动画的中间帧、图表坐标、aria-valuenow），会丢精度 */\nexport function toNumber(value: NumericValue): number {\n  if (typeof value === 'number') return value;\n  if (typeof value === 'bigint') return Number(value);\n  return value.toNumber();\n}\n\n/** 十进制文本，不用科学计数法：表单提交、复制给服务端；NaN、Infinity 原样 */\nexport function numericText(value: NumericValue): string {\n  if (typeof value === 'bigint') return value.toString();\n  if (typeof value === 'number') {\n    if (!Number.isFinite(value)) return String(value);\n    // 1e21 以上、1e-6 以下 String() 会写成科学计数法；toLocaleString 不带分组时给出完整的十进制\n    const plain = value === 0 || (Math.abs(value) < 1e21 && Math.abs(value) >= 1e-6);\n    return plain\n      ? String(value)\n      : value.toLocaleString('en-US', { useGrouping: false, maximumFractionDigits: 20 });\n  }\n  return value.isFinite() ? value.toFixed() : value.toString();\n}\n\n/**\n * 十进制文本的小数点左移 places 位（除以 10 的 places 次方；负数右移），按文字移位、不经过浮点数：\n * `shiftDecimal('155353.2', 4)` → `'15.53532'`。不是普通十进制写法的文本（NaN、科学计数法）原样返回\n */\nexport function shiftDecimal(text: string, places: number): string {\n  const match = /^([+-]?)(\\d*)(?:\\.(\\d*))?$/.exec(text);\n  if (!match || places === 0 || !/\\d/.test(text)) return text;\n  const [, sign, whole = '', fraction = ''] = match;\n  const digits = whole + fraction;\n  const point = whole.length - places;\n  const padded = point <= 0 ? '0'.repeat(1 - point) + digits : digits.padEnd(point, '0');\n  const at = Math.max(point, 1);\n  const integer = padded.slice(0, at).replace(/^0+(?=\\d)/, '');\n  const decimal = padded.slice(at).replace(/0+$/, '');\n  return `${sign}${integer}${decimal ? `.${decimal}` : ''}`;\n}\n\n/** 用 Decimal 的构造函数（从 a 或 b 里找）把两个值都转成 Decimal 比较 */\nfunction compareWithDecimal(a: NumericValue, b: NumericValue, Ctor: DecimalConstructor): number {\n  const left = isDecimal(a) ? a : new Ctor(numericText(a));\n  return left.cmp(isDecimal(b) ? b : new Ctor(numericText(b)));\n}\n\n/**\n * 按大小比较两个数值，不同类型混着也行：返回负数、0 或正数（同 Array.prototype.sort 的约定）。\n * 有 Decimal 时按十进制精确比较；number 与 bigint 之间不经过浮点数（大整数不丢精度）；NaN 排在最后\n */\nexport function compareNumeric(a: NumericValue, b: NumericValue): number {\n  if (typeof a === 'number' && Number.isNaN(a))\n    return typeof b === 'number' && Number.isNaN(b) ? 0 : 1;\n  if (typeof b === 'number' && Number.isNaN(b)) return -1;\n  if (isDecimal(a)) return compareWithDecimal(a, b, a.constructor as DecimalConstructor);\n  if (isDecimal(b)) return compareWithDecimal(a, b, b.constructor as DecimalConstructor);\n  // number、bigint 之间：JavaScript 的关系运算符对混合类型按数学值比较，不丢精度\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** 十进制写法（可带指数）：'19.90'、'-.5'、'1e3' */\nconst DECIMAL_TEXT =\n  /^([+-]?)(\\d+)(?:\\.(\\d*))?(?:[eE]([+-]?\\d+))?$|^([+-]?)\\.(\\d+)(?:[eE]([+-]?\\d+))?$/;\n\n/** 拆开的十进制数：符号、去掉前导零的整数位、去掉末尾零的小数位 */\ninterface DecimalParts {\n  negative: boolean;\n  int: string;\n  frac: string;\n}\n\nfunction decimalParts(text: string): DecimalParts | undefined {\n  const match = DECIMAL_TEXT.exec(text);\n  if (!match) return undefined;\n  const [, sign1, int1, frac1, exp1, sign2, frac2, exp2] = match;\n  const intDigits = int1 ?? '';\n  const digits = intDigits + (frac1 ?? frac2 ?? '');\n  // 小数点按指数移动后，再拆成整数位与小数位\n  const point = intDigits.length + Number(exp1 ?? exp2 ?? 0);\n  const padded =\n    point < 0\n      ? '0'.repeat(-point) + digits\n      : point > digits.length\n        ? digits + '0'.repeat(point - digits.length)\n        : digits;\n  const at = Math.max(point, 0);\n  const int = padded.slice(0, at).replace(/^0+/, '');\n  const frac = padded.slice(at).replace(/0+$/, '');\n  return { negative: (sign1 ?? sign2) === '-' && (int !== '' || frac !== ''), int, frac };\n}\n\n/**\n * 能精确比较的值 → 十进制文本：number（NaN、Infinity 不算）、bigint、Decimal、十进制写法的文字；其余是 undefined。\n * 条件比较（input/condition.ts）用它：与流程引擎模型包的规则一致，长小数、大整数不丢精度\n */\nexport function decimalTextOf(value: unknown): string | undefined {\n  if (typeof value === 'number') return Number.isFinite(value) ? String(value) : undefined;\n  if (typeof value === 'bigint' || isDecimal(value)) return numericText(value);\n  if (typeof value === 'string' && DECIMAL_TEXT.test(value.trim())) return value.trim();\n  return undefined;\n}\n\n/** 两段十进制文本（decimalTextOf 给出的）按数值比：负数、0、正数；不经过浮点数 */\nexport function compareDecimalText(a: string, b: string): number {\n  const x = decimalParts(a);\n  const y = decimalParts(b);\n  if (!x || !y) return a === b ? 0 : a < b ? -1 : 1;\n  if (x.negative !== y.negative) return x.negative ? -1 : 1;\n  let magnitude = 0;\n  if (x.int.length !== y.int.length) magnitude = x.int.length < y.int.length ? -1 : 1;\n  else if (x.int !== y.int) magnitude = x.int < y.int ? -1 : 1;\n  else {\n    const width = Math.max(x.frac.length, y.frac.length);\n    const left = x.frac.padEnd(width, '0');\n    const right = y.frac.padEnd(width, '0');\n    magnitude = left === right ? 0 : left < right ? -1 : 1;\n  }\n  return x.negative ? -magnitude : magnitude;\n}\n\n/** 两个数值是否相等（1 与 1n、Decimal('1.0') 与 1 都算相等） */\nexport const sameNumeric = (a: NumericValue, b: NumericValue) => compareNumeric(a, b) === 0;\n\n/** 数值写回成什么类型：number、bigint，或某个 Decimal 构造函数（使用方 Decimal.clone 配过精度的也行） */\nexport type NumericKind = 'number' | 'bigint' | DecimalConstructor;\n\n/** 值的类型：Decimal 取它自己的构造函数 */\nexport function numericKind(value: NumericValue): NumericKind {\n  if (typeof value === 'number') return 'number';\n  if (typeof value === 'bigint') return 'bigint';\n  return value.constructor as DecimalConstructor;\n}\n\n/** 十进制文本（'-12.5'）→ 整数，四舍五入（远离 0） */\nfunction roundedBigInt(text: string): bigint {\n  const [whole = '0', fraction = ''] = text.replace(/^[+-]/, '').split('.');\n  const negative = text.startsWith('-');\n  let result = BigInt(whole || '0');\n  if (Number(fraction[0] ?? 0) >= 5) result += 1n;\n  return negative ? -result : result;\n}\n\n/**\n * 转成指定类型；value 也可以是十进制文本（'-12.5'，输入框解析出来的）。\n * bigint 四舍五入到整数，Decimal 按十进制文本转（不经过浮点数）\n */\nexport function toNumericKind(value: NumericValue | string, kind: NumericKind): NumericValue {\n  const text = () => (typeof value === 'string' ? value : numericText(value));\n  if (kind === 'number') return typeof value === 'string' ? Number(value) : toNumber(value);\n  if (kind === 'bigint') return typeof value === 'bigint' ? value : roundedBigInt(text());\n  return isDecimal(value) && value.constructor === kind ? value : new kind(text());\n}\n\n/** 按 kind 精确相加：Decimal 用它的构造函数算，bigint 整数相加，number 浮点相加（再由 snapNumeric 去掉误差） */\nexport function addNumeric(value: NumericValue, delta: NumericValue, kind: NumericKind) {\n  const left = toNumericKind(value, kind);\n  const right = toNumericKind(delta, kind);\n  if (typeof left === 'number') return left + (right as number);\n  if (typeof left === 'bigint') return left + (right as bigint);\n  return (left as Decimal).plus(right as Decimal);\n}\n\n/** value 的 times 倍（times 是整数，如 -1、10），按 kind 精确运算 */\nexport function multiplyNumeric(value: NumericValue, times: number, kind: NumericKind) {\n  const typed = toNumericKind(value, kind);\n  if (typeof typed === 'number') return typed * times;\n  if (typeof typed === 'bigint') return typed * BigInt(times);\n  return (typed as Decimal).times(times);\n}\n\n/**\n * 夹在 [min, max] 之间并对齐到 min + n × step（没有 min 时对齐到 0 + n × step），按 kind 精确运算：\n * number 走 snapToStep（按小数位取整去掉浮点误差），bigint 的步长至少为 1，Decimal 用值自己的构造函数\n */\nexport function snapNumeric(\n  value: NumericValue,\n  step: NumericValue,\n  min: NumericValue | undefined,\n  max: NumericValue | undefined,\n  kind: NumericKind,\n): NumericValue {\n  if (kind === 'number') {\n    return snapToStep(\n      toNumber(value),\n      toNumber(step),\n      min == null ? -Infinity : toNumber(min),\n      max == null ? Infinity : toNumber(max),\n    );\n  }\n  const at = (item: NumericValue) => toNumericKind(item, kind);\n  let snapped: NumericValue;\n  if (kind === 'bigint') {\n    const size = (at(step) as bigint) > 0n ? (at(step) as bigint) : 1n;\n    const base = min == null ? 0n : (at(min) as bigint);\n    const offset = (at(value) as bigint) - base;\n    // 整数除法四舍五入（远离 0）\n    const half = offset < 0n ? -size : size;\n    snapped = base + ((2n * offset + half) / (2n * size)) * size;\n  } else {\n    const base = (min == null ? new kind(0) : at(min)) as Decimal;\n    const size = at(step) as Decimal;\n    snapped = base.plus((at(value) as Decimal).minus(base).div(size).round().times(size));\n  }\n  if (min != null && compareNumeric(snapped, min) < 0) snapped = at(min);\n  if (max != null && compareNumeric(snapped, max) > 0) snapped = at(max);\n  return snapped;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+/**
+ * 分页的页码序列（纯函数，算法同 MUI 的 usePagination）：首尾各留 boundaries 页、当前页左右各留 siblings 页，
+ * 中间用省略号；序列长度固定（页数够多时总是 2 × boundaries + 2 × siblings + 3 项），翻页时按钮不跳动。
+ *
+ *   paginationItems({ page: 6, pageCount: 20 })  // [1, 'start-ellipsis', 5, 6, 7, 'end-ellipsis', 20]
+ */
+/** 省略号：start 在当前页之前，end 在之后（两者都可能出现，作为 key 要区分开） */
+export type PaginationEllipsis = 'start-ellipsis' | 'end-ellipsis';
+/** paginationItems 的参数 */
+export interface PaginationOptions {
+    /** 当前页，从 1 开始 */
+    page: number;
+    /** 总页数 */
+    pageCount: number;
+    /** 当前页左右各显示几页，默认 1 */
+    siblings?: number;
+    /** 首尾各固定显示几页，默认 1 */
+    boundaries?: number;
+}
+/** 要显示的页码与省略号，依次排列 */
+export declare function paginationItems({ page, pageCount, siblings, boundaries, }: PaginationOptions): (number | PaginationEllipsis)[];

package/dist/utils/data/pagination.js

@@ -0,0 +1,22 @@
+//#region src/utils/data/pagination.ts
+var range = (from, to) => Array.from({ length: Math.max(0, to - from + 1) }, (_, index) => from + index);
+/** 要显示的页码与省略号，依次排列 */
+function paginationItems({ page, pageCount, siblings = 1, boundaries = 1 }) {
+	const startPages = range(1, Math.min(boundaries, pageCount));
+	const endPages = range(Math.max(pageCount - boundaries + 1, boundaries + 1), pageCount);
+	const siblingsStart = Math.max(Math.min(page - siblings, pageCount - boundaries - siblings * 2 - 1), boundaries + 2);
+	const siblingsEnd = Math.min(Math.max(page + siblings, boundaries + siblings * 2 + 2), endPages.length > 0 ? endPages[0] - 2 : pageCount - 1);
+	const before = siblingsStart > boundaries + 2 ? ["start-ellipsis"] : boundaries + 1 < pageCount - boundaries ? [boundaries + 1] : [];
+	const after = siblingsEnd < pageCount - boundaries - 1 ? ["end-ellipsis"] : pageCount - boundaries > boundaries ? [pageCount - boundaries] : [];
+	return [
+		...startPages,
+		...before,
+		...range(siblingsStart, siblingsEnd),
+		...after,
+		...endPages
+	];
+}
+//#endregion
+export { paginationItems };
+
+//# sourceMappingURL=pagination.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","names":[],"sources":["../../../src/utils/data/pagination.ts"],"sourcesContent":["/**\n * 分页的页码序列（纯函数，算法同 MUI 的 usePagination）：首尾各留 boundaries 页、当前页左右各留 siblings 页，\n * 中间用省略号；序列长度固定（页数够多时总是 2 × boundaries + 2 × siblings + 3 项），翻页时按钮不跳动。\n *\n *   paginationItems({ page: 6, pageCount: 20 })  // [1, 'start-ellipsis', 5, 6, 7, 'end-ellipsis', 20]\n */\n\n/** 省略号：start 在当前页之前，end 在之后（两者都可能出现，作为 key 要区分开） */\nexport type PaginationEllipsis = 'start-ellipsis' | 'end-ellipsis';\n\n/** paginationItems 的参数 */\nexport interface PaginationOptions {\n  /** 当前页，从 1 开始 */\n  page: number;\n  /** 总页数 */\n  pageCount: number;\n  /** 当前页左右各显示几页，默认 1 */\n  siblings?: number;\n  /** 首尾各固定显示几页，默认 1 */\n  boundaries?: number;\n}\n\nconst range = (from: number, to: number) =>\n  Array.from({ length: Math.max(0, to - from + 1) }, (_, index) => from + index);\n\n/** 要显示的页码与省略号，依次排列 */\nexport function paginationItems({\n  page,\n  pageCount,\n  siblings = 1,\n  boundaries = 1,\n}: PaginationOptions): (number | PaginationEllipsis)[] {\n  const startPages = range(1, Math.min(boundaries, pageCount));\n  const endPages = range(Math.max(pageCount - boundaries + 1, boundaries + 1), pageCount);\n  // 当前页这一组的起止：靠近两端时向另一侧多借几页，保持总项数不变\n  const siblingsStart = Math.max(\n    Math.min(page - siblings, pageCount - boundaries - siblings * 2 - 1),\n    boundaries + 2,\n  );\n  const siblingsEnd = Math.min(\n    Math.max(page + siblings, boundaries + siblings * 2 + 2),\n    endPages.length > 0 ? endPages[0]! - 2 : pageCount - 1,\n  );\n  // 省略号只代替两页以上；只隔一页时直接显示那一页\n  const before =\n    siblingsStart > boundaries + 2\n      ? ['start-ellipsis' as const]\n      : boundaries + 1 < pageCount - boundaries\n        ? [boundaries + 1]\n        : [];\n  const after =\n    siblingsEnd < pageCount - boundaries - 1\n      ? ['end-ellipsis' as const]\n      : pageCount - boundaries > boundaries\n        ? [pageCount - boundaries]\n        : [];\n  return [...startPages, ...before, ...range(siblingsStart, siblingsEnd), ...after, ...endPages];\n}\n"],"mappings":";AAsBA,IAAM,SAAS,MAAc,OAC3B,MAAM,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,KAAK,OAAO,CAAC,EAAE,IAAI,GAAG,UAAU,OAAO,KAAK;;AAG/E,SAAgB,gBAAgB,EAC9B,MACA,WACA,WAAW,GACX,aAAa,KACwC;CACrD,MAAM,aAAa,MAAM,GAAG,KAAK,IAAI,YAAY,SAAS,CAAC;CAC3D,MAAM,WAAW,MAAM,KAAK,IAAI,YAAY,aAAa,GAAG,aAAa,CAAC,GAAG,SAAS;CAEtF,MAAM,gBAAgB,KAAK,IACzB,KAAK,IAAI,OAAO,UAAU,YAAY,aAAa,WAAW,IAAI,CAAC,GACnE,aAAa,CACf;CACA,MAAM,cAAc,KAAK,IACvB,KAAK,IAAI,OAAO,UAAU,aAAa,WAAW,IAAI,CAAC,GACvD,SAAS,SAAS,IAAI,SAAS,KAAM,IAAI,YAAY,CACvD;CAEA,MAAM,SACJ,gBAAgB,aAAa,IACzB,CAAC,gBAAyB,IAC1B,aAAa,IAAI,YAAY,aAC3B,CAAC,aAAa,CAAC,IACf,CAAC;CACT,MAAM,QACJ,cAAc,YAAY,aAAa,IACnC,CAAC,cAAuB,IACxB,YAAY,aAAa,aACvB,CAAC,YAAY,UAAU,IACvB,CAAC;CACT,OAAO;EAAC,GAAG;EAAY,GAAG;EAAQ,GAAG,MAAM,eAAe,WAAW;EAAG,GAAG;EAAO,GAAG;CAAQ;AAC/F"}

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

@@ -0,0 +1,41 @@
+/**
+ * 选择模型：单选、多选怎样响应“点了一项”（纯函数），以及单选 / 多选组件共用的 props。
+ * ToggleGroup、Listbox、Select、Combobox、CheckboxGroup、DataTable 的行选择都用它。
+ */
+/** 选择方式 */
+export interface SelectionModes {
+    /** 单选：选中一项会取消其他项；再点已选的项取消选中（required 时不取消） */
+    single: unknown;
+    /** 多选：每项独立切换 */
+    multiple: unknown;
+}
+/** 单选：value 是选中项的值 */
+export interface SingleSelectionProps {
+    /** 选择方式，默认 single */
+    selectionMode?: Extract<keyof SelectionModes, 'single'>;
+    /** 选中项：父级写 _value={x}；没有选中时是 null */
+    _value?: string | null;
+}
+/** 多选：value 是选中项的值的数组 */
+export interface MultipleSelectionProps {
+    /** 选择方式 */
+    selectionMode: Extract<keyof SelectionModes, 'multiple'>;
+    /** 选中项：父级写 _value={list} */
+    _value?: string[];
+}
+/** 单选或多选：按 selectionMode 区分 value 是一个值还是数组（Listbox、Select、ToggleGroup） */
+export type SelectionProps = SingleSelectionProps | MultipleSelectionProps;
+/** toggleSelection 的选项 */
+export interface SelectionOptions {
+    /** 选择方式 */
+    mode: keyof SelectionModes;
+    /** 至少保留一项：最后一个已选项不能被取消 */
+    required?: boolean;
+}
+/**
+ * 单选的值或多选的值数组 → 已选值的数组（单选、多选共用一套渲染与列表状态时）。
+ * 单选的空字符串算没有选中：表单的初始值常写 ''（同原生 select 的占位项），这时显示占位文字、不出清除按钮
+ */
+export declare const selectedValues: (value: string | readonly string[] | null | undefined) => readonly string[];
+/** 点了 key 之后的选择；没有变化时返回原数组 */
+export declare function toggleSelection<Key>(selected: readonly Key[], key: Key, { mode, required }: SelectionOptions): readonly Key[];

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>;