niuma-ui 1.1.12 → 1.2.0

package/dist/composables/useRsTableScrollLayout.js

@@ -0,0 +1,195 @@
+import { computed, nextTick, onUnmounted, ref, watch } from "vue";
+//#region src/composables/useRsTableScrollLayout.ts
+/**
+* RsTable 滚动与视口布局：测量、节流同步、keep-alive / layoutActive 恢复。
+*
+* 职责边界：
+* - 做：scrollTop/Left、视口宽高、写回 DOM、ResizeObserver、RAF 节流滚动
+* - 不做：虚拟切片本身、无限加载业务判定（由调用方在 onScroll 钩子中处理）
+*/
+/** 统一读取 ComputedRef / getter */
+function read(source) {
+	return typeof source === "function" ? source() : source.value;
+}
+/**
+* 表格滚动容器与视口状态。
+*
+* @returns 滚动状态、视口尺寸、恢复/重置 API、bindScrollElement / onScrollFrame
+*/
+function useRsTableScrollLayout(options) {
+	const scrollTop = ref(0);
+	const scrollLeft = ref(0);
+	const scrollContainerRef = ref(null);
+	const measuredViewportHeight = ref(0);
+	const measuredViewportWidth = ref(0);
+	let viewportResizeObserver = null;
+	let preservedScrollTop = 0;
+	let preservedScrollLeft = 0;
+	let restoringScroll = false;
+	let restoreGeneration = 0;
+	let scrollRafId = 0;
+	const fallback = options.fallbackViewportHeight ?? 320;
+	/** 虚拟切片用视口高度：显式 height > 测量值 > DOM > fallback */
+	const viewportHeight = computed(() => {
+		const h = read(options.height);
+		if (typeof h === "number" && h > 0) return h;
+		if (typeof h === "string") {
+			const parsed = Number.parseInt(h, 10);
+			if (Number.isFinite(parsed) && parsed > 0 && !h.includes("%")) return parsed;
+		}
+		if (measuredViewportHeight.value > 0) return measuredViewportHeight.value;
+		const el = scrollContainerRef.value;
+		if (el && el.clientHeight > 0) return el.clientHeight;
+		return fallback;
+	});
+	function syncMeasuredViewportSize() {
+		const el = scrollContainerRef.value;
+		if (!el) return;
+		const nextH = el.clientHeight;
+		if (nextH > 0 && nextH !== measuredViewportHeight.value) measuredViewportHeight.value = nextH;
+		const nextW = el.clientWidth;
+		if (nextW > 0 && nextW !== measuredViewportWidth.value) measuredViewportWidth.value = nextW;
+	}
+	/**
+	* 失活前快照滚动。
+	* DOM 脱离文档后 scrollTop 常为 0——切勿用 0 覆盖 onScroll 已写入的位置。
+	*/
+	function captureScrollFromDom() {
+		const el = scrollContainerRef.value;
+		if (el) {
+			if (el.scrollTop > 0) scrollTop.value = el.scrollTop;
+			if (el.scrollLeft > 0) scrollLeft.value = el.scrollLeft;
+		}
+		if (scrollTop.value > 0) preservedScrollTop = scrollTop.value;
+		if (scrollLeft.value > 0) preservedScrollLeft = scrollLeft.value;
+	}
+	/** 将内部保存的滚动写回 DOM，并同步 reactive（驱动虚拟切片）。 */
+	function restoreScrollToDom() {
+		const el = scrollContainerRef.value;
+		if (!el) return;
+		syncMeasuredViewportSize();
+		const top = preservedScrollTop;
+		const left = preservedScrollLeft;
+		if (scrollTop.value !== top) scrollTop.value = top;
+		if (scrollLeft.value !== left) scrollLeft.value = left;
+		if (el.scrollTop !== top) el.scrollTop = top;
+		if (el.scrollLeft !== left) el.scrollLeft = left;
+	}
+	/**
+	* 布局稳定后多次写回滚动：keep-alive 切回首帧 clientHeight 常为 0，
+	* 需等 nextTick / rAF / 视口测稳后再设 scrollTop，否则会被浏览器钳成 0。
+	*/
+	function scheduleVirtualLayoutSync() {
+		restoreGeneration += 1;
+		const gen = restoreGeneration;
+		restoringScroll = true;
+		const apply = () => {
+			if (gen !== restoreGeneration) return;
+			restoreScrollToDom();
+		};
+		apply();
+		nextTick(() => {
+			apply();
+			requestAnimationFrame(() => {
+				apply();
+				requestAnimationFrame(() => {
+					apply();
+					if (gen === restoreGeneration) restoringScroll = false;
+				});
+			});
+		});
+	}
+	function resetScrollPosition() {
+		preservedScrollTop = 0;
+		preservedScrollLeft = 0;
+		scrollTop.value = 0;
+		scrollLeft.value = 0;
+		const el = scrollContainerRef.value;
+		if (el) {
+			el.scrollTop = 0;
+			el.scrollLeft = 0;
+		}
+		scheduleVirtualLayoutSync();
+	}
+	function isRestoringScroll() {
+		return restoringScroll;
+	}
+	/**
+	* RAF 节流写入滚动位置；恢复窗口内忽略伪 scrollTop=0。
+	* @returns true 表示本帧已调度或处于恢复中（调用方仍可先做无限加载判断）
+	*/
+	function onScrollFrame(element) {
+		if (scrollRafId) return;
+		scrollRafId = requestAnimationFrame(() => {
+			if (restoringScroll) {
+				scrollRafId = 0;
+				return;
+			}
+			scrollTop.value = element.scrollTop;
+			scrollLeft.value = element.scrollLeft;
+			preservedScrollTop = element.scrollTop;
+			preservedScrollLeft = element.scrollLeft;
+			scrollRafId = 0;
+		});
+	}
+	/**
+	* 绑定滚动容器 ResizeObserver：视口从 0→实高时补一次恢复写回。
+	*/
+	function bindScrollElement(el) {
+		viewportResizeObserver?.disconnect();
+		viewportResizeObserver = null;
+		if (!el || typeof ResizeObserver === "undefined") return;
+		viewportResizeObserver = new ResizeObserver(() => {
+			const prevH = measuredViewportHeight.value;
+			syncMeasuredViewportSize();
+			if (prevH === 0 && measuredViewportHeight.value > 0 && (preservedScrollTop > 0 || preservedScrollLeft > 0)) {
+				restoringScroll = true;
+				restoreScrollToDom();
+				requestAnimationFrame(() => {
+					restoringScroll = false;
+				});
+			}
+		});
+		viewportResizeObserver.observe(el);
+	}
+	function disposeScrollLayout() {
+		viewportResizeObserver?.disconnect();
+		viewportResizeObserver = null;
+		if (scrollRafId) {
+			cancelAnimationFrame(scrollRafId);
+			scrollRafId = 0;
+		}
+	}
+	watch(() => read(options.layoutActive), (active, prev) => {
+		if (active === false && prev !== false) captureScrollFromDom();
+	}, { flush: "sync" });
+	watch(() => read(options.layoutActive), (active) => {
+		if (active) scheduleVirtualLayoutSync();
+	}, { flush: "post" });
+	watch(() => read(options.viewKey), (_next, prev) => {
+		if (prev === void 0) return;
+		resetScrollPosition();
+	});
+	onUnmounted(() => {
+		disposeScrollLayout();
+	});
+	return {
+		scrollTop,
+		scrollLeft,
+		scrollContainerRef,
+		measuredViewportHeight,
+		measuredViewportWidth,
+		viewportHeight,
+		syncMeasuredViewportSize,
+		captureScrollFromDom,
+		restoreScrollToDom,
+		scheduleVirtualLayoutSync,
+		resetScrollPosition,
+		isRestoringScroll,
+		onScrollFrame,
+		bindScrollElement,
+		disposeScrollLayout
+	};
+}
+//#endregion
+export { useRsTableScrollLayout };

