niuma-ui 1.3.9 → 2.0.1

package/dist/composables/useRsTableHeadless.d.ts

@@ -1,138 +0,0 @@
-/**
- * RsTable 无头驱动入口（无模板也能跑 Engine / Features / Api）。
- *
- * 适用：服务端预计算、自定义渲染器、图表只消费 snapshot。
- * 不含列宽 DOM / 右键 / 编辑交互（那些依赖视图壳）。
- *
- * 多表：每次调用产生独立 Core + FeatureHost；互不共享状态。
- * 唯一全局点是 RsTableModuleRegistry（显式 register 才会影响所有实例）。
- */
-import type { Ref } from 'vue';
-import type { RsTableColumn, RsTableRowData, RsTableRowKey } from '../components/table-utils';
-import type { RsTableFeature } from '../components/table/table-features';
-import { type UseRsTableCoreOptions } from './useRsTableCore';
-export interface UseRsTableHeadlessOptions<T extends RsTableRowData> {
-    columns: Ref<RsTableColumn<T>[]> | (() => RsTableColumn<T>[]);
-    data: Ref<T[]> | (() => T[]);
-    rowKey?: RsTableRowKey<T> | (() => RsTableRowKey<T> | undefined);
-    selectable?: boolean;
-    features?: RsTableFeature<T>[] | (() => RsTableFeature<T>[] | undefined);
-    /** 最小 emit 桩；受控同步时可传入 */
-    emit?: UseRsTableCoreOptions<T>['emit'];
-}
-/**
- * 无头表格：复用 useRsTableCore（已含 Feature 绑定），再装配 Api。
- */
-export declare function useRsTableHeadless<T extends RsTableRowData>(options: UseRsTableHeadlessOptions<T>): {
-    api: import("./useRsTable").RsTableApi<T>;
-    core: {
-        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: Ref<number, number>;
-        scrollLeft: Ref<number, number>;
-        scrollContainerRef: Ref<HTMLElement | null, HTMLElement | null>;
-        measuredViewportHeight: Ref<number, number>;
-        measuredViewportWidth: 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: Ref<{
-            key: string;
-            order: Exclude<import("..").RsTableSortOrder, null>;
-        } | null, import("..").RsTableSortState | {
-            key: string;
-            order: Exclude<import("..").RsTableSortOrder, null>;
-        } | null>;
-        internalSorts: Ref<{
-            key: string;
-            order: Exclude<import("..").RsTableSortOrder, null>;
-        }[], import("..").RsTableSortState[] | {
-            key: string;
-            order: Exclude<import("..").RsTableSortOrder, null>;
-        }[]>;
-        internalSelectedRowKeys: Ref<string[], string[]>;
-        internalExpandedRowKeys: Ref<string[], string[]>;
-        treeLoadingKeys: Ref<string[], string[]>;
-        isSortControlled: import("vue").ComputedRef<boolean>;
-        sortState: import("vue").WritableComputedRef<import("..").RsTableSortState | null, import("..").RsTableSortState | null>;
-        isSortsControlled: import("vue").ComputedRef<boolean>;
-        sortsState: import("vue").WritableComputedRef<import("..").RsTableSortState[], import("..").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: Ref<string[], string[]>;
-        internalColumnFilters: Ref<Record<string, string>, Record<string, string>>;
-        internalColumnWidths: 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<import("..").RsTableSize>;
-        fixedRowHeight: import("vue").ComputedRef<number>;
-        tableEntriesForThreshold: import("vue").ComputedRef<number>;
-    };
-    getToolbarItems: () => import("..").RsTableToolbarItem[];
-    getOverlayContributions: () => import("..").RsTableOverlayContribution[];
-};

package/dist/composables/useRsTableHeadless.js

