niuma-ui 1.3.9 → 2.0.0

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

@@ -0,0 +1,57 @@
+import { computed, watch } from "vue";
+//#region src/components/table/src/composables/useRsTableSelectionSource.ts
+/**
+* 表格分析/图表数据源：viewRows + selectedRows → 稳定 sourceRows。
+*
+* 约定（便于柱状图/饼图等后期扩展）：
+* - 有选中行时 sourceMode='selected'，图表跟随勾选
+* - 无选中时回退 viewRows（筛选/排序后的业务行）
+* - subscribe 仅在浅层引用变化时通知，不做 deep watch
+*/
+/**
+* 选中优先的分析数据源。
+*
+* @returns sourceRows / sourceMode / getSnapshot / subscribe
+*/
+function useRsTableSelectionSource(options) {
+	const viewRows = computed(() => options.viewRows.value ?? []);
+	const selectedRows = computed(() => options.selectedRows?.value ?? []);
+	const sourceMode = computed(() => selectedRows.value.length > 0 ? "selected" : "view");
+	const sourceRows = computed(() => sourceMode.value === "selected" ? selectedRows.value : viewRows.value);
+	function getSnapshot() {
+		return {
+			viewRows: viewRows.value,
+			selectedRows: selectedRows.value,
+			sourceRows: sourceRows.value,
+			sourceMode: sourceMode.value,
+			selectedCount: selectedRows.value.length,
+			viewCount: viewRows.value.length
+		};
+	}
+	/**
+	* 订阅快照变化。
+	* 依赖：viewRows 引用、selectedRows 引用、sourceMode。
+	* @returns teardown
+	*/
+	function subscribe(listener) {
+		const stop = watch(() => [
+			viewRows.value,
+			selectedRows.value,
+			sourceMode.value
+		], () => {
+			listener(getSnapshot());
+		}, { flush: "post" });
+		listener(getSnapshot());
+		return stop;
+	}
+	return {
+		viewRows,
+		selectedRows,
+		sourceRows,
+		sourceMode,
+		getSnapshot,
+		subscribe
+	};
+}
+//#endregion
+export { useRsTableSelectionSource };

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

