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

package/dist/table/columns.js

@@ -0,0 +1,271 @@
+import { addNumeric, isDecimal, isNumeric, isNumericText, numericKind } from "../utils/data/numeric.js";
+import { createComparer, createMatcher, isDateValue, sortByValues } from "../utils/data/collation.js";
+//#region src/table/columns.ts
+/**
+* 按分组排出表头第一行：隐藏了的列不算，组里的列全隐藏时这一组也不显示；
+* 组里的列被别的列隔开时，后一段另起一格、重复组标题
+*/
+function headerLayout(columns, groups) {
+	const groupOf = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const key of group.columns) groupOf.set(key, group);
+	const cells = [];
+	for (const column of columns) {
+		const group = groupOf.get(column.key);
+		const last = cells.at(-1);
+		if (!group) cells.push({
+			kind: "column",
+			column
+		});
+		else if (last?.kind === "group" && last.group === group) last.columns.push(column);
+		else cells.push({
+			kind: "group",
+			group,
+			columns: [column]
+		});
+	}
+	return cells;
+}
+/** 没写宽度的列，计算表格最小宽度与固定列偏移时按这么宽算（px） */
+var COLUMN_FLEX_MIN_WIDTH = 120;
+/** 拖动调整列宽时默认的最小宽度（px） */
+var COLUMN_MIN_WIDTH = 64;
+/** 固定列的偏移（px）：起始边的从 leading（勾选列的宽度）之后累加，结束边的从末尾往回累加 */
+function stickyOffsets(columns, widthOf, leading) {
+	const accumulate = (side, ordered, from) => {
+		const offsets = /* @__PURE__ */ new Map();
+		let offset = from;
+		for (const column of ordered) {
+			if (column.sticky !== side) continue;
+			offsets.set(column.key, offset);
+			offset += widthOf(column) ?? 120;
+		}
+		return offsets;
+	};
+	const start = accumulate("start", columns, leading);
+	const end = accumulate("end", [...columns].reverse(), 0);
+	return {
+		start,
+		end,
+		startEdge: [...start.keys()].at(-1),
+		endEdge: [...end.keys()].at(-1)
+	};
+}
+/** 两组固定列的偏移是否相同（列与偏移都一样） */
+function sameStickyOffsets(a, b) {
+	const sameMap = (x, y) => x.size === y.size && [...x].every(([key, offset]) => y.get(key) === offset);
+	return a.startEdge === b.startEdge && a.endEdge === b.endEdge && sameMap(a.start, b.start) && sameMap(a.end, b.end);
+}
+/** 表格的最小宽度（px）：写了宽度的列按宽度，没写的按 minWidth 或 COLUMN_FLEX_MIN_WIDTH；放不下时横向滚动 */
+function tableMinWidth(columns, widthOf, leading) {
+	return columns.reduce((total, column) => total + (widthOf(column) ?? column.minWidth ?? 120), leading);
+}
+/** 列在这一行的值：value 函数，或 row[key] */
+function columnValue(column, row) {
+	if (column.value) return column.value(row);
+	return row[column.key];
+}
+var NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"number",
+	"currency",
+	"percent",
+	"fileSize"
+]);
+/**
+* 列的值类型：写了 type 用它；写了数字格式（format）、或合计是 'sum' 的是数字列（这一页全是空值时也靠结束边对齐）；
+* 否则看第一个非空值（ISO 字符串不猜，算文字）
+*/
+function columnType(column, rows) {
+	if (column.type) return column.type;
+	if (column.format || column.summary === "sum") return "number";
+	for (const row of rows) {
+		const value = columnValue(column, row);
+		if (value == null) continue;
+		if (isNumeric(value)) return "number";
+		return value instanceof Date || isDateValue(value) ? "date" : "text";
+	}
+	return "text";
+}
+/** 列的对齐：写了 align 用它，数字类靠结束边方便对比位数 */
+function columnAlign(type) {
+	return NUMERIC_TYPES.has(type) ? "end" : "start";
+}
+/** 没写 cell 时单元格的文字：按值类型与当前语言格式化；值与类型对不上（数字列里的文字）时原样显示 */
+function formatCell(value, type, format, options) {
+	if (value == null) return "";
+	const numeric = isNumeric(value) || isNumericText(value);
+	if (numeric && type === "number") return format.number(value, options);
+	if (numeric && type === "currency") return format.number(value, {
+		style: "currency",
+		...options
+	});
+	if (numeric && type === "percent") return format.number(value, {
+		style: "percent",
+		maximumFractionDigits: 1,
+		...options
+	});
+	if (typeof value === "number" && type === "fileSize") return format.fileSize(value);
+	const date = value instanceof Date || isDateValue(value) || typeof value === "string";
+	if (date && type === "date") return format.date(value);
+	if (date && type === "dateTime") return format.date(value, {
+		dateStyle: "medium",
+		timeStyle: "short"
+	});
+	return String(value);
+}
+/**
+* 一列数值的合计：跳过空值与不是数字的值；有 Decimal 时用它的构造函数精确相加，全是 bigint 时整数相加，
+* 接口给的十进制字符串（'19.90'）按数字算。没有任何数值时为 null
+*/
+function sumColumn(column, rows) {
+	const values = [];
+	let kind;
+	for (const row of rows) {
+		const value = columnValue(column, row);
+		const numeric = isNumeric(value) ? value : isNumericText(value) ? Number(value) : null;
+		if (numeric == null) continue;
+		values.push(numeric);
+		if (isDecimal(numeric)) kind = numericKind(numeric);
+		else if (kind === void 0) kind = typeof numeric === "bigint" ? "bigint" : "number";
+		else if (kind === "bigint" && typeof numeric !== "bigint") kind = "number";
+	}
+	if (values.length === 0 || kind === void 0) return null;
+	return values.reduce((total, value) => addNumeric(total, value, kind), 0);
+}
+/** 点表头时的下一个排序：没排 → 升序 → 降序 → 不排 */
+function nextSort(current, key) {
+	if (current?.key !== key) return {
+		key,
+		direction: "ascending"
+	};
+	return current.direction === "ascending" ? {
+		key,
+		direction: "descending"
+	} : null;
+}
+/**
+* 多列排序时点表头：additive（按住 Shift）时在已有的排序后面加上这一列、或切换它的方向（降序时再点去掉）；
+* 否则只按这一列（同 nextSort）
+*/
+function nextSorts(current, key, additive) {
+	if (!additive) {
+		const next = nextSort(current.length === 1 ? current[0] : void 0, key);
+		return next ? [next] : [];
+	}
+	const existing = current.find((item) => item.key === key);
+	if (!existing) return [...current, {
+		key,
+		direction: "ascending"
+	}];
+	if (existing.direction === "ascending") return current.map((item) => item.key === key ? {
+		key,
+		direction: "descending"
+	} : item);
+	return current.filter((item) => item.key !== key);
+}
+/** 排序状态统一成数组：单列排序是一个或零个 */
+function sortList(sort) {
+	if (!sort) return [];
+	return Array.isArray(sort) ? sort : [sort];
+}
+/**
+* 排序写成一段文字：逗号分隔的列 key，倒序的前面加减号（同 JSON:API），如 `-amount,name`；没有排序时是空字符串。
+* 地址栏的 sort 参数与发给服务端的 sort 参数都是它，query 库的 `sortBy` 直接认
+*/
+function formatSorts(sort) {
+	return sortList(sort).map((item) => (item.direction === "descending" ? "-" : "") + item.key).join(",");
+}
+/** 读 formatSorts 写的文字：`-amount,name` 是两列排序；空的项跳过 */
+function parseSorts(text) {
+	return text.split(",").map((part) => part.trim()).filter((part) => part.replace(/^-/, "") !== "").map((part) => part.startsWith("-") ? {
+		key: part.slice(1),
+		direction: "descending"
+	} : {
+		key: part,
+		direction: "ascending"
+	});
+}
+/**
+* 按当前排序排列（返回新数组，原数组不变）；可以是几列（前一列相等时比下一列），没有排序、排序列都不存在时原样返回。
+* 比较用 createComparer：数字按大小、日期按时间、文字按语言（中文按拼音、“第2章”在“第10章”前），空值总在最后
+*/
+function sortRows(rows, columns, sort, locale) {
+	const keys = sortList(sort).flatMap((state) => {
+		const column = columns.find((item) => item.key === state.key);
+		if (!column) return [];
+		const numeric = NUMERIC_TYPES.has(columnType(column, rows));
+		const value = (row) => {
+			const raw = columnValue(column, row);
+			return numeric && isNumericText(raw) ? Number(raw) : raw;
+		};
+		return [{
+			value,
+			direction: state.direction
+		}];
+	});
+	return keys.length ? sortByValues(rows, keys, locale) : rows;
+}
+/** 这一格能不能编辑 */
+function isCellEditable(column, row) {
+	return typeof column.editable === "function" ? column.editable(row) : !!column.editable;
+}
+/** 列的筛选设置：没写或 false 时 undefined，true 是列出出现过的值 */
+function columnFilter(column) {
+	if (!column.filter) return void 0;
+	return column.filter === true ? {} : column.filter;
+}
+/** 表头筛选的选项：写了的原样（字符串转成选项），没写的列出这一列出现过的值（按语言排序，有 statuses 时用状态名） */
+function filterOptions(column, rows, locale) {
+	const options = columnFilter(column)?.options;
+	if (options === "text") return [];
+	if (options) return options.map((option) => typeof option === "string" ? { value: option } : option);
+	const seen = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const value = columnValue(column, row);
+		if (value == null || value === "") continue;
+		const text = String(value);
+		if (!seen.has(text)) seen.set(text, value);
+	}
+	const { statuses } = column;
+	const compare = createComparer(locale);
+	const order = statuses ? (a, b) => statuses.order(a) - statuses.order(b) : (a, b) => compare(seen.get(a), seen.get(b));
+	return [...seen.keys()].sort(order).map((value) => ({
+		value,
+		label: statuses?.label(value)
+	}));
+}
+/** 按表头筛选留下的行：filters 是各列选中的值（关键字筛选时是 [关键字]），空的不算 */
+function filterRows(rows, columns, filters, locale) {
+	const matchText = createMatcher(locale);
+	const tests = columns.flatMap((column) => {
+		const values = filters[column.key];
+		const filter = columnFilter(column);
+		if (!filter || !values?.length) return [];
+		const { match } = filter;
+		if (match) return [(row) => match(row, values)];
+		if (filter.options === "text") return [(row) => matchText(String(columnValue(column, row) ?? ""), values[0])];
+		const allowed = new Set(values);
+		return [(row) => allowed.has(String(columnValue(column, row) ?? ""))];
+	});
+	return tests.length ? rows.filter((row) => tests.every((test) => test(row))) : rows;
+}
+/**
+* 列的位置调整（列菜单、列设置）：order 是列的 key 的顺序，没列到的按定义的顺序排在后面；
+* pins 覆盖列的 sticky（null 取消固定）。固定在起始边的排到最前、结束边的排到最后：固定列要挨着表格的边
+*/
+function arrangeColumns(columns, order, pins) {
+	const rank = new Map((order ?? []).map((key, index) => [key, index]));
+	const position = (column) => rank.get(column.key) ?? rank.size + columns.indexOf(column);
+	const arranged = [...columns].sort((a, b) => position(a) - position(b)).map((column) => pins && column.key in pins ? {
+		...column,
+		sticky: pins[column.key] ?? void 0
+	} : column);
+	return [
+		...arranged.filter((column) => column.sticky === "start"),
+		...arranged.filter((column) => !column.sticky),
+		...arranged.filter((column) => column.sticky === "end")
+	];
+}
+//#endregion
+export { COLUMN_FLEX_MIN_WIDTH, COLUMN_MIN_WIDTH, arrangeColumns, columnAlign, columnFilter, columnType, columnValue, filterOptions, filterRows, formatCell, formatSorts, headerLayout, isCellEditable, nextSort, nextSorts, parseSorts, sameStickyOffsets, sortList, sortRows, stickyOffsets, sumColumn, tableMinWidth };
+
+//# sourceMappingURL=columns.js.map