@@ -1,105 +0,0 @@
-import { useRsTableCore } from "./useRsTableCore.js";
-//#region src/composables/useRsTableHeadless.ts
-function readRefOrGetter(source) {
-	return typeof source === "function" ? source : () => source.value;
-}
-/**
-* 无头表格：复用 useRsTableCore（已含 Feature 绑定），再装配 Api。
-*/
-function useRsTableHeadless(options) {
-	const getColumns = readRefOrGetter(options.columns);
-	const getData = readRefOrGetter(options.data);
-	const getRowKey = () => {
-		const key = options.rowKey;
-		if (key == null) return void 0;
-		if (typeof key === "string") return key;
-		if (typeof key === "function" && key.length === 0) return key();
-		return key;
-	};
-	const getFeatures = () => typeof options.features === "function" ? options.features() : options.features;
-	const noopEmit = (() => void 0);
-	const core = useRsTableCore({
-		columns: getColumns,
-		data: getData,
-		rowKey: getRowKey,
-		compact: () => false,
-		size: () => "md",
-		columnOrder: () => void 0,
-		defaultColumnOrder: [],
-		columnFilters: () => void 0,
-		defaultColumnFilters: {},
-		initialColumnWidths: () => void 0,
-		resizable: () => false,
-		columnLayout: () => "auto",
-		sort: () => void 0,
-		defaultSort: null,
-		sorts: () => void 0,
-		defaultSorts: [],
-		multiSort: () => false,
-		remoteSort: () => false,
-		filterText: () => void 0,
-		filterKeys: () => void 0,
-		groupBy: () => void 0,
-		groupLabel: () => void 0,
-		treeConfig: () => void 0,
-		expandable: () => false,
-		rowExpandable: () => void 0,
-		selectedRowKeys: () => void 0,
-		defaultSelectedRowKeys: [],
-		expandedRowKeys: () => void 0,
-		defaultExpandedRowKeys: [],
-		rowSelectable: () => void 0,
-		height: () => 320,
-		layoutActive: () => true,
-		viewKey: () => void 0,
-		virtual: () => false,
-		virtualAutoThreshold: () => 50,
-		fill: () => false,
-		infinite: () => false,
-		virtualOnInfinite: () => true,
-		overscan: () => 4,
-		expandRowHeight: () => void 0,
-		rowHeight: () => void 0,
-		selectable: () => Boolean(options.selectable),
-		editable: () => false,
-		contextMenu: () => false,
-		summaryFeatureEnabled: () => false,
-		features: getFeatures,
-		emit: options.emit ?? noopEmit
-	});
-	return {
-		api: core.tableSurface.createApi({
-			getRowByKey: (rowKey) => {
-				return core.dataRows.value.find((item) => core.rowKeyByIndex.value.get(item.rowIndex) === rowKey)?.row;
-			},
-			getRowByIndex: (index) => core.dataRows.value.find((item) => item.rowIndex === index)?.row,
-			getColumnValues: () => [],
-			getCellValue: () => void 0,
-			getViewRows: () => core.viewRows.value,
-			getSelectedRows: () => core.selectedRows.value,
-			getSelectedRowKeys: () => [...core.selectedRowKeys.value],
-			getAnalyticsSnapshot: () => core.analyticsSource.getSnapshot(),
-			subscribeAnalytics: (listener) => core.analyticsSource.subscribe(listener),
-			getHighlightedRowKey: () => void 0,
-			setHighlightedRowKey: () => void 0,
-			cancelCellEdit: () => void 0,
-			cancelAllEdits: () => void 0,
-			getDirtyCellKeys: () => [],
-			getCellError: () => void 0,
-			setCellError: () => void 0,
-			stageCell: () => void 0,
-			rejectRowEdit: () => void 0,
-			undoEdit: () => void 0,
-			redoEdit: () => void 0,
-			commitRowEdits: () => void 0,
-			rollbackRowEdits: () => void 0,
-			getToolbarItems: () => core.tableSurface.getToolbarItems(),
-			getOverlayContributions: () => core.tableSurface.getOverlayContributions()
-		}, { provide: false }),
-		core,
-		getToolbarItems: () => core.tableSurface.getToolbarItems(),
-		getOverlayContributions: () => core.tableSurface.getOverlayContributions()
-	};
-}
-//#endregion
-export { useRsTableHeadless };

package/dist/composables/useRsTableInteraction.d.ts

