ensis-ui 0.0.0-stage → 3.0.0

package/dist/components/table/src/composables/useRsTableColumns.d.ts

@@ -0,0 +1,70 @@
+/**
+ * RsTable 列模型编排：顺序、列筛选、宽度与 displayColumns。
+ *
+ * 从 RsTable.vue 抽离，保持受控 / 非受控 API 与原先行为一致。
+ * 不负责虚拟列切片、列拖拽排序的 DOM 交互（仍由 RsTable 编排）。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import { type RsTableColumn, type RsTableRowData } from '../utils/table-utils';
+/** 列相关事件（与 RsTable emit 子集对齐） */
+export interface UseRsTableColumnsEmit {
+    (e: 'update:columnOrder', value: string[]): void;
+    (e: 'columnOrderChange', value: string[]): void;
+    (e: 'update:columnFilters', value: Record<string, string>): void;
+    (e: 'columnFiltersChange', value: Record<string, string>): void;
+}
+/**
+ * useRsTableColumns 入参。
+ * 多数字段支持 ComputedRef 或 getter，便于在 RsTable 内直接绑定 props。
+ */
+export interface UseRsTableColumnsOptions<T extends RsTableRowData> {
+    /** 原始列定义（未排序） */
+    columns: ComputedRef<RsTableColumn<T>[]> | (() => RsTableColumn<T>[]);
+    /** 受控列顺序；undefined 表示非受控 */
+    columnOrder: ComputedRef<string[] | undefined> | (() => string[] | undefined);
+    /** 非受控初始列顺序 */
+    defaultColumnOrder: string[];
+    /** 受控列筛选；undefined 表示非受控 */
+    columnFilters: ComputedRef<Record<string, string> | undefined> | (() => Record<string, string> | undefined);
+    /** 非受控初始列筛选 */
+    defaultColumnFilters: Record<string, string>;
+    /** 初始列宽（像素） */
+    initialColumnWidths: ComputedRef<Record<string, number> | undefined> | (() => Record<string, number> | undefined);
+    /** 是否允许拖拽改列宽 */
+    resizable: ComputedRef<boolean> | (() => boolean);
+    /** 列布局：auto 自适应；fixed 固定表布局 */
+    columnLayout: ComputedRef<'auto' | 'fixed'> | (() => 'auto' | 'fixed');
+    /** 是否树表（影响展开列固定） */
+    treeMode: ComputedRef<boolean> | (() => boolean);
+    /** 树表是否固定展开列到左侧 */
+    treeFixExpandColumn: ComputedRef<boolean> | (() => boolean);
+    /** 树表展开列 key */
+    treeExpandColumnKey: ComputedRef<string | null> | (() => string | null);
+    emit: UseRsTableColumnsEmit;
+}
+/**
+ * 列顺序 / 列筛选 / 列宽 / displayColumns。
+ *
+ * @returns
+ * - `columnOrderState` / `columnFiltersState`：受控或非受控读写
+ * - `displayColumns`：按顺序排列；树表可将展开列钉为 fixed-left
+ * - `resolvedColumnWidths` / `useStableColumnWidths`：拖拽列宽与稳定布局判定
+ * - `updateColumnFilter` / `columnFilterValue`：表头筛选写入与读取
+ */
+export declare function useRsTableColumns<T extends RsTableRowData>(options: UseRsTableColumnsOptions<T>): {
+    internalColumnOrder: Ref<string[], string[]>;
+    internalColumnFilters: Ref<Record<string, string>, Record<string, string>>;
+    internalColumnWidths: Ref<Record<string, number>, Record<string, number>>;
+    isColumnOrderControlled: ComputedRef<boolean>;
+    columnOrderState: import("vue").WritableComputedRef<string[], string[]>;
+    isColumnFiltersControlled: ComputedRef<boolean>;
+    columnFiltersState: ComputedRef<Record<string, string>>;
+    displayColumns: ComputedRef<RsTableColumn<T>[]>;
+    resolvedColumnWidths: import("vue").WritableComputedRef<Record<string, number>, Record<string, number>>;
+    useStableColumnWidths: ComputedRef<boolean>;
+    syncInternalColumnWidths: (columns: RsTableColumn<T>[]) => void;
+    updateColumnFilter: (key: string, value: string) => void;
+    columnFilterValue: (key: string) => string;
+};
+/** useRsTableColumns 返回值类型 */
+export type RsTableColumnsApi<T extends RsTableRowData> = ReturnType<typeof useRsTableColumns<T>>;

