niuma-ui 1.3.8 → 2.0.0

package/dist/components/table/src/utils/table-utils.js

@@ -0,0 +1,722 @@
+//#region src/components/table/src/utils/table-utils.ts
+function readConvention(row) {
+	const record = row;
+	const result = {};
+	const { id, key, disabled } = record;
+	if (typeof id === "string" || typeof id === "number") result.id = id;
+	if (typeof key === "string" || typeof key === "number") result.key = key;
+	if (typeof disabled === "boolean") result.disabled = disabled;
+	return result;
+}
+function formatComparableValue(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value instanceof Date) return value.toISOString();
+	return JSON.stringify(value);
+}
+function readRowKeyFallback(row) {
+	const { id, key } = readConvention(row);
+	if (typeof id === "string" || typeof id === "number") return String(id);
+	if (typeof key === "string" || typeof key === "number") return String(key);
+}
+var TABLE_ROW_HEIGHT = {
+	sm: 33,
+	md: 41,
+	lg: 48,
+	group: 36,
+	expand: 80
+};
+function getCellValue(row, column) {
+	return row[column.dataIndex ?? column.key];
+}
+function columnUsesSharedTooltip(column) {
+	return Boolean(column.ellipsis || column.tooltip);
+}
+function resolveCellTooltipMode(column) {
+	if (column.tooltip) return "always";
+	if (column.ellipsis) return "overflow";
+	return null;
+}
+function resolveCellTooltipText(column, row, index) {
+	if (column.tooltip) {
+		const tip = column.tooltip(row, index);
+		if (tip != null && tip !== "") return String(tip);
+		return "";
+	}
+	const value = getCellValue(row, column);
+	if (column.formatter) return column.formatter(value, row, index);
+	if (value == null) return "";
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch {
+		return Object.prototype.toString.call(value);
+	}
+	return String(value);
+}
+function compareTableValues(a, b) {
+	if (a === b) return 0;
+	if (a === void 0 || a === null) return -1;
+	if (b === void 0 || b === null) return 1;
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	return formatComparableValue(a).localeCompare(formatComparableValue(b));
+}
+function toggleSortState(current, key) {
+	if (current?.key !== key) return {
+		key,
+		order: "asc"
+	};
+	if (current.order === "asc") return {
+		key,
+		order: "desc"
+	};
+	return null;
+}
+function toggleMultiSortState(sorts, key, maxSort = 3) {
+	const existingIndex = sorts.findIndex((item) => item.key === key);
+	if (existingIndex < 0) {
+		const next = [...sorts, {
+			key,
+			order: "asc"
+		}];
+		return next.length > maxSort ? next.slice(next.length - maxSort) : next;
+	}
+	const existing = sorts[existingIndex];
+	if (!existing) return [...sorts];
+	if (existing.order === "asc") return sorts.map((item, index) => index === existingIndex ? {
+		key,
+		order: "desc"
+	} : item);
+	return sorts.filter((_, index) => index !== existingIndex);
+}
+function getSortOrderForKey(sorts, key) {
+	return sorts.find((item) => item.key === key)?.order ?? null;
+}
+function getSortPriorityForKey(sorts, key) {
+	const index = sorts.findIndex((item) => item.key === key);
+	return index >= 0 ? index + 1 : 0;
+}
+function compareTableRowsBySort(left, right, column, order) {
+	const direction = order === "asc" ? 1 : -1;
+	if (column.sorter) return column.sorter(left, right) * direction;
+	return compareTableValues(getCellValue(left, column), getCellValue(right, column)) * direction;
+}
+function sortTableRows(rows, columns, sort) {
+	if (!sort) return rows;
+	const column = columns.find((item) => item.key === sort.key);
+	if (!column) return rows;
+	return [...rows].sort((left, right) => compareTableRowsBySort(left, right, column, sort.order));
+}
+function sortTableRowsMulti(rows, columns, sorts) {
+	if (sorts.length === 0) return rows;
+	return [...rows].sort((left, right) => {
+		for (const sort of sorts) {
+			const column = columns.find((item) => item.key === sort.key);
+			if (!column) continue;
+			const compare = compareTableRowsBySort(left, right, column, sort.order);
+			if (compare !== 0) return compare;
+		}
+		return 0;
+	});
+}
+function filterTableRows(rows, query, columns, keys) {
+	const trimmed = query.trim();
+	if (!trimmed) return rows;
+	const searchKeys = keys ?? columns.map((column) => column.key);
+	const lower = trimmed.toLowerCase();
+	return rows.filter((row) => searchKeys.some((key) => {
+		const column = columns.find((item) => item.key === key);
+		return formatComparableValue(column ? getCellValue(row, column) : row[key]).toLowerCase().includes(lower);
+	}));
+}
+function filterTableRowsByColumnFilters(rows, columns, filters) {
+	const active = Object.entries(filters).map(([key, query]) => [key, query.trim()]).filter(([, query]) => query.length > 0);
+	if (!active.length) return rows;
+	const columnMap = new Map(columns.map((column) => [column.key, column]));
+	return rows.filter((row) => active.every(([key, query]) => {
+		const column = columnMap.get(key);
+		if (!column) return true;
+		const value = getCellValue(row, column);
+		if (column.filter) return column.filter(value, row, query);
+		const lower = query.toLowerCase();
+		return formatComparableValue(value).toLowerCase().includes(lower);
+	}));
+}
+function isColumnFilterActive(filters, key) {
+	return Boolean(filters[key]?.trim());
+}
+function resolveGroupKey(row, groupBy) {
+	if (typeof groupBy === "function") return groupBy(row);
+	return String(row[groupBy] ?? "");
+}
+function groupTableRows(rows, groupBy, labelFormatter) {
+	const result = [];
+	let lastKey = null;
+	rows.forEach((row, rowIndex) => {
+		const key = resolveGroupKey(row, groupBy);
+		if (key !== lastKey) {
+			result.push({
+				type: "group",
+				key,
+				label: labelFormatter?.(key) ?? key
+			});
+			lastKey = key;
+		}
+		result.push({
+			type: "row",
+			row,
+			rowIndex
+		});
+	});
+	return result;
+}
+function resolveColumnOrder(columns, order) {
+	const keys = columns.map((column) => column.key);
+	if (!order?.length) return keys;
+	const valid = order.filter((key) => keys.includes(key));
+	const missing = keys.filter((key) => !valid.includes(key));
+	return [...valid, ...missing];
+}
+function resolveOrderedColumns(columns, order) {
+	const map = new Map(columns.map((column) => [column.key, column]));
+	return resolveColumnOrder(columns, order).map((key) => map.get(key)).filter((column) => column !== void 0);
+}
+function reorderColumnKeys(order, dragKey, dropKey) {
+	if (dragKey === dropKey) return [...order];
+	const next = order.filter((key) => key !== dragKey);
+	const dropIndex = next.indexOf(dropKey);
+	if (dropIndex < 0) return [...order];
+	next.splice(dropIndex, 0, dragKey);
+	return next;
+}
+function reorderTableRows(rows, dragIndex, dropIndex, position) {
+	if (dragIndex < 0 || dropIndex < 0 || dragIndex === dropIndex) return [...rows];
+	const next = [...rows];
+	const [moved] = next.splice(dragIndex, 1);
+	if (moved === void 0) return [...rows];
+	let targetIndex = dropIndex;
+	if (dragIndex < dropIndex) targetIndex -= 1;
+	if (position === "after") targetIndex += 1;
+	next.splice(targetIndex, 0, moved);
+	return next;
+}
+function buildTableEntries(rows, columns, options = {}) {
+	let processed = rows;
+	const filterText = options.filterText ?? "";
+	if (filterText.trim()) processed = filterTableRows(processed, filterText, columns, options.filterKeys);
+	const columnFilters = options.columnFilters ?? {};
+	if (Object.values(columnFilters).some((q) => q.trim())) processed = filterTableRowsByColumnFilters(processed, columns, columnFilters);
+	if (!options.remoteSort) {
+		if (options.multiSort && options.sorts?.length) processed = sortTableRowsMulti(processed, columns, options.sorts);
+		else if (options.sort) processed = sortTableRows(processed, columns, options.sort);
+	}
+	if (options.groupBy) {
+		const groupBy = options.groupBy;
+		processed = [...processed].sort((left, right) => compareTableValues(resolveGroupKey(left, groupBy), resolveGroupKey(right, groupBy)));
+		return groupTableRows(processed, groupBy, options.groupLabel);
+	}
+	return processed.map((row, rowIndex) => ({
+		type: "row",
+		row,
+		rowIndex
+	}));
+}
+function injectExpandRows(entries, expandedKeys, rowKey, rowExpandable) {
+	const result = [];
+	for (const entry of entries) {
+		result.push(entry);
+		if (entry.type !== "row") continue;
+		if (rowExpandable && !rowExpandable(entry.row, entry.rowIndex)) continue;
+		const key = resolveRowKey(entry.row, entry.rowIndex, rowKey);
+		if (expandedKeys.has(key)) result.push({
+			type: "expand",
+			row: entry.row,
+			rowIndex: entry.rowIndex,
+			rowKey: key
+		});
+	}
+	return result;
+}
+function toggleExpandedRowKeys(keys, key) {
+	const next = new Set(keys);
+	if (next.has(key)) next.delete(key);
+	else next.add(key);
+	return [...next];
+}
+/** 读取树表子节点数组（非数组视为无子节点） */
+function getTableTreeChildren(row, childrenField = "children") {
+	const value = row[childrenField];
+	return Array.isArray(value) ? value : [];
+}
+/** 是否为叶子（显式 isLeaf 优先） */
+function getTableTreeIsLeaf(row, isLeafField = "isLeaf") {
+	return Boolean(row[isLeafField]);
+}
+/** 是否可展开：非叶子且（有子节点，或懒加载） */
+function hasTableTreeChildren(row, options = {}) {
+	const childrenField = options.childrenField ?? "children";
+	if (getTableTreeIsLeaf(row, options.isLeafField ?? "isLeaf")) return false;
+	if (getTableTreeChildren(row, childrenField).length > 0) return true;
+	return Boolean(options.lazy);
+}
+/**
+* 解析树表行 key。
+* 有 `rowKey` 时走 `resolveRowKey`；否则用路径回退（避免兄弟下标跨分支碰撞）。
+* 树表强烈建议显式传 `rowKey`。
+*/
+function resolveTableTreeRowKey(row, index, parentKey, rowKey) {
+	if (rowKey !== void 0 && rowKey !== null && rowKey !== "") return resolveRowKey(row, index, rowKey);
+	return parentKey == null ? `tree:${index}` : `${parentKey}/${index}`;
+}
+/** 是否配置了可用的稳定 rowKey（字段名或函数） */
+function hasStableTableTreeRowKey(rowKey) {
+	return rowKey !== void 0 && rowKey !== null && rowKey !== "";
+}
+/** 收集所有可展开节点 key（用于 defaultExpandAll） */
+function collectTableTreeExpandableKeys(rows, options = {}) {
+	const childrenField = options.childrenField ?? "children";
+	const keys = [];
+	const walk = (items, parentKey) => {
+		items.forEach((row, index) => {
+			const key = resolveTableTreeRowKey(row, index, parentKey, options.rowKey);
+			if (hasTableTreeChildren(row, options)) {
+				keys.push(key);
+				walk(getTableTreeChildren(row, childrenField), key);
+			}
+		});
+	};
+	walk(rows, null);
+	return keys;
+}
+/** 构建整棵树的 parent/children key 索引（级联勾选） */
+function buildTableTreeNodeIndex(rows, options = {}) {
+	const childrenField = options.childrenField ?? "children";
+	const map = /* @__PURE__ */ new Map();
+	const walk = (items, parentKey) => {
+		for (let i = 0; i < items.length; i += 1) {
+			const row = items[i];
+			const key = resolveTableTreeRowKey(row, i, parentKey, options.rowKey);
+			const children = getTableTreeChildren(row, childrenField);
+			const childrenKeys = hasTableTreeChildren(row, options) ? children.map((child, childIndex) => resolveTableTreeRowKey(child, childIndex, key, options.rowKey)) : [];
+			map.set(key, {
+				parentKey,
+				childrenKeys
+			});
+			if (children.length > 0) walk(children, key);
+		}
+	};
+	walk(rows, null);
+	return map;
+}
+function collectTableTreeDescendantKeys(key, index) {
+	const entry = index.get(key);
+	if (!entry) return [];
+	const result = [];
+	for (const childKey of entry.childrenKeys) result.push(childKey, ...collectTableTreeDescendantKeys(childKey, index));
+	return result;
+}
+function resolveTableTreeCheckState(key, checkedKeys, index, checkStrictly) {
+	if (checkStrictly) return checkedKeys.has(key) ? "checked" : "unchecked";
+	if (checkedKeys.size === 0) return "unchecked";
+	const entry = index.get(key);
+	if (!entry || entry.childrenKeys.length === 0) return checkedKeys.has(key) ? "checked" : "unchecked";
+	const childStates = entry.childrenKeys.map((childKey) => resolveTableTreeCheckState(childKey, checkedKeys, index, checkStrictly));
+	if (childStates.every((state) => state === "checked")) return "checked";
+	if (childStates.some((state) => state === "checked" || state === "indeterminate")) return "indeterminate";
+	return "unchecked";
+}
+function collectTableTreeHalfCheckedKeys(index, checkedKeys, checkStrictly) {
+	if (checkStrictly || checkedKeys.size === 0) return [];
+	const half = [];
+	for (const key of index.keys()) if (resolveTableTreeCheckState(key, checkedKeys, index, checkStrictly) === "indeterminate") half.push(key);
+	return half;
+}
+/** 切换树表勾选；`checkStrictly=false` 时父子联动 */
+function toggleTableTreeCheck(key, checkedKeys, index, checkStrictly) {
+	const next = new Set(checkedKeys);
+	const shouldCheck = resolveTableTreeCheckState(key, next, index, checkStrictly) !== "checked";
+	if (checkStrictly) {
+		if (shouldCheck) next.add(key);
+		else next.delete(key);
+		return [...next];
+	}
+	for (const id of [key, ...collectTableTreeDescendantKeys(key, index)]) if (shouldCheck) next.add(id);
+	else next.delete(id);
+	let parentKey = index.get(key)?.parentKey ?? null;
+	while (parentKey) {
+		const parent = index.get(parentKey);
+		if (!parent) break;
+		if (parent.childrenKeys.every((childKey) => resolveTableTreeCheckState(childKey, next, index, false) === "checked")) next.add(parentKey);
+		else next.delete(parentKey);
+		parentKey = parent.parentKey;
+	}
+	return [...next];
+}
+/**
+* 树过滤：匹配节点或其后代匹配时保留该节点，并裁剪子树。
+* 与 RsTree `filterTreeNodes` 语义一致（保留祖先路径）。
+*/
+function filterTableTreeRows(rows, query, columns, options = {}) {
+	const childrenField = options.childrenField ?? "children";
+	const trimmed = query.trim();
+	const columnFilters = options.columnFilters ?? {};
+	const hasColumnFilters = Object.values(columnFilters).some((q) => q.trim());
+	if (!trimmed && !hasColumnFilters) return rows;
+	const matchesSelf = (row) => {
+		let ok = true;
+		if (trimmed) ok = filterTableRows([row], trimmed, columns, options.filterKeys).length > 0;
+		if (ok && hasColumnFilters) ok = filterTableRowsByColumnFilters([row], columns, columnFilters).length > 0;
+		return ok;
+	};
+	const walk = (items) => {
+		const result = [];
+		for (const row of items) {
+			const children = getTableTreeChildren(row, childrenField);
+			const nextChildren = children.length ? walk(children) : [];
+			if (matchesSelf(row) || nextChildren.length > 0) result.push(nextChildren.length || children.length ? {
+				...row,
+				[childrenField]: nextChildren
+			} : row);
+		}
+		return result;
+	};
+	return walk(rows);
+}
+/** 树排序：仅对同级节点排序，递归处理子树 */
+function sortTableTreeRows(rows, columns, options) {
+	const childrenField = options.childrenField ?? "children";
+	let sorted;
+	if (options.multiSort && options.sorts?.length) sorted = sortTableRowsMulti(rows, columns, options.sorts);
+	else if (options.sort) sorted = sortTableRows(rows, columns, options.sort);
+	else sorted = rows;
+	return sorted.map((row) => {
+		const children = getTableTreeChildren(row, childrenField);
+		if (!children.length) return row;
+		return {
+			...row,
+			[childrenField]: sortTableTreeRows(children, columns, options)
+		};
+	});
+}
+/**
+* 按展开 key 展平可见树行为表格 row entries（不含 detail expand 行）。
+*/
+function flattenVisibleTableTreeEntries(rows, expandedKeys, options = {}) {
+	const childrenField = options.childrenField ?? "children";
+	const result = [];
+	const walk = (items, depth, parentKey) => {
+		items.forEach((row, index) => {
+			const key = resolveTableTreeRowKey(row, index, parentKey, options.rowKey);
+			const hasChildren = hasTableTreeChildren(row, options);
+			const rowIndex = result.length;
+			result.push({
+				type: "row",
+				row,
+				rowIndex,
+				depth,
+				hasChildren,
+				parentKey,
+				treeKey: key
+			});
+			if (hasChildren && expandedKeys.has(key)) walk(getTableTreeChildren(row, childrenField), depth + 1, key);
+		});
+	};
+	walk(rows, 0, null);
+	return result;
+}
+/**
+* 树表入口构建：过滤 → 同级排序 → 按展开状态展平。
+* 不支持与 `groupBy` / detail `expandable` 同时使用。
+*/
+function buildTableTreeEntries(rows, columns, expandedKeys, options) {
+	const childrenField = options.tree.childrenField ?? "children";
+	let processed = rows;
+	const filterText = options.filterText ?? "";
+	const columnFilters = options.columnFilters ?? {};
+	if (filterText.trim() || Object.values(columnFilters).some((q) => q.trim())) processed = filterTableTreeRows(processed, filterText, columns, {
+		childrenField,
+		filterKeys: options.filterKeys,
+		columnFilters
+	});
+	if (!options.remoteSort && (options.sort || options.multiSort && options.sorts?.length)) processed = sortTableTreeRows(processed, columns, {
+		childrenField,
+		sort: options.sort,
+		sorts: options.sorts,
+		multiSort: options.multiSort
+	});
+	return flattenVisibleTableTreeEntries(processed, expandedKeys, {
+		childrenField,
+		isLeafField: options.tree.isLeafField,
+		lazy: options.tree.lazy,
+		rowKey: options.rowKey
+	});
+}
+/** 按表格 size 解析树缩进默认值 */
+function resolveTableTreeIndent(size = "md", custom) {
+	if (custom !== void 0) return custom;
+	if (size === "sm") return 16;
+	if (size === "lg") return 24;
+	return 20;
+}
+function resolveTableSize(compact, size = "md") {
+	if (compact) return "sm";
+	return size;
+}
+function resolveTableRowHeight(size = "md", custom) {
+	if (custom !== void 0) return custom;
+	return TABLE_ROW_HEIGHT[size];
+}
+function resolveTableVirtualEnabled(options) {
+	if (options.virtual) return true;
+	if (options.infinite && options.virtualOnInfinite !== false) return true;
+	return false;
+}
+function isNearScrollBottom(scrollTop, scrollHeight, clientHeight, distance = 80) {
+	return scrollHeight - scrollTop - clientHeight <= distance;
+}
+function entryHeight(entry, rowHeight, groupRowHeight = TABLE_ROW_HEIGHT.group, expandRowHeight = TABLE_ROW_HEIGHT.expand) {
+	if (entry.type === "group") return groupRowHeight;
+	if (entry.type === "expand") return expandRowHeight;
+	return rowHeight;
+}
+function resolveScrollWidth(scrollX, _columns) {
+	if (scrollX === void 0) return void 0;
+	if (typeof scrollX === "number") return `${scrollX}px`;
+	return scrollX;
+}
+function resolveLeadingColumnWidth(options) {
+	let width = 0;
+	if (options.rowDraggable) width += 40;
+	if (options.expandable) width += 40;
+	if (options.selectable) width += 40;
+	if (options.showEditGutter) width += options.gutterWidth ?? 32;
+	else if (options.showIndex) width += options.indexWidth ?? 48;
+	return width;
+}
+function resolveFixedColumnStyles(columns, widths, options = {}) {
+	const result = /* @__PURE__ */ new Map();
+	let leftOffset = resolveLeadingColumnWidth(options);
+	for (const column of columns) {
+		if (column.fixed !== "left") continue;
+		result.set(column.key, {
+			fixed: "left",
+			left: leftOffset
+		});
+		leftOffset += parseColumnWidth(widths[column.key] ?? column.width);
+	}
+	let rightOffset = 0;
+	for (let index = columns.length - 1; index >= 0; index -= 1) {
+		const column = columns[index];
+		if (column?.fixed !== "right") continue;
+		result.set(column.key, {
+			fixed: "right",
+			right: rightOffset
+		});
+		rightOffset += parseColumnWidth(widths[column.key] ?? column.width);
+	}
+	return result;
+}
+function fixedCellStyle(style, options) {
+	if (!style) return void 0;
+	const result = {
+		position: "sticky",
+		zIndex: options?.header ? "4" : "2"
+	};
+	if (options?.header) result.top = "0";
+	if (style.fixed === "left" && style.left !== void 0) {
+		result.left = `${style.left}px`;
+		return result;
+	}
+	if (style.fixed === "right" && style.right !== void 0) {
+		result.right = `${style.right}px`;
+		return result;
+	}
+}
+function selectRowKeys(selectedKeys, key, selectionType) {
+	if (selectionType === "radio") return [key];
+	return toggleRowSelection(selectedKeys, key);
+}
+/** 行点击多选（plain / Ctrl·Cmd / Shift），供 selectionType=`row` 使用。 */
+function selectRowKeysByClick(selectedKeys, key, options) {
+	if (options.range && options.orderedKeys.length > 0) {
+		const anchor = options.anchorKey && options.orderedKeys.includes(options.anchorKey) ? options.anchorKey : key;
+		const from = options.orderedKeys.indexOf(anchor);
+		const to = options.orderedKeys.indexOf(key);
+		if (from < 0 || to < 0) return [key];
+		const start = Math.min(from, to);
+		const end = Math.max(from, to);
+		return options.orderedKeys.slice(start, end + 1);
+	}
+	if (options.toggle) return toggleRowSelection(selectedKeys, key);
+	return [key];
+}
+function sliceVirtualTableEntries(entries, scrollTop, viewportHeight, rowHeight, groupRowHeight = TABLE_ROW_HEIGHT.group, overscan = 4, expandRowHeight = TABLE_ROW_HEIGHT.expand) {
+	if (entries.length === 0) return {
+		entries: [],
+		paddingTop: 0,
+		paddingBottom: 0
+	};
+	return sliceVirtualHeightModel(buildVirtualHeightModel(entries, rowHeight, groupRowHeight, expandRowHeight), scrollTop, viewportHeight, rowHeight, overscan);
+}
+/** 预计算行高前缀和，供虚拟滚动复用，避免每次 scroll 全量 map/reduce */
+function buildVirtualHeightModel(entries, rowHeight, groupRowHeight = TABLE_ROW_HEIGHT.group, expandRowHeight = TABLE_ROW_HEIGHT.expand) {
+	const prefix = new Array(entries.length + 1);
+	prefix[0] = 0;
+	for (let index = 0; index < entries.length; index += 1) prefix[index + 1] = prefix[index] + entryHeight(entries[index], rowHeight, groupRowHeight, expandRowHeight);
+	return {
+		entries,
+		prefix,
+		total: prefix[entries.length] ?? 0
+	};
+}
+function findVirtualStartIndex(prefix, targetTop) {
+	let low = 0;
+	let high = prefix.length - 2;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		if ((prefix[mid + 1] ?? 0) <= targetTop) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+function sliceVirtualHeightModel(model, scrollTop, viewportHeight, rowHeight, overscan = 4) {
+	const { entries, prefix, total } = model;
+	if (entries.length === 0) return {
+		entries: [],
+		paddingTop: 0,
+		paddingBottom: 0
+	};
+	const overscanPx = overscan * rowHeight;
+	const start = findVirtualStartIndex(prefix, Math.max(0, scrollTop - overscanPx));
+	const paddingTop = prefix[start] ?? 0;
+	const maxVisible = viewportHeight + overscanPx * 2;
+	let end = start;
+	while (end < entries.length && (prefix[end] ?? 0) - paddingTop < maxVisible) end += 1;
+	if (end === start) end = Math.min(start + 1, entries.length);
+	const renderedBottom = prefix[end] ?? total;
+	const paddingBottom = Math.max(0, total - renderedBottom);
+	return {
+		entries: entries.slice(start, end),
+		paddingTop,
+		paddingBottom
+	};
+}
+/** 列像素宽：优先已测量/配置 widths，其次 column.width / minWidth */
+function resolveColumnPixelWidth(column, widths, fallback = 120) {
+	const fromMap = widths?.[column.key];
+	if (fromMap !== void 0) return parseColumnWidth(fromMap, fallback);
+	return parseColumnWidth(column.width ?? column.minWidth, fallback);
+}
+/**
+* 横向列虚拟切片（仅针对可横滚的流体列）。
+* 调用方负责：冻结列始终实体渲染；`scrollLeft` 为相对流体区起点的偏移
+* （即容器 scrollLeft 减去前缀列与左冻结列宽度）。
+*/
+function sliceVirtualColumns(columns, options) {
+	const n = columns.length;
+	if (n === 0) return {
+		columns: [],
+		paddingLeft: 0,
+		paddingRight: 0,
+		startIndex: 0,
+		endIndex: 0
+	};
+	const overscan = options.overscan ?? 2;
+	const prefix = new Array(n + 1);
+	prefix[0] = 0;
+	for (let i = 0; i < n; i += 1) prefix[i + 1] = (prefix[i] ?? 0) + Math.max(1, options.getWidth(columns[i]));
+	const total = prefix[n] ?? 0;
+	const viewLeft = Math.max(0, options.scrollLeft);
+	const viewRight = viewLeft + Math.max(1, options.viewportWidth);
+	let start = 0;
+	while (start < n && (prefix[start + 1] ?? 0) <= viewLeft) start += 1;
+	start = Math.max(0, start - overscan);
+	let end = start;
+	while (end < n && (prefix[end] ?? 0) < viewRight) end += 1;
+	end = Math.min(n, Math.max(end + overscan, start + 1));
+	return {
+		columns: columns.slice(start, end),
+		paddingLeft: prefix[start] ?? 0,
+		paddingRight: Math.max(0, total - (prefix[end] ?? total)),
+		startIndex: start,
+		endIndex: end
+	};
+}
+function resolveRowKey(row, index, rowKey) {
+	if (typeof rowKey === "function") return rowKey(row);
+	if (rowKey) return String(row[rowKey]);
+	return readRowKeyFallback(row) ?? String(index);
+}
+function resolveEntryKey(entry, rowKey) {
+	if (entry.type === "group") return `group:${entry.key}`;
+	if (entry.type === "expand") return `expand:${entry.rowKey}`;
+	if (entry.treeKey) return entry.treeKey;
+	return resolveRowKey(entry.row, entry.rowIndex, rowKey);
+}
+function resolveColumnStyle(column, widths) {
+	const style = {};
+	const width = widths?.[column.key] ?? column.width;
+	if (width !== void 0) style.width = typeof width === "number" ? `${width}px` : width;
+	if (column.minWidth !== void 0) style.minWidth = typeof column.minWidth === "number" ? `${column.minWidth}px` : column.minWidth;
+	return Object.keys(style).length ? style : void 0;
+}
+function clampColumnWidth(width, min = 48, max = 640) {
+	return Math.min(max, Math.max(min, width));
+}
+function parseColumnWidth(width, fallback = 120) {
+	if (typeof width === "number") return width;
+	if (typeof width === "string" && width.endsWith("px")) return Number.parseInt(width, 10) || fallback;
+	return fallback;
+}
+function createInitialColumnWidths(columns, overrides, options) {
+	const result = {};
+	for (const column of columns) {
+		const override = overrides?.[column.key];
+		if (typeof override === "number") {
+			result[column.key] = override;
+			continue;
+		}
+		if (typeof override === "string" && override.endsWith("px")) {
+			result[column.key] = Number.parseInt(override, 10) || parseColumnWidth(column.width);
+			continue;
+		}
+		if (typeof column.width === "number") {
+			result[column.key] = column.width;
+			continue;
+		}
+		if (options?.forceAll) result[column.key] = parseColumnWidth(column.width ?? column.minWidth);
+	}
+	return result;
+}
+function isTableRowDisabled(row) {
+	return readConvention(row).disabled === true;
+}
+function resolveSelectableRowKeys(rows, rowKey, rowSelectable) {
+	return rows.map((row, index) => ({
+		row,
+		index
+	})).filter(({ row, index }) => {
+		if (isTableRowDisabled(row)) return false;
+		return rowSelectable ? rowSelectable(row, index) : true;
+	}).map(({ row, index }) => resolveRowKey(row, index, rowKey));
+}
+function resolveSelectAllState(selectedKeys, allKeys) {
+	if (allKeys.length === 0) return "unchecked";
+	const selectedCount = allKeys.filter((key) => selectedKeys.includes(key)).length;
+	if (selectedCount === 0) return "unchecked";
+	if (selectedCount === allKeys.length) return "checked";
+	return "indeterminate";
+}
+function toggleRowSelection(selectedKeys, key) {
+	const next = new Set(selectedKeys);
+	if (next.has(key)) next.delete(key);
+	else next.add(key);
+	return [...next];
+}
+function toggleSelectAll(selectedKeys, allKeys, select) {
+	const next = new Set(selectedKeys);
+	if (select) for (const key of allKeys) next.add(key);
+	else for (const key of allKeys) next.delete(key);
+	return [...next];
+}
+//#endregion
+export { TABLE_ROW_HEIGHT, buildTableEntries, buildTableTreeEntries, buildTableTreeNodeIndex, buildVirtualHeightModel, clampColumnWidth, collectTableTreeDescendantKeys, collectTableTreeExpandableKeys, collectTableTreeHalfCheckedKeys, columnUsesSharedTooltip, compareTableRowsBySort, compareTableValues, createInitialColumnWidths, entryHeight, filterTableRows, filterTableRowsByColumnFilters, filterTableTreeRows, fixedCellStyle, flattenVisibleTableTreeEntries, getCellValue, getSortOrderForKey, getSortPriorityForKey, getTableTreeChildren, getTableTreeIsLeaf, groupTableRows, hasStableTableTreeRowKey, hasTableTreeChildren, injectExpandRows, isColumnFilterActive, isNearScrollBottom, isTableRowDisabled, parseColumnWidth, reorderColumnKeys, reorderTableRows, resolveCellTooltipMode, resolveCellTooltipText, resolveColumnOrder, resolveColumnPixelWidth, resolveColumnStyle, resolveEntryKey, resolveFixedColumnStyles, resolveGroupKey, resolveLeadingColumnWidth, resolveOrderedColumns, resolveRowKey, resolveScrollWidth, resolveSelectAllState, resolveSelectableRowKeys, resolveTableRowHeight, resolveTableSize, resolveTableTreeCheckState, resolveTableTreeIndent, resolveTableTreeRowKey, resolveTableVirtualEnabled, selectRowKeys, selectRowKeysByClick, sliceVirtualColumns, sliceVirtualHeightModel, sliceVirtualTableEntries, sortTableRows, sortTableRowsMulti, sortTableTreeRows, toggleExpandedRowKeys, toggleMultiSortState, toggleRowSelection, toggleSelectAll, toggleSortState, toggleTableTreeCheck };