@@ -1,145 +0,0 @@
-/**
- * RsTable 行/列交互：排序点击、列拖拽排序、行选/展开、行拖拽封装。
- *
- * 性能约定：
- * - 不引入对 data 的 deep watch
- * - rowKeyFor 走 Engine 的 rowKeyByIndex 缓存，避免热路径重复 resolve
- */
-import { type Ref } from 'vue';
-import { type RsTableRowDragTrigger, type RsTableRowDropMode } from '../components/table-drag';
-import { type RsTableColumn, type RsTableRowData, type RsTableRowEntry, type RsTableRowKey, type RsTableSelectionType, type RsTableSortOrder, type RsTableSortState, type RsTableTreeConfig, type RsTableTreeNodeIndex, type RsTableRowDropPosition } from '../components/table-utils';
-export interface UseRsTableInteractionOptions<T extends RsTableRowData> {
-    multiSort: () => boolean;
-    maxSort: () => number | undefined;
-    columnDraggable: () => boolean;
-    selectable: () => boolean;
-    selectionType: () => RsTableSelectionType;
-    rowSelectable?: (row: T, index: number) => boolean;
-    rowDraggable: () => boolean;
-    rowDragTrigger: () => RsTableRowDragTrigger;
-    rowDropMode: () => RsTableRowDropMode;
-    rowDraggableWhen?: (row: T, index: number) => boolean;
-    rowDropTargetWhen?: (row: T, index: number) => boolean;
-    canRowDrop?: (dragKeys: string[], dropKey: string) => boolean;
-    rowKey: () => RsTableRowKey<T> | undefined;
-    rowKeyByIndex: () => Map<number, string>;
-    selectedRowKeys: {
-        get: () => string[];
-        set: (keys: string[]) => void;
-    };
-    selectedKeySet: () => Set<string>;
-    selectableRowKeys: () => string[];
-    selectAllState: () => 'checked' | 'indeterminate' | 'unchecked';
-    expandedRowKeys: {
-        get: () => string[];
-        set: (keys: string[]) => void;
-    };
-    expandedKeySet: () => Set<string>;
-    treeMode: () => boolean;
-    treeCheckStrictly: () => boolean;
-    treeLazy: () => boolean;
-    treeChildrenField: () => string;
-    treeIsLeafField: () => string;
-    treeLoadingKeys: {
-        get: () => string[];
-        set: (keys: string[]) => void;
-    };
-    treeLoadingKeySet: () => Set<string>;
-    tableTreeNodeIndex: () => Map<string, RsTableTreeNodeIndex> | null;
-    treeConfig: () => RsTableTreeConfig<T> | undefined;
-    expandable: () => boolean;
-    rowExpandable?: (row: T, index: number) => boolean;
-    sortState: {
-        get: () => RsTableSortState | null;
-        set: (value: RsTableSortState | null) => void;
-    };
-    sortsState: {
-        get: () => RsTableSortState[];
-        set: (value: RsTableSortState[]) => void;
-    };
-    columnOrderState: {
-        get: () => string[];
-        set: (value: string[]) => void;
-    };
-    /** 行选时若正在编辑则不改选中 */
-    isEditingAny: () => boolean;
-    applyRowClickHighlight: (rowKey: 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;
-}
-/**
- * 表格交互 API（排序 / 列拖 / 行选展开 / 行拖）。
- */
-export declare function useRsTableInteraction<T extends RsTableRowData>(options: UseRsTableInteractionOptions<T>): {
-    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>;
-    rowKeyFor: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => string;
-    sortOrderFor: (key: string) => 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: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    isRowSelected: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    isRowIndeterminate: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    onToggleRow: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => void;
-    onToggleSelectAll: () => void;
-    canExpandRow: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    isRowExpanded: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    treeDepthOf: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => number;
-    onToggleExpand: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => Promise<void>;
-    onRowClick: (entry: RsTableRowEntry<T>, event?: MouseEvent) => void;
-    onRowSelectMouseDown: (event: MouseEvent) => void;
-    onRowDblclick: (entry: RsTableRowEntry<T>, _event?: MouseEvent) => void;
-    onRowDragStart: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>, event: DragEvent) => void;
-    onRowDragOver: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>, event: DragEvent) => void;
-    onRowDragLeave: (event: DragEvent) => void;
-    onRowDrop: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>, event: DragEvent) => void;
-    onRowDragEnd: () => void;
-    isRowDropTarget: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    isRowDragging: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    canDragRow: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-    isRowDragByRow: (entry: Extract<RsTableRowEntry<T>, {
-        type: "row";
-    }>) => boolean;
-};
-export type RsTableInteractionApi<T extends RsTableRowData> = ReturnType<typeof useRsTableInteraction<T>>;

package/dist/composables/useRsTableInteraction.js

