niuma-ui 1.1.12 → 1.2.0

package/dist/composables/useRsTableContextMenu.d.ts

@@ -0,0 +1,83 @@
+/**
+ * RsTable 右键菜单：上下文状态、默认复制项、捕获阶段预填。
+ *
+ * 选择联动（右键选中行）通过回调注入，避免 composable 直接持有 Engine。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import type { RsContextMenuItem } from '../components/context-menu-utils';
+import { type RsTableColumn, type RsTableRowData, type RsTableRowEntry, type RsTableRowKey, type RsTableSelectionType } from '../components/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;
+        disabled?: boolean | undefined;
+        danger?: boolean | undefined;
+        separator?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+        shortcut?: string | undefined;
+    }[], RsContextMenuItem[] | {
+        key: string;
+        label: string;
+        icon?: string | undefined;
+        disabled?: boolean | undefined;
+        danger?: boolean | undefined;
+        separator?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+        shortcut?: string | 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/composables/useRsTableContextMenu.js

@@ -0,0 +1,152 @@
+import { resolveRowKey } from "../components/table-utils.js";
+import { buildDefaultTableContextMenuItems, resolveTableCellCopyText, resolveTableRowCopyText } from "../components/table/table-context-menu.js";
+import { copyTextToClipboard } from "../utils/rs-clipboard.js";
+import { ref, watch } from "vue";
+//#region 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;
+		}
+	}
+	/**
+	* 捕获阶段预填：须早于 ContextMenuTrigger 冒泡打开。
+	*/
+	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/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 '../components/table-utils';
+import { type RsTableFeature } from '../components/table/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>>;

package/dist/composables/useRsTableCore.js

