niuma-ui 1.1.12 → 1.2.1

package/dist/components/time-picker-utils.js

@@ -0,0 +1,158 @@
+//#region src/components/time-picker-utils.ts
+var EMPTY_TIME_RANGE = {};
+var TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)$/;
+var TIME_WITH_SECONDS_PATTERN = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/;
+function scheduleAfterPaint(callback) {
+	let cancelled = false;
+	requestAnimationFrame(() => {
+		requestAnimationFrame(() => {
+			if (!cancelled) callback();
+		});
+	});
+	return () => {
+		cancelled = true;
+	};
+}
+function formatTimeUnitLabel(value) {
+	return String(value).padStart(2, "0");
+}
+function buildTimeUnitOptions(max, step = 1) {
+	const options = [];
+	for (let value = 0; value <= max; value += step) options.push({
+		value,
+		label: formatTimeUnitLabel(value)
+	});
+	return options;
+}
+/** 小时列固定选项 00–23 */
+var TIME_HOUR_OPTIONS = buildTimeUnitOptions(23);
+/** 秒列固定选项 00–59 */
+var TIME_SECOND_OPTIONS = buildTimeUnitOptions(59);
+var minuteOptionsCache = /* @__PURE__ */ new Map();
+/** 按步进缓存分钟列选项，默认 step=1 为 00–59 */
+function getTimeMinuteOptions(step = 1) {
+	const normalized = Math.max(1, Math.floor(step) || 1);
+	const cached = minuteOptionsCache.get(normalized);
+	if (cached) return cached;
+	const options = buildTimeUnitOptions(59, normalized);
+	minuteOptionsCache.set(normalized, options);
+	return options;
+}
+/**
+* 将时间列滚到指定 value，只改容器 scrollTop。
+* 避免 scrollIntoView 带动外层页面 / Popover 滚动。
+*/
+function scrollTimeColumnToValue(container, value) {
+	if (!container) return;
+	const item = container.querySelector(`:scope > [data-value="${value}"]`);
+	if (!item) return;
+	const top = item.offsetTop - (container.clientHeight - item.offsetHeight) / 2;
+	container.scrollTop = Math.max(0, top);
+}
+function parseTimeValue(value, withSeconds = false) {
+	if (!value?.trim()) return null;
+	const trimmed = value.trim();
+	if (withSeconds) {
+		const withSec = TIME_WITH_SECONDS_PATTERN.exec(trimmed);
+		if (withSec) return {
+			hour: Number.parseInt(withSec[1], 10),
+			minute: Number.parseInt(withSec[2], 10),
+			second: Number.parseInt(withSec[3], 10)
+		};
+		const minuteOnly = TIME_PATTERN.exec(trimmed);
+		if (minuteOnly) return {
+			hour: Number.parseInt(minuteOnly[1], 10),
+			minute: Number.parseInt(minuteOnly[2], 10),
+			second: 0
+		};
+		return null;
+	}
+	const match = TIME_PATTERN.exec(trimmed);
+	if (!match) return null;
+	return {
+		hour: Number.parseInt(match[1], 10),
+		minute: Number.parseInt(match[2], 10),
+		second: 0
+	};
+}
+function formatTimeParts(hour, minute, second) {
+	const h = String(hour).padStart(2, "0");
+	const m = String(minute).padStart(2, "0");
+	if (second !== void 0) return `${h}:${m}:${String(second).padStart(2, "0")}`;
+	return `${h}:${m}`;
+}
+function formatTimeFromParts(hour, minute, second, withSeconds = false) {
+	return formatTimeParts(hour, minute, withSeconds ? second : void 0);
+}
+function getCurrentTime() {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		hour: now.getHours(),
+		minute: now.getMinutes(),
+		second: now.getSeconds()
+	};
+}
+function formatTimeValue(value) {
+	return value ?? "";
+}
+function timeToSeconds(hour, minute, second = 0) {
+	return hour * 3600 + minute * 60 + second;
+}
+function parseTimeToSeconds(value, withSeconds = false) {
+	const parsed = parseTimeValue(value, withSeconds);
+	if (!parsed) return null;
+	return timeToSeconds(parsed.hour, parsed.minute, parsed.second);
+}
+function isTimeWithinBounds(hour, minute, second, options = {}) {
+	const { minTime, maxTime, withSeconds = false } = options;
+	const candidate = timeToSeconds(hour, minute, second);
+	if (minTime) {
+		const minSeconds = parseTimeToSeconds(minTime, withSeconds);
+		if (minSeconds !== null && candidate < minSeconds) return false;
+	}
+	if (maxTime) {
+		const maxSeconds = parseTimeToSeconds(maxTime, withSeconds);
+		if (maxSeconds !== null && candidate > maxSeconds) return false;
+	}
+	return true;
+}
+function isTimeRangeEmpty(value) {
+	return !value.start?.trim() && !value.end?.trim();
+}
+function isTimeRangeOrdered(range, withSeconds = false) {
+	if (!range.start || !range.end) return true;
+	return isTimeRangeOrderedValues(range.start, range.end, withSeconds);
+}
+function isTimeRangeOrderedValues(start, end, withSeconds = false) {
+	const startSeconds = parseTimeToSeconds(start, withSeconds);
+	const endSeconds = parseTimeToSeconds(end, withSeconds);
+	if (startSeconds === null || endSeconds === null) return true;
+	return startSeconds <= endSeconds;
+}
+function pickEarlierTime(a, b, withSeconds = false) {
+	if (!a) return b;
+	if (!b) return a;
+	const ta = parseTimeToSeconds(a, withSeconds);
+	const tb = parseTimeToSeconds(b, withSeconds);
+	if (ta === null) return b;
+	if (tb === null) return a;
+	return ta <= tb ? a : b;
+}
+function pickLaterTime(a, b, withSeconds = false) {
+	if (!a) return b;
+	if (!b) return a;
+	const ta = parseTimeToSeconds(a, withSeconds);
+	const tb = parseTimeToSeconds(b, withSeconds);
+	if (ta === null) return b;
+	if (tb === null) return a;
+	return ta >= tb ? a : b;
+}
+function formatTimeRangeDisplay(range, options) {
+	const separator = options?.separator ?? " ~ ";
+	const start = range.start ? formatTimeValue(range.start) : "";
+	const end = range.end ? formatTimeValue(range.end) : "";
+	if (start && end) return `${start}${separator}${end}`;
+	return start || end;
+}
+//#endregion
+export { EMPTY_TIME_RANGE, TIME_HOUR_OPTIONS, TIME_SECOND_OPTIONS, formatTimeFromParts, formatTimeParts, formatTimeRangeDisplay, formatTimeUnitLabel, formatTimeValue, getCurrentTime, getTimeMinuteOptions, isTimeRangeEmpty, isTimeRangeOrdered, isTimeRangeOrderedValues, isTimeWithinBounds, parseTimeToSeconds, parseTimeValue, pickEarlierTime, pickLaterTime, scheduleAfterPaint, scrollTimeColumnToValue, timeToSeconds };

