niuma-ui 1.1.12 → 1.2.1

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

@@ -0,0 +1,83 @@
+export type RsSelectValue = string | number;
+/** 过滤 / 回显比对字段名，默认 label；可传 value 或 fieldNames 映射后的键 */
+export type RsSelectOptionFilterProp = string;
+export type RsSelectPlacement = 'top' | 'bottom' | 'left' | 'right';
+export type RsSelectStatus = 'error' | 'warning' | '';
+/** 自定义过滤（对齐 Ant Design filterOption）。返回 false 则隐藏该项。 */
+export type RsSelectFilterOption = (query: string, option: RsSelectOption) => boolean;
+/** 过滤后排序（对齐 Ant Design filterSort） */
+export type RsSelectFilterSort = (a: RsSelectOption, b: RsSelectOption) => number;
+export interface RsSelectOption {
+    label: string;
+    value: RsSelectValue;
+    disabled?: boolean;
+    /** 原生 title；悬停展示补充说明 */
+    title?: string;
+}
+export interface RsSelectOptionGroup {
+    label: string;
+    options: RsSelectOption[];
+}
+export type RsSelectOptions = ReadonlyArray<RsSelectOption | RsSelectOptionGroup>;
+/** 未正规化的选项（配合 fieldNames 可用 name/id/children 等业务字段） */
+export type RsSelectOptionInput = RsSelectOption | RsSelectOptionGroup | Record<string, unknown>;
+export type RsSelectOptionsInput = ReadonlyArray<RsSelectOptionInput>;
+/** 对齐 Ant Design fieldNames */
+export interface RsSelectFieldNames {
+    label?: string;
+    value?: string;
+    options?: string;
+    disabled?: string;
+    groupLabel?: string;
+}
+export type RsSelectGetPopupContainer = (triggerNode?: HTMLElement) => string | HTMLElement | undefined;
+/** labelInValue 时的 v-model 项（对齐 Ant Design） */
+export interface RsSelectLabeledValue {
+    label: string;
+    value: RsSelectValue;
+}
+export type RsSelectModelValue = RsSelectValue | RsSelectValue[] | RsSelectLabeledValue | RsSelectLabeledValue[] | '';
+/**
+ * 按泛型收窄后的 v-model。
+ * 默认单选、值为 string：宿主 `@update:model-value="(v: string) => void"` 可直接赋值。
+ * `multiple` / `labelInValue` 为字面量 true 时收成数组或 labeled；为 `boolean` 时保留联合。
+ */
+export type RsSelectResolvedModel<Value extends RsSelectValue = string, Multiple extends boolean = false, LabelInValue extends boolean = false> = LabelInValue extends true ? Multiple extends true ? RsSelectLabeledValue[] : Multiple extends false ? RsSelectLabeledValue | '' : RsSelectLabeledValue | RsSelectLabeledValue[] | '' : Multiple extends true ? Value[] : Multiple extends false ? Value | '' : Value | Value[] | '';
+/**
+ * Reka ComboboxItem 禁止 value 为空串（空串表示未选中 / placeholder）。
+ * 选项若传入 value: ''，对内映射为此哨兵，避免崩溃；对外读写仍为 ''。
+ */
+export declare const RS_SELECT_EMPTY_VALUE = "__rs_select_empty__";
+/** 业务 value → ComboboxItem token（空串走哨兵；数字转为十进制字符串） */
+export declare function toComboboxValue(value: RsSelectValue): string;
+/** ComboboxItem token → 业务字符串（仅还原空串哨兵，不恢复 number） */
+export declare function fromComboboxValue(value: string): string;
+export declare function isSelectOptionGroup(item: RsSelectOption | RsSelectOptionGroup): item is RsSelectOptionGroup;
+export declare function flattenSelectOptions(options: RsSelectOptions): RsSelectOption[];
+export declare function findSelectOption(options: RsSelectOptions, token: string): RsSelectOption | undefined;
+/**
+ * Combobox token → 业务 value。
+ * 优先返回 options 里的原始类型（number 0 保持为 0）；手输/未知项保持字符串。
+ */
+export declare function restoreSelectValue(token: string, options: RsSelectOptions): RsSelectValue;
+export declare function restoreSelectValues(tokens: string[], options: RsSelectOptions): RsSelectValue[];
+export declare function buildOptionLabelMap(options: RsSelectOptions): Map<string, string>;
+export declare function buildOptionDisabledMap(options: RsSelectOptions): Map<string, boolean>;
+/**
+ * 按 fieldNames 把业务选项正规化为 { label, value, disabled }。
+ * 默认键即为 label / value / options，既有调用无需改。
+ */
+export declare function normalizeSelectOptions(options: RsSelectOptionsInput, fieldNames?: RsSelectFieldNames): RsSelectOptions;
+/** 触发器 / tag 展示文案，对齐 Ant optionLabelProp */
+export declare function optionDisplayLabel(option: RsSelectOption, prop?: string): string;
+export declare function comboboxBindingToTokens(value: unknown, multiple: boolean): string[];
+export declare function selectModelEntries(value: unknown): unknown[];
+export declare function filterSelectOptions(options: RsSelectOptions, query: string, contains: (text: string, search: string) => boolean, filterOption?: RsSelectFilterOption | boolean, optionFilterProp?: RsSelectOptionFilterProp): RsSelectOptions;
+export declare function flattenSelectValues(options: RsSelectOptions): string[];
+export declare function toSelectedTokens(value: unknown, multiple: boolean): string[];
+export declare function isSelectLabeledValue(value: unknown): value is RsSelectLabeledValue;
+export declare function unwrapSelectEntry(item: unknown): RsSelectValue | null;
+export declare function toLabeledValue(value: RsSelectValue, options: RsSelectOptions): RsSelectLabeledValue;
+export declare function packSelectModel(values: RsSelectValue[], options: RsSelectOptions, multiple: boolean, labelInValue: boolean): RsSelectModelValue;
+export declare function sortSelectOptions(options: RsSelectOptions, sort?: RsSelectFilterSort): RsSelectOptions;
+export declare function splitByTokenSeparators(raw: string, separators: string[]): string[] | null;