package/dist/composables/useRsTableSelectionSource.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 表格分析/图表数据源：viewRows + selectedRows → 稳定 sourceRows。
+ *
+ * 约定（便于柱状图/饼图等后期扩展）：
+ * - 有选中行时 sourceMode='selected'，图表跟随勾选
+ * - 无选中时回退 viewRows（筛选/排序后的业务行）
+ * - subscribe 仅在浅层引用变化时通知，不做 deep watch
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import type { RsTableRowData } from '../components/table-utils';
+export type RsTableAnalyticsSourceMode = 'selected' | 'view';
+/** 分析快照：图表 / 指标卡 / 服务端请求共用 */
+export interface RsTableAnalyticsSnapshot<T extends RsTableRowData = RsTableRowData> {
+    viewRows: readonly T[];
+    selectedRows: readonly T[];
+    sourceRows: readonly T[];
+    sourceMode: RsTableAnalyticsSourceMode;
+    selectedCount: number;
+    viewCount: number;
+}
+export interface UseRsTableSelectionSourceOptions<T extends RsTableRowData> {
+    viewRows: Ref<T[]> | ComputedRef<T[]>;
+    selectedRows?: Ref<T[]> | ComputedRef<T[]>;
+}
+/**
+ * 选中优先的分析数据源。
+ *
+ * @returns sourceRows / sourceMode / getSnapshot / subscribe
+ */
+export declare function useRsTableSelectionSource<T extends RsTableRowData>(options: UseRsTableSelectionSourceOptions<T>): {
+    viewRows: ComputedRef<T[]>;
+    selectedRows: ComputedRef<T[]>;
+    sourceRows: ComputedRef<T[]>;
+    sourceMode: ComputedRef<RsTableAnalyticsSourceMode>;
+    getSnapshot: () => RsTableAnalyticsSnapshot<T>;
+    subscribe: (listener: (snap: RsTableAnalyticsSnapshot<T>) => void) => () => void;
+};
+export type RsTableSelectionSourceApi<T extends RsTableRowData> = ReturnType<typeof useRsTableSelectionSource<T>>;

package/dist/composables/useRsTableSelectionSource.js

@@ -0,0 +1,57 @@
+import { computed, watch } from "vue";
+//#region 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/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 '../components/context-menu-utils';
+import type { RsTableRowDragTrigger, RsTableRowDropMode } from '../components/table-drag';
+import type { RsTableColumn, RsTableRowData, RsTableRowEntry, RsTableRowKey, RsTableSelectionType, RsTableSortState, RsTableTreeConfig, RsTableTreeNodeIndex, RsTableRowDropPosition } from '../components/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("../components/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>>;