@@ -0,0 +1,164 @@
+import { resolveTableRowHeight, resolveTableSize } from "../components/table-utils.js";
+import { resolveBuiltinTableFeatures } from "../components/table/table-features.js";
+import { useRsTable } from "./useRsTable.js";
+import { useRsTableColumns } from "./useRsTableColumns.js";
+import { useRsTableEngine } from "./useRsTableEngine.js";
+import { useRsTableScrollLayout } from "./useRsTableScrollLayout.js";
+import { useRsTableSelectionSource } from "./useRsTableSelectionSource.js";
+import { flattenVisibleCountRough, useRsTableVirtual } from "./useRsTableVirtual.js";
+import { computed, onUnmounted, watch } from "vue";
+//#region src/composables/useRsTableCore.ts
+/**
+* RsTable 内核装配（Columns + Engine + Scroll + Virtual + Analytics + Features）。
+*
+* 性能约定：
+* - data / columns 仅按引用浅层失效，不做 deep watch
+* - Feature 按 id + setup 引用签名重绑，避免无关 props 抖动拆掉图表订阅
+* - 行派生（dataRows / viewRows / keyMap）单次遍历 tableEntries
+*
+* 不负责：列宽拖拽 DOM、列虚拟（依赖 resize 快照）、编辑/右键交互、模板。
+*/
+/**
+* 装配表格内核状态。
+*/
+function useRsTableCore(options) {
+	const treeModeEarly = computed(() => Boolean(options.treeConfig()));
+	const treeExpandColumnKeyEarly = computed(() => {
+		const tree = options.treeConfig();
+		if (!tree) return null;
+		return tree.expandColumnKey ?? options.columns()[0]?.key ?? null;
+	});
+	const treeFixExpandColumnEarly = computed(() => options.treeConfig()?.fixExpandColumn !== false);
+	const columnsApi = useRsTableColumns({
+		columns: () => options.columns(),
+		columnOrder: () => options.columnOrder(),
+		defaultColumnOrder: options.defaultColumnOrder,
+		columnFilters: () => options.columnFilters(),
+		defaultColumnFilters: options.defaultColumnFilters,
+		initialColumnWidths: () => options.initialColumnWidths(),
+		resizable: () => options.resizable(),
+		columnLayout: () => options.columnLayout(),
+		treeMode: treeModeEarly,
+		treeFixExpandColumn: treeFixExpandColumnEarly,
+		treeExpandColumnKey: treeExpandColumnKeyEarly,
+		emit: options.emit
+	});
+	const resolvedSize = computed(() => resolveTableSize(options.compact() ?? false, options.size() ?? "md"));
+	const engine = useRsTableEngine({
+		data: () => options.data(),
+		displayColumns: () => columnsApi.displayColumns.value,
+		rowKey: () => options.rowKey(),
+		sort: () => options.sort(),
+		defaultSort: options.defaultSort,
+		sorts: () => options.sorts(),
+		defaultSorts: options.defaultSorts,
+		multiSort: () => options.multiSort(),
+		remoteSort: () => options.remoteSort(),
+		filterText: () => options.filterText(),
+		filterKeys: () => options.filterKeys(),
+		columnFilters: () => columnsApi.columnFiltersState.value,
+		groupBy: () => options.groupBy(),
+		groupLabel: () => options.groupLabel(),
+		treeConfig: () => options.treeConfig(),
+		expandable: () => options.expandable(),
+		rowExpandable: () => options.rowExpandable(),
+		selectedRowKeys: () => options.selectedRowKeys(),
+		defaultSelectedRowKeys: options.defaultSelectedRowKeys,
+		expandedRowKeys: () => options.expandedRowKeys(),
+		defaultExpandedRowKeys: options.defaultExpandedRowKeys,
+		rowSelectable: () => options.rowSelectable(),
+		size: resolvedSize,
+		emit: options.emit
+	});
+	/** 树表阈值粗算：不构建完整 entries，避免与 virtual 循环依赖 */
+	const tableEntriesForThreshold = computed(() => {
+		if (!options.treeConfig()) return options.data().length;
+		return flattenVisibleCountRough(options.data(), engine.expandedKeySet.value, {
+			childrenField: engine.treeChildrenField.value,
+			isLeafField: engine.treeIsLeafField.value,
+			lazy: engine.treeLazy.value,
+			rowKey: options.rowKey()
+		});
+	});
+	const scroll = useRsTableScrollLayout({
+		height: () => options.height(),
+		layoutActive: () => options.layoutActive(),
+		viewKey: () => options.viewKey()
+	});
+	const fixedRowHeight = computed(() => resolveTableRowHeight(resolvedSize.value, options.rowHeight()));
+	const virtual = useRsTableVirtual({
+		dataLength: () => options.data().length,
+		treeMode: engine.treeMode,
+		tableEntriesForThreshold,
+		virtual: () => options.virtual(),
+		virtualAutoThreshold: () => options.virtualAutoThreshold(),
+		fill: () => options.fill(),
+		infinite: () => options.infinite(),
+		virtualOnInfinite: () => options.virtualOnInfinite(),
+		overscan: () => options.overscan(),
+		expandRowHeight: () => options.expandRowHeight(),
+		scrollTop: scroll.scrollTop,
+		viewportHeight: scroll.viewportHeight,
+		fixedRowHeight,
+		tableEntries: () => engine.tableEntries.value
+	});
+	const analyticsSource = useRsTableSelectionSource({
+		viewRows: engine.viewRows,
+		selectedRows: engine.selectedRows
+	});
+	const tableSurface = useRsTable();
+	/** 列是否可筛选：只跟 columns 引用走，避免每次访问 .some */
+	const hasFilterableColumn = computed(() => options.columns().some((c) => c.filterable));
+	const builtinFeatureIds = computed(() => resolveBuiltinTableFeatures({
+		selectable: options.selectable(),
+		filterable: hasFilterableColumn.value,
+		virtual: options.virtual() === false ? false : options.virtual() ?? "auto",
+		editable: options.editable(),
+		tree: Boolean(options.treeConfig()),
+		contextMenu: options.contextMenu() !== false,
+		summary: options.summaryFeatureEnabled()
+	}));
+	/**
+	* Feature 重绑签名：builtin id 集合 + 实例 feature 的 id/setup 引用。
+	* 不监听 data/viewRows，避免滚动/选中拆掉 analytics 订阅。
+	*/
+	const featureBindSignature = computed(() => {
+		const extras = options.features() ?? [];
+		return [
+			builtinFeatureIds.value.join("\0"),
+			extras.length,
+			...extras.map((f) => f.id),
+			...extras.map((f) => f.setup)
+		];
+	});
+	let disposeTableFeatures = null;
+	watch(featureBindSignature, () => {
+		disposeTableFeatures?.();
+		disposeTableFeatures = tableSurface.bindFeatures({
+			builtinIds: builtinFeatureIds.value,
+			instanceFeatures: options.features() ?? null,
+			getViewRows: () => engine.viewRows.value,
+			getSelectedRows: () => engine.selectedRows.value,
+			getAnalyticsSnapshot: () => analyticsSource.getSnapshot(),
+			subscribeAnalytics: (listener) => analyticsSource.subscribe(listener)
+		});
+	}, { immediate: true });
+	onUnmounted(() => {
+		disposeTableFeatures?.();
+		disposeTableFeatures = null;
+	});
+	return {
+		resolvedSize,
+		fixedRowHeight,
+		tableEntriesForThreshold,
+		...columnsApi,
+		...engine,
+		...scroll,
+		...virtual,
+		analyticsSource,
+		tableSurface,
+		builtinFeatureIds
+	};
+}
+//#endregion
+export { useRsTableCore };