package/dist/components/select-utils.js

@@ -0,0 +1,211 @@
+//#region src/components/select-utils.ts
+/**
+* Reka ComboboxItem 禁止 value 为空串（空串表示未选中 / placeholder）。
+* 选项若传入 value: ''，对内映射为此哨兵，避免崩溃；对外读写仍为 ''。
+*/
+var RS_SELECT_EMPTY_VALUE = "__rs_select_empty__";
+/** 业务 value → ComboboxItem token（空串走哨兵；数字转为十进制字符串） */
+function toComboboxValue(value) {
+	return value === "" ? RS_SELECT_EMPTY_VALUE : String(value);
+}
+/** ComboboxItem token → 业务字符串（仅还原空串哨兵，不恢复 number） */
+function fromComboboxValue(value) {
+	return value === "__rs_select_empty__" ? "" : value;
+}
+function isSelectOptionGroup(item) {
+	return "options" in item && Array.isArray(item.options);
+}
+function flattenSelectOptions(options) {
+	const result = [];
+	for (const item of options) if (isSelectOptionGroup(item)) result.push(...item.options);
+	else result.push(item);
+	return result;
+}
+function findSelectOption(options, token) {
+	const raw = fromComboboxValue(token);
+	return flattenSelectOptions(options).find((opt) => String(opt.value) === String(raw));
+}
+/**
+* Combobox token → 业务 value。
+* 优先返回 options 里的原始类型（number 0 保持为 0）；手输/未知项保持字符串。
+*/
+function restoreSelectValue(token, options) {
+	const matched = findSelectOption(options, token);
+	if (matched) return matched.value;
+	return fromComboboxValue(token);
+}
+function restoreSelectValues(tokens, options) {
+	return tokens.map((token) => restoreSelectValue(token, options));
+}
+function buildOptionLabelMap(options) {
+	const map = /* @__PURE__ */ new Map();
+	for (const opt of flattenSelectOptions(options)) {
+		const key = toComboboxValue(opt.value);
+		map.set(key, opt.label);
+		if (opt.value === "") map.set("", opt.label);
+	}
+	return map;
+}
+function buildOptionDisabledMap(options) {
+	const map = /* @__PURE__ */ new Map();
+	for (const opt of flattenSelectOptions(options)) {
+		const key = toComboboxValue(opt.value);
+		map.set(key, Boolean(opt.disabled));
+	}
+	return map;
+}
+function optionFieldText(option, prop) {
+	if (prop === "value") return String(option.value);
+	if (prop === "label" || !prop) return String(option.label);
+	const extra = Reflect.get(option, prop);
+	return extra == null ? String(option.label) : String(extra);
+}
+function defaultMatchOption(option, query, contains, optionFilterProp) {
+	return contains(optionFieldText(option, optionFilterProp), query);
+}
+function coerceSelectValue(raw) {
+	if (typeof raw === "number" || typeof raw === "string") return raw;
+	if (raw == null) return "";
+	return String(raw);
+}
+function mapSelectOption(raw, names) {
+	const value = coerceSelectValue(raw[names.value]);
+	const label = raw[names.label];
+	return {
+		...raw,
+		value,
+		label: label == null ? String(value) : String(label),
+		disabled: Boolean(raw[names.disabled]),
+		title: typeof raw.title === "string" ? raw.title : void 0
+	};
+}
+/**
+* 按 fieldNames 把业务选项正规化为 { label, value, disabled }。
+* 默认键即为 label / value / options，既有调用无需改。
+*/
+function normalizeSelectOptions(options, fieldNames) {
+	const labelKey = fieldNames?.label ?? "label";
+	const valueKey = fieldNames?.value ?? "value";
+	const optionsKey = fieldNames?.options ?? "options";
+	const disabledKey = fieldNames?.disabled ?? "disabled";
+	const groupLabelKey = fieldNames?.groupLabel ?? labelKey;
+	const result = [];
+	for (const item of options) {
+		if (!item || typeof item !== "object") continue;
+		const raw = item;
+		const nested = raw[optionsKey];
+		if (Array.isArray(nested)) {
+			const children = [];
+			for (const child of nested) {
+				if (!child || typeof child !== "object") continue;
+				children.push(mapSelectOption(child, {
+					label: labelKey,
+					value: valueKey,
+					disabled: disabledKey
+				}));
+			}
+			result.push({
+				label: String(raw[groupLabelKey] ?? ""),
+				options: children
+			});
+			continue;
+		}
+		result.push(mapSelectOption(raw, {
+			label: labelKey,
+			value: valueKey,
+			disabled: disabledKey
+		}));
+	}
+	return result;
+}
+/** 触发器 / tag 展示文案，对齐 Ant optionLabelProp */
+function optionDisplayLabel(option, prop = "label") {
+	return optionFieldText(option, prop);
+}
+function comboboxBindingToTokens(value, multiple) {
+	if (multiple) return Array.isArray(value) ? value.map(String) : [];
+	if (value == null || value === "") return [];
+	return [String(value)];
+}
+function selectModelEntries(value) {
+	if (Array.isArray(value)) return value;
+	if (value === "" || value == null) return [];
+	return [value];
+}
+function filterSelectOptions(options, query, contains, filterOption, optionFilterProp = "label") {
+	if (filterOption === false) return options;
+	const trimmed = query.trim();
+	if (!trimmed) return options;
+	const match = typeof filterOption === "function" ? (opt) => filterOption(trimmed, opt) : (opt) => defaultMatchOption(opt, trimmed, contains, optionFilterProp);
+	const result = [];
+	for (const item of options) if (isSelectOptionGroup(item)) {
+		const filtered = item.options.filter(match);
+		if (filtered.length > 0) result.push({
+			label: item.label,
+			options: filtered
+		});
+	} else if (match(item)) result.push(item);
+	return result;
+}
+function flattenSelectValues(options) {
+	return flattenSelectOptions(options).map((opt) => toComboboxValue(opt.value));
+}
+function toSelectedTokens(value, multiple) {
+	const entries = multiple ? selectModelEntries(value) : Array.isArray(value) || value === "" || value == null ? [] : [value];
+	const tokens = [];
+	for (const entry of entries) {
+		const raw = unwrapSelectEntry(entry);
+		if (raw === null) continue;
+		tokens.push(toComboboxValue(raw));
+	}
+	return tokens;
+}
+function isSelectLabeledValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "value" in value;
+}
+function unwrapSelectEntry(item) {
+	if (item == null || item === "") return null;
+	if (isSelectLabeledValue(item)) return item.value;
+	if (typeof item === "string" || typeof item === "number") return item;
+	return null;
+}
+function toLabeledValue(value, options) {
+	const matched = flattenSelectOptions(options).find((opt) => String(opt.value) === String(value));
+	return {
+		value: matched ? matched.value : value,
+		label: matched?.label ?? String(value)
+	};
+}
+function packSelectModel(values, options, multiple, labelInValue) {
+	if (multiple) return labelInValue ? values.map((value) => toLabeledValue(value, options)) : values;
+	const first = values[0];
+	if (first === void 0) return "";
+	return labelInValue ? toLabeledValue(first, options) : first;
+}
+function sortSelectOptions(options, sort) {
+	if (!sort) return options;
+	const next = [];
+	const flats = [];
+	const flushFlats = () => {
+		if (!flats.length) return;
+		next.push(...[...flats].sort(sort));
+		flats.length = 0;
+	};
+	for (const item of options) if (isSelectOptionGroup(item)) {
+		flushFlats();
+		next.push({
+			label: item.label,
+			options: [...item.options].sort(sort)
+		});
+	} else flats.push(item);
+	flushFlats();
+	return next;
+}
+function splitByTokenSeparators(raw, separators) {
+	if (!separators.length) return null;
+	const found = separators.find((sep) => sep && raw.includes(sep));
+	if (!found) return null;
+	return raw.split(found);
+}
+//#endregion
+export { RS_SELECT_EMPTY_VALUE, buildOptionDisabledMap, buildOptionLabelMap, comboboxBindingToTokens, filterSelectOptions, findSelectOption, flattenSelectOptions, flattenSelectValues, fromComboboxValue, isSelectLabeledValue, isSelectOptionGroup, normalizeSelectOptions, optionDisplayLabel, packSelectModel, restoreSelectValue, restoreSelectValues, selectModelEntries, sortSelectOptions, splitByTokenSeparators, toComboboxValue, toLabeledValue, toSelectedTokens, unwrapSelectEntry };