package/dist/components/time-range-validation.d.ts

@@ -0,0 +1,11 @@
+import type { RsTimeRangeValue } from './time-picker-utils';
+export interface RsTimeRangeValidationRules {
+    required?: boolean;
+    ordered?: boolean;
+}
+export type RsTimeRangeValidationError = 'required' | 'order';
+export interface RsTimeRangeValidationResult {
+    valid: boolean;
+    error?: RsTimeRangeValidationError;
+}
+export declare function validateTimeRangeValue(value: RsTimeRangeValue, rules?: RsTimeRangeValidationRules): RsTimeRangeValidationResult;

package/dist/components/time-range-validation.js

@@ -0,0 +1,15 @@
+import { isTimeRangeOrdered } from "./time-picker-utils.js";
+//#region src/components/time-range-validation.ts
+function validateTimeRangeValue(value, rules = {}) {
+	if (rules.required && (!value.start || !value.end)) return {
+		valid: false,
+		error: "required"
+	};
+	if (rules.ordered !== false && !isTimeRangeOrdered(value)) return {
+		valid: false,
+		error: "order"
+	};
+	return { valid: true };
+}
+//#endregion
+export { validateTimeRangeValue };

package/dist/components/time-validation.d.ts

@@ -0,0 +1,11 @@
+export interface RsTimeValidationRules {
+    required?: boolean;
+    min?: string;
+    max?: string;
+}
+export type RsTimeValidationError = 'required' | 'min' | 'max' | 'format';
+export interface RsTimeValidationResult {
+    valid: boolean;
+    error?: RsTimeValidationError;
+}
+export declare function validateTimeValue(value: string, rules?: RsTimeValidationRules): RsTimeValidationResult;