package/dist/table/columns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.js","names":[],"sources":["../../src/table/columns.ts"],"sourcesContent":["/**\n * 表格的列定义与排序：DataTable、TreeDataTable 共用（参考 TanStack DataTable 的列模型，只取最常用的部分）。\n *\n *   const columns: DataTableColumn<Order>[] = [\n *     { key: 'id', header: '订单号', width: 120, sticky: 'start' },\n *     { key: 'customer', header: '客户', sortable: true },\n *     { key: 'amount', header: '金额', type: 'currency', sortable: true },\n *   ];\n */\nimport type { VNodeChild } from 'vue';\nimport type { NumericFormat, useFormat } from '../config/lang/format';\nimport {\n  createComparer,\n  createMatcher,\n  isDateValue,\n  sortByValues,\n  type SortValue,\n} from '../utils/data/collation';\nimport {\n  addNumeric,\n  isDecimal,\n  isNumeric,\n  isNumericText,\n  numericKind,\n  type NumericKind,\n  type NumericValue,\n} from '../utils/data/numeric';\nimport type { StatusMap } from '../utils/data/status';\n\n/** 单元格内容的对齐 */\nexport interface ColumnAligns {\n  /** 起始边（默认）：文字 */\n  start: unknown;\n  /** 居中：状态、图标 */\n  center: unknown;\n  /** 结束边：数字、金额，方便对比位数 */\n  end: unknown;\n}\n\n/** 列的值类型：不写 cell 时按它格式化（跟随语言），数字类默认靠结束边对齐 */\nexport interface ColumnTypes {\n  /** 文字：原样显示 */\n  text: unknown;\n  /** 数字：按语言分组，1234.5 → 1,234.5 */\n  number: unknown;\n  /** 金额，语言的币种：19.9 → ¥19.90 */\n  currency: unknown;\n  /** 百分比：0.125 → 12.5% */\n  percent: unknown;\n  /** 文件大小（字节）：1234567 → 1.2 MB */\n  fileSize: unknown;\n  /** 日期：Date、DateValue 或 ISO 字符串 */\n  date: unknown;\n  /** 日期与时间 */\n  dateTime: unknown;\n}\n\n/** 固定在哪一侧（横向滚动时不动） */\nexport interface ColumnStickies {\n  /** 起始边：名称、编号 */\n  start: unknown;\n  /** 结束边：操作 */\n  end: unknown;\n}\n\n/** 表头筛选里的一个选项 */\nexport interface ColumnFilterOption {\n  /** 值：筛选状态里存它，默认与这一列的值（转成文字）比较 */\n  value: string;\n  /** 显示的文字；不写时用 value */\n  label?: VNodeChild;\n}\n\n/** 列的表头筛选 */\nexport interface ColumnFilter<T> {\n  /**\n   * 选项（可以多选）：不写时列出这一列出现过的值（有 statuses 时显示状态的名称）；\n   * 'text' 是输入关键字，不列选项\n   */\n  options?: readonly (string | ColumnFilterOption)[] | 'text';\n  /** 这一行留不留：values 是选中的值（关键字筛选时是 [关键字]）；默认这一列的值在其中 / 文字包含关键字 */\n  match?: (row: T, values: readonly string[]) => boolean;\n}\n\n/** 自定义单元格编辑器拿到的 */\nexport interface CellEditorContext<T> {\n  /** 这一行 */\n  row: T;\n  /** 正在编辑的值（草稿） */\n  value: unknown;\n  /** 改草稿 */\n  onChange: (value: unknown) => void;\n  /** 提交（校验通过后交给 onCellChange） */\n  commit: () => void;\n  /** 放弃，回到原来的值 */\n  cancel: () => void;\n  /** 校验没过的原因：编辑器用它标出错误（aria-invalid） */\n  error: string | undefined;\n}\n\n/** 一列 */\nexport interface DataTableColumn<T> {\n  /** 列的标识：同一表格里不能重复；不写 value 时也是取值的字段名 */\n  key: string;\n  /** 表头内容 */\n  header: VNodeChild;\n  /** 单元格内容；不写时按 type 格式化 value */\n  cell?: (row: T, index: number) => VNodeChild;\n  /** 值的类型：决定默认的格式与对齐；不写时按第一个非空值推断（数字 → number，日期 → date，其余 text） */\n  type?: keyof ColumnTypes;\n  /**\n   * 数字类（number、currency、percent）的格式，与 type 的默认格式合并：\n   * 金额以万元显示写 `{ scale: 10_000, maximumFractionDigits: 2 }`（单位写在表头里），美元写 `{ currency: 'USD' }`\n   */\n  format?: NumericFormat;\n  /** 排序用的值；不写时取 row[key] */\n  value?: (row: T) => SortValue;\n  /** 宽度（px）；不写时与其他没写宽度的列平分剩余宽度。固定列一定要写（偏移量按它算） */\n  width?: number;\n  /**\n   * 最小宽度（px）：拖动调整宽度时不能更窄，默认 COLUMN_MIN_WIDTH（64）；\n   * 没写宽度的列按它（默认 COLUMN_FLEX_MIN_WIDTH）算表格的最小宽度，放不下时横向滚动而不是继续压窄\n   */\n  minWidth?: number;\n  /** 对齐；默认数字类（number、currency、percent、fileSize）靠 end，其余 start */\n  align?: keyof ColumnAligns;\n  /** 可以点表头排序 */\n  sortable?: boolean;\n  /** 表头筛选：true 列出这一列出现过的值，也可以给选项或关键字筛选（见 ColumnFilter） */\n  filter?: boolean | ColumnFilter<T>;\n  /** 可以编辑（DataTable 的 onCellChange 写回）：true 或按行判断；表格随之变成可以用方向键走格的网格 */\n  editable?: boolean | ((row: T) => boolean);\n  /**\n   * 编辑器：不写时按列选——状态列是 Select，数字类是 NumberField，其余是 TextField。\n   * 自己写时拿到草稿与提交、放弃（日期、下拉选人这类）\n   */\n  editor?: (context: CellEditorContext<T>) => VNodeChild;\n  /** 提交前校验这一格：返回原因就不提交，编辑器标红并说明 */\n  validate?: (value: unknown, row: T) => string | null | undefined;\n  /** 固定在哪一侧 */\n  sticky?: keyof ColumnStickies;\n  /** 可以拖动调整宽度；不写时跟随表格的 resizable */\n  resizable?: boolean;\n  /** 内容可以换行；默认一行显示不下时省略 */\n  wrap?: boolean;\n  /** 没有值（null、undefined、空字符串）时显示的内容，如“待定价”；默认语言包的 emptyValue（—） */\n  empty?: VNodeChild;\n  /** 状态映射（createStatusMap）：值是状态的 key，显示成 StatusBadge；写了 cell 时以 cell 为准 */\n  statuses?: StatusMap;\n  /**\n   * 合计行里这一列的内容：`'sum'` 把这一列的数值精确相加（有 Decimal 时按 Decimal），按列的类型与 format 显示；\n   * 也可以是函数，拿到全部行（如平均值、“3 项待定价”）。有一列写了 summary，表格底部就多一行吸底的合计\n   */\n  summary?: 'sum' | ((rows: readonly T[]) => VNodeChild);\n}\n\n/** 分组表头：相邻的几列上方共用一个标题（如“测算”下的 A、B、D 值）；只分一层 */\nexport interface DataTableColumnGroup {\n  /** 组的标识 */\n  key: string;\n  /** 组标题 */\n  header: VNodeChild;\n  /** 组里各列的 key：要相邻，显示顺序随列定义 */\n  columns: readonly string[];\n}\n\n/** 表头第一行的一格：一个分组（跨组里的几列），或没有分组的一列（跨两行） */\nexport type HeaderLayoutCell<T> =\n  | { kind: 'group'; group: DataTableColumnGroup; columns: DataTableColumn<T>[] }\n  | { kind: 'column'; column: DataTableColumn<T> };\n\n/**\n * 按分组排出表头第一行：隐藏了的列不算，组里的列全隐藏时这一组也不显示；\n * 组里的列被别的列隔开时，后一段另起一格、重复组标题\n */\nexport function headerLayout<T>(\n  columns: readonly DataTableColumn<T>[],\n  groups: readonly DataTableColumnGroup[],\n): HeaderLayoutCell<T>[] {\n  const groupOf = new Map<string, DataTableColumnGroup>();\n  for (const group of groups) for (const key of group.columns) groupOf.set(key, group);\n  const cells: HeaderLayoutCell<T>[] = [];\n  for (const column of columns) {\n    const group = groupOf.get(column.key);\n    const last = cells.at(-1);\n    if (!group) cells.push({ kind: 'column', column });\n    else if (last?.kind === 'group' && last.group === group) last.columns.push(column);\n    else cells.push({ kind: 'group', group, columns: [column] });\n  }\n  return cells;\n}\n\n/** 排序方向（与 aria-sort 的取值一致） */\nexport interface SortDirections {\n  /** 升序：小到大、A 到 Z */\n  ascending: unknown;\n  /** 降序 */\n  descending: unknown;\n}\n\n/** 当前的排序：按哪一列、哪个方向 */\nexport interface SortState {\n  /** 列的 key */\n  key: string;\n  /** 方向 */\n  direction: keyof SortDirections;\n}\n\n/** 没写宽度的列，计算表格最小宽度与固定列偏移时按这么宽算（px） */\nexport const COLUMN_FLEX_MIN_WIDTH = 120;\n\n/** 拖动调整列宽时默认的最小宽度（px） */\nexport const COLUMN_MIN_WIDTH = 64;\n\n/** 列当前的宽度（px）：调整过的、列定义里的；都没有时 undefined（与其他没写宽度的列平分） */\nexport type ColumnWidthOf<T> = (column: DataTableColumn<T>) => number | undefined;\n\n/** 固定列的偏移（px），按列的 key 取 */\nexport interface StickyOffsets {\n  /** 固定在起始边的列 */\n  start: Map<string, number>;\n  /** 固定在结束边的列 */\n  end: Map<string, number>;\n  /** 起始边固定列里最靠里的一列（挨着滚动的列，画分隔线） */\n  startEdge?: string;\n  /** 结束边固定列里最靠里的一列 */\n  endEdge?: string;\n}\n\n/** 固定列的偏移（px）：起始边的从 leading（勾选列的宽度）之后累加，结束边的从末尾往回累加 */\nexport function stickyOffsets<T>(\n  columns: readonly DataTableColumn<T>[],\n  widthOf: ColumnWidthOf<T>,\n  leading: number,\n): StickyOffsets {\n  const accumulate = (\n    side: 'start' | 'end',\n    ordered: readonly DataTableColumn<T>[],\n    from: number,\n  ) => {\n    const offsets = new Map<string, number>();\n    let offset = from;\n    for (const column of ordered) {\n      if (column.sticky !== side) continue;\n      offsets.set(column.key, offset);\n      offset += widthOf(column) ?? COLUMN_FLEX_MIN_WIDTH;\n    }\n    return offsets;\n  };\n  const start = accumulate('start', columns, leading);\n  const end = accumulate('end', [...columns].reverse(), 0);\n  // Map 按插入顺序：最后插入的就是最靠里的\n  return { start, end, startEdge: [...start.keys()].at(-1), endEdge: [...end.keys()].at(-1) };\n}\n\n/** 两组固定列的偏移是否相同（列与偏移都一样） */\nexport function sameStickyOffsets(a: StickyOffsets, b: StickyOffsets): boolean {\n  const sameMap = (x: Map<string, number>, y: Map<string, number>) =>\n    x.size === y.size && [...x].every(([key, offset]) => y.get(key) === offset);\n  return (\n    a.startEdge === b.startEdge &&\n    a.endEdge === b.endEdge &&\n    sameMap(a.start, b.start) &&\n    sameMap(a.end, b.end)\n  );\n}\n\n/** 表格的最小宽度（px）：写了宽度的列按宽度，没写的按 minWidth 或 COLUMN_FLEX_MIN_WIDTH；放不下时横向滚动 */\nexport function tableMinWidth<T>(\n  columns: readonly DataTableColumn<T>[],\n  widthOf: ColumnWidthOf<T>,\n  leading: number,\n): number {\n  return columns.reduce(\n    (total, column) => total + (widthOf(column) ?? column.minWidth ?? COLUMN_FLEX_MIN_WIDTH),\n    leading,\n  );\n}\n\n/** 列在这一行的值：value 函数，或 row[key] */\nexport function columnValue<T>(column: DataTableColumn<T>, row: T): SortValue {\n  if (column.value) return column.value(row);\n  return (row as Record<string, SortValue>)[column.key];\n}\n\nconst NUMERIC_TYPES = new Set<keyof ColumnTypes>(['number', 'currency', 'percent', 'fileSize']);\n\n/**\n * 列的值类型：写了 type 用它；写了数字格式（format）、或合计是 'sum' 的是数字列（这一页全是空值时也靠结束边对齐）；\n * 否则看第一个非空值（ISO 字符串不猜，算文字）\n */\nexport function columnType<T>(column: DataTableColumn<T>, rows: Iterable<T>): keyof ColumnTypes {\n  if (column.type) return column.type;\n  if (column.format || column.summary === 'sum') return 'number';\n  for (const row of rows) {\n    const value = columnValue(column, row);\n    if (value == null) continue;\n    if (isNumeric(value)) return 'number';\n    return value instanceof Date || isDateValue(value) ? 'date' : 'text';\n  }\n  return 'text';\n}\n\n/** 列的对齐：写了 align 用它，数字类靠结束边方便对比位数 */\nexport function columnAlign(type: keyof ColumnTypes): keyof ColumnAligns {\n  return NUMERIC_TYPES.has(type) ? 'end' : 'start';\n}\n\n/** 没写 cell 时单元格的文字：按值类型与当前语言格式化；值与类型对不上（数字列里的文字）时原样显示 */\nexport function formatCell(\n  value: SortValue,\n  type: keyof ColumnTypes,\n  format: ReturnType<typeof useFormat>,\n  options?: NumericFormat,\n): string {\n  if (value == null) return '';\n  // 接口常把金额给成十进制字符串（'19.90'）：能读成数字的字符串也按数字格式化，且不经过浮点\n  const numeric = isNumeric(value) || isNumericText(value);\n  if (numeric && type === 'number') return format.number(value, options);\n  if (numeric && type === 'currency')\n    return format.number(value, { style: 'currency', ...options });\n  if (numeric && type === 'percent')\n    return format.number(value, { style: 'percent', maximumFractionDigits: 1, ...options });\n  if (typeof value === 'number' && type === 'fileSize') return format.fileSize(value);\n  const date = value instanceof Date || isDateValue(value) || typeof value === 'string';\n  if (date && type === 'date') return format.date(value);\n  if (date && type === 'dateTime')\n    return format.date(value, { dateStyle: 'medium', timeStyle: 'short' });\n  return String(value);\n}\n\n/**\n * 一列数值的合计：跳过空值与不是数字的值；有 Decimal 时用它的构造函数精确相加，全是 bigint 时整数相加，\n * 接口给的十进制字符串（'19.90'）按数字算。没有任何数值时为 null\n */\nexport function sumColumn<T>(column: DataTableColumn<T>, rows: Iterable<T>): NumericValue | null {\n  const values: NumericValue[] = [];\n  let kind: NumericKind | undefined;\n  for (const row of rows) {\n    const value = columnValue(column, row);\n    const numeric = isNumeric(value) ? value : isNumericText(value) ? Number(value) : null;\n    if (numeric == null) continue;\n    values.push(numeric);\n    // 有 Decimal 就按 Decimal；否则全是 bigint 才按 bigint\n    if (isDecimal(numeric)) kind = numericKind(numeric);\n    else if (kind === undefined) kind = typeof numeric === 'bigint' ? 'bigint' : 'number';\n    else if (kind === 'bigint' && typeof numeric !== 'bigint') kind = 'number';\n  }\n  if (values.length === 0 || kind === undefined) return null;\n  return values.reduce<NumericValue>((total, value) => addNumeric(total, value, kind!), 0);\n}\n\n/** 点表头时的下一个排序：没排 → 升序 → 降序 → 不排 */\nexport function nextSort(current: SortState | null | undefined, key: string): SortState | null {\n  if (current?.key !== key) return { key, direction: 'ascending' };\n  return current.direction === 'ascending' ? { key, direction: 'descending' } : null;\n}\n\n/**\n * 多列排序时点表头：additive（按住 Shift）时在已有的排序后面加上这一列、或切换它的方向（降序时再点去掉）；\n * 否则只按这一列（同 nextSort）\n */\nexport function nextSorts(\n  current: readonly SortState[],\n  key: string,\n  additive: boolean,\n): SortState[] {\n  if (!additive) {\n    const own = current.length === 1 ? current[0] : undefined;\n    const next = nextSort(own, key);\n    return next ? [next] : [];\n  }\n  const existing = current.find((item) => item.key === key);\n  if (!existing) return [...current, { key, direction: 'ascending' }];\n  if (existing.direction === 'ascending')\n    return current.map((item) => (item.key === key ? { key, direction: 'descending' } : item));\n  return current.filter((item) => item.key !== key);\n}\n\n/** 排序状态统一成数组：单列排序是一个或零个 */\nexport function sortList(\n  sort: SortState | readonly SortState[] | null | undefined,\n): readonly SortState[] {\n  if (!sort) return [];\n  return Array.isArray(sort) ? sort : [sort as SortState];\n}\n\n/**\n * 排序写成一段文字：逗号分隔的列 key，倒序的前面加减号（同 JSON:API），如 `-amount,name`；没有排序时是空字符串。\n * 地址栏的 sort 参数与发给服务端的 sort 参数都是它，query 库的 `sortBy` 直接认\n */\nexport function formatSorts(sort: SortState | readonly SortState[] | null | undefined): string {\n  return sortList(sort)\n    .map((item) => (item.direction === 'descending' ? '-' : '') + item.key)\n    .join(',');\n}\n\n/** 读 formatSorts 写的文字：`-amount,name` 是两列排序；空的项跳过 */\nexport function parseSorts(text: string): SortState[] {\n  return text\n    .split(',')\n    .map((part) => part.trim())\n    .filter((part) => part.replace(/^-/, '') !== '')\n    .map((part) =>\n      part.startsWith('-')\n        ? { key: part.slice(1), direction: 'descending' }\n        : { key: part, direction: 'ascending' },\n    );\n}\n\n/**\n * 按当前排序排列（返回新数组，原数组不变）；可以是几列（前一列相等时比下一列），没有排序、排序列都不存在时原样返回。\n * 比较用 createComparer：数字按大小、日期按时间、文字按语言（中文按拼音、“第2章”在“第10章”前），空值总在最后\n */\nexport function sortRows<T>(\n  rows: readonly T[],\n  columns: readonly DataTableColumn<T>[],\n  sort: SortState | readonly SortState[] | null | undefined,\n  locale: string,\n): readonly T[] {\n  const keys = sortList(sort).flatMap((state) => {\n    const column = columns.find((item) => item.key === state.key);\n    if (!column) return [];\n    // 数字类的列里，十进制字符串（'2.5'、'2.10'）按数值排：按文字比较时 '2.5' 会排在 '2.10' 前面\n    const numeric = NUMERIC_TYPES.has(columnType(column, rows));\n    const value = (row: T) => {\n      const raw = columnValue(column, row);\n      return numeric && isNumericText(raw) ? Number(raw) : raw;\n    };\n    return [{ value, direction: state.direction }];\n  });\n  return keys.length ? sortByValues(rows, keys, locale) : rows;\n}\n\n/** 这一格能不能编辑 */\nexport function isCellEditable<T>(column: DataTableColumn<T>, row: T): boolean {\n  return typeof column.editable === 'function' ? column.editable(row) : !!column.editable;\n}\n\n/** 列的筛选设置：没写或 false 时 undefined，true 是列出出现过的值 */\nexport function columnFilter<T>(column: DataTableColumn<T>): ColumnFilter<T> | undefined {\n  if (!column.filter) return undefined;\n  return column.filter === true ? {} : column.filter;\n}\n\n/** 表头筛选的选项：写了的原样（字符串转成选项），没写的列出这一列出现过的值（按语言排序，有 statuses 时用状态名） */\nexport function filterOptions<T>(\n  column: DataTableColumn<T>,\n  rows: Iterable<T>,\n  locale: string,\n): ColumnFilterOption[] {\n  const options = columnFilter(column)?.options;\n  if (options === 'text') return [];\n  if (options)\n    return options.map((option) => (typeof option === 'string' ? { value: option } : option));\n  const seen = new Map<string, SortValue>();\n  for (const row of rows) {\n    const value = columnValue(column, row);\n    if (value == null || value === '') continue;\n    const text = String(value);\n    if (!seen.has(text)) seen.set(text, value);\n  }\n  const { statuses } = column;\n  // 状态按阶段的顺序，其余按语言排序\n  const compare = createComparer(locale);\n  const order = statuses\n    ? (a: string, b: string) => statuses.order(a) - statuses.order(b)\n    : (a: string, b: string) => compare(seen.get(a), seen.get(b));\n  return [...seen.keys()].sort(order).map((value) => ({ value, label: statuses?.label(value) }));\n}\n\n/** 按表头筛选留下的行：filters 是各列选中的值（关键字筛选时是 [关键字]），空的不算 */\nexport function filterRows<T>(\n  rows: readonly T[],\n  columns: readonly DataTableColumn<T>[],\n  filters: Readonly<Record<string, readonly string[]>>,\n  locale: string,\n): readonly T[] {\n  const matchText = createMatcher(locale);\n  const tests = columns.flatMap((column) => {\n    const values = filters[column.key];\n    const filter = columnFilter(column);\n    if (!filter || !values?.length) return [];\n    const { match } = filter;\n    if (match) return [(row: T) => match(row, values)];\n    if (filter.options === 'text')\n      return [(row: T) => matchText(String(columnValue(column, row) ?? ''), values[0]!)];\n    const allowed = new Set(values);\n    return [(row: T) => allowed.has(String(columnValue(column, row) ?? ''))];\n  });\n  return tests.length ? rows.filter((row) => tests.every((test) => test(row))) : rows;\n}\n\n/**\n * 列的位置调整（列菜单、列设置）：order 是列的 key 的顺序，没列到的按定义的顺序排在后面；\n * pins 覆盖列的 sticky（null 取消固定）。固定在起始边的排到最前、结束边的排到最后：固定列要挨着表格的边\n */\nexport function arrangeColumns<T>(\n  columns: readonly DataTableColumn<T>[],\n  order: readonly string[] | undefined,\n  pins: Readonly<Record<string, keyof ColumnStickies | null>> | undefined,\n): DataTableColumn<T>[] {\n  const rank = new Map((order ?? []).map((key, index) => [key, index]));\n  const position = (column: DataTableColumn<T>) =>\n    rank.get(column.key) ?? rank.size + columns.indexOf(column);\n  const arranged = [...columns]\n    .sort((a, b) => position(a) - position(b))\n    .map((column) =>\n      pins && column.key in pins ? { ...column, sticky: pins[column.key] ?? undefined } : column,\n    );\n  return [\n    ...arranged.filter((column) => column.sticky === 'start'),\n    ...arranged.filter((column) => !column.sticky),\n    ...arranged.filter((column) => column.sticky === 'end'),\n  ];\n}\n"],"mappings":"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"}

package/dist/table/csv.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 按列定义把行导出成 CSV（RFC 4180）：表头是列的标题文字，单元格是表格里看到的文字
+ * （状态映射显示名字，数字、金额、日期按列的 type 与 format 格式化）；开头带 BOM，Excel 打开中文不乱码。
+ *
+ *   const format = useFormat();
+ *   downloadFile('台账.csv', tableToCsv(rows, columns, format), 'text/csv');
+ *
+ * 只要导出部分列时先筛 columns（去掉操作列）；raw 时数值、日期导出原值，便于表格软件再计算。
+ * 文字列里以 = + - @ 开头的内容前面加 '，打开时不会被当成公式执行（CSV 注入；同 PapaParse 的 escapeFormulae）；
+ * 数字、金额、日期列是格式化出来的，不会是公式，负数照常。
+ */
+import type { useFormat } from '../config/lang/format';
+import { type DataTableColumn, type DataTableColumnGroup } from './columns';
+/** tableToCsv 的选项 */
+export interface CsvOptions {
+    /** 开头加 BOM（U+FEFF），默认 true：Excel 按 UTF-8 读，中文不乱码 */
+    bom?: boolean;
+    /** 导出原值，不按列的格式格式化（数值不带千分位、日期是 ISO），默认 false */
+    raw?: boolean;
+    /** 分组表头（同 DataTable 的 columnGroups）：组里的列的表头写成“组标题 / 列标题”（如“收益（万元）/ 目标”） */
+    groups?: readonly DataTableColumnGroup[];
+}
+/** 行 → CSV 文字（见文件开头） */
+export declare function tableToCsv<T>(rows: readonly T[], columns: readonly DataTableColumn<T>[], format: ReturnType<typeof useFormat>, { bom, raw, groups }?: CsvOptions): string;

package/dist/table/csv.js

@@ -0,0 +1,35 @@
+import { isNumeric, isNumericText, numericText } from "../utils/data/numeric.js";
+import { plainText } from "../utils/data/text.js";
+import { columnType, columnValue, formatCell } from "./columns.js";
+//#region src/table/csv.ts
+/** 行 → CSV 文字（见文件开头） */
+function tableToCsv(rows, columns, format, { bom = true, raw = false, groups = [] } = {}) {
+	const types = columns.map((column) => columnType(column, rows));
+	const text = [columns.map((column) => {
+		const title = plainText(column.header) ?? column.key;
+		const group = groups.find((item) => item.columns.includes(column.key));
+		const groupTitle = group && plainText(group.header);
+		return guardFormula(groupTitle ? `${groupTitle} / ${title}` : title);
+	}), ...rows.map((row) => columns.map((column, index) => {
+		const value = columnValue(column, row);
+		if (value == null) return "";
+		if (column.statuses && typeof value === "string") return column.statuses.label(value);
+		if (isNumeric(value)) return raw ? numericText(value) : formatCell(value, types[index], format, column.format);
+		if (raw || types[index] === "text") return guardFormula(rawText(value));
+		return formatCell(value, types[index], format, column.format);
+	}))].map((line) => line.map(field).join(",")).join("\r\n");
+	return bom ? `\uFEFF${text}` : text;
+}
+/** 原值的文字：日期是 ISO */
+var rawText = (value) => value instanceof Date ? value.toISOString() : String(value);
+/** 文字以 = + - @ 开头（且不是数字）时前面加 '：表格软件不会当成公式执行 */
+var guardFormula = (text) => {
+	const value = text;
+	return /^[=+\-@\t\r]/.test(text) && !isNumericText(value) ? `'${text}` : text;
+};
+/** 一格：含逗号、引号、换行时加引号（引号写两遍） */
+var field = (text) => /[",\r\n]/.test(text) ? `"${text.replaceAll("\"", "\"\"")}"` : text;
+//#endregion
+export { tableToCsv };
+
+//# sourceMappingURL=csv.js.map

package/dist/table/csv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv.js","names":[],"sources":["../../src/table/csv.ts"],"sourcesContent":["/**\n * 按列定义把行导出成 CSV（RFC 4180）：表头是列的标题文字，单元格是表格里看到的文字\n * （状态映射显示名字，数字、金额、日期按列的 type 与 format 格式化）；开头带 BOM，Excel 打开中文不乱码。\n *\n *   const format = useFormat();\n *   downloadFile('台账.csv', tableToCsv(rows, columns, format), 'text/csv');\n *\n * 只要导出部分列时先筛 columns（去掉操作列）；raw 时数值、日期导出原值，便于表格软件再计算。\n * 文字列里以 = + - @ 开头的内容前面加 '，打开时不会被当成公式执行（CSV 注入；同 PapaParse 的 escapeFormulae）；\n * 数字、金额、日期列是格式化出来的，不会是公式，负数照常。\n */\nimport type { useFormat } from '../config/lang/format';\nimport { isNumeric, isNumericText, numericText } from '../utils/data/numeric';\nimport { plainText } from '../utils/data/text';\nimport {\n  columnType,\n  columnValue,\n  formatCell,\n  type DataTableColumn,\n  type DataTableColumnGroup,\n} from './columns';\n\n/** tableToCsv 的选项 */\nexport interface CsvOptions {\n  /** 开头加 BOM（U+FEFF），默认 true：Excel 按 UTF-8 读，中文不乱码 */\n  bom?: boolean;\n  /** 导出原值，不按列的格式格式化（数值不带千分位、日期是 ISO），默认 false */\n  raw?: boolean;\n  /** 分组表头（同 DataTable 的 columnGroups）：组里的列的表头写成“组标题 / 列标题”（如“收益（万元）/ 目标”） */\n  groups?: readonly DataTableColumnGroup[];\n}\n\n/** 行 → CSV 文字（见文件开头） */\nexport function tableToCsv<T>(\n  rows: readonly T[],\n  columns: readonly DataTableColumn<T>[],\n  format: ReturnType<typeof useFormat>,\n  { bom = true, raw = false, groups = [] }: CsvOptions = {},\n): string {\n  const types = columns.map((column) => columnType(column, rows));\n  const header = columns.map((column) => {\n    const title = plainText(column.header) ?? column.key;\n    const group = groups.find((item) => item.columns.includes(column.key));\n    const groupTitle = group && plainText(group.header);\n    return guardFormula(groupTitle ? `${groupTitle} / ${title}` : title);\n  });\n  const lines = rows.map((row) =>\n    columns.map((column, index) => {\n      const value = columnValue(column, row);\n      if (value == null) return '';\n      if (column.statuses && typeof value === 'string') return column.statuses.label(value);\n      if (isNumeric(value))\n        return raw ? numericText(value) : formatCell(value, types[index]!, format, column.format);\n      if (raw || types[index] === 'text') return guardFormula(rawText(value));\n      return formatCell(value, types[index]!, format, column.format);\n    }),\n  );\n  const text = [header, ...lines].map((line) => line.map(field).join(',')).join('\\r\\n');\n  return bom ? `\\uFEFF${text}` : text;\n}\n\n/** 原值的文字：日期是 ISO */\nconst rawText = (value: unknown) => (value instanceof Date ? value.toISOString() : String(value));\n\n/** 文字以 = + - @ 开头（且不是数字）时前面加 '：表格软件不会当成公式执行 */\nconst guardFormula = (text: string) => {\n  // isNumericText 是类型守卫：判断一个 unknown 的副本，text 本身不被收窄成 never\n  const value: unknown = text;\n  return /^[=+\\-@\\t\\r]/.test(text) && !isNumericText(value) ? `'${text}` : text;\n};\n\n/** 一格：含逗号、引号、换行时加引号（引号写两遍） */\nconst field = (text: string) => (/[\",\\r\\n]/.test(text) ? `\"${text.replaceAll('\"', '\"\"')}\"` : text);\n"],"mappings":";;;;;AAiCA,SAAgB,WACd,MACA,SACA,QACA,EAAE,MAAM,MAAM,MAAM,OAAO,SAAS,CAAC,MAAkB,CAAC,GAChD;CACR,MAAM,QAAQ,QAAQ,KAAK,WAAW,WAAW,QAAQ,IAAI,CAAC;CAkB9D,MAAM,OAAO,CAjBE,QAAQ,KAAK,WAAW;EACrC,MAAM,QAAQ,UAAU,OAAO,MAAM,KAAK,OAAO;EACjD,MAAM,QAAQ,OAAO,MAAM,SAAS,KAAK,QAAQ,SAAS,OAAO,GAAG,CAAC;EACrE,MAAM,aAAa,SAAS,UAAU,MAAM,MAAM;EAClD,OAAO,aAAa,aAAa,GAAG,WAAW,KAAK,UAAU,KAAK;CACrE,CAYc,GAAQ,GAXR,KAAK,KAAK,QACtB,QAAQ,KAAK,QAAQ,UAAU;EAC7B,MAAM,QAAQ,YAAY,QAAQ,GAAG;EACrC,IAAI,SAAS,MAAM,OAAO;EAC1B,IAAI,OAAO,YAAY,OAAO,UAAU,UAAU,OAAO,OAAO,SAAS,MAAM,KAAK;EACpF,IAAI,UAAU,KAAK,GACjB,OAAO,MAAM,YAAY,KAAK,IAAI,WAAW,OAAO,MAAM,QAAS,QAAQ,OAAO,MAAM;EAC1F,IAAI,OAAO,MAAM,WAAW,QAAQ,OAAO,aAAa,QAAQ,KAAK,CAAC;EACtE,OAAO,WAAW,OAAO,MAAM,QAAS,QAAQ,OAAO,MAAM;CAC/D,CAAC,CAEsB,CAAK,CAAC,CAAC,KAAK,SAAS,KAAK,IAAI,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM;CACpF,OAAO,MAAM,SAAS,SAAS;AACjC;;AAGA,IAAM,WAAW,UAAoB,iBAAiB,OAAO,MAAM,YAAY,IAAI,OAAO,KAAK;;AAG/F,IAAM,gBAAgB,SAAiB;CAErC,MAAM,QAAiB;CACvB,OAAO,eAAe,KAAK,IAAI,KAAK,CAAC,cAAc,KAAK,IAAI,IAAI,SAAS;AAC3E;;AAGA,IAAM,SAAS,SAAkB,WAAW,KAAK,IAAI,IAAI,IAAI,KAAK,WAAW,MAAK,MAAI,EAAE,KAAK"}

package/dist/table/pivot.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 透视：把明细按行维度（可以多级）与列维度分组，每格聚合一个数值（求和、计数、平均、最小、最大），
+ * 带行合计、列合计与总计。PivotTable 用它；要自己画（热力图、导出）时直接用。
+ *
+ *   const result = pivot(records, {
+ *     rows: [(r) => r.region, (r) => r.supplier],
+ *     columns: (r) => r.quarter,
+ *     value: (r) => r.amount,
+ *     aggregate: 'sum',
+ *   });
+ *   result.cell(['华东', '华辰'], 'Q1')   // 这一格的值；没有明细时 null
+ *
+ * 求和按 sumColumn：有 Decimal 时精确相加，接口给的十进制字符串按数字算；平均是和除以个数（浮点）。
+ * 行、列的顺序：给了 order 时按它（没列出的排在后面），否则按值排序（数字按大小、文字按当前语言）。
+ */
+import type { SortValue } from '../utils/data/collation';
+import { type NumericValue } from '../utils/data/numeric';
+/** 聚合的方式 */
+export interface PivotAggregates {
+    /** 求和（默认） */
+    sum: unknown;
+    /** 明细的条数 */
+    count: unknown;
+    /** 平均 */
+    avg: unknown;
+    /** 最小 */
+    min: unknown;
+    /** 最大 */
+    max: unknown;
+}
+/** pivot 的选项 */
+export interface PivotOptions<T> {
+    /** 行维度：每个取出一级的分组值（地区、供应商） */
+    rows: readonly ((row: T) => SortValue)[];
+    /** 列维度；不写时只有一列（只按行分组） */
+    columns?: (row: T) => SortValue;
+    /** 聚合的数值；count 时可以不写 */
+    value?: (row: T) => SortValue;
+    /** 聚合的方式，默认 sum */
+    aggregate?: keyof PivotAggregates;
+    /** 各级行维度的顺序（按位置对应 rows） */
+    rowOrder?: readonly (readonly string[] | undefined)[];
+    /** 列的顺序 */
+    columnOrder?: readonly string[];
+    /** 排序用的比较（文字按语言）；默认 localeCompare */
+    compare?: (a: string, b: string) => number;
+}
+/** 透视的结果 */
+export interface PivotResult {
+    /** 各行的维度值（每级一个），按顺序 */
+    rowKeys: string[][];
+    /** 各列的值，按顺序；没有列维度时是 [''] */
+    columnKeys: string[];
+    /** 一格的值：没有明细（或明细里都没有数值）时 null */
+    cell: (row: readonly string[], column: string) => NumericValue | null;
+    /** 一行的合计（这一行全部明细的聚合） */
+    rowTotal: (row: readonly string[]) => NumericValue | null;
+    /** 一列的合计 */
+    columnTotal: (column: string) => NumericValue | null;
+    /** 总计 */
+    grandTotal: NumericValue | null;
+    /** 各格（不含合计）里最小、最大的值：热力图按它定颜色深浅；没有值时 null */
+    extent: [number, number] | null;
+}
+/** 按行维度、列维度分组聚合 */
+export declare function pivot<T>(data: readonly T[], options: PivotOptions<T>): PivotResult;

package/dist/table/pivot.js

@@ -0,0 +1,85 @@
+import { compareNumeric, isNumeric, toNumber } from "../utils/data/numeric.js";
+import { sumColumn } from "./columns.js";
+//#region src/table/pivot.ts
+var SEP = "\0";
+/** 一组明细的聚合 */
+function aggregateOf(rows, value, how) {
+	if (how === "count") return rows.length;
+	if (!value || rows.length === 0) return null;
+	const column = {
+		key: "",
+		header: "",
+		value
+	};
+	if (how === "sum") return sumColumn(column, rows);
+	if (how === "avg") {
+		const numbers = rows.map(value).filter(isNumeric);
+		const total = sumColumn(column, rows);
+		return total == null || numbers.length === 0 ? null : toNumber(total) / numbers.length;
+	}
+	const numbers = rows.map(value).filter(isNumeric);
+	if (numbers.length === 0) return null;
+	return numbers.reduce((best, current) => (how === "min" ? compareNumeric(current, best) < 0 : compareNumeric(current, best) > 0) ? current : best);
+}
+/** 按 order 排，没列出的按 compare 排在后面 */
+function ordered(values, order, compare) {
+	const rank = new Map((order ?? []).map((value, position) => [value, position]));
+	return [...new Set(values)].sort((a, b) => {
+		const ra = rank.get(a);
+		const rb = rank.get(b);
+		if (ra !== void 0 || rb !== void 0) return (ra ?? Infinity) - (rb ?? Infinity);
+		return compare(a, b);
+	});
+}
+/** 文字形式的维度值：空值是空字符串 */
+var text = (value) => value == null ? "" : String(value);
+/** 按行维度、列维度分组聚合 */
+function pivot(data, options) {
+	const { rows: dimensions, columns, value, aggregate = "sum", rowOrder, columnOrder, compare = (a, b) => a.localeCompare(b, void 0, { numeric: true }) } = options;
+	const groups = /* @__PURE__ */ new Map();
+	const byRow = /* @__PURE__ */ new Map();
+	const byColumn = /* @__PURE__ */ new Map();
+	const push = (map, key, row) => {
+		const list = map.get(key);
+		if (list) list.push(row);
+		else map.set(key, [row]);
+	};
+	for (const row of data) {
+		const rowKey = dimensions.map((dimension) => text(dimension(row))).join(SEP);
+		const columnKey = columns ? text(columns(row)) : "";
+		push(groups, `${rowKey}${SEP}${SEP}${columnKey}`, row);
+		push(byRow, rowKey, row);
+		push(byColumn, columnKey, row);
+	}
+	const rowKeys = [...byRow.keys()].map((key) => key.split(SEP)).sort((a, b) => {
+		for (let level = 0; level < dimensions.length; level++) {
+			if (a[level] === b[level]) continue;
+			return ordered([a[level], b[level]], rowOrder?.[level], compare)[0] === a[level] ? -1 : 1;
+		}
+		return 0;
+	});
+	const columnKeys = ordered(byColumn.keys(), columnOrder, compare);
+	const cache = /* @__PURE__ */ new Map();
+	const cell = (row, column) => {
+		const key = `${row.join(SEP)}${SEP}${SEP}${column}`;
+		if (!cache.has(key)) cache.set(key, aggregateOf(groups.get(key) ?? [], value, aggregate));
+		return cache.get(key);
+	};
+	const values = rowKeys.flatMap((row) => columnKeys.flatMap((column) => {
+		const result = cell(row, column);
+		return result == null ? [] : [toNumber(result)];
+	}));
+	return {
+		rowKeys,
+		columnKeys,
+		cell,
+		rowTotal: (row) => aggregateOf(byRow.get(row.join(SEP)) ?? [], value, aggregate),
+		columnTotal: (column) => aggregateOf(byColumn.get(column) ?? [], value, aggregate),
+		grandTotal: aggregateOf(data, value, aggregate),
+		extent: values.length ? [Math.min(...values), Math.max(...values)] : null
+	};
+}
+//#endregion
+export { pivot };
+
+//# sourceMappingURL=pivot.js.map

package/dist/table/pivot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot.js","names":[],"sources":["../../src/table/pivot.ts"],"sourcesContent":["/**\n * 透视：把明细按行维度（可以多级）与列维度分组，每格聚合一个数值（求和、计数、平均、最小、最大），\n * 带行合计、列合计与总计。PivotTable 用它；要自己画（热力图、导出）时直接用。\n *\n *   const result = pivot(records, {\n *     rows: [(r) => r.region, (r) => r.supplier],\n *     columns: (r) => r.quarter,\n *     value: (r) => r.amount,\n *     aggregate: 'sum',\n *   });\n *   result.cell(['华东', '华辰'], 'Q1')   // 这一格的值；没有明细时 null\n *\n * 求和按 sumColumn：有 Decimal 时精确相加，接口给的十进制字符串按数字算；平均是和除以个数（浮点）。\n * 行、列的顺序：给了 order 时按它（没列出的排在后面），否则按值排序（数字按大小、文字按当前语言）。\n */\nimport type { SortValue } from '../utils/data/collation';\nimport { compareNumeric, isNumeric, toNumber, type NumericValue } from '../utils/data/numeric';\nimport { sumColumn } from './columns';\n\n/** 聚合的方式 */\nexport interface PivotAggregates {\n  /** 求和（默认） */\n  sum: unknown;\n  /** 明细的条数 */\n  count: unknown;\n  /** 平均 */\n  avg: unknown;\n  /** 最小 */\n  min: unknown;\n  /** 最大 */\n  max: unknown;\n}\n\n/** pivot 的选项 */\nexport interface PivotOptions<T> {\n  /** 行维度：每个取出一级的分组值（地区、供应商） */\n  rows: readonly ((row: T) => SortValue)[];\n  /** 列维度；不写时只有一列（只按行分组） */\n  columns?: (row: T) => SortValue;\n  /** 聚合的数值；count 时可以不写 */\n  value?: (row: T) => SortValue;\n  /** 聚合的方式，默认 sum */\n  aggregate?: keyof PivotAggregates;\n  /** 各级行维度的顺序（按位置对应 rows） */\n  rowOrder?: readonly (readonly string[] | undefined)[];\n  /** 列的顺序 */\n  columnOrder?: readonly string[];\n  /** 排序用的比较（文字按语言）；默认 localeCompare */\n  compare?: (a: string, b: string) => number;\n}\n\n/** 透视的结果 */\nexport interface PivotResult {\n  /** 各行的维度值（每级一个），按顺序 */\n  rowKeys: string[][];\n  /** 各列的值，按顺序；没有列维度时是 [''] */\n  columnKeys: string[];\n  /** 一格的值：没有明细（或明细里都没有数值）时 null */\n  cell: (row: readonly string[], column: string) => NumericValue | null;\n  /** 一行的合计（这一行全部明细的聚合） */\n  rowTotal: (row: readonly string[]) => NumericValue | null;\n  /** 一列的合计 */\n  columnTotal: (column: string) => NumericValue | null;\n  /** 总计 */\n  grandTotal: NumericValue | null;\n  /** 各格（不含合计）里最小、最大的值：热力图按它定颜色深浅；没有值时 null */\n  extent: [number, number] | null;\n}\n\nconst SEP = '\\u0000';\n\n/** 一组明细的聚合 */\nfunction aggregateOf<T>(\n  rows: readonly T[],\n  value: ((row: T) => SortValue) | undefined,\n  how: keyof PivotAggregates,\n): NumericValue | null {\n  if (how === 'count') return rows.length;\n  if (!value || rows.length === 0) return null;\n  const column = { key: '', header: '', value };\n  if (how === 'sum') return sumColumn(column, rows);\n  if (how === 'avg') {\n    const numbers = rows.map(value).filter(isNumeric);\n    const total = sumColumn(column, rows);\n    return total == null || numbers.length === 0 ? null : toNumber(total) / numbers.length;\n  }\n  const numbers = rows.map(value).filter(isNumeric);\n  if (numbers.length === 0) return null;\n  return numbers.reduce((best, current) =>\n    (how === 'min' ? compareNumeric(current, best) < 0 : compareNumeric(current, best) > 0)\n      ? current\n      : best,\n  );\n}\n\n/** 按 order 排，没列出的按 compare 排在后面 */\nfunction ordered(\n  values: Iterable<string>,\n  order: readonly string[] | undefined,\n  compare: (a: string, b: string) => number,\n): string[] {\n  const rank = new Map((order ?? []).map((value, position) => [value, position]));\n  return [...new Set(values)].sort((a, b) => {\n    const ra = rank.get(a);\n    const rb = rank.get(b);\n    if (ra !== undefined || rb !== undefined) return (ra ?? Infinity) - (rb ?? Infinity);\n    return compare(a, b);\n  });\n}\n\n/** 文字形式的维度值：空值是空字符串 */\nconst text = (value: SortValue) => (value == null ? '' : String(value));\n\n/** 按行维度、列维度分组聚合 */\nexport function pivot<T>(data: readonly T[], options: PivotOptions<T>): PivotResult {\n  const {\n    rows: dimensions,\n    columns,\n    value,\n    aggregate = 'sum',\n    rowOrder,\n    columnOrder,\n    compare = (a, b) => a.localeCompare(b, undefined, { numeric: true }),\n  } = options;\n  const groups = new Map<string, T[]>();\n  const byRow = new Map<string, T[]>();\n  const byColumn = new Map<string, T[]>();\n  const push = (map: Map<string, T[]>, key: string, row: T) => {\n    const list = map.get(key);\n    if (list) list.push(row);\n    else map.set(key, [row]);\n  };\n  for (const row of data) {\n    const rowKey = dimensions.map((dimension) => text(dimension(row))).join(SEP);\n    const columnKey = columns ? text(columns(row)) : '';\n    push(groups, `${rowKey}${SEP}${SEP}${columnKey}`, row);\n    push(byRow, rowKey, row);\n    push(byColumn, columnKey, row);\n  }\n\n  // 行：逐级排序（同一上级下的下级按 order 或 compare）\n  const rowKeys = [...byRow.keys()]\n    .map((key) => key.split(SEP))\n    .sort((a, b) => {\n      for (let level = 0; level < dimensions.length; level++) {\n        if (a[level] === b[level]) continue;\n        const sorted = ordered([a[level]!, b[level]!], rowOrder?.[level], compare);\n        return sorted[0] === a[level] ? -1 : 1;\n      }\n      return 0;\n    });\n  const columnKeys = ordered(byColumn.keys(), columnOrder, compare);\n\n  const cache = new Map<string, NumericValue | null>();\n  const cell = (row: readonly string[], column: string) => {\n    const key = `${row.join(SEP)}${SEP}${SEP}${column}`;\n    if (!cache.has(key)) cache.set(key, aggregateOf(groups.get(key) ?? [], value, aggregate));\n    return cache.get(key)!;\n  };\n  const values = rowKeys.flatMap((row) =>\n    columnKeys.flatMap((column) => {\n      const result = cell(row, column);\n      return result == null ? [] : [toNumber(result)];\n    }),\n  );\n  return {\n    rowKeys,\n    columnKeys,\n    cell,\n    rowTotal: (row) => aggregateOf(byRow.get(row.join(SEP)) ?? [], value, aggregate),\n    columnTotal: (column) => aggregateOf(byColumn.get(column) ?? [], value, aggregate),\n    grandTotal: aggregateOf(data, value, aggregate),\n    extent: values.length ? [Math.min(...values), Math.max(...values)] : null,\n  };\n}\n"],"mappings":"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"}

package/dist/table/sheet.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 读进来的表格（CSV、Excel 的一张工作表）统一成 SheetTable：表头是各列的标题文字，每行是“标题 → 值”。
+ * 导入（DataImport）、@zerodep-dev/vue-tsx-pro-ui/xlsx 的 readXlsx 都产出它；CSV 由这里的 readCsvFile 读，不依赖别的库。
+ *
+ *   const [sheet] = await readCsvFile(file);
+ *   sheet.headers   // ['零件号', '名称', '数量']
+ *   sheet.rows[0]   // { 零件号: 'P-001', 名称: '支架', 数量: '40' }
+ *
+ * 从行列矩阵转成表（sheetFromMatrix）时：
+ * - 多行表头（headerRows > 1，合并单元格已展开）：同一列各行的标题用“ / ”连接，上下相同的只留一个（“收益（万元）/ 目标”，
+ *   与 tableToCsv、exportXlsx 的分组表头一致）；
+ * - 全空的行去掉；标题重复时后面的加序号（“备注”“备注 2”）；
+ * - splitLines：这些列的单元格里有换行时拆成几行，别的列照抄（一格里写了几个零件号的报价单）。
+ */
+/** 单元格的值 */
+export type SheetValue = string | number | boolean | Date | null;
+/** 一行：列标题 → 值 */
+export type SheetRow = Record<string, SheetValue>;
+/** 一张表 */
+export interface SheetTable {
+    /** 工作表名（CSV 是文件名） */
+    name: string;
+    /** 各列的标题，按列的顺序 */
+    headers: string[];
+    /** 数据行 */
+    rows: SheetRow[];
+}
+/** sheetFromMatrix 的选项 */
+export interface SheetMatrixOptions {
+    /** 表头占几行，默认 1 */
+    headerRows?: number;
+    /** 这些列（标题）的单元格里有换行时拆成几行；true 是所有列 */
+    splitLines?: boolean | readonly string[];
+    /** 没有标题的列叫什么（从 0 起的列号），默认“第 N 列”；跟随语言时传 lang.sheetColumn */
+    untitled?: (column: number) => string;
+}
+/** 行列矩阵（合并单元格已展开）→ 表：表头可以是几行，见文件开头 */
+export declare function sheetFromMatrix(name: string, matrix: readonly (readonly SheetValue[])[], { headerRows, splitLines, untitled, }?: SheetMatrixOptions): SheetTable;
+/** CSV 文字 → 行列矩阵（RFC 4180：引号里的逗号、换行、两个引号；开头的 BOM 去掉） */
+export declare function parseCsv(text: string): string[][];
+/** 读 CSV 文件：一张表，名字是文件名（去掉扩展名） */
+export declare function readCsvFile(file: Blob & {
+    name?: string;
+}, options?: SheetMatrixOptions): Promise<SheetTable[]>;