package/dist/components/split-pane-utils.d.ts

@@ -0,0 +1,74 @@
+/** 面板分割方向：horizontal 左右排布（拖动横向）· vertical 上下排布（拖动纵向） */
+export type RsSplitOrientation = 'horizontal' | 'vertical';
+/** 面板尺寸：数字为占比百分比；'auto' 按内容自适应（不占百分比配额） */
+export type RsSplitPaneSize = number | 'auto';
+/** 单个面板定义；百分比尺寸单位为 0~100 */
+export interface RsSplitPaneItem {
+    /** 唯一标识，用于插槽名与 v-model:sizes 的顺序映射 */
+    key: string;
+    /**
+     * 初始尺寸
+     * - number：占比百分比
+     * - 'auto'：按内容自适应（flex-basis: auto）
+     * - 缺省：在「非 auto」面板的剩余百分比内均分
+     */
+    size?: RsSplitPaneSize;
+    /** 最小尺寸（百分比），默认 0；auto 面板可作为 min-height/min-width % */
+    min?: number;
+    /** 最大尺寸（百分比），默认 100；auto 面板可作为 max-height/max-width % */
+    max?: number;
+    /** 是否可折叠：拖动越过阈值时吸附到 collapsedSize */
+    collapsible?: boolean;
+    /** 折叠后的尺寸（百分比），默认 0；会被限制在 [0, min] */
+    collapsedSize?: number;
+    /** 本面板右侧分隔条是否显示抓手；缺省时继承 RsSplitPane.withHandle */
+    resizerHandle?: boolean;
+}
+/**
+ * RsSplitPane 模板 ref 请用此类型。
+ * 不要写 `InstanceType<typeof RsSplitPane>`：组件实例类型过深，vue-tsc 会报 Excessive stack depth。
+ */
+export interface RsSplitPaneExpose {
+    collapse: (key: string) => void;
+    expand: (key: string, toSize?: number) => void;
+    reset: () => void;
+    getSizes: () => number[];
+}
+/** 模板 ref 实例：expose + 根节点 */
+export type RsSplitPaneInstance = RsSplitPaneExpose & {
+    $el: HTMLElement;
+};
+/** 由 RsSplitPaneItem 解析出的规范化约束 */
+export interface RsSplitConstraint {
+    min: number;
+    max: number;
+    collapsible: boolean;
+    collapsedSize: number;
+}
+/** 保留有限位小数，消除浮点毛刺 */
+export declare function roundSize(value: number, precision?: number): number;
+/** 是否为内容自适应尺寸 */
+export declare function isRsSplitPaneAutoSize(size: RsSplitPaneSize | undefined): size is 'auto';
+/** 各面板是否声明为 auto（忽略受控 provided 时的瞬时物化） */
+export declare function resolveSplitAutoFlags(panes: RsSplitPaneItem[]): boolean[];
+/** 将面板定义解析为规范化约束，保证 0 ≤ min ≤ max ≤ 100 且 collapsedSize ≤ min */
+export declare function resolveSplitConstraints(panes: RsSplitPaneItem[]): RsSplitConstraint[];
+/**
+ * 计算初始尺寸数组（非 auto 面板总和 100；auto 位为 0 占位，样式层不使用 flex-grow）。
+ * 优先使用 provided（受控值），其次面板自身的 number size，未指定的非 auto 项在剩余空间内均分。
+ */
+export declare function normalizeSplitSizes(panes: RsSplitPaneItem[], provided?: number[] | null): number[];
+/** 判断某面板当前是否处于折叠态 */
+export declare function isSplitPaneCollapsed(size: number, constraint: RsSplitConstraint): boolean;
+/**
+ * 在第 index 个分隔条（介于 pane[index] 与 pane[index+1] 之间）上拖动 deltaPercent。
+ * 仅调整相邻两个面板，遵守各自 min/max，并在可折叠时吸附到 collapsedSize。
+ * 返回新的尺寸数组（引用不同，总和保持不变）。
+ */
+export declare function applySplitResize(sizes: number[], constraints: RsSplitConstraint[], index: number, deltaPercent: number): number[];
+/** 折叠 pane[index]（可折叠→collapsedSize，否则→min） */
+export declare function collapseSplitPane(sizes: number[], constraints: RsSplitConstraint[], index: number): number[];
+/** 展开 pane[index]（toSize 缺省时回到 min 或均分值），并夹紧到 [min, max] */
+export declare function expandSplitPane(sizes: number[], constraints: RsSplitConstraint[], index: number, toSize?: number): number[];
+/** 两组尺寸是否近似相等（用于受控回写时避免抖动） */
+export declare function splitSizesEqual(a: number[], b: number[], epsilon?: number): boolean;