package/dist/components/table/src/composables/useRsTableColumns.js

@@ -0,0 +1,132 @@
+import { createInitialColumnWidths, resolveColumnOrder, resolveOrderedColumns } from "../utils/table-utils.js";
+import { computed, ref, watch } from "vue";
+//#region src/components/table/src/composables/useRsTableColumns.ts
+/**
+* RsTable 列模型编排：顺序、列筛选、宽度与 displayColumns。
+*
+* 从 RsTable.vue 抽离，保持受控 / 非受控 API 与原先行为一致。
+* 不负责虚拟列切片、列拖拽排序的 DOM 交互（仍由 RsTable 编排）。
+*/
+/** 统一读取 ComputedRef / getter */
+function read(source) {
+	return typeof source === "function" ? source() : source.value;
+}
+/**
+* 列顺序 / 列筛选 / 列宽 / displayColumns。
+*
+* @returns
+* - `columnOrderState` / `columnFiltersState`：受控或非受控读写
+* - `displayColumns`：按顺序排列；树表可将展开列钉为 fixed-left
+* - `resolvedColumnWidths` / `useStableColumnWidths`：拖拽列宽与稳定布局判定
+* - `updateColumnFilter` / `columnFilterValue`：表头筛选写入与读取
+*/
+function useRsTableColumns(options) {
+	const internalColumnOrder = ref([...options.defaultColumnOrder]);
+	const internalColumnFilters = ref({ ...options.defaultColumnFilters });
+	const internalColumnWidths = ref({});
+	const isColumnOrderControlled = computed(() => read(options.columnOrder) !== void 0);
+	/** 当前列 key 顺序；受控时写回 update:columnOrder */
+	const columnOrderState = computed({
+		get: () => {
+			if (isColumnOrderControlled.value) return read(options.columnOrder) ?? [];
+			if (internalColumnOrder.value.length) return internalColumnOrder.value;
+			return resolveColumnOrder(read(options.columns));
+		},
+		set: (value) => {
+			if (isColumnOrderControlled.value) options.emit("update:columnOrder", value);
+			else internalColumnOrder.value = value;
+			options.emit("columnOrderChange", value);
+		}
+	});
+	const isColumnFiltersControlled = computed(() => read(options.columnFilters) !== void 0);
+	/** 当前列筛选 map（列 key → 查询串） */
+	const columnFiltersState = computed(() => read(options.columnFilters) ?? internalColumnFilters.value);
+	/**
+	* 更新单列筛选值。
+	* 空串会删除该 key；同时发出 update:columnFilters / columnFiltersChange。
+	*/
+	function updateColumnFilter(key, value) {
+		const next = { ...columnFiltersState.value };
+		if (value.trim()) next[key] = value;
+		else delete next[key];
+		if (isColumnFiltersControlled.value) options.emit("update:columnFilters", next);
+		else internalColumnFilters.value = next;
+		options.emit("columnFiltersChange", next);
+	}
+	/** 读取单列当前筛选文案（无则空串） */
+	function columnFilterValue(key) {
+		return columnFiltersState.value[key] ?? "";
+	}
+	/**
+	* 渲染用列列表：先按 columnOrder 排序；
+	* 树表且 fixExpandColumn 时，将展开列强制 fixed=left（已有 fixed 则不动）。
+	*/
+	const displayColumns = computed(() => {
+		const ordered = resolveOrderedColumns(read(options.columns), columnOrderState.value);
+		if (!read(options.treeMode) || !read(options.treeFixExpandColumn)) return ordered;
+		const expandKey = read(options.treeExpandColumnKey);
+		if (!expandKey) return ordered;
+		return ordered.map((column) => {
+			if (column.key !== expandKey || column.fixed) return column;
+			return {
+				...column,
+				fixed: "left"
+			};
+		});
+	});
+	/** 持久化列宽（像素）；拖拽过程中由 RsTable 另用 DOM 直写避免整表重渲 */
+	const resolvedColumnWidths = computed({
+		get: () => internalColumnWidths.value,
+		set: (value) => {
+			internalColumnWidths.value = value;
+		}
+	});
+	/**
+	* 是否启用「稳定列宽」布局（resizable 下避免松手回弹）。
+	* fixed 布局，或每一列都有显式 width / 已测宽时为 true。
+	*/
+	const useStableColumnWidths = computed(() => {
+		if (!read(options.resizable)) return false;
+		if (read(options.columnLayout) === "fixed") return true;
+		const widths = internalColumnWidths.value;
+		return displayColumns.value.every((col) => {
+			return typeof widths[col.key] === "number" || col.width !== void 0;
+		});
+	});
+	/**
+	* 按当前 columns 重建内部列宽：保留已有测量值，合并 initialColumnWidths。
+	* columns 变化时由 watch 调用。
+	*/
+	function syncInternalColumnWidths(columns) {
+		const preserved = {};
+		for (const column of columns) {
+			const width = internalColumnWidths.value[column.key];
+			if (typeof width === "number") preserved[column.key] = width;
+		}
+		internalColumnWidths.value = createInitialColumnWidths(columns, {
+			...read(options.initialColumnWidths) ?? {},
+			...preserved
+		}, { forceAll: read(options.resizable) && useStableColumnWidths.value });
+	}
+	watch(() => read(options.columns), (columns) => {
+		syncInternalColumnWidths(columns);
+		if (!isColumnOrderControlled.value) internalColumnOrder.value = resolveColumnOrder(columns, internalColumnOrder.value);
+	}, { immediate: true });
+	return {
+		internalColumnOrder,
+		internalColumnFilters,
+		internalColumnWidths,
+		isColumnOrderControlled,
+		columnOrderState,
+		isColumnFiltersControlled,
+		columnFiltersState,
+		displayColumns,
+		resolvedColumnWidths,
+		useStableColumnWidths,
+		syncInternalColumnWidths,
+		updateColumnFilter,
+		columnFilterValue
+	};
+}
+//#endregion
+export { useRsTableColumns };