@@ -1,249 +0,0 @@
-import { getSortOrderForKey, getSortPriorityForKey, getTableTreeChildren, hasTableTreeChildren, isTableRowDisabled, reorderColumnKeys, resolveRowKey, resolveTableTreeCheckState, selectRowKeys, selectRowKeysByClick, toggleExpandedRowKeys, toggleMultiSortState, toggleSelectAll, toggleSortState, toggleTableTreeCheck } from "../components/table-utils.js";
-import { createTableRowDragHandlers, createTableRowDragState } from "../components/table-drag.js";
-import { ref } from "vue";
-//#region src/composables/useRsTableInteraction.ts
-/**
-* RsTable 行/列交互：排序点击、列拖拽排序、行选/展开、行拖拽封装。
-*
-* 性能约定：
-* - 不引入对 data 的 deep watch
-* - rowKeyFor 走 Engine 的 rowKeyByIndex 缓存，避免热路径重复 resolve
-*/
-/**
-* 表格交互 API（排序 / 列拖 / 行选展开 / 行拖）。
-*/
-function useRsTableInteraction(options) {
-	const dragColumnKey = ref(null);
-	const dropColumnKey = ref(null);
-	const selectionAnchorKey = ref(null);
-	const rowDragState = createTableRowDragState();
-	const { dragRowKeys, dropRowTargetKey, dropRowPosition } = rowDragState;
-	function rowKeyFor(entry) {
-		return options.rowKeyByIndex().get(entry.rowIndex) ?? entry.treeKey ?? resolveRowKey(entry.row, entry.rowIndex, options.rowKey());
-	}
-	function sortOrderFor(key) {
-		if (options.multiSort()) return getSortOrderForKey(options.sortsState.get(), key);
-		const sort = options.sortState.get();
-		return sort?.key === key ? sort.order : null;
-	}
-	function sortPriorityFor(key) {
-		if (!options.multiSort()) return 0;
-		return getSortPriorityForKey(options.sortsState.get(), key);
-	}
-	function sortIconName(key) {
-		const order = sortOrderFor(key);
-		if (order === "asc") return "arrow-up";
-		if (order === "desc") return "arrow-down";
-		return "arrow-up-down";
-	}
-	function onHeaderClick(column) {
-		if (!column.sortable) return;
-		if (options.multiSort()) {
-			options.sortsState.set(toggleMultiSortState(options.sortsState.get(), column.key, options.maxSort()));
-			return;
-		}
-		options.sortState.set(toggleSortState(options.sortState.get(), column.key));
-	}
-	function onColumnDragStart(key, event) {
-		if (!options.columnDraggable()) return;
-		dragColumnKey.value = key;
-		dropColumnKey.value = null;
-		if (!event.dataTransfer) return;
-		event.dataTransfer.setData("text/plain", key);
-		event.dataTransfer.effectAllowed = "move";
-	}
-	function onColumnDragOver(key, event) {
-		if (!options.columnDraggable() || !dragColumnKey.value) return;
-		if (dragColumnKey.value === key) {
-			if (dropColumnKey.value !== null) dropColumnKey.value = null;
-			return;
-		}
-		event.preventDefault();
-		if (dropColumnKey.value !== key) dropColumnKey.value = key;
-	}
-	function onColumnDrop(key, event) {
-		if (!options.columnDraggable() || !dragColumnKey.value) return;
-		event.preventDefault();
-		if (dragColumnKey.value === key) return;
-		options.columnOrderState.set(reorderColumnKeys(options.columnOrderState.get(), dragColumnKey.value, key));
-		dragColumnKey.value = null;
-		dropColumnKey.value = null;
-	}
-	function onColumnDragEnd() {
-		dragColumnKey.value = null;
-		dropColumnKey.value = null;
-	}
-	const isRowSelection = () => options.selectable() && options.selectionType() === "row";
-	function canSelectRow(entry) {
-		if (isTableRowDisabled(entry.row)) return false;
-		return options.rowSelectable ? options.rowSelectable(entry.row, entry.rowIndex) : true;
-	}
-	function isRowSelected(entry) {
-		const key = rowKeyFor(entry);
-		const index = options.tableTreeNodeIndex();
-		if (index && !options.treeCheckStrictly()) return resolveTableTreeCheckState(key, options.selectedKeySet(), index, false) === "checked";
-		return options.selectedKeySet().has(key);
-	}
-	function isRowIndeterminate(entry) {
-		const index = options.tableTreeNodeIndex();
-		if (!index || options.treeCheckStrictly()) return false;
-		return resolveTableTreeCheckState(rowKeyFor(entry), options.selectedKeySet(), index, false) === "indeterminate";
-	}
-	function onToggleRow(entry) {
-		if (!canSelectRow(entry)) return;
-		const key = rowKeyFor(entry);
-		const index = options.tableTreeNodeIndex();
-		if (index && !options.treeCheckStrictly() && options.selectionType() !== "radio") {
-			options.selectedRowKeys.set(toggleTableTreeCheck(key, options.selectedKeySet(), index, false));
-			return;
-		}
-		options.selectedRowKeys.set(selectRowKeys(options.selectedRowKeys.get(), key, options.selectionType()));
-	}
-	function onToggleSelectAll() {
-		const select = options.selectAllState() !== "checked";
-		options.selectedRowKeys.set(toggleSelectAll(options.selectedRowKeys.get(), options.selectableRowKeys(), select));
-	}
-	function canExpandRow(entry) {
-		if (options.treeMode()) {
-			if (entry.hasChildren != null) return entry.hasChildren;
-			return hasTableTreeChildren(entry.row, {
-				childrenField: options.treeChildrenField(),
-				isLeafField: options.treeIsLeafField(),
-				lazy: options.treeLazy()
-			});
-		}
-		if (!options.expandable()) return false;
-		if (options.rowExpandable) return options.rowExpandable(entry.row, entry.rowIndex);
-		return true;
-	}
-	function isRowExpanded(entry) {
-		return options.expandedKeySet().has(rowKeyFor(entry));
-	}
-	function treeDepthOf(entry) {
-		return entry.depth ?? 0;
-	}
-	async function onToggleExpand(entry) {
-		if (!canExpandRow(entry)) return;
-		const key = rowKeyFor(entry);
-		const expanding = !options.expandedKeySet().has(key);
-		const tree = options.treeConfig();
-		if (options.treeMode() && expanding && options.treeLazy() && tree?.loadData && getTableTreeChildren(entry.row, options.treeChildrenField()).length === 0) {
-			if (options.treeLoadingKeySet().has(key)) return;
-			options.treeLoadingKeys.set([...options.treeLoadingKeys.get(), key]);
-			try {
-				const loaded = await tree.loadData(entry.row, key);
-				if (Array.isArray(loaded)) entry.row[options.treeChildrenField()] = loaded;
-			} finally {
-				options.treeLoadingKeys.set(options.treeLoadingKeys.get().filter((item) => item !== key));
-			}
-		}
-		options.expandedRowKeys.set(toggleExpandedRowKeys(options.expandedRowKeys.get(), key));
-	}
-	function onRowClick(entry, event) {
-		if (entry.type !== "row") return;
-		const rowKey = rowKeyFor(entry);
-		if (isRowSelection() && canSelectRow(entry) && !options.isEditingAny()) {
-			const toggle = Boolean(event && (event.ctrlKey || event.metaKey));
-			const range = Boolean(event?.shiftKey);
-			options.selectedRowKeys.set(selectRowKeysByClick(options.selectedRowKeys.get(), rowKey, {
-				toggle,
-				range,
-				orderedKeys: options.selectableRowKeys(),
-				anchorKey: selectionAnchorKey.value
-			}));
-			if (!range) selectionAnchorKey.value = rowKey;
-			if (typeof window !== "undefined") window.getSelection()?.removeAllRanges();
-		}
-		options.applyRowClickHighlight(rowKey);
-		options.onRowClickEmit(entry.row, entry.rowIndex);
-	}
-	function onRowSelectMouseDown(event) {
-		if (!isRowSelection()) return;
-		if (event.shiftKey || event.ctrlKey || event.metaKey) event.preventDefault();
-	}
-	function onRowDblclick(entry, _event) {
-		if (entry.type !== "row") return;
-		options.onRowDblclickEmit(entry.row, entry.rowIndex);
-	}
-	const rowDrag = createTableRowDragHandlers({
-		state: rowDragState,
-		getRowDraggable: () => options.rowDraggable(),
-		getRowDragTrigger: () => options.rowDragTrigger(),
-		getRowDropMode: () => options.rowDropMode(),
-		rowDraggableWhen: options.rowDraggableWhen,
-		rowDropTargetWhen: options.rowDropTargetWhen,
-		canRowDrop: options.canRowDrop,
-		rowKeyFor: (row, index) => resolveRowKey(row, index, options.rowKey()),
-		isRowDisabled: isTableRowDisabled,
-		getSelectedKeys: () => options.selectedRowKeys.get(),
-		onDragStart: (dragKeys, event) => options.onRowDragStartEmit(dragKeys, event),
-		onDrop: (dragKeys, dropKey, position) => options.onRowDropEmit(dragKeys, dropKey, position)
-	});
-	function onRowDragStart(entry, event) {
-		rowDrag.onRowDragStart(entry.row, entry.rowIndex, event);
-	}
-	function onRowDragOver(entry, event) {
-		rowDrag.onRowDragOver(entry.row, entry.rowIndex, event);
-	}
-	function onRowDragLeave(event) {
-		rowDrag.onRowDragLeave(event);
-	}
-	function onRowDrop(entry, event) {
-		rowDrag.onRowDrop(entry.row, entry.rowIndex, event);
-	}
-	function onRowDragEnd() {
-		rowDrag.onRowDragEnd();
-	}
-	function isRowDropTarget(entry) {
-		return rowDrag.isRowDropTarget(rowKeyFor(entry));
-	}
-	function isRowDragging(entry) {
-		return rowDrag.isRowDragging(rowKeyFor(entry));
-	}
-	function canDragRow(entry) {
-		return rowDrag.canDragRow(entry.row, entry.rowIndex);
-	}
-	function isRowDragByRow(entry) {
-		return options.rowDraggable() && options.rowDragTrigger() === "row" && canDragRow(entry);
-	}
-	return {
-		dragColumnKey,
-		dropColumnKey,
-		selectionAnchorKey,
-		dragRowKeys,
-		dropRowTargetKey,
-		dropRowPosition,
-		rowKeyFor,
-		sortOrderFor,
-		sortPriorityFor,
-		sortIconName,
-		onHeaderClick,
-		onColumnDragStart,
-		onColumnDragOver,
-		onColumnDrop,
-		onColumnDragEnd,
-		canSelectRow,
-		isRowSelected,
-		isRowIndeterminate,
-		onToggleRow,
-		onToggleSelectAll,
-		canExpandRow,
-		isRowExpanded,
-		treeDepthOf,
-		onToggleExpand,
-		onRowClick,
-		onRowSelectMouseDown,
-		onRowDblclick,
-		onRowDragStart,
-		onRowDragOver,
-		onRowDragLeave,
-		onRowDrop,
-		onRowDragEnd,
-		isRowDropTarget,
-		isRowDragging,
-		canDragRow,
-		isRowDragByRow
-	};
-}
-//#endregion
-export { useRsTableInteraction };