package/dist/components/split-pane-utils.js

@@ -0,0 +1,135 @@
+//#region src/components/split-pane-utils.ts
+var clamp = (value, lower, upper) => Math.min(Math.max(value, lower), upper);
+/** 保留有限位小数，消除浮点毛刺 */
+function roundSize(value, precision = 4) {
+	const factor = 10 ** precision;
+	return Math.round(value * factor) / factor;
+}
+/** 是否为内容自适应尺寸 */
+function isRsSplitPaneAutoSize(size) {
+	return size === "auto";
+}
+/** 各面板是否声明为 auto（忽略受控 provided 时的瞬时物化） */
+function resolveSplitAutoFlags(panes) {
+	return panes.map((pane) => isRsSplitPaneAutoSize(pane.size));
+}
+/** 将面板定义解析为规范化约束，保证 0 ≤ min ≤ max ≤ 100 且 collapsedSize ≤ min */
+function resolveSplitConstraints(panes) {
+	return panes.map((pane) => {
+		const rawMin = clamp(pane.min ?? 0, 0, 100);
+		const rawMax = clamp(pane.max ?? 100, 0, 100);
+		const min = Math.min(rawMin, rawMax);
+		const max = Math.max(rawMin, rawMax);
+		const collapsedSize = clamp(pane.collapsedSize ?? 0, 0, min);
+		return {
+			min,
+			max,
+			collapsible: pane.collapsible ?? false,
+			collapsedSize
+		};
+	});
+}
+/** 按比例把一组尺寸缩放到总和为 100 */
+function rescaleTo100(sizes) {
+	if (!sizes.length) return [];
+	const sum = sizes.reduce((acc, value) => acc + Math.max(0, value), 0);
+	if (sum <= 0) {
+		const each = 100 / sizes.length;
+		return sizes.map(() => each);
+	}
+	return sizes.map((value) => Math.max(0, value) / sum * 100);
+}
+/**
+* 计算初始尺寸数组（非 auto 面板总和 100；auto 位为 0 占位，样式层不使用 flex-grow）。
+* 优先使用 provided（受控值），其次面板自身的 number size，未指定的非 auto 项在剩余空间内均分。
+*/
+function normalizeSplitSizes(panes, provided) {
+	const count = panes.length;
+	if (count === 0) return [];
+	const autoFlags = resolveSplitAutoFlags(panes);
+	if (Array.isArray(provided) && provided.length === count && provided.every((value) => typeof value === "number" && Number.isFinite(value))) return rescaleTo100(provided.map((value) => Math.max(0, value))).map((value) => roundSize(value));
+	const seed = panes.map((pane, index) => {
+		if (autoFlags[index]) return 0;
+		const candidate = provided?.[index] ?? (typeof pane.size === "number" ? pane.size : null);
+		return typeof candidate === "number" && Number.isFinite(candidate) ? Math.max(0, candidate) : null;
+	});
+	const flexibleIndices = panes.map((_, index) => index).filter((index) => !autoFlags[index]);
+	if (flexibleIndices.length === 0) return panes.map(() => 0);
+	const missing = flexibleIndices.filter((index) => seed[index] === null).length;
+	const knownSum = flexibleIndices.reduce((acc, index) => acc + (seed[index] ?? 0), 0);
+	const each = missing > 0 ? Math.max(0, 100 - knownSum) / missing : 0;
+	const filled = seed.map((value, index) => {
+		if (autoFlags[index]) return 0;
+		return value ?? each;
+	});
+	const scaledFlexible = rescaleTo100(flexibleIndices.map((index) => filled[index] ?? 0));
+	const next = filled.slice();
+	flexibleIndices.forEach((paneIndex, i) => {
+		next[paneIndex] = roundSize(scaledFlexible[i] ?? 0);
+	});
+	return next;
+}
+/** 判断某面板当前是否处于折叠态 */
+function isSplitPaneCollapsed(size, constraint) {
+	if (!constraint.collapsible) return false;
+	return size <= constraint.collapsedSize + .01;
+}
+/**
+* 在第 index 个分隔条（介于 pane[index] 与 pane[index+1] 之间）上拖动 deltaPercent。
+* 仅调整相邻两个面板，遵守各自 min/max，并在可折叠时吸附到 collapsedSize。
+* 返回新的尺寸数组（引用不同，总和保持不变）。
+*/
+function applySplitResize(sizes, constraints, index, deltaPercent) {
+	if (index < 0 || index >= sizes.length - 1) return sizes;
+	const a = sizes[index];
+	const b = sizes[index + 1];
+	const ca = constraints[index];
+	const cb = constraints[index + 1];
+	if (a === void 0 || b === void 0 || !ca || !cb) return sizes;
+	const total = a + b;
+	let nextA = a + deltaPercent;
+	if (ca.collapsible && deltaPercent < 0 && nextA < ca.min) nextA = nextA <= (ca.min + ca.collapsedSize) / 2 ? ca.collapsedSize : ca.min;
+	if (cb.collapsible && deltaPercent > 0) {
+		const nextB = total - nextA;
+		if (nextB < cb.min) nextA = total - (nextB <= (cb.min + cb.collapsedSize) / 2 ? cb.collapsedSize : cb.min);
+	}
+	const lowerA = Math.max(ca.collapsible ? ca.collapsedSize : ca.min, total - cb.max);
+	const upperA = Math.min(ca.max, total - (cb.collapsible ? cb.collapsedSize : cb.min));
+	nextA = clamp(nextA, Math.min(lowerA, upperA), Math.max(lowerA, upperA));
+	const next = sizes.slice();
+	next[index] = roundSize(nextA);
+	next[index + 1] = roundSize(total - nextA);
+	return next;
+}
+/** 把 pane[index] 设为 target，差额从相邻面板（优先右侧）补偿 */
+function redistribute(sizes, index, target) {
+	const current = sizes[index];
+	if (current === void 0) return sizes;
+	const neighbor = index + 1 < sizes.length ? index + 1 : index - 1;
+	if (neighbor < 0) return sizes;
+	const next = sizes.slice();
+	const delta = target - current;
+	next[index] = roundSize(target);
+	next[neighbor] = roundSize(Math.max(0, (next[neighbor] ?? 0) - delta));
+	return next;
+}
+/** 折叠 pane[index]（可折叠→collapsedSize，否则→min） */
+function collapseSplitPane(sizes, constraints, index) {
+	const constraint = constraints[index];
+	if (!constraint || sizes[index] === void 0) return sizes;
+	return redistribute(sizes, index, constraint.collapsible ? constraint.collapsedSize : constraint.min);
+}
+/** 展开 pane[index]（toSize 缺省时回到 min 或均分值），并夹紧到 [min, max] */
+function expandSplitPane(sizes, constraints, index, toSize) {
+	const constraint = constraints[index];
+	if (!constraint || sizes[index] === void 0) return sizes;
+	const fallback = constraint.min > 0 ? constraint.min : 100 / Math.max(1, sizes.length);
+	return redistribute(sizes, index, clamp(toSize ?? fallback, constraint.min, constraint.max));
+}
+/** 两组尺寸是否近似相等（用于受控回写时避免抖动） */
+function splitSizesEqual(a, b, epsilon = .01) {
+	if (a.length !== b.length) return false;
+	return a.every((value, index) => Math.abs(value - (b[index] ?? 0)) <= epsilon);
+}
+//#endregion
+export { applySplitResize, collapseSplitPane, expandSplitPane, isRsSplitPaneAutoSize, isSplitPaneCollapsed, normalizeSplitSizes, resolveSplitAutoFlags, resolveSplitConstraints, roundSize, splitSizesEqual };

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