package/dist/components/time-validation.js

@@ -0,0 +1,22 @@
+//#region src/components/time-validation.ts
+function validateTimeValue(value, rules = {}) {
+	if (!value) return rules.required ? {
+		valid: false,
+		error: "required"
+	} : { valid: true };
+	if (!/^\d{2}:\d{2}(?::\d{2})?$/.test(value)) return {
+		valid: false,
+		error: "format"
+	};
+	if (rules.min && value < rules.min) return {
+		valid: false,
+		error: "min"
+	};
+	if (rules.max && value > rules.max) return {
+		valid: false,
+		error: "max"
+	};
+	return { valid: true };
+}
+//#endregion
+export { validateTimeValue };

package/dist/components/tree-utils.d.ts

@@ -0,0 +1,112 @@
+import type { RsComponentSize } from '../theme/types';
+export interface RsTreeNode {
+    key?: string;
+    id?: string;
+    label?: string;
+    title?: string;
+    children?: RsTreeNode[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+    icon?: string;
+    disableCheckbox?: boolean;
+    loading?: boolean;
+    [key: string]: unknown;
+}
+export interface RsTreeFieldNames {
+    key?: string;
+    label?: string;
+    children?: string;
+    disabled?: string;
+    isLeaf?: string;
+    icon?: string;
+    disableCheckbox?: string;
+    loading?: string;
+}
+export interface RsTreeFlatNode {
+    key: string;
+    node: RsTreeNode;
+    depth: number;
+    hasChildren: boolean;
+    isLast: boolean;
+    parentKey: string | null;
+    /**
+     * showLine 用：下标对应祖先深度 `0..depth-1`。
+     * `true` 表示该祖先不是同级最后一项，竖线需贯穿当前行；`false` 则留空缺口。
+     */
+    levelLines: boolean[];
+}
+export interface RsTreeNodeIndex {
+    node: RsTreeNode;
+    parentKey: string | null;
+    childrenKeys: string[];
+}
+export type RsTreeCheckState = 'checked' | 'indeterminate' | 'unchecked';
+export type RsTreeFocusMove = 'next' | 'prev' | 'parent' | 'first' | 'last';
+export type RsTreeDropPosition = 'before' | 'inside' | 'after';
+/** handle=显示拖拽手柄；row=整行拖拽且不显示手柄 */
+export type RsTreeDragTrigger = 'handle' | 'row';
+export type RsTreeSize = RsComponentSize;
+export declare const DEFAULT_TREE_FIELD_NAMES: Required<RsTreeFieldNames>;
+/**
+ * 各尺寸档行高 / 缩进。
+ * 显式标注 Record<RsTreeSize, number>：尺寸类型再加档位时这里会直接编译报错，
+ * 而不是在运行时取到 undefined —— 行高 undefined 会让虚拟滚动的 padding 全变 NaN。
+ */
+export declare const TREE_ROW_HEIGHT: Record<RsTreeSize, number>;
+export declare const TREE_INDENT_BY_SIZE: Record<RsTreeSize, number>;
+export declare function resolveTreeFieldNames(fieldNames?: RsTreeFieldNames): Required<RsTreeFieldNames>;
+export declare function resolveTreeRowHeight(size?: RsTreeSize, custom?: number): number;
+export declare function resolveTreeIndent(size?: RsTreeSize): number;
+export declare function getTreeKey(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): string;
+export declare function getTreeLabel(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): string;
+export declare function getTreeChildren(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): RsTreeNode[];
+export declare function getTreeIsLeaf(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function isTreeNodeDisabled(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function isTreeCheckboxDisabled(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, options?: {
+    onlyCheckLeaf?: boolean;
+    lazy?: boolean;
+}): boolean;
+export declare function shouldShowTreeCheckbox(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, options?: {
+    onlyCheckLeaf?: boolean;
+    lazy?: boolean;
+}): boolean;
+export declare function isTreeNodeLoading(node: RsTreeNode, key: string, loadingKeys: ReadonlySet<string>, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function hasTreeChildren(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, lazy?: boolean): boolean;
+export declare function flattenTreeNodeIds(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>): string[];
+export declare function collectExpandableKeys(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>, lazy?: boolean): string[];
+export declare function buildTreeNodeIndex(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>, lazy?: boolean): Map<string, RsTreeNodeIndex>;
+export declare function collectDescendantKeys(key: string, index: ReadonlyMap<string, RsTreeNodeIndex>): string[];
+/**
+ * `ancestorKey` 是否为 `descendantKey` 的祖先。
+ * 沿 parentKey 上溯 O(depth)，比收集整棵子树再 includes 便宜得多（拖拽 dragover 每帧都要判一次）。
+ */
+export declare function isTreeAncestorKey(ancestorKey: string, descendantKey: string, index: ReadonlyMap<string, RsTreeNodeIndex>): boolean;
+export declare function collectHalfCheckedKeys(index: ReadonlyMap<string, RsTreeNodeIndex>, checkedKeys: ReadonlySet<string>, checkStrictly: boolean, onlyCheckLeaf?: boolean): string[];
+export declare function flattenVisibleTreeNodes(nodes: readonly RsTreeNode[], expandedKeys: ReadonlySet<string>, fields?: Required<RsTreeFieldNames>, lazy?: boolean, depth?: number, parentKey?: string | null, 
+/** 路径上各祖先是否为同级最后一项（长度 = depth） */
+ancestorIsLast?: readonly boolean[]): RsTreeFlatNode[];
+export declare function defaultTreeFilterNode(node: RsTreeNode, keyword: string, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function filterTreeNodes(nodes: readonly RsTreeNode[], keyword: string, options?: {
+    fieldNames?: RsTreeFieldNames;
+    filterNode?: (node: RsTreeNode, keyword: string) => boolean;
+}): RsTreeNode[];
+export declare function splitTreeLabelHighlight(label: string, keyword: string): Array<{
+    text: string;
+    highlight: boolean;
+}>;
+export declare function resolveTreeCheckState(key: string, checkedKeys: ReadonlySet<string>, index: ReadonlyMap<string, RsTreeNodeIndex>, checkStrictly: boolean, onlyCheckLeaf?: boolean): RsTreeCheckState;
+export declare function toggleTreeCheck(key: string, checkedKeys: ReadonlySet<string>, index: ReadonlyMap<string, RsTreeNodeIndex>, checkStrictly: boolean, onlyCheckLeaf?: boolean): string[];
+export declare function resolveAccordionExpandedKeys(key: string, expandedKeys: readonly string[], index: ReadonlyMap<string, RsTreeNodeIndex>, rootKeys: readonly string[]): string[];
+export declare function resolveTreeFocusKey(flatNodes: readonly RsTreeFlatNode[], currentKey: string | null, move: RsTreeFocusMove, index: ReadonlyMap<string, RsTreeNodeIndex>): string | null;
+export declare function resolveTreeVirtualEnabled(options: {
+    virtual?: boolean;
+    flatCount: number;
+    virtualThreshold?: number;
+}): boolean;
+export declare function sliceVirtualTreeNodes(nodes: readonly RsTreeFlatNode[], scrollTop: number, viewportHeight: number, itemHeight: number, overscan?: number): {
+    nodes: RsTreeFlatNode[];
+    /** 切片首项在完整扁平列表中的下标，供 aria-posinset 等按 O(1) 定位 */
+    startIndex: number;
+    paddingTop: number;
+    paddingBottom: number;
+};

package/dist/components/tree-utils.js

@@ -0,0 +1,310 @@
+//#region src/components/tree-utils.ts
+var DEFAULT_TREE_FIELD_NAMES = {
+	key: "key",
+	label: "label",
+	children: "children",
+	disabled: "disabled",
+	isLeaf: "isLeaf",
+	icon: "icon",
+	disableCheckbox: "disableCheckbox",
+	loading: "loading"
+};
+/**
+* 各尺寸档行高 / 缩进。
+* 显式标注 Record<RsTreeSize, number>：尺寸类型再加档位时这里会直接编译报错，
+* 而不是在运行时取到 undefined —— 行高 undefined 会让虚拟滚动的 padding 全变 NaN。
+*/
+var TREE_ROW_HEIGHT = {
+	ssm: 24,
+	sm: 28,
+	md: 32,
+	lg: 40
+};
+var TREE_INDENT_BY_SIZE = {
+	ssm: 12,
+	sm: 16,
+	md: 20,
+	lg: 24
+};
+function resolveTreeFieldNames(fieldNames) {
+	return {
+		...DEFAULT_TREE_FIELD_NAMES,
+		...fieldNames
+	};
+}
+function resolveTreeRowHeight(size = "md", custom) {
+	if (custom !== void 0) return custom;
+	return TREE_ROW_HEIGHT[size];
+}
+function resolveTreeIndent(size = "md") {
+	return TREE_INDENT_BY_SIZE[size];
+}
+function readNodeField(node, field) {
+	return node[field];
+}
+function getTreeKey(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.key);
+	if (mapped !== void 0 && mapped !== null && mapped !== "") return String(mapped);
+	if (node.key !== void 0 && node.key !== "") return String(node.key);
+	if (node.id !== void 0 && node.id !== "") return String(node.id);
+	const label = readNodeField(node, fields.label) ?? node.label ?? node.title;
+	return String(label ?? "");
+}
+function getTreeLabel(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.label);
+	if (mapped !== void 0 && mapped !== null && mapped !== "") return String(mapped);
+	if (node.label !== void 0 && node.label !== "") return String(node.label);
+	if (node.title !== void 0 && node.title !== "") return String(node.title);
+	return getTreeKey(node, fields);
+}
+function getTreeChildren(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.children);
+	if (Array.isArray(mapped)) return mapped;
+	return node.children ?? [];
+}
+function getTreeIsLeaf(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return Boolean(readNodeField(node, fields.isLeaf) ?? node.isLeaf);
+}
+function isTreeNodeDisabled(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return Boolean(readNodeField(node, fields.disabled) ?? node.disabled);
+}
+function isTreeCheckboxDisabled(node, fields = DEFAULT_TREE_FIELD_NAMES, options = {}) {
+	if (isTreeNodeDisabled(node, fields)) return true;
+	if (options.onlyCheckLeaf && hasTreeChildren(node, fields, options.lazy ?? false)) return true;
+	return Boolean(readNodeField(node, fields.disableCheckbox) ?? node.disableCheckbox);
+}
+function shouldShowTreeCheckbox(node, fields = DEFAULT_TREE_FIELD_NAMES, options = {}) {
+	if (!options.onlyCheckLeaf) return true;
+	return !hasTreeChildren(node, fields, options.lazy ?? false);
+}
+function isTreeNodeLoading(node, key, loadingKeys, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return loadingKeys.has(key) || Boolean(readNodeField(node, fields.loading) ?? node.loading);
+}
+function hasTreeChildren(node, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	if (getTreeIsLeaf(node, fields)) return false;
+	if (getTreeChildren(node, fields).length > 0) return true;
+	return lazy;
+}
+function flattenTreeNodeIds(nodes, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return nodes.flatMap((node) => [getTreeKey(node, fields), ...flattenTreeNodeIds(getTreeChildren(node, fields), fields)]);
+}
+function collectExpandableKeys(nodes, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	const keys = [];
+	function walk(items) {
+		for (const node of items) {
+			const key = getTreeKey(node, fields);
+			if (hasTreeChildren(node, fields, lazy)) {
+				keys.push(key);
+				walk(getTreeChildren(node, fields));
+			}
+		}
+	}
+	walk(nodes);
+	return keys;
+}
+function buildTreeNodeIndex(nodes, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	const map = /* @__PURE__ */ new Map();
+	function walk(items, parentKey) {
+		for (const node of items) {
+			const key = getTreeKey(node, fields);
+			const childrenKeys = hasTreeChildren(node, fields, lazy) ? getTreeChildren(node, fields).map((child) => getTreeKey(child, fields)) : [];
+			map.set(key, {
+				node,
+				parentKey,
+				childrenKeys
+			});
+			if (getTreeChildren(node, fields).length > 0) walk(getTreeChildren(node, fields), key);
+		}
+	}
+	walk(nodes, null);
+	return map;
+}
+function collectDescendantKeys(key, index) {
+	const entry = index.get(key);
+	if (!entry) return [];
+	const result = [];
+	for (const childKey of entry.childrenKeys) result.push(childKey, ...collectDescendantKeys(childKey, index));
+	return result;
+}
+/**
+* `ancestorKey` 是否为 `descendantKey` 的祖先。
+* 沿 parentKey 上溯 O(depth)，比收集整棵子树再 includes 便宜得多（拖拽 dragover 每帧都要判一次）。
+*/
+function isTreeAncestorKey(ancestorKey, descendantKey, index) {
+	let parentKey = index.get(descendantKey)?.parentKey ?? null;
+	while (parentKey !== null) {
+		if (parentKey === ancestorKey) return true;
+		parentKey = index.get(parentKey)?.parentKey ?? null;
+	}
+	return false;
+}
+function collectHalfCheckedKeys(index, checkedKeys, checkStrictly, onlyCheckLeaf = false) {
+	if (checkStrictly && !onlyCheckLeaf) return [];
+	if (checkedKeys.size === 0) return [];
+	const half = [];
+	for (const key of index.keys()) if (resolveTreeCheckState(key, checkedKeys, index, checkStrictly, onlyCheckLeaf) === "indeterminate") half.push(key);
+	return half;
+}
+/** 根层节点无祖先竖线；共享同一个空数组，省去每个节点一次数组分配 */
+var NO_LEVEL_LINES = Object.freeze([]);
+function flattenVisibleTreeNodes(nodes, expandedKeys, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false, depth = 0, parentKey = null, ancestorIsLast = []) {
+	const result = [];
+	function walk(items, currentDepth, currentParentKey, ancestors) {
+		const lastIndex = items.length - 1;
+		const levelLines = ancestors.length === 0 ? NO_LEVEL_LINES : ancestors.map((last) => !last);
+		for (let index = 0; index <= lastIndex; index += 1) {
+			const node = items[index];
+			const key = getTreeKey(node, fields);
+			const hasChildren = hasTreeChildren(node, fields, lazy);
+			const isLast = index === lastIndex;
+			result.push({
+				key,
+				node,
+				depth: currentDepth,
+				hasChildren,
+				isLast,
+				parentKey: currentParentKey,
+				levelLines
+			});
+			if (hasChildren && expandedKeys.has(key)) walk(getTreeChildren(node, fields), currentDepth + 1, key, [...ancestors, isLast]);
+		}
+	}
+	walk(nodes, depth, parentKey, ancestorIsLast);
+	return result;
+}
+function defaultTreeFilterNode(node, keyword, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return getTreeLabel(node, fields).toLowerCase().includes(keyword.trim().toLowerCase());
+}
+function filterTreeNodes(nodes, keyword, options = {}) {
+	const fields = resolveTreeFieldNames(options.fieldNames);
+	const query = keyword.trim();
+	if (!query) return [...nodes];
+	const match = options.filterNode ?? ((node, value) => defaultTreeFilterNode(node, value, fields));
+	function filterNode(node) {
+		const children = getTreeChildren(node, fields);
+		const filteredChildren = children.map(filterNode).filter((item) => item !== null);
+		if (match(node, query)) return {
+			...node,
+			children
+		};
+		if (filteredChildren.length > 0) return {
+			...node,
+			children: filteredChildren
+		};
+		return null;
+	}
+	return nodes.map(filterNode).filter((item) => item !== null);
+}
+function splitTreeLabelHighlight(label, keyword) {
+	const query = keyword.trim();
+	if (!query) return [{
+		text: label,
+		highlight: false
+	}];
+	const lowerLabel = label.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+	const index = lowerLabel.indexOf(lowerQuery);
+	if (index < 0) return [{
+		text: label,
+		highlight: false
+	}];
+	const parts = [];
+	if (index > 0) parts.push({
+		text: label.slice(0, index),
+		highlight: false
+	});
+	parts.push({
+		text: label.slice(index, index + query.length),
+		highlight: true
+	});
+	if (index + query.length < label.length) parts.push({
+		text: label.slice(index + query.length),
+		highlight: false
+	});
+	return parts;
+}
+function resolveTreeCheckState(key, checkedKeys, index, checkStrictly, onlyCheckLeaf = false) {
+	if (checkStrictly && !onlyCheckLeaf) 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) => resolveTreeCheckState(childKey, checkedKeys, index, checkStrictly, onlyCheckLeaf));
+	if (childStates.every((state) => state === "checked")) return "checked";
+	if (childStates.some((state) => state === "checked" || state === "indeterminate")) return "indeterminate";
+	return "unchecked";
+}
+function toggleTreeCheck(key, checkedKeys, index, checkStrictly, onlyCheckLeaf = false) {
+	const next = new Set(checkedKeys);
+	const shouldCheck = resolveTreeCheckState(key, next, index, checkStrictly, onlyCheckLeaf) !== "checked";
+	if (checkStrictly && !onlyCheckLeaf) {
+		if (shouldCheck) next.add(key);
+		else next.delete(key);
+		return [...next];
+	}
+	if (onlyCheckLeaf) {
+		const entry = index.get(key);
+		if (!entry || entry.childrenKeys.length > 0) return [...checkedKeys];
+		if (shouldCheck) next.add(key);
+		else next.delete(key);
+		return [...next];
+	}
+	for (const id of [key, ...collectDescendantKeys(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) => resolveTreeCheckState(childKey, next, index, false, onlyCheckLeaf) === "checked")) next.add(parentKey);
+		else next.delete(parentKey);
+		parentKey = parent.parentKey;
+	}
+	return [...next];
+}
+function resolveAccordionExpandedKeys(key, expandedKeys, index, rootKeys) {
+	const parentKey = index.get(key)?.parentKey ?? null;
+	const siblings = parentKey ? index.get(parentKey)?.childrenKeys ?? [] : [...rootKeys];
+	const next = new Set(expandedKeys);
+	for (const sibling of siblings) if (sibling !== key) next.delete(sibling);
+	next.add(key);
+	return [...next];
+}
+function resolveTreeFocusKey(flatNodes, currentKey, move, index) {
+	const keys = flatNodes.map((item) => item.key);
+	if (keys.length === 0) return null;
+	if (!currentKey) return keys[0] ?? null;
+	const currentIndex = keys.indexOf(currentKey);
+	if (currentIndex < 0) return keys[0] ?? null;
+	switch (move) {
+		case "next": return keys[Math.min(currentIndex + 1, keys.length - 1)] ?? null;
+		case "prev": return keys[Math.max(currentIndex - 1, 0)] ?? null;
+		case "first": return keys[0] ?? null;
+		case "last": return keys[keys.length - 1] ?? null;
+		case "parent": return index.get(currentKey)?.parentKey ?? currentKey;
+		default: return currentKey;
+	}
+}
+function resolveTreeVirtualEnabled(options) {
+	if (options.virtual) return true;
+	return options.flatCount > (options.virtualThreshold ?? 100);
+}
+function sliceVirtualTreeNodes(nodes, scrollTop, viewportHeight, itemHeight, overscan = 4) {
+	if (nodes.length === 0) return {
+		nodes: [],
+		startIndex: 0,
+		paddingTop: 0,
+		paddingBottom: 0
+	};
+	const totalHeight = nodes.length * itemHeight;
+	const maxScrollTop = Math.max(0, totalHeight - Math.max(0, viewportHeight));
+	const start = Math.max(0, Math.floor(Math.min(Math.max(0, scrollTop), maxScrollTop) / itemHeight) - overscan);
+	const visibleCount = Math.ceil(Math.max(0, viewportHeight) / itemHeight) + overscan * 2;
+	const end = Math.min(nodes.length, start + visibleCount);
+	return {
+		nodes: nodes.slice(start, end),
+		startIndex: start,
+		paddingTop: start * itemHeight,
+		paddingBottom: Math.max(0, totalHeight - end * itemHeight)
+	};
+}
+//#endregion
+export { DEFAULT_TREE_FIELD_NAMES, TREE_INDENT_BY_SIZE, TREE_ROW_HEIGHT, buildTreeNodeIndex, collectDescendantKeys, collectExpandableKeys, collectHalfCheckedKeys, defaultTreeFilterNode, filterTreeNodes, flattenTreeNodeIds, flattenVisibleTreeNodes, getTreeChildren, getTreeIsLeaf, getTreeKey, getTreeLabel, hasTreeChildren, isTreeAncestorKey, isTreeCheckboxDisabled, isTreeNodeDisabled, isTreeNodeLoading, resolveAccordionExpandedKeys, resolveTreeCheckState, resolveTreeFieldNames, resolveTreeFocusKey, resolveTreeIndent, resolveTreeRowHeight, resolveTreeVirtualEnabled, shouldShowTreeCheckbox, sliceVirtualTreeNodes, splitTreeLabelHighlight, toggleTreeCheck };