package/dist/components/table/src/composables/useRsTableContextMenu.d.ts

@@ -0,0 +1,99 @@
+/**
+ * RsTable 右键菜单：上下文状态、默认复制项、捕获阶段预填。
+ *
+ * 选择联动（右键选中行）通过回调注入，避免 composable 直接持有 Engine。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import type { RsContextMenuItem } from '../../../context-menu/src/context-menu-utils';
+import { type RsTableColumn, type RsTableRowData, type RsTableRowEntry, type RsTableRowKey, type RsTableSelectionType } from '../utils/table-utils';
+export interface UseRsTableContextMenuOptions<T extends RsTableRowData> {
+    enabled: ComputedRef<boolean> | (() => boolean);
+    dataRows: ComputedRef<Array<Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>>> | (() => Array<Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>>);
+    displayColumns: ComputedRef<RsTableColumn<T>[]> | (() => RsTableColumn<T>[]);
+    selectedRows: ComputedRef<T[]> | (() => T[]);
+    rowKey: ComputedRef<RsTableRowKey<T> | undefined> | (() => RsTableRowKey<T> | undefined);
+    rowKeyByIndex: ComputedRef<Map<number, string>> | (() => Map<number, string>);
+    copyCellLabel: ComputedRef<string> | (() => string);
+    copyRowLabel: ComputedRef<string> | (() => string);
+    contextMenuItems?: (row: T | null, selectedRows: T[]) => RsContextMenuItem[];
+    /**
+     * Feature 贡献合并：在 props 自定义项之后调用。
+     * 入参为已含默认复制 + 业务自定义的列表，应返回最终列表。
+     */
+    mergeFeatureMenuItems?: (items: RsContextMenuItem[], ctx: {
+        row: T | null;
+        selectedRows: T[];
+    }) => RsContextMenuItem[];
+    /** 右键时是否选中该行 */
+    shouldSelectOnContextmenu: () => boolean;
+    canSelectRow: (entry: Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>) => boolean;
+    isRowSelected: (entry: Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>) => boolean;
+    selectionType: () => RsTableSelectionType;
+    getSelectedRowKeys: () => string[];
+    setSelectedRowKeys: (keys: string[]) => void;
+    selectRowKeys: (current: string[], key: string, type: RsTableSelectionType) => string[];
+    getDraft: (rowKey: string, colKey: string) => string | undefined;
+    onSelect: (key: string, row: T | null, selected: T[]) => void;
+    onRowContextmenu: (row: T, rowIndex: number, event: MouseEvent) => void;
+}
+/**
+ * 表格右键菜单状态与交互。
+ */
+export declare function useRsTableContextMenu<T extends RsTableRowData>(options: UseRsTableContextMenuOptions<T>): {
+    ctxRow: Ref<T | null, T | null>;
+    ctxRowIndex: Ref<number | null, number | null>;
+    ctxColKey: Ref<string | null, string | null>;
+    ctxMenuItems: Ref<{
+        key: string;
+        label: string;
+        icon?: string | undefined;
+        hint?: string | undefined;
+        disabled?: boolean | undefined;
+        danger?: boolean | undefined;
+        separator?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+        shortcut?: string | undefined;
+        type?: import("../../../context-menu").RsContextMenuItemType | undefined;
+        checked?: boolean | undefined;
+        group?: string | undefined;
+        href?: string | undefined;
+        target?: string | undefined;
+        rel?: string | undefined;
+        closeOnSelect?: boolean | undefined;
+    }[], RsContextMenuItem[] | {
+        key: string;
+        label: string;
+        icon?: string | undefined;
+        hint?: string | undefined;
+        disabled?: boolean | undefined;
+        danger?: boolean | undefined;
+        separator?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+        shortcut?: string | undefined;
+        type?: import("../../../context-menu").RsContextMenuItemType | undefined;
+        checked?: boolean | undefined;
+        group?: string | undefined;
+        href?: string | undefined;
+        target?: string | undefined;
+        rel?: string | undefined;
+        closeOnSelect?: boolean | undefined;
+    }[]>;
+    refreshCtxMenuItems: () => void;
+    onCtxMenuSelect: (key: string) => Promise<void>;
+    onContextmenuCapture: (event: MouseEvent) => void;
+    onTableContextmenu: (event: MouseEvent) => void;
+    onRowContextmenu: (entry: RsTableRowEntry<T>, event: MouseEvent) => void;
+    onCellContextmenu: (entry: RsTableRowEntry<T>, colKey: string, event: MouseEvent) => void;
+    rowKeyFor: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => string;
+};
+export type RsTableContextMenuApi<T extends RsTableRowData> = ReturnType<typeof useRsTableContextMenu<T>>;