@@ -0,0 +1,12 @@
+export type RsStepStatus = 'wait' | 'process' | 'finish' | 'error';
+export type RsStepsOrientation = 'horizontal' | 'vertical';
+export type RsStepsSize = 'sm' | 'md';
+export interface RsStepItem {
+    value: string;
+    title: string;
+    description?: string;
+    status?: RsStepStatus;
+    disabled?: boolean;
+}
+export declare function resolveStepStatus(index: number, activeIndex: number, explicit?: RsStepStatus): RsStepStatus;
+export declare function isStepSeparatorCompleted(status: RsStepStatus): boolean;

package/dist/components/steps-utils.js

@@ -0,0 +1,12 @@
+//#region src/components/steps-utils.ts
+function resolveStepStatus(index, activeIndex, explicit) {
+	if (explicit) return explicit;
+	if (index < activeIndex) return "finish";
+	if (index === activeIndex) return "process";
+	return "wait";
+}
+function isStepSeparatorCompleted(status) {
+	return status === "finish";
+}
+//#endregion
+export { isStepSeparatorCompleted, resolveStepStatus };

package/dist/components/table/RsTableBody.d.ts

@@ -0,0 +1,47 @@
+declare const __VLS_export: <T extends import("../table-utils").RsTableRowData = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: {
+            row: T;
+            column: import("../table-utils").RsTableColumn<T>;
+            index: number;
+        }) => any) | undefined;
+    } & {
+        [x: `edit-${string}`]: ((props: {
+            draft: string;
+            row: T;
+            column: import("../table-utils").RsTableColumn<T>;
+            index: number;
+            error: string | null;
+            update: (value: string) => void;
+            commit: () => void;
+            cancel: () => void;
+        }) => any) | undefined;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        group?: (props: {
+            key: string;
+            label: string;
+        }) => any;
+    } & {
+        expand?: (props: {
+            row: T;
+            index: number;
+        }) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};