package/dist/components/upload-utils.d.ts

@@ -0,0 +1,26 @@
+export interface RsUploadValidationRules {
+    accept?: string;
+    maxSize?: number;
+    maxCount?: number;
+}
+export interface RsUploadValidationError {
+    file: File;
+    reason: 'accept' | 'maxSize' | 'maxCount';
+}
+export declare function formatFileSize(size: number): string;
+export declare function isFileAccepted(file: File, accept?: string): boolean;
+export declare function validateUploadFiles(files: readonly File[], rules?: RsUploadValidationRules): {
+    accepted: File[];
+    rejected: RsUploadValidationError[];
+};
+export declare function mergeUploadFiles(current: readonly File[], next: readonly File[], maxCount?: number): File[];
+export declare function removeUploadFileAt(files: readonly File[], index: number): File[];
+/** 触发浏览器下载指定 File / Blob */
+export declare function downloadUploadFile(file: File | Blob, filename?: string): void;
+/** 将文本等内容还原为可回显的 File（编辑态回填） */
+export declare function createUploadFileFromContent(name: string, content: BlobPart, type?: string): File;
+/**
+ * 按文件名扩展名 / MIME 解析列表图标（Lucide kebab-case）。
+ * 未匹配时返回 `file`。
+ */
+export declare function resolveUploadFileIcon(file: Pick<File, 'name' | 'type'> | string): string;