@@ -0,0 +1,380 @@
+/**
+ * RsTable 壳层装配：前缀列几何 + 列宽/列虚拟/列布局 + 交互 + 右键菜单。
+ *
+ * 性能约定（不可破）：
+ * - 列宽拖拽仍走 useRsTableColumnResize 的 DOM 直写（禁止拖拽中写 reactive 全表宽）
+ * - columnVirtual 在 isColumnResizing 时冻结切片，避免拖宽时重算窗口
+ * - 不引入对 data 的 deep watch；状态经 getter / 受控 ref 读写
+ *
+ * 不做：Engine/Virtual 行切片（useRsTableCore）、编辑提交（useRsTableEditActions）、模板。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import type { RsContextMenuItem } from '../../../context-menu/src/context-menu-utils';
+import type { RsTableRowDragTrigger, RsTableRowDropMode } from '../utils/table-drag';
+import type { RsTableColumn, RsTableRowData, RsTableRowEntry, RsTableRowKey, RsTableSelectionType, RsTableSortState, RsTableTreeConfig, RsTableTreeNodeIndex, RsTableRowDropPosition } from '../utils/table-utils';
+/** 壳层依赖的 Core 状态切片（显式列出，避免吞整个 core） */
+export interface UseRsTableShellCoreSlice<T extends RsTableRowData> {
+    displayColumns: ComputedRef<RsTableColumn<T>[]>;
+    resolvedColumnWidths: {
+        get: () => Record<string, number>;
+        set: (value: Record<string, number>) => void;
+    } | Ref<Record<string, number>>;
+    useStableColumnWidths: ComputedRef<boolean>;
+    scrollLeft: Ref<number>;
+    measuredViewportWidth: Ref<number>;
+    virtualScrollEnabled: ComputedRef<boolean>;
+    dataRows: ComputedRef<Array<Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>>>;
+    selectedRows: ComputedRef<T[]>;
+    rowKeyByIndex: ComputedRef<Map<number, string>>;
+    selectedRowKeys: {
+        get: () => string[];
+        set: (keys: string[]) => void;
+    } | Ref<string[]>;
+    selectedKeySet: ComputedRef<Set<string>>;
+    selectableRowKeys: ComputedRef<string[]>;
+    selectAllState: ComputedRef<'checked' | 'indeterminate' | 'unchecked'>;
+    expandedRowKeys: {
+        get: () => string[];
+        set: (keys: string[]) => void;
+    } | Ref<string[]>;
+    expandedKeySet: ComputedRef<Set<string>>;
+    detailExpandable: ComputedRef<boolean>;
+    treeMode: ComputedRef<boolean>;
+    treeCheckStrictly: ComputedRef<boolean>;
+    treeLazy: ComputedRef<boolean>;
+    treeChildrenField: ComputedRef<string>;
+    treeIsLeafField: ComputedRef<string>;
+    treeLoadingKeys: {
+        get: () => string[];
+        set: (keys: string[]) => void;
+    } | Ref<string[]>;
+    treeLoadingKeySet: ComputedRef<Set<string>>;
+    tableTreeNodeIndex: ComputedRef<Map<string, RsTableTreeNodeIndex> | null>;
+    sortState: {
+        get: () => RsTableSortState | null;
+        set: (value: RsTableSortState | null) => void;
+    } | Ref<RsTableSortState | null>;
+    sortsState: {
+        get: () => RsTableSortState[];
+        set: (value: RsTableSortState[]) => void;
+    } | Ref<RsTableSortState[]>;
+    columnOrderState: {
+        get: () => string[];
+        set: (value: string[]) => void;
+    } | Ref<string[]>;
+}
+export interface UseRsTableShellOptions<T extends RsTableRowData> {
+    core: UseRsTableShellCoreSlice<T>;
+    rowDraggable: () => boolean;
+    rowDragTrigger: () => RsTableRowDragTrigger;
+    selectable: () => boolean;
+    selectionType: () => RsTableSelectionType;
+    scrollX: () => number | string | undefined;
+    resizable: () => boolean;
+    minColumnWidth: () => number | undefined;
+    maxColumnWidth: () => number | undefined;
+    columnLayout: () => 'auto' | 'fixed';
+    virtualColumns: () => boolean | 'auto' | undefined;
+    virtualColumnsAutoThreshold: () => number | undefined;
+    virtualColumnOverscan: () => number | undefined;
+    fill: () => boolean;
+    infinite: () => boolean;
+    height: () => number | string | undefined;
+    showEditGutterColumn: () => boolean;
+    showIndexColumn: () => boolean;
+    showRowStatusColumn: () => boolean;
+    resolvedGutterWidth: () => number;
+    resolvedIndexWidth: () => number;
+    multiSort: () => boolean;
+    maxSort: () => number | undefined;
+    columnDraggable: () => boolean;
+    rowSelectable?: (row: T, index: number) => boolean;
+    rowDropMode: () => RsTableRowDropMode;
+    rowDraggableWhen?: (row: T, index: number) => boolean;
+    rowDropTargetWhen?: (row: T, index: number) => boolean;
+    canRowDrop?: (dragKeys: string[], dropKey: string) => boolean;
+    rowKey: () => RsTableRowKey<T> | undefined;
+    treeConfig: () => RsTableTreeConfig<T> | undefined;
+    expandable: () => boolean;
+    rowExpandable?: (row: T, index: number) => boolean;
+    isEditingAny: () => boolean;
+    applyRowClickHighlight: (key: string) => void;
+    onRowClickEmit: (row: T, index: number) => void;
+    onRowDblclickEmit: (row: T, index: number) => void;
+    onRowDragStartEmit: (dragKeys: string[], event: DragEvent) => void;
+    onRowDropEmit: (dragKeys: string[], dropKey: string, position: RsTableRowDropPosition) => void;
+    onColumnResize: (key: string, width: number) => void;
+    contextMenuEnabled: ComputedRef<boolean> | (() => boolean);
+    copyCellLabel: () => string;
+    copyRowLabel: () => string;
+    contextMenuItems?: (row: T | null, selectedRows: T[]) => RsContextMenuItem[];
+    mergeFeatureMenuItems?: (items: RsContextMenuItem[], ctx: {
+        row: T | null;
+        selectedRows: T[];
+    }) => RsContextMenuItem[];
+    selectOnContextmenu: () => boolean;
+    getDraft: (rowKey: string, colKey: string) => string | undefined;
+    onContextMenuSelect: (key: string, row: T | null, selected: T[]) => void;
+    onRowContextmenuEmit: (row: T, rowIndex: number, event: MouseEvent) => void;
+}
+/**
+ * 装配壳层：列几何/布局/交互/右键。
+ */
+export declare function useRsTableShell<T extends RsTableRowData>(options: UseRsTableShellOptions<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: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => string;
+    dragColumnKey: Ref<string | null, string | null>;
+    dropColumnKey: Ref<string | null, string | null>;
+    selectionAnchorKey: Ref<string | null, string | null>;
+    dragRowKeys: Ref<string[], string[]>;
+    dropRowTargetKey: Ref<string | null, string | null>;
+    dropRowPosition: Ref<RsTableRowDropPosition, RsTableRowDropPosition>;
+    sortOrderFor: (key: string) => import("../..").RsTableSortOrder;
+    sortPriorityFor: (key: string) => number;
+    sortIconName: (key: string) => string;
+    onHeaderClick: (column: RsTableColumn<T>) => void;
+    onColumnDragStart: (key: string, event: DragEvent) => void;
+    onColumnDragOver: (key: string, event: DragEvent) => void;
+    onColumnDrop: (key: string, event: DragEvent) => void;
+    onColumnDragEnd: () => void;
+    canSelectRow: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    isRowSelected: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    isRowIndeterminate: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    onToggleRow: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => void;
+    onToggleSelectAll: () => void;
+    canExpandRow: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    isRowExpanded: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    treeDepthOf: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => number;
+    onToggleExpand: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => Promise<void>;
+    onRowClick: (entry: RsTableRowEntry<T>, event?: MouseEvent) => void;
+    onRowSelectMouseDown: (event: MouseEvent) => void;
+    onRowDblclick: (entry: RsTableRowEntry<T>, _event?: MouseEvent) => void;
+    onRowDragStart: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }, event: DragEvent) => void;
+    onRowDragOver: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }, event: DragEvent) => void;
+    onRowDragLeave: (event: DragEvent) => void;
+    onRowDrop: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }, event: DragEvent) => void;
+    onRowDragEnd: () => void;
+    isRowDropTarget: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    isRowDragging: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    canDragRow: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    isRowDragByRow: (entry: {
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }) => boolean;
+    useScrollContainer: ComputedRef<boolean>;
+    scrollContainerStyle: ComputedRef<Record<string, string> | undefined>;
+    bodyColspan: ComputedRef<number>;
+    emptyContentStyle: ComputedRef<{
+        width: string;
+    } | undefined>;
+    EMPTY_FILL_EXTRAS: Record<string, number>;
+    measurePrefixColumnWidth: () => number;
+    resizableTableWidth: ComputedRef<string | undefined>;
+    useFixedColumnLayout: ComputedRef<boolean>;
+    columnFillExtras: ComputedRef<Record<string, number>>;
+    renderColumnWidths: ComputedRef<Record<string, number>>;
+    tableInlineStyle: ComputedRef<{
+        width: string;
+        minWidth: string;
+    } | {
+        width: string;
+        minWidth?: undefined;
+    } | {
+        minWidth: string;
+        width?: undefined;
+    } | undefined>;
+    overflowXEnabled: ComputedRef<boolean>;
+    resolvedDataColumnWidth: (key: string, fallback?: number | string) => number;
+    fixedColumnStyles: ComputedRef<Map<string, import("../utils/table-utils").RsTableFixedCellStyle>>;
+    columnStyleMap: ComputedRef<Map<string, Record<string, string> | undefined>>;
+    columnHeaderStyleMap: ComputedRef<Map<string, Record<string, string> | undefined>>;
+    columnTdClassMap: ComputedRef<Map<string, string[]>>;
+    dragLeadStyle: ComputedRef<Record<string, string>>;
+    expandLeadStyle: ComputedRef<Record<string, string>>;
+    selectLeadStyle: ComputedRef<Record<string, string>>;
+    indexLeadStyle: ComputedRef<Record<string, string>>;
+    gutterLeadStyle: ComputedRef<Record<string, string>>;
+    dragLeadHeaderStyle: ComputedRef<Record<string, string>>;
+    expandLeadHeaderStyle: ComputedRef<Record<string, string>>;
+    selectLeadHeaderStyle: ComputedRef<Record<string, string>>;
+    indexLeadHeaderStyle: ComputedRef<Record<string, string>>;
+    gutterLeadHeaderStyle: ComputedRef<Record<string, string>>;
+    PREFIX_COL_WIDTH: {
+        readonly drag: 40;
+        readonly expand: 40;
+        readonly select: 40;
+        readonly status: 52;
+    };
+    showRowDragHandle: ComputedRef<boolean>;
+    dragColumnOffset: ComputedRef<0 | 40>;
+    expandColumnOffset: ComputedRef<number>;
+    showSelectColumn: ComputedRef<boolean>;
+    isRowSelection: ComputedRef<boolean>;
+    isRadioSelection: ComputedRef<boolean>;
+    selectColumnOffset: ComputedRef<number>;
+    tableMinWidth: ComputedRef<string | undefined>;
+    tableRef: Ref<HTMLTableElement | null, HTMLTableElement | null>;
+    isColumnResizing: Ref<boolean, boolean>;
+    resizePaintWidths: Ref<Record<string, number> | null, Record<string, number> | null>;
+    onResizeStart: (key: string, event: MouseEvent) => void;
+    effectiveColumnWidths: ComputedRef<Record<string, number>>;
+    virtualColumnsEnabled: ComputedRef<boolean>;
+    visibleDataColumns: ComputedRef<RsTableColumn<T>[]>;
+    columnPadLeft: ComputedRef<number>;
+    columnPadRight: ComputedRef<number>;
+};
+export type RsTableShellApi<T extends RsTableRowData> = ReturnType<typeof useRsTableShell<T>>;

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