package/dist/composables/useRsTableScrollHost.js

@@ -1,42 +0,0 @@
-import { isNearScrollBottom } from "../components/table-utils.js";
-import { onActivated, onDeactivated, onMounted, ref, watch } from "vue";
-//#region src/composables/useRsTableScrollHost.ts
-/**
-* RsTable 滚动宿主生命周期 + 无限加载触底。
-*/
-/**
-* 绑定滚动生命周期与无限加载。
-*/
-function useRsTableScrollHost(options) {
-	const loadMoreLocked = ref(false);
-	onMounted(() => {
-		options.scheduleVirtualLayoutSync();
-		options.bindScrollElement(options.scrollContainerRef.value);
-	});
-	onActivated(() => {
-		options.scheduleVirtualLayoutSync();
-	});
-	onDeactivated(() => {
-		options.captureScrollFromDom();
-	});
-	function onScroll(event) {
-		options.hideCellTooltip();
-		const element = event.target;
-		if (options.infinite() && !options.loading() && !options.loadingMore() && options.hasMore() && !loadMoreLocked.value) {
-			if (isNearScrollBottom(element.scrollTop, element.scrollHeight, element.clientHeight, options.infiniteDistance())) {
-				loadMoreLocked.value = true;
-				options.onLoadMore();
-			}
-		}
-		options.onScrollFrame(element);
-	}
-	watch(() => [options.loadingMore(), options.hasMore()], ([loadingMore, hasMore]) => {
-		if (!loadingMore || !hasMore) loadMoreLocked.value = false;
-	});
-	return {
-		onScroll,
-		loadMoreLocked
-	};
-}
-//#endregion
-export { useRsTableScrollHost };