niuma-ui 1.1.12 → 1.2.0

package/dist/components/upload-utils.js

@@ -0,0 +1,177 @@
+//#region src/components/upload-utils.ts
+function formatFileSize(size) {
+	if (size < 1024) return `${size} B`;
+	if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KB`;
+	return `${(size / 1024 / 1024).toFixed(1)} MB`;
+}
+function isFileAccepted(file, accept) {
+	if (!accept) return true;
+	return accept.split(",").map((item) => item.trim()).filter(Boolean).some((rule) => {
+		if (rule.startsWith(".")) return file.name.toLowerCase().endsWith(rule.toLowerCase());
+		if (rule.endsWith("/*")) return file.type.startsWith(rule.slice(0, -1));
+		return file.type === rule;
+	});
+}
+function validateUploadFiles(files, rules = {}) {
+	const accepted = [];
+	const rejected = [];
+	for (const file of files) if (rules.maxCount && accepted.length >= rules.maxCount) rejected.push({
+		file,
+		reason: "maxCount"
+	});
+	else if (!isFileAccepted(file, rules.accept)) rejected.push({
+		file,
+		reason: "accept"
+	});
+	else if (rules.maxSize && file.size > rules.maxSize) rejected.push({
+		file,
+		reason: "maxSize"
+	});
+	else accepted.push(file);
+	return {
+		accepted,
+		rejected
+	};
+}
+function mergeUploadFiles(current, next, maxCount) {
+	const merged = [...current, ...next];
+	return maxCount ? merged.slice(0, maxCount) : merged;
+}
+function removeUploadFileAt(files, index) {
+	return files.filter((_, currentIndex) => currentIndex !== index);
+}
+/** 触发浏览器下载指定 File / Blob */
+function downloadUploadFile(file, filename) {
+	const name = filename || (file instanceof File ? file.name : "download");
+	const url = URL.createObjectURL(file);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = name;
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+	URL.revokeObjectURL(url);
+}
+/** 将文本等内容还原为可回显的 File（编辑态回填） */
+function createUploadFileFromContent(name, content, type = "application/octet-stream") {
+	return new File([content], name, { type });
+}
+/** 扩展名 → Lucide 图标名（kebab-case） */
+var UPLOAD_EXT_ICON = {
+	pem: "file-key",
+	crt: "file-key",
+	cer: "file-key",
+	key: "key-round",
+	p12: "file-lock",
+	pfx: "file-lock",
+	txt: "file-text",
+	md: "file-text",
+	markdown: "file-text",
+	log: "file-text",
+	pdf: "file-type",
+	doc: "file-text",
+	docx: "file-text",
+	rtf: "file-text",
+	csv: "file-spreadsheet",
+	xls: "file-spreadsheet",
+	xlsx: "file-spreadsheet",
+	json: "file-braces",
+	yaml: "file-code",
+	yml: "file-code",
+	xml: "file-code",
+	html: "file-code",
+	htm: "file-code",
+	css: "file-code",
+	scss: "file-code",
+	js: "file-code",
+	mjs: "file-code",
+	cjs: "file-code",
+	ts: "file-code",
+	tsx: "file-code",
+	jsx: "file-code",
+	vue: "file-code",
+	go: "file-code",
+	py: "file-code",
+	java: "file-code",
+	rs: "file-code",
+	sql: "file-terminal",
+	sh: "file-terminal",
+	bat: "file-terminal",
+	ps1: "file-terminal",
+	png: "file-image",
+	jpg: "file-image",
+	jpeg: "file-image",
+	gif: "file-image",
+	webp: "file-image",
+	svg: "file-image",
+	bmp: "file-image",
+	ico: "file-image",
+	mp3: "file-music",
+	wav: "file-music",
+	flac: "file-music",
+	aac: "file-music",
+	mp4: "file-video-camera",
+	webm: "file-video-camera",
+	mov: "file-video-camera",
+	avi: "file-video-camera",
+	zip: "file-archive",
+	rar: "file-archive",
+	"7z": "file-archive",
+	tar: "file-archive",
+	gz: "file-archive",
+	tgz: "file-archive"
+};
+/** MIME 前缀 → Lucide 图标名（扩展名未知时回退） */
+var UPLOAD_MIME_ICON = [
+	{
+		prefix: "image/",
+		icon: "file-image"
+	},
+	{
+		prefix: "audio/",
+		icon: "file-music"
+	},
+	{
+		prefix: "video/",
+		icon: "file-video-camera"
+	},
+	{
+		prefix: "text/",
+		icon: "file-text"
+	},
+	{
+		prefix: "application/pdf",
+		icon: "file-type"
+	},
+	{
+		prefix: "application/json",
+		icon: "file-braces"
+	},
+	{
+		prefix: "application/zip",
+		icon: "file-archive"
+	},
+	{
+		prefix: "application/x-tar",
+		icon: "file-archive"
+	},
+	{
+		prefix: "application/gzip",
+		icon: "file-archive"
+	}
+];
+/**
+* 按文件名扩展名 / MIME 解析列表图标（Lucide kebab-case）。
+* 未匹配时返回 `file`。
+*/
+function resolveUploadFileIcon(file) {
+	const name = typeof file === "string" ? file : file.name;
+	const mime = typeof file === "string" ? "" : file.type || "";
+	const ext = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
+	if (ext && UPLOAD_EXT_ICON[ext]) return UPLOAD_EXT_ICON[ext];
+	const byMime = UPLOAD_MIME_ICON.find((item) => mime.startsWith(item.prefix));
+	if (byMime) return byMime.icon;
+	return "file";
+}
+//#endregion
+export { createUploadFileFromContent, downloadUploadFile, formatFileSize, isFileAccepted, mergeUploadFiles, removeUploadFileAt, resolveUploadFileIcon, validateUploadFiles };

package/dist/components/use-rs-select.d.ts

@@ -0,0 +1,78 @@
+import { type ModelRef } from 'vue';
+import type { RsTranslateFn } from '../composables/useRsI18n';
+import { type RsSelectFieldNames, type RsSelectFilterOption, type RsSelectFilterSort, type RsSelectModelValue, type RsSelectOption, type RsSelectOptionFilterProp, type RsSelectOptionsInput, type RsSelectValue } from './select-utils';
+/** RsSelect 行为层入参（不含尺寸 / 表单外观） */
+export interface RsSelectEngineProps {
+    options: RsSelectOptionsInput;
+    fieldNames?: RsSelectFieldNames;
+    optionLabelProp?: string;
+    optionFilterProp?: RsSelectOptionFilterProp;
+    filterOption?: RsSelectFilterOption | boolean;
+    filterSort?: RsSelectFilterSort;
+    searchable?: boolean;
+    creatable?: boolean;
+    multiple?: boolean;
+    remote?: boolean;
+    virtual?: boolean;
+    virtualThreshold?: number;
+    maxTagCount?: number;
+    maxTagPlaceholder?: string | ((omitted: number) => string);
+    maxTagTooltip?: boolean;
+    maxTagTextLength?: number;
+    multipleLimit?: number;
+    labelInValue?: boolean;
+    tokenSeparators?: string[];
+    autoClearSearchValue?: boolean;
+    /** 打开下拉时把当前选中值写入搜索框；默认不回填 */
+    fillSearchWithValue?: boolean;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    loadingText?: string;
+    placeholder?: string;
+}
+export type RsSelectEngineEmit = {
+    (e: 'search', query: string): void;
+    (e: 'select', value: RsSelectValue, option?: RsSelectOption): void;
+    (e: 'deselect', value: RsSelectValue, option?: RsSelectOption): void;
+    (e: 'clear'): void;
+};
+/**
+ * Select 过滤、选中、多选 tag、creatable / 分隔符提交。
+ * 组件模板只消费返回值；表单校验仍留在 SFC。
+ */
+export declare function useRsSelect(props: RsSelectEngineProps, model: ModelRef<RsSelectModelValue>, open: ModelRef<boolean>, searchQuery: ModelRef<string>, emit: RsSelectEngineEmit, t: RsTranslateFn): {
+    normalizedOptions: import("vue").ComputedRef<import("./select-utils").RsSelectOptions>;
+    resolvedPlaceholder: import("vue").ComputedRef<string>;
+    resolvedSearchPlaceholder: import("vue").ComputedRef<string>;
+    resolvedEmptyText: import("vue").ComputedRef<string>;
+    resolvedLoadingText: import("vue").ComputedRef<string>;
+    isSearchable: import("vue").ComputedRef<boolean>;
+    labelMap: import("vue").ComputedRef<Map<string, string>>;
+    useVirtual: import("vue").ComputedRef<boolean>;
+    useManualFilter: import("vue").ComputedRef<boolean>;
+    displayOptions: import("vue").ComputedRef<import("./select-utils").RsSelectOptions>;
+    createValue: import("vue").ComputedRef<string>;
+    canCreate: import("vue").ComputedRef<boolean>;
+    createOptionLabel: import("vue").ComputedRef<string>;
+    virtualValues: import("vue").ComputedRef<string[]>;
+    selectedValues: import("vue").ComputedRef<string[]>;
+    hasValue: import("vue").ComputedRef<boolean>;
+    visibleTagTokens: import("vue").ComputedRef<string[]>;
+    omittedTagCount: import("vue").ComputedRef<number>;
+    omittedTagLabel: import("vue").ComputedRef<string>;
+    omittedTagTitle: import("vue").ComputedRef<string>;
+    singleDisplayLabel: import("vue").ComputedRef<string>;
+    comboboxModel: import("vue").WritableComputedRef<string | string[] | undefined, string | string[] | undefined>;
+    tokenLabel: (token: string) => string;
+    truncateTagLabel: (label: string) => string;
+    optionFromToken: (token: string) => RsSelectOption | undefined;
+    optionOrCreate: (token: string) => RsSelectOption;
+    isOptionLimited: (option: RsSelectOption) => boolean;
+    isTokenDisabled: (token: string) => boolean;
+    restoreTokenValue: (token: string) => RsSelectValue;
+    onSearchKeydown: (event: KeyboardEvent) => void;
+    onClear: (event: MouseEvent) => void;
+    removeTag: (value: string, event: MouseEvent) => void;
+    setValue: (value: unknown) => void;
+    resetSearch: () => void;
+};

package/dist/components/use-rs-select.js

@@ -0,0 +1,266 @@
+import { useFilter } from "./reka.js";
+import { buildOptionDisabledMap, buildOptionLabelMap, comboboxBindingToTokens, filterSelectOptions, findSelectOption, flattenSelectOptions, flattenSelectValues, fromComboboxValue, isSelectLabeledValue, normalizeSelectOptions, optionDisplayLabel, packSelectModel, restoreSelectValue, restoreSelectValues, selectModelEntries, sortSelectOptions, splitByTokenSeparators, toComboboxValue, toSelectedTokens } from "./select-utils.js";
+import { computed, nextTick, watch } from "vue";
+//#region src/components/use-rs-select.ts
+/**
+* Select 过滤、选中、多选 tag、creatable / 分隔符提交。
+* 组件模板只消费返回值；表单校验仍留在 SFC。
+*/
+function useRsSelect(props, model, open, searchQuery, emit, t) {
+	const { contains } = useFilter({ sensitivity: "base" });
+	const normalizedOptions = computed(() => normalizeSelectOptions(props.options, props.fieldNames));
+	const resolvedPlaceholder = computed(() => props.placeholder ?? t("select.placeholder"));
+	const resolvedSearchPlaceholder = computed(() => props.searchPlaceholder ?? t("select.searchPlaceholder"));
+	const resolvedEmptyText = computed(() => props.emptyText ?? t("select.empty"));
+	const resolvedLoadingText = computed(() => props.loadingText ?? t("select.loading"));
+	const isSearchable = computed(() => Boolean(props.searchable || props.creatable));
+	const labelMap = computed(() => buildOptionLabelMap(normalizedOptions.value));
+	const disabledMap = computed(() => buildOptionDisabledMap(normalizedOptions.value));
+	const flatOptions = computed(() => flattenSelectOptions(normalizedOptions.value));
+	const flatCount = computed(() => flatOptions.value.length);
+	const useVirtual = computed(() => Boolean(props.virtual) || flatCount.value > (props.virtualThreshold ?? 50));
+	/**
+	* 可搜索时一律走本地过滤，并关掉 Reka 内置 filter。
+	* Reka 的 filterSearch 与搜索框 searchQuery 不同步（打开时会被清空），
+	* 默认依赖内置过滤时会出现：手输「NVA」已出「使用 NVA」，但 NVARCHAR 仍被整表挡住。
+	*/
+	const useManualFilter = computed(() => Boolean(props.remote) || useVirtual.value || isSearchable.value || typeof props.filterOption === "function" || props.filterOption === false || Boolean(props.optionFilterProp && props.optionFilterProp !== "label") || Boolean(props.filterSort) || Boolean(props.fieldNames));
+	const displayOptions = computed(() => {
+		let next = normalizedOptions.value;
+		if (!props.remote && props.filterOption !== false) {
+			if (useManualFilter.value || props.filterOption) next = filterSelectOptions(normalizedOptions.value, searchQuery.value, contains, props.filterOption, props.optionFilterProp);
+		}
+		return sortSelectOptions(next, props.filterSort);
+	});
+	const createValue = computed(() => searchQuery.value.trim());
+	const canCreate = computed(() => {
+		if (!props.creatable) return false;
+		const q = createValue.value;
+		if (!q) return false;
+		const lower = q.toLowerCase();
+		return !flatOptions.value.some((opt) => String(opt.value).toLowerCase() === lower || String(opt.label).toLowerCase() === lower);
+	});
+	const createOptionLabel = computed(() => t("select.createOption", "使用 “{query}”").replace("{query}", createValue.value));
+	const virtualValues = computed(() => {
+		const values = flattenSelectValues(displayOptions.value);
+		if (!canCreate.value) return values;
+		return [createValue.value, ...values.filter((item) => String(item) !== createValue.value)];
+	});
+	const selectedValues = computed(() => toSelectedTokens(model.value, Boolean(props.multiple)));
+	const hasValue = computed(() => selectedValues.value.length > 0);
+	const visibleTagTokens = computed(() => {
+		const all = selectedValues.value;
+		if (!props.multiple || props.maxTagCount == null || all.length <= props.maxTagCount) return all;
+		return all.slice(0, Math.max(0, props.maxTagCount));
+	});
+	const omittedTagCount = computed(() => Math.max(0, selectedValues.value.length - visibleTagTokens.value.length));
+	const omittedTagLabel = computed(() => {
+		const count = omittedTagCount.value;
+		if (typeof props.maxTagPlaceholder === "function") return props.maxTagPlaceholder(count);
+		if (props.maxTagPlaceholder) return props.maxTagPlaceholder;
+		return t("select.maxTagPlaceholder", { count });
+	});
+	function optionFromToken(token) {
+		return findSelectOption(normalizedOptions.value, String(token));
+	}
+	function tokenLabel(token) {
+		if (props.labelInValue) {
+			for (const entry of selectModelEntries(model.value)) if (isSelectLabeledValue(entry) && toComboboxValue(entry.value) === token && entry.label) return entry.label;
+		}
+		const option = optionFromToken(token);
+		if (option) return optionDisplayLabel(option, props.optionLabelProp);
+		return labelMap.value.get(token) ?? fromComboboxValue(token);
+	}
+	const omittedTagTitle = computed(() => {
+		if (!props.maxTagTooltip) return omittedTagLabel.value;
+		const omitted = selectedValues.value.slice(visibleTagTokens.value.length);
+		if (!omitted.length) return omittedTagLabel.value;
+		return omitted.map((token) => tokenLabel(token)).join("、");
+	});
+	function truncateTagLabel(label) {
+		const max = props.maxTagTextLength;
+		if (!max || max < 1 || label.length <= max) return label;
+		return `${label.slice(0, max)}…`;
+	}
+	const atMultipleLimit = computed(() => Boolean(props.multiple) && props.multipleLimit != null && props.multipleLimit > 0 && selectedValues.value.length >= props.multipleLimit);
+	function isOptionLimited(option) {
+		if (!atMultipleLimit.value) return false;
+		return !selectedValues.value.includes(toComboboxValue(option.value));
+	}
+	function isTokenDisabled(token) {
+		if (disabledMap.value.get(String(token))) return true;
+		const option = optionFromToken(token);
+		return option ? isOptionLimited(option) : false;
+	}
+	const singleDisplayLabel = computed(() => {
+		if (props.multiple || !hasValue.value) return "";
+		return tokenLabel(selectedValues.value[0]);
+	});
+	function writeTokens(tokens) {
+		model.value = packSelectModel(restoreSelectValues(tokens, normalizedOptions.value), normalizedOptions.value, Boolean(props.multiple), Boolean(props.labelInValue));
+	}
+	function emitSelectionDiff(prev, next) {
+		const prevSet = new Set(prev);
+		const nextSet = new Set(next);
+		for (const token of next) {
+			if (prevSet.has(token)) continue;
+			emit("select", restoreSelectValue(token, normalizedOptions.value), findSelectOption(normalizedOptions.value, token));
+		}
+		for (const token of prev) {
+			if (nextSet.has(token)) continue;
+			emit("deselect", restoreSelectValue(token, normalizedOptions.value), findSelectOption(normalizedOptions.value, token));
+		}
+	}
+	const comboboxModel = computed({
+		get() {
+			if (props.multiple) return selectedValues.value.map((token) => token);
+			return hasValue.value ? selectedValues.value[0] : void 0;
+		},
+		set(value) {
+			const prev = selectedValues.value;
+			const tokens = comboboxBindingToTokens(value, Boolean(props.multiple));
+			emitSelectionDiff(prev, tokens);
+			writeTokens(tokens);
+			if (props.autoClearSearchValue) searchQuery.value = "";
+		}
+	});
+	function currentValues() {
+		return restoreSelectValues(selectedValues.value, normalizedOptions.value);
+	}
+	function commitCreatedValue(value) {
+		const next = value.trim();
+		if (!next) return;
+		const values = currentValues();
+		if (values.some((item) => String(item) === next)) return;
+		if (props.multiple) {
+			if (atMultipleLimit.value) return;
+			const prev = selectedValues.value;
+			const packed = packSelectModel([...values, next], normalizedOptions.value, true, Boolean(props.labelInValue));
+			model.value = packed;
+			emitSelectionDiff(prev, toSelectedTokens(packed, true));
+		} else {
+			const prev = selectedValues.value;
+			model.value = packSelectModel([next], normalizedOptions.value, false, Boolean(props.labelInValue));
+			emitSelectionDiff(prev, toSelectedTokens(model.value, false));
+			open.value = false;
+		}
+		if (props.autoClearSearchValue) searchQuery.value = "";
+	}
+	function consumeTokenSeparators(raw) {
+		if (!props.multiple && !props.creatable) return;
+		const parts = splitByTokenSeparators(raw, props.tokenSeparators ?? []);
+		if (!parts) return;
+		const rest = parts.pop() ?? "";
+		for (const part of parts) {
+			const token = part.trim();
+			if (!token) continue;
+			const matched = flatOptions.value.find((opt) => String(opt.value) === token || String(opt.label) === token);
+			if (matched) {
+				const prev = selectedValues.value;
+				const key = toComboboxValue(matched.value);
+				if (prev.includes(key)) continue;
+				if (props.multiple && atMultipleLimit.value) continue;
+				const nextTokens = props.multiple ? [...prev, key] : [key];
+				emitSelectionDiff(prev, nextTokens);
+				writeTokens(nextTokens);
+				if (!props.multiple) open.value = false;
+			} else if (props.creatable) commitCreatedValue(token);
+		}
+		if (rest !== raw) searchQuery.value = rest;
+	}
+	watch(searchQuery, (query) => {
+		if (props.remote) emit("search", query);
+		if (props.tokenSeparators?.length) consumeTokenSeparators(query);
+	});
+	watch(open, async (isOpen) => {
+		if (isOpen) {
+			const pending = searchQuery.value;
+			await nextTick();
+			await nextTick();
+			if (pending) searchQuery.value = pending;
+			else if (props.fillSearchWithValue && !props.multiple && hasValue.value) searchQuery.value = singleDisplayLabel.value;
+			else searchQuery.value = "";
+			return;
+		}
+		if (props.autoClearSearchValue) searchQuery.value = "";
+	});
+	function onSearchKeydown(event) {
+		if (event.key !== "Enter" || event.isComposing) return;
+		if (!canCreate.value) return;
+		event.preventDefault();
+		event.stopPropagation();
+		commitCreatedValue(createValue.value);
+	}
+	function onClear(event) {
+		event.preventDefault();
+		event.stopPropagation();
+		emitSelectionDiff(selectedValues.value, []);
+		emit("clear");
+		model.value = props.multiple ? [] : "";
+	}
+	function removeTag(value, event) {
+		event.preventDefault();
+		event.stopPropagation();
+		if (!props.multiple) return;
+		const prev = selectedValues.value;
+		const tokens = prev.filter((item) => item !== value);
+		emitSelectionDiff(prev, tokens);
+		writeTokens(tokens);
+	}
+	function setValue(value) {
+		if (props.multiple) {
+			writeTokens(toSelectedTokens(Array.isArray(value) ? value : value !== "" && value != null ? [value] : [], true));
+			return;
+		}
+		writeTokens(toSelectedTokens(value, false));
+	}
+	function restoreTokenValue(token) {
+		return restoreSelectValue(token, normalizedOptions.value);
+	}
+	function optionOrCreate(token) {
+		return optionFromToken(token) ?? {
+			label: fromComboboxValue(token),
+			value: restoreTokenValue(token)
+		};
+	}
+	return {
+		normalizedOptions,
+		resolvedPlaceholder,
+		resolvedSearchPlaceholder,
+		resolvedEmptyText,
+		resolvedLoadingText,
+		isSearchable,
+		labelMap,
+		useVirtual,
+		useManualFilter,
+		displayOptions,
+		createValue,
+		canCreate,
+		createOptionLabel,
+		virtualValues,
+		selectedValues,
+		hasValue,
+		visibleTagTokens,
+		omittedTagCount,
+		omittedTagLabel,
+		omittedTagTitle,
+		singleDisplayLabel,
+		comboboxModel,
+		tokenLabel,
+		truncateTagLabel,
+		optionFromToken,
+		optionOrCreate,
+		isOptionLimited,
+		isTokenDisabled,
+		restoreTokenValue,
+		onSearchKeydown,
+		onClear,
+		removeTag,
+		setValue,
+		resetSearch: () => {
+			searchQuery.value = "";
+		}
+	};
+}
+//#endregion
+export { useRsSelect };

package/dist/components/virtual-list-utils.d.ts

@@ -0,0 +1,7 @@
+export type RsVirtualListItemSize = number | ((index: number) => number);
+export declare function resolveItemSize(itemSize: RsVirtualListItemSize, index?: number): number;
+export declare function resolveVirtualListHeight(height?: number | string, fallback?: number): string | undefined;
+/** height 为 0 / 百分比时由父级撑满，组件内用 ResizeObserver 测量可视高度 */
+export declare function isVirtualListFillHeight(height?: number | string): boolean;
+/** 解析虚拟列表数值视口高度；百分比 / 填满模式返回 null，交由测量值处理 */
+export declare function parseVirtualListHeightPx(height?: number | string): number | null;

package/dist/components/virtual-list-utils.js

@@ -0,0 +1,28 @@
+//#region src/components/virtual-list-utils.ts
+function resolveItemSize(itemSize, index = 0) {
+	const size = typeof itemSize === "function" ? itemSize(index) : itemSize;
+	return Number.isFinite(size) && size > 0 ? size : 32;
+}
+function resolveVirtualListHeight(height, fallback = 240) {
+	if (height === 0) return void 0;
+	if (height === void 0) return `${fallback}px`;
+	return typeof height === "number" ? `${height}px` : height;
+}
+/** height 为 0 / 百分比时由父级撑满，组件内用 ResizeObserver 测量可视高度 */
+function isVirtualListFillHeight(height) {
+	if (height === 0) return true;
+	if (typeof height === "string" && height.trim().endsWith("%")) return true;
+	return false;
+}
+/** 解析虚拟列表数值视口高度；百分比 / 填满模式返回 null，交由测量值处理 */
+function parseVirtualListHeightPx(height) {
+	if (typeof height === "number" && height > 0) return height;
+	if (typeof height === "string") {
+		if (height.includes("%")) return null;
+		const parsed = Number.parseInt(height, 10);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return null;
+}
+//#endregion
+export { isVirtualListFillHeight, parseVirtualListHeightPx, resolveItemSize, resolveVirtualListHeight };

package/dist/composables/assembleRsTableApi.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 装配 RsTable 公开 Api（从 SFC 下沉，单一出口）。
+ */
+import type { ComputedRef, Ref } from 'vue';
+import type { RsTableApi } from '../components/table/rs-table-api';
+import type { RsTableRowData, RsTableRowEntry } from '../components/table-utils';
+import type { RsTableAnalyticsSnapshot } from './useRsTableSelectionSource';
+import type { useRsTable } from './useRsTable';
+type RowEntry<T extends RsTableRowData> = Extract<RsTableRowEntry<T>, {
+    type: 'row';
+}>;
+export interface AssembleRsTableApiOptions<T extends RsTableRowData> {
+    tableSurface: ReturnType<typeof useRsTable<T>>;
+    dataRows: Ref<RowEntry<T>[]> | ComputedRef<RowEntry<T>[]>;
+    rowKeyByIndex: Ref<Map<number, string>> | ComputedRef<Map<number, string>>;
+    viewRows: Ref<T[]> | ComputedRef<T[]>;
+    selectedRows: Ref<T[]> | ComputedRef<T[]>;
+    selectedRowKeys: Ref<string[]> | ComputedRef<string[]>;
+    getAnalyticsSnapshot: () => RsTableAnalyticsSnapshot<T>;
+    subscribeAnalytics: (listener: (snap: RsTableAnalyticsSnapshot<T>) => void) => () => void;
+    getRowByKey: (rowKey: string, dataRows: RowEntry<T>[], rowKeyByIndex: Map<number, string>) => T | undefined;
+    getRowByIndex: (index: number, dataRows: RowEntry<T>[]) => T | undefined;
+    getColumnValues: (colKey: string, dataRows: RowEntry<T>[]) => unknown[];
+    getCellValue: (rowKey: string, colKey: string, dataRows: RowEntry<T>[], rowKeyByIndex: Map<number, string>) => unknown;
+    toApiEditSlice: (ctx: {
+        dataRows: Ref<RowEntry<T>[]> | ComputedRef<RowEntry<T>[]>;
+        rowKeyByIndex: Ref<Map<number, string>> | ComputedRef<Map<number, string>>;
+    }) => Pick<RsTableApi<T>, 'getHighlightedRowKey' | 'setHighlightedRowKey' | 'cancelCellEdit' | 'cancelAllEdits' | 'getDirtyCellKeys' | 'getCellError' | 'setCellError' | 'stageCell' | 'rejectRowEdit' | 'undoEdit' | 'redoEdit' | 'commitRowEdits' | 'rollbackRowEdits'>;
+}
+/**
+ * 创建并返回 RsTableApi（含 feature 元数据）。
+ */
+export declare function assembleRsTableApi<T extends RsTableRowData>(options: AssembleRsTableApiOptions<T>): RsTableApi<T>;
+export {};

package/dist/composables/assembleRsTableApi.js

@@ -0,0 +1,26 @@
+//#region src/composables/assembleRsTableApi.ts
+/**
+* 创建并返回 RsTableApi（含 feature 元数据）。
+*/
+function assembleRsTableApi(options) {
+	const { tableSurface, dataRows, rowKeyByIndex } = options;
+	return tableSurface.createApi({
+		getRowByKey: (rowKey) => options.getRowByKey(rowKey, dataRows.value, rowKeyByIndex.value),
+		getRowByIndex: (index) => options.getRowByIndex(index, dataRows.value),
+		getColumnValues: (colKey) => options.getColumnValues(colKey, dataRows.value),
+		getCellValue: (rowKey, colKey) => options.getCellValue(rowKey, colKey, dataRows.value, rowKeyByIndex.value),
+		getViewRows: () => options.viewRows.value,
+		getSelectedRows: () => options.selectedRows.value,
+		getSelectedRowKeys: () => [...options.selectedRowKeys.value],
+		getAnalyticsSnapshot: options.getAnalyticsSnapshot,
+		subscribeAnalytics: options.subscribeAnalytics,
+		...options.toApiEditSlice({
+			dataRows,
+			rowKeyByIndex
+		}),
+		getToolbarItems: () => tableSurface.getToolbarItems(),
+		getOverlayContributions: () => tableSurface.getOverlayContributions()
+	});
+}
+//#endregion
+export { assembleRsTableApi };