@@ -0,0 +1,237 @@
+import { resolveVirtualListHeight } from "../../../virtual-list/src/virtual-list-utils.js";
+import { resolveScrollWidth, selectRowKeys } from "../utils/table-utils.js";
+import { RS_TABLE_PREFIX_COL_WIDTH, measureRsTablePrefixWidth, useRsTableColumnVirtual } from "./useRsTableColumnVirtual.js";
+import { useRsTableColumnLayout } from "./useRsTableColumnLayout.js";
+import { useRsTableColumnResize } from "./useRsTableColumnResize.js";
+import { useRsTableContextMenu } from "./useRsTableContextMenu.js";
+import { useRsTableInteraction } from "./useRsTableInteraction.js";
+import { computed } from "vue";
+//#region src/components/table/src/composables/useRsTableShell.ts
+/**
+* RsTable 壳层装配：前缀列几何 + 列宽/列虚拟/列布局 + 交互 + 右键菜单。
+*
+* 性能约定（不可破）：
+* - 列宽拖拽仍走 useRsTableColumnResize 的 DOM 直写（禁止拖拽中写 reactive 全表宽）
+* - columnVirtual 在 isColumnResizing 时冻结切片，避免拖宽时重算窗口
+* - 不引入对 data 的 deep watch；状态经 getter / 受控 ref 读写
+*
+* 不做：Engine/Virtual 行切片（useRsTableCore）、编辑提交（useRsTableEditActions）、模板。
+*/
+function asAccessor(source) {
+	if ("get" in source && typeof source.get === "function") return source;
+	const r = source;
+	return {
+		get: () => r.value,
+		set: (v) => {
+			r.value = v;
+		}
+	};
+}
+/**
+* 装配壳层：列几何/布局/交互/右键。
+*/
+function useRsTableShell(options) {
+	const { core } = options;
+	const PREFIX_COL_WIDTH = RS_TABLE_PREFIX_COL_WIDTH;
+	const showRowDragHandle = computed(() => options.rowDraggable() && options.rowDragTrigger() === "handle");
+	const dragColumnOffset = computed(() => showRowDragHandle.value ? 40 : 0);
+	const expandColumnOffset = computed(() => dragColumnOffset.value + (core.detailExpandable.value ? 40 : 0));
+	const showSelectColumn = computed(() => options.selectable() && options.selectionType() !== "row");
+	const isRowSelection = computed(() => options.selectable() && options.selectionType() === "row");
+	const isRadioSelection = computed(() => options.selectionType() === "radio");
+	const selectColumnOffset = computed(() => expandColumnOffset.value + (showSelectColumn.value ? 40 : 0));
+	const tableMinWidth = computed(() => resolveScrollWidth(options.scrollX()));
+	const selectedRowKeysAcc = asAccessor(core.selectedRowKeys);
+	const expandedRowKeysAcc = asAccessor(core.expandedRowKeys);
+	const treeLoadingKeysAcc = asAccessor(core.treeLoadingKeys);
+	const sortStateAcc = asAccessor(core.sortState);
+	const sortsStateAcc = asAccessor(core.sortsState);
+	const columnOrderStateAcc = asAccessor(core.columnOrderState);
+	const resolvedWidthsAcc = asAccessor(core.resolvedColumnWidths);
+	const { tableRef, isColumnResizing, resizePaintWidths, onResizeStart } = useRsTableColumnResize({
+		resizable: () => options.resizable(),
+		minColumnWidth: () => options.minColumnWidth(),
+		maxColumnWidth: () => options.maxColumnWidth(),
+		displayColumns: () => core.displayColumns.value,
+		resolvedColumnWidths: resolvedWidthsAcc,
+		measurePrefixColumnWidth: () => measureRsTablePrefixWidth({
+			showRowDragHandle: showRowDragHandle.value,
+			detailExpandable: core.detailExpandable.value,
+			showSelectColumn: showSelectColumn.value,
+			showEditGutterColumn: options.showEditGutterColumn(),
+			showIndexColumn: options.showIndexColumn(),
+			gutterWidth: options.resolvedGutterWidth(),
+			indexWidth: options.resolvedIndexWidth()
+		}),
+		tableMinWidth: () => tableMinWidth.value,
+		onColumnResize: options.onColumnResize
+	});
+	/** 拖拽帧用快照，否则持久化宽 —— 供布局/列虚拟共用，避免双份计算 */
+	const effectiveColumnWidths = computed(() => resizePaintWidths.value ?? resolvedWidthsAcc.get());
+	const { virtualColumnsEnabled, visibleDataColumns, columnPadLeft, columnPadRight } = useRsTableColumnVirtual({
+		displayColumns: () => core.displayColumns.value,
+		virtualColumns: () => options.virtualColumns(),
+		virtualColumnsAutoThreshold: () => options.virtualColumnsAutoThreshold(),
+		virtualColumnOverscan: () => options.virtualColumnOverscan(),
+		isColumnResizing: () => isColumnResizing.value,
+		scrollLeft: () => core.scrollLeft.value,
+		measuredViewportWidth: () => core.measuredViewportWidth.value,
+		columnWidths: () => effectiveColumnWidths.value,
+		showRowDragHandle: () => showRowDragHandle.value,
+		detailExpandable: () => core.detailExpandable.value,
+		showSelectColumn: () => showSelectColumn.value,
+		showEditGutterColumn: () => options.showEditGutterColumn(),
+		showIndexColumn: () => options.showIndexColumn(),
+		showRowStatusColumn: () => options.showRowStatusColumn(),
+		resolvedGutterWidth: () => options.resolvedGutterWidth(),
+		resolvedIndexWidth: () => options.resolvedIndexWidth()
+	});
+	const layout = useRsTableColumnLayout({
+		displayColumns: () => core.displayColumns.value,
+		effectiveColumnWidths: () => effectiveColumnWidths.value,
+		measuredViewportWidth: () => core.measuredViewportWidth.value,
+		tableMinWidth: () => tableMinWidth.value,
+		resizable: () => options.resizable(),
+		columnLayout: () => options.columnLayout(),
+		useStableColumnWidths: () => core.useStableColumnWidths.value,
+		isColumnResizing: () => isColumnResizing.value,
+		virtualColumnsEnabled: () => virtualColumnsEnabled.value,
+		scrollX: () => options.scrollX(),
+		showRowDragHandle: () => showRowDragHandle.value,
+		detailExpandable: () => core.detailExpandable.value,
+		showSelectColumn: () => showSelectColumn.value,
+		showEditGutterColumn: () => options.showEditGutterColumn(),
+		showIndexColumn: () => options.showIndexColumn(),
+		showRowStatusColumn: () => options.showRowStatusColumn(),
+		resolvedGutterWidth: () => options.resolvedGutterWidth(),
+		resolvedIndexWidth: () => options.resolvedIndexWidth(),
+		dragColumnOffset: () => dragColumnOffset.value,
+		expandColumnOffset: () => expandColumnOffset.value,
+		selectColumnOffset: () => selectColumnOffset.value,
+		resizePaintWidths: () => resizePaintWidths.value
+	});
+	const useScrollContainer = computed(() => core.virtualScrollEnabled.value || options.infinite() || virtualColumnsEnabled.value);
+	const scrollContainerStyle = computed(() => {
+		const style = {};
+		if (useScrollContainer.value && !options.fill()) {
+			const resolvedHeight = resolveVirtualListHeight(options.height(), 320);
+			if (resolvedHeight) {
+				style.height = resolvedHeight;
+				style.maxHeight = resolvedHeight;
+			}
+		}
+		if (options.showEditGutterColumn()) style["--rs-table-gutter-width"] = `${options.resolvedGutterWidth()}px`;
+		if (showSelectColumn.value) style["--rs-table-select-width"] = `${PREFIX_COL_WIDTH.select}px`;
+		if (options.showIndexColumn()) style["--rs-table-index-width"] = `${options.resolvedIndexWidth()}px`;
+		return Object.keys(style).length ? style : void 0;
+	});
+	const bodyColspan = computed(() => {
+		let count = visibleDataColumns.value.length;
+		if (columnPadLeft.value > 0) count += 1;
+		if (columnPadRight.value > 0) count += 1;
+		if (showRowDragHandle.value) count += 1;
+		if (core.detailExpandable.value) count += 1;
+		if (showSelectColumn.value) count += 1;
+		if (options.showEditGutterColumn() || options.showIndexColumn()) count += 1;
+		if (options.showRowStatusColumn()) count += 1;
+		return count;
+	});
+	const emptyContentStyle = computed(() => {
+		const w = core.measuredViewportWidth.value;
+		if (w <= 0) return void 0;
+		return { width: `${w}px` };
+	});
+	const interaction = useRsTableInteraction({
+		multiSort: () => options.multiSort(),
+		maxSort: () => options.maxSort(),
+		columnDraggable: () => options.columnDraggable(),
+		selectable: () => options.selectable(),
+		selectionType: () => options.selectionType(),
+		rowSelectable: options.rowSelectable,
+		rowDraggable: () => options.rowDraggable(),
+		rowDragTrigger: () => options.rowDragTrigger(),
+		rowDropMode: () => options.rowDropMode(),
+		rowDraggableWhen: options.rowDraggableWhen,
+		rowDropTargetWhen: options.rowDropTargetWhen,
+		canRowDrop: options.canRowDrop,
+		rowKey: () => options.rowKey(),
+		rowKeyByIndex: () => core.rowKeyByIndex.value,
+		selectedRowKeys: selectedRowKeysAcc,
+		selectedKeySet: () => core.selectedKeySet.value,
+		selectableRowKeys: () => core.selectableRowKeys.value,
+		selectAllState: () => core.selectAllState.value,
+		expandedRowKeys: expandedRowKeysAcc,
+		expandedKeySet: () => core.expandedKeySet.value,
+		treeMode: () => core.treeMode.value,
+		treeCheckStrictly: () => core.treeCheckStrictly.value,
+		treeLazy: () => core.treeLazy.value,
+		treeChildrenField: () => core.treeChildrenField.value,
+		treeIsLeafField: () => core.treeIsLeafField.value,
+		treeLoadingKeys: treeLoadingKeysAcc,
+		treeLoadingKeySet: () => core.treeLoadingKeySet.value,
+		tableTreeNodeIndex: () => core.tableTreeNodeIndex.value,
+		treeConfig: () => options.treeConfig(),
+		expandable: () => options.expandable(),
+		rowExpandable: options.rowExpandable,
+		sortState: sortStateAcc,
+		sortsState: sortsStateAcc,
+		columnOrderState: columnOrderStateAcc,
+		isEditingAny: () => options.isEditingAny(),
+		applyRowClickHighlight: options.applyRowClickHighlight,
+		onRowClickEmit: options.onRowClickEmit,
+		onRowDblclickEmit: options.onRowDblclickEmit,
+		onRowDragStartEmit: options.onRowDragStartEmit,
+		onRowDropEmit: options.onRowDropEmit
+	});
+	const contextMenu = useRsTableContextMenu({
+		enabled: options.contextMenuEnabled,
+		dataRows: () => core.dataRows.value,
+		displayColumns: () => core.displayColumns.value,
+		selectedRows: () => core.selectedRows.value,
+		rowKey: () => options.rowKey(),
+		rowKeyByIndex: () => core.rowKeyByIndex.value,
+		copyCellLabel: () => options.copyCellLabel(),
+		copyRowLabel: () => options.copyRowLabel(),
+		contextMenuItems: (row, selected) => options.contextMenuItems?.(row, selected) ?? [],
+		mergeFeatureMenuItems: options.mergeFeatureMenuItems,
+		shouldSelectOnContextmenu: () => options.selectOnContextmenu(),
+		canSelectRow: interaction.canSelectRow,
+		isRowSelected: interaction.isRowSelected,
+		selectionType: () => options.selectionType(),
+		getSelectedRowKeys: () => selectedRowKeysAcc.get(),
+		setSelectedRowKeys: (keys) => selectedRowKeysAcc.set(keys),
+		selectRowKeys,
+		getDraft: options.getDraft,
+		onSelect: options.onContextMenuSelect,
+		onRowContextmenu: options.onRowContextmenuEmit
+	});
+	return {
+		PREFIX_COL_WIDTH,
+		showRowDragHandle,
+		dragColumnOffset,
+		expandColumnOffset,
+		showSelectColumn,
+		isRowSelection,
+		isRadioSelection,
+		selectColumnOffset,
+		tableMinWidth,
+		tableRef,
+		isColumnResizing,
+		resizePaintWidths,
+		onResizeStart,
+		effectiveColumnWidths,
+		virtualColumnsEnabled,
+		visibleDataColumns,
+		columnPadLeft,
+		columnPadRight,
+		...layout,
+		useScrollContainer,
+		scrollContainerStyle,
+		bodyColspan,
+		emptyContentStyle,
+		...interaction,
+		...contextMenu
+	};
+}
+//#endregion
+export { useRsTableShell };