package/dist/components/table/src/composables/useRsTableContextMenu.js

@@ -0,0 +1,152 @@
+import { resolveRowKey } from "../utils/table-utils.js";
+import { buildDefaultTableContextMenuItems, resolveTableCellCopyText, resolveTableRowCopyText } from "../utils/table-context-menu.js";
+import { copyTextToClipboard } from "../../../../utils/rs-clipboard.js";
+import { ref, watch } from "vue";
+//#region src/components/table/src/composables/useRsTableContextMenu.ts
+/**
+* RsTable 右键菜单：上下文状态、默认复制项、捕获阶段预填。
+*
+* 选择联动（右键选中行）通过回调注入，避免 composable 直接持有 Engine。
+*/
+function read(source) {
+	if (typeof source === "function") return source();
+	return source.value;
+}
+/**
+* 表格右键菜单状态与交互。
+*/
+function useRsTableContextMenu(options) {
+	/** 当前右键行（null = 表体空白或尚未命中） */
+	const ctxRow = ref(null);
+	const ctxRowIndex = ref(null);
+	/** 右键命中的数据列 key */
+	const ctxColKey = ref(null);
+	const ctxMenuItems = ref([]);
+	function rowKeyFor(entry) {
+		return read(options.rowKeyByIndex).get(entry.rowIndex) ?? entry.treeKey ?? resolveRowKey(entry.row, entry.rowIndex, read(options.rowKey));
+	}
+	/**
+	* 重建菜单项：默认复制 + 业务自定义。
+	* 有数据时预置复制项，避免 Trigger 打开瞬间 items 为空拒开。
+	*/
+	function refreshCtxMenuItems() {
+		if (!read(options.enabled)) {
+			ctxMenuItems.value = [];
+			return;
+		}
+		const hasDataRows = read(options.dataRows).length > 0;
+		const items = buildDefaultTableContextMenuItems({
+			copyCellLabel: read(options.copyCellLabel),
+			copyRowLabel: read(options.copyRowLabel),
+			hasRow: ctxRow.value != null || hasDataRows,
+			hasCell: ctxColKey.value != null || hasDataRows
+		});
+		const selected = read(options.selectedRows);
+		const custom = options.contextMenuItems?.(ctxRow.value, selected) ?? [];
+		if (custom.length > 0) {
+			if (items.length > 0) items.push({
+				key: "__ctx-sep",
+				label: "",
+				separator: true
+			});
+			items.push(...custom);
+		}
+		const menuCtx = {
+			row: ctxRow.value,
+			selectedRows: selected
+		};
+		ctxMenuItems.value = options.mergeFeatureMenuItems ? options.mergeFeatureMenuItems(items, menuCtx) : items;
+	}
+	watch(() => [read(options.enabled), read(options.dataRows).length], () => {
+		refreshCtxMenuItems();
+	}, { immediate: true });
+	async function copyCtxCell() {
+		if (!ctxRow.value || ctxRowIndex.value == null || !ctxColKey.value) return;
+		const column = read(options.displayColumns).find((item) => item.key === ctxColKey.value);
+		if (!column) return;
+		const key = resolveRowKey(ctxRow.value, ctxRowIndex.value, read(options.rowKey));
+		await copyTextToClipboard(resolveTableCellCopyText(ctxRow.value, column, ctxRowIndex.value, options.getDraft(key, column.key)));
+	}
+	async function copyCtxRow() {
+		if (!ctxRow.value || ctxRowIndex.value == null) return;
+		const key = resolveRowKey(ctxRow.value, ctxRowIndex.value, read(options.rowKey));
+		await copyTextToClipboard(resolveTableRowCopyText(ctxRow.value, ctxRowIndex.value, read(options.displayColumns), options.getDraft, key));
+	}
+	async function onCtxMenuSelect(key) {
+		if (key === "copyCell") {
+			await copyCtxCell();
+			options.onSelect(key, ctxRow.value, read(options.selectedRows));
+			return;
+		}
+		if (key === "copyRow") {
+			await copyCtxRow();
+			options.onSelect(key, ctxRow.value, read(options.selectedRows));
+			return;
+		}
+		options.onSelect(key, ctxRow.value, read(options.selectedRows));
+	}
+	function prepareRowContextmenu(entry) {
+		if (options.shouldSelectOnContextmenu() && options.canSelectRow(entry) && !options.isRowSelected(entry)) options.setSelectedRowKeys(options.selectRowKeys(options.getSelectedRowKeys(), rowKeyFor(entry), options.selectionType()));
+		if (read(options.enabled)) {
+			ctxRow.value = entry.row;
+			ctxRowIndex.value = entry.rowIndex;
+		}
+	}
+	/**
+	* 捕获阶段预填：须早于右键菜单在冒泡阶段打开。
+	*/
+	function onContextmenuCapture(event) {
+		if (!read(options.enabled)) return;
+		const target = event.target;
+		if (!target) return;
+		const tr = target.closest("tr.rs-table__row");
+		if (!tr) return;
+		const rowKeyAttr = tr.getAttribute("data-row-key");
+		if (!rowKeyAttr) return;
+		const entry = read(options.dataRows).find((item) => (item.treeKey ?? read(options.rowKeyByIndex).get(item.rowIndex) ?? "") === rowKeyAttr);
+		if (!entry) return;
+		prepareRowContextmenu(entry);
+		const colKey = target.closest("td.rs-table__td--data")?.getAttribute("data-col-key");
+		ctxColKey.value = colKey || null;
+		refreshCtxMenuItems();
+	}
+	function onTableContextmenu(event) {
+		if (!read(options.enabled)) return;
+		if (!event.target.closest("tr.rs-table__row")) {
+			ctxRow.value = null;
+			ctxRowIndex.value = null;
+			ctxColKey.value = null;
+			refreshCtxMenuItems();
+		}
+	}
+	function onRowContextmenu(entry, event) {
+		if (entry.type !== "row") return;
+		if (event.target.closest(".rs-table__td--data")) return;
+		prepareRowContextmenu(entry);
+		ctxColKey.value = null;
+		refreshCtxMenuItems();
+		options.onRowContextmenu(entry.row, entry.rowIndex, event);
+	}
+	function onCellContextmenu(entry, colKey, event) {
+		if (entry.type !== "row") return;
+		prepareRowContextmenu(entry);
+		ctxColKey.value = colKey;
+		refreshCtxMenuItems();
+		options.onRowContextmenu(entry.row, entry.rowIndex, event);
+	}
+	return {
+		ctxRow,
+		ctxRowIndex,
+		ctxColKey,
+		ctxMenuItems,
+		refreshCtxMenuItems,
+		onCtxMenuSelect,
+		onContextmenuCapture,
+		onTableContextmenu,
+		onRowContextmenu,
+		onCellContextmenu,
+		rowKeyFor
+	};
+}
+//#endregion
+export { useRsTableContextMenu };

package/dist/components/table/src/composables/useRsTableCore.d.ts

@@ -0,0 +1,177 @@
+/**
+ * RsTable 内核装配（Columns + Engine + Scroll + Virtual + Analytics + Features）。
+ *
+ * 性能约定：
+ * - data / columns 仅按引用浅层失效，不做 deep watch
+ * - Feature 按 id + setup 引用签名重绑，避免无关 props 抖动拆掉图表订阅
+ * - 行派生（dataRows / viewRows / keyMap）单次遍历 tableEntries
+ *
+ * 不负责：列宽拖拽 DOM、列虚拟（依赖 resize 快照）、编辑/右键交互、模板。
+ */
+import type { RsTableColumn, RsTableGroupBy, RsTableRowData, RsTableRowKey, RsTableSize, RsTableSortState, RsTableTreeConfig } from '../utils/table-utils';
+import { type RsTableFeature } from '../features/table-features';
+import { type UseRsTableColumnsEmit } from './useRsTableColumns';
+import { type UseRsTableEngineEmit } from './useRsTableEngine';
+/** useRsTableCore 入参：全部用 getter，避免捕获过期 props */
+export interface UseRsTableCoreOptions<T extends RsTableRowData> {
+    columns: () => RsTableColumn<T>[];
+    data: () => T[];
+    rowKey: () => RsTableRowKey<T> | undefined;
+    compact: () => boolean | undefined;
+    size: () => RsTableSize | undefined;
+    columnOrder: () => string[] | undefined;
+    defaultColumnOrder: string[];
+    columnFilters: () => Record<string, string> | undefined;
+    defaultColumnFilters: Record<string, string>;
+    initialColumnWidths: () => Record<string, number> | undefined;
+    resizable: () => boolean;
+    columnLayout: () => 'auto' | 'fixed';
+    sort: () => RsTableSortState | null | undefined;
+    defaultSort: RsTableSortState | null;
+    sorts: () => RsTableSortState[] | undefined;
+    defaultSorts: RsTableSortState[];
+    multiSort: () => boolean;
+    remoteSort: () => boolean;
+    filterText: () => string | undefined;
+    filterKeys: () => string[] | undefined;
+    groupBy: () => RsTableGroupBy<T> | undefined;
+    groupLabel: () => ((key: string) => string) | undefined;
+    treeConfig: () => RsTableTreeConfig<T> | undefined;
+    expandable: () => boolean;
+    rowExpandable: () => ((row: T, index: number) => boolean) | undefined;
+    selectedRowKeys: () => string[] | undefined;
+    defaultSelectedRowKeys: string[];
+    expandedRowKeys: () => string[] | undefined;
+    defaultExpandedRowKeys: string[];
+    rowSelectable: () => ((row: T, index: number) => boolean) | undefined;
+    height: () => number | string | undefined;
+    layoutActive: () => boolean | undefined;
+    viewKey: () => string | number | undefined;
+    virtual: () => boolean | undefined;
+    virtualAutoThreshold: () => number;
+    fill: () => boolean;
+    infinite: () => boolean;
+    virtualOnInfinite: () => boolean;
+    overscan: () => number;
+    expandRowHeight: () => number | undefined;
+    rowHeight: () => number | undefined;
+    selectable: () => boolean;
+    editable: () => boolean;
+    contextMenu: () => boolean;
+    /** 汇总 feature 是否启用（由 Summary composable 或轻量判定注入） */
+    summaryFeatureEnabled: () => boolean;
+    features: () => RsTableFeature<T>[] | undefined;
+    emit: UseRsTableColumnsEmit & UseRsTableEngineEmit;
+}
+/**
+ * 装配表格内核状态。
+ */
+export declare function useRsTableCore<T extends RsTableRowData>(options: UseRsTableCoreOptions<T>): {
+    analyticsSource: {
+        viewRows: import("vue").ComputedRef<T[]>;
+        selectedRows: import("vue").ComputedRef<T[]>;
+        sourceRows: import("vue").ComputedRef<T[]>;
+        sourceMode: import("vue").ComputedRef<import("./useRsTableSelectionSource").RsTableAnalyticsSourceMode>;
+        getSnapshot: () => import("./useRsTableSelectionSource").RsTableAnalyticsSnapshot<T>;
+        subscribe: (listener: (snap: import("./useRsTableSelectionSource").RsTableAnalyticsSnapshot<T>) => void) => () => void;
+    };
+    tableSurface: import("./useRsTable").UseRsTableSurface<T>;
+    builtinFeatureIds: import("vue").ComputedRef<import("../..").RsTableBuiltinFeatureId[]>;
+    virtualScrollEnabled: import("vue").ComputedRef<boolean>;
+    virtualHeightModel: import("vue").ComputedRef<{
+        entries: readonly import("../..").RsTableRowEntry<T>[];
+        prefix: number[];
+        total: number;
+    }>;
+    virtualSlice: import("vue").ComputedRef<{
+        entries: import("../..").RsTableRowEntry<T>[];
+        paddingTop: number;
+        paddingBottom: number;
+    }>;
+    visibleEntries: import("vue").ComputedRef<import("../..").RsTableRowEntry<T>[]>;
+    scrollTop: import("vue").Ref<number, number>;
+    scrollLeft: import("vue").Ref<number, number>;
+    scrollContainerRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    measuredViewportHeight: import("vue").Ref<number, number>;
+    measuredViewportWidth: import("vue").Ref<number, number>;
+    viewportHeight: import("vue").ComputedRef<number>;
+    syncMeasuredViewportSize: () => void;
+    captureScrollFromDom: () => void;
+    restoreScrollToDom: () => void;
+    scheduleVirtualLayoutSync: () => void;
+    resetScrollPosition: () => void;
+    isRestoringScroll: () => boolean;
+    onScrollFrame: (element: HTMLElement) => void;
+    bindScrollElement: (el: HTMLElement | null | undefined) => void;
+    disposeScrollLayout: () => void;
+    internalSort: import("vue").Ref<{
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    } | null, RsTableSortState | {
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    } | null>;
+    internalSorts: import("vue").Ref<{
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    }[], RsTableSortState[] | {
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    }[]>;
+    internalSelectedRowKeys: import("vue").Ref<string[], string[]>;
+    internalExpandedRowKeys: import("vue").Ref<string[], string[]>;
+    treeLoadingKeys: import("vue").Ref<string[], string[]>;
+    isSortControlled: import("vue").ComputedRef<boolean>;
+    sortState: import("vue").WritableComputedRef<RsTableSortState | null, RsTableSortState | null>;
+    isSortsControlled: import("vue").ComputedRef<boolean>;
+    sortsState: import("vue").WritableComputedRef<RsTableSortState[], RsTableSortState[]>;
+    isSelectionControlled: import("vue").ComputedRef<boolean>;
+    selectedRowKeys: import("vue").WritableComputedRef<string[], string[]>;
+    selectedKeySet: import("vue").ComputedRef<Set<string>>;
+    isExpandedControlled: import("vue").ComputedRef<boolean>;
+    expandedRowKeys: import("vue").WritableComputedRef<string[], string[]>;
+    expandedKeySet: import("vue").ComputedRef<Set<string>>;
+    treeMode: import("vue").ComputedRef<boolean>;
+    detailExpandable: import("vue").ComputedRef<boolean>;
+    treeChildrenField: import("vue").ComputedRef<string>;
+    treeIsLeafField: import("vue").ComputedRef<string>;
+    treeLazy: import("vue").ComputedRef<boolean>;
+    treeCheckStrictly: import("vue").ComputedRef<boolean>;
+    treeIndentPx: import("vue").ComputedRef<number>;
+    treeExpandColumnKey: import("vue").ComputedRef<string | null>;
+    treeFixExpandColumn: import("vue").ComputedRef<boolean>;
+    treeLoadingKeySet: import("vue").ComputedRef<Set<string>>;
+    tableTreeNodeIndex: import("vue").ComputedRef<Map<string, import("../..").RsTableTreeNodeIndex> | null>;
+    tableEntries: import("vue").ComputedRef<import("../..").RsTableRowEntry<T>[]>;
+    dataRows: import("vue").ComputedRef<{
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }[]>;
+    selectableRowKeys: import("vue").ComputedRef<string[]>;
+    rowKeyByIndex: import("vue").ComputedRef<Map<number, string>>;
+    selectedRows: import("vue").ComputedRef<T[]>;
+    selectAllState: import("vue").ComputedRef<import("../..").RsTableSelectAllState>;
+    viewRows: import("vue").ComputedRef<T[]>;
+    internalColumnOrder: import("vue").Ref<string[], string[]>;
+    internalColumnFilters: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    internalColumnWidths: import("vue").Ref<Record<string, number>, Record<string, number>>;
+    isColumnOrderControlled: import("vue").ComputedRef<boolean>;
+    columnOrderState: import("vue").WritableComputedRef<string[], string[]>;
+    isColumnFiltersControlled: import("vue").ComputedRef<boolean>;
+    columnFiltersState: import("vue").ComputedRef<Record<string, string>>;
+    displayColumns: import("vue").ComputedRef<RsTableColumn<T>[]>;
+    resolvedColumnWidths: import("vue").WritableComputedRef<Record<string, number>, Record<string, number>>;
+    useStableColumnWidths: import("vue").ComputedRef<boolean>;
+    syncInternalColumnWidths: (columns: RsTableColumn<T>[]) => void;
+    updateColumnFilter: (key: string, value: string) => void;
+    columnFilterValue: (key: string) => string;
+    resolvedSize: import("vue").ComputedRef<RsTableSize>;
+    fixedRowHeight: import("vue").ComputedRef<number>;
+    tableEntriesForThreshold: import("vue").ComputedRef<number>;
+};
+export type RsTableCoreApi<T extends RsTableRowData> = ReturnType<typeof useRsTableCore<T>>;