ensis-ui 0.0.0-stage → 3.0.0

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

@@ -0,0 +1,229 @@
+import { useRsI18n } from "../../../../composables/useRsI18n.js";
+import { buildTableEntries, buildTableTreeEntries, buildTableTreeNodeIndex, collectTableTreeExpandableKeys, injectExpandRows, isTableRowDisabled, resolveRowKey, resolveSelectAllState, resolveTableTreeIndent } from "../utils/table-utils.js";
+import { computed, ref, watch } from "vue";
+//#region src/components/table/src/composables/useRsTableEngine.ts
+/**
+* RsTable 数据内核：排序 / 筛选 / 分组后的 entries，以及选择、展开、树索引。
+*
+* 职责边界：
+* - 做：受控/非受控 sort、selection、expand；构建 tableEntries / viewRows
+* - 不做：虚拟滚动、列宽、右键菜单 DOM、行内编辑提交（由 RsTable + 其它 composable 负责）
+*
+* `viewRows` 供 summary / 表外 analytics 使用（仅业务行，不含 group/expand 伪行）。
+*/
+/** 统一读取 ComputedRef / Ref / getter */
+function read(source) {
+	if (typeof source === "function") return source();
+	return source.value;
+}
+/**
+* 表格数据内核。
+*
+* @returns 排序状态、选择/展开、树字段、tableEntries、dataRows、viewRows 等；
+*          行勾选/展开的「交互处理函数」仍留在 RsTable（依赖 DOM 与其它 UI 状态）。
+*/
+function useRsTableEngine(options) {
+	const { locale } = useRsI18n();
+	const internalSort = ref(options.defaultSort ?? null);
+	const internalSorts = ref([...options.defaultSorts]);
+	const internalSelectedRowKeys = ref([...options.defaultSelectedRowKeys]);
+	const internalExpandedRowKeys = ref([...options.defaultExpandedRowKeys]);
+	/** 树懒加载中的行 key（UI loading 用） */
+	const treeLoadingKeys = ref([]);
+	const isSortControlled = computed(() => read(options.sort) !== void 0);
+	/** 单列排序状态（受控或内部） */
+	const sortState = computed({
+		get: () => isSortControlled.value ? read(options.sort) ?? null : internalSort.value,
+		set: (value) => {
+			if (isSortControlled.value) options.emit("update:sort", value);
+			else internalSort.value = value;
+		}
+	});
+	const isSortsControlled = computed(() => read(options.sorts) !== void 0);
+	/** 多列排序状态 */
+	const sortsState = computed({
+		get: () => isSortsControlled.value ? read(options.sorts) ?? [] : internalSorts.value,
+		set: (value) => {
+			if (isSortsControlled.value) options.emit("update:sorts", value);
+			else internalSorts.value = value;
+			options.emit("sortsChange", value);
+		}
+	});
+	const isSelectionControlled = computed(() => read(options.selectedRowKeys) !== void 0);
+	/** 已选行 key 列表；写入时同步 selectionChange */
+	const selectedRowKeys = computed({
+		get: () => isSelectionControlled.value ? read(options.selectedRowKeys) ?? [] : internalSelectedRowKeys.value,
+		set: (value) => {
+			if (isSelectionControlled.value) options.emit("update:selectedRowKeys", value);
+			else internalSelectedRowKeys.value = value;
+			options.emit("selectionChange", value);
+		}
+	});
+	const selectedKeySet = computed(() => new Set(selectedRowKeys.value));
+	const isExpandedControlled = computed(() => read(options.expandedRowKeys) !== void 0);
+	/** 展开行 key（明细展开或树展开共用） */
+	const expandedRowKeys = computed({
+		get: () => isExpandedControlled.value ? read(options.expandedRowKeys) ?? [] : internalExpandedRowKeys.value,
+		set: (value) => {
+			if (isExpandedControlled.value) options.emit("update:expandedRowKeys", value);
+			else internalExpandedRowKeys.value = value;
+			options.emit("expandChange", value);
+		}
+	});
+	const expandedKeySet = computed(() => new Set(expandedRowKeys.value));
+	const treeMode = computed(() => Boolean(read(options.treeConfig)));
+	/** 明细行展开：与 tree 互斥，树表下强制关闭 */
+	const detailExpandable = computed(() => read(options.expandable) && !treeMode.value);
+	const treeChildrenField = computed(() => read(options.treeConfig)?.childrenField ?? "children");
+	const treeIsLeafField = computed(() => read(options.treeConfig)?.isLeafField ?? "isLeaf");
+	const treeLazy = computed(() => Boolean(read(options.treeConfig)?.lazy));
+	/** 默认严格勾选（父子不联动）；checkStrictly === false 时启用级联 */
+	const treeCheckStrictly = computed(() => read(options.treeConfig)?.checkStrictly !== false);
+	const treeIndentPx = computed(() => resolveTableTreeIndent(read(options.size), read(options.treeConfig)?.indent));
+	const treeExpandColumnKey = computed(() => {
+		const tree = read(options.treeConfig);
+		if (!tree) return null;
+		return tree.expandColumnKey ?? read(options.displayColumns)[0]?.key ?? null;
+	});
+	const treeFixExpandColumn = computed(() => read(options.treeConfig)?.fixExpandColumn !== false);
+	const treeLoadingKeySet = computed(() => new Set(treeLoadingKeys.value));
+	/** 全树索引：仅非严格勾选时构建，供级联半选等使用 */
+	const tableTreeNodeIndex = computed(() => {
+		if (!read(options.treeConfig) || treeCheckStrictly.value) return null;
+		return buildTableTreeNodeIndex(read(options.data), {
+			childrenField: treeChildrenField.value,
+			isLeafField: treeIsLeafField.value,
+			lazy: treeLazy.value,
+			rowKey: read(options.rowKey)
+		});
+	});
+	/** defaultExpandAll 是否已种过种子（避免空数据把 seeded 提前锁死） */
+	const treeExpandAllSeeded = ref(false);
+	watch(() => read(options.data), (data) => {
+		if (!read(options.treeConfig)?.defaultExpandAll) return;
+		if (isExpandedControlled.value) return;
+		if (treeExpandAllSeeded.value) return;
+		if (options.defaultExpandedRowKeys.length > 0) {
+			treeExpandAllSeeded.value = true;
+			return;
+		}
+		if (!data.length) return;
+		internalExpandedRowKeys.value = collectTableTreeExpandableKeys(data, {
+			childrenField: treeChildrenField.value,
+			isLeafField: treeIsLeafField.value,
+			lazy: treeLazy.value,
+			rowKey: read(options.rowKey)
+		});
+		treeExpandAllSeeded.value = true;
+	}, { immediate: true });
+	/**
+	* 渲染用 entry 流水线：
+	* - 树表：buildTableTreeEntries
+	* - 普通：buildTableEntries（sort/filter/group）再 injectExpandRows
+	*/
+	const tableEntries = computed(() => {
+		const tree = read(options.treeConfig);
+		const columns = read(options.displayColumns);
+		const data = read(options.data);
+		const rowKey = read(options.rowKey);
+		if (tree) return buildTableTreeEntries(data, columns, expandedKeySet.value, {
+			tree,
+			rowKey,
+			sort: sortState.value,
+			sorts: sortsState.value,
+			multiSort: read(options.multiSort),
+			filterText: read(options.filterText),
+			filterKeys: read(options.filterKeys),
+			columnFilters: read(options.columnFilters),
+			remoteSort: read(options.remoteSort),
+			locale: locale.value
+		});
+		return injectExpandRows(buildTableEntries(data, columns, {
+			sort: sortState.value,
+			sorts: sortsState.value,
+			multiSort: read(options.multiSort),
+			filterText: read(options.filterText),
+			filterKeys: read(options.filterKeys),
+			columnFilters: read(options.columnFilters),
+			groupBy: read(options.groupBy),
+			groupLabel: read(options.groupLabel),
+			remoteSort: read(options.remoteSort),
+			locale: locale.value
+		}), expandedKeySet.value, rowKey, read(options.rowExpandable));
+	});
+	/**
+	* 单次遍历 tableEntries，产出 dataRows / viewRows / selectableRowKeys / rowKeyByIndex。
+	* 不依赖 selectedKeySet，避免选中变化触发全量重遍历。
+	*/
+	const rowDerivedState = computed(() => {
+		const rows = [];
+		const view = [];
+		const selKeys = [];
+		const keyByIndex = /* @__PURE__ */ new Map();
+		const rowKey = read(options.rowKey);
+		const rowSelectable = read(options.rowSelectable);
+		for (const entry of tableEntries.value) {
+			if (entry.type !== "row") continue;
+			rows.push(entry);
+			view.push(entry.row);
+			const key = entry.treeKey ?? resolveRowKey(entry.row, entry.rowIndex, rowKey);
+			keyByIndex.set(entry.rowIndex, key);
+			if (!isTableRowDisabled(entry.row) && (rowSelectable ? rowSelectable(entry.row, entry.rowIndex) : true)) selKeys.push(key);
+		}
+		return {
+			rows,
+			view,
+			selKeys,
+			keyByIndex
+		};
+	});
+	const dataRows = computed(() => rowDerivedState.value.rows);
+	const selectableRowKeys = computed(() => rowDerivedState.value.selKeys);
+	/** rowIndex → rowKey，供模板热路径 O(1) 查询 */
+	const rowKeyByIndex = computed(() => rowDerivedState.value.keyByIndex);
+	/** 当前筛选/排序后的业务行（不含 group/expand 伪行），与 dataRows 同趟产出 */
+	const viewRows = computed(() => rowDerivedState.value.view);
+	return {
+		internalSort,
+		internalSorts,
+		internalSelectedRowKeys,
+		internalExpandedRowKeys,
+		treeLoadingKeys,
+		isSortControlled,
+		sortState,
+		isSortsControlled,
+		sortsState,
+		isSelectionControlled,
+		selectedRowKeys,
+		selectedKeySet,
+		isExpandedControlled,
+		expandedRowKeys,
+		expandedKeySet,
+		treeMode,
+		detailExpandable,
+		treeChildrenField,
+		treeIsLeafField,
+		treeLazy,
+		treeCheckStrictly,
+		treeIndentPx,
+		treeExpandColumnKey,
+		treeFixExpandColumn,
+		treeLoadingKeySet,
+		tableTreeNodeIndex,
+		tableEntries,
+		dataRows,
+		selectableRowKeys,
+		rowKeyByIndex,
+		selectedRows: computed(() => {
+			const keySet = selectedKeySet.value;
+			const keyMap = rowKeyByIndex.value;
+			const out = [];
+			for (const entry of dataRows.value) if (keySet.has(keyMap.get(entry.rowIndex) ?? "")) out.push(entry.row);
+			return out;
+		}),
+		selectAllState: computed(() => resolveSelectAllState(selectedRowKeys.value, selectableRowKeys.value)),
+		viewRows
+	};
+}
+//#endregion
+export { useRsTableEngine };

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

@@ -0,0 +1,38 @@
+/**
+ * RsTable ARIA Grid 键盘漫游（与编辑键盘解耦）。
+ *
+ * - 始终可在壳层焦点下移动 focusCell（只读表也可用）
+ * - 编辑中 / 表单控件内不抢键
+ * - 箭头 / Home / End / Ctrl+Home|End / PageUp|PageDown
+ * - 移动后将焦点格 scrollIntoView（nearest）
+ */
+import { type Ref } from 'vue';
+import type { useTableEdit } from './useTableEdit';
+import type { RsTableColumn, RsTableRowData, RsTableRowEntry } from '../utils/table-utils';
+type TableEditApi = ReturnType<typeof useTableEdit>;
+export interface UseRsTableGridKeyboardOptions<T extends RsTableRowData> {
+    tableEdit: TableEditApi;
+    /** 默认 true；可关以兼容旧行为 */
+    enabled?: () => boolean;
+    dataRows: () => Array<Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>>;
+    rowKeyFor: (entry: Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>) => string;
+    /** 可见数据列（与虚拟列切片一致） */
+    colKeys: () => string[];
+    displayColumns?: () => RsTableColumn<T>[];
+    applyRowClickHighlight: (rowKey: string) => void;
+    /** PageUp/Down 跨越行数，默认 10 */
+    pageSize?: () => number;
+    /** 滚动容器：用于焦点格滚入视口 */
+    scrollContainerRef?: Ref<HTMLElement | null | undefined>;
+}
+/**
+ * 网格键盘漫游 API。
+ */
+export declare function useRsTableGridKeyboard<T extends RsTableRowData>(options: UseRsTableGridKeyboardOptions<T>): {
+    onGridKeydown: (event: KeyboardEvent) => boolean;
+};
+export {};

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

@@ -0,0 +1,70 @@
+import { navigateGridCell, resolveGridNavDirection } from "../utils/rs-table-grid-nav.js";
+import { nextTick } from "vue";
+//#region src/components/table/src/composables/useRsTableGridKeyboard.ts
+/**
+* RsTable ARIA Grid 键盘漫游（与编辑键盘解耦）。
+*
+* - 始终可在壳层焦点下移动 focusCell（只读表也可用）
+* - 编辑中 / 表单控件内不抢键
+* - 箭头 / Home / End / Ctrl+Home|End / PageUp|PageDown
+* - 移动后将焦点格 scrollIntoView（nearest）
+*/
+function escapeAttr(value) {
+	if (typeof CSS !== "undefined" && typeof CSS.escape === "function") return CSS.escape(value);
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function scrollFocusCellIntoView(container, cell) {
+	if (!container) return;
+	const selector = `tr[data-row-key="${escapeAttr(cell.rowKey)}"] td[data-col-key="${escapeAttr(cell.colKey)}"]`;
+	const el = container.querySelector(selector);
+	if (el && typeof el.scrollIntoView === "function") el.scrollIntoView({
+		block: "nearest",
+		inline: "nearest"
+	});
+}
+/**
+* 网格键盘漫游 API。
+*/
+function useRsTableGridKeyboard(options) {
+	function buildRows() {
+		return options.dataRows().map((entry) => ({
+			rowKey: options.rowKeyFor(entry),
+			rowIndex: entry.rowIndex
+		}));
+	}
+	function resolveColKeys() {
+		const keys = options.colKeys();
+		if (keys.length) return keys;
+		return (options.displayColumns?.() ?? []).map((c) => c.key);
+	}
+	/**
+	* 处理网格导航键。已处理返回 true（调用方应停止后续编辑键逻辑中的箭头分支）。
+	*/
+	function onGridKeydown(event) {
+		if (options.enabled && !options.enabled()) return false;
+		if (options.tableEdit.editingCell.value) return false;
+		if (event.target?.closest("input, textarea, select, [contenteditable=\"true\"]")) return false;
+		const direction = resolveGridNavDirection(event);
+		if (!direction) return false;
+		const rows = buildRows();
+		const colKeys = resolveColKeys();
+		if (!rows.length || !colKeys.length) return false;
+		const focus = options.tableEdit.focusCell.value;
+		const next = navigateGridCell(rows, colKeys, focus ? {
+			rowKey: focus.rowKey,
+			colKey: focus.colKey,
+			rowIndex: focus.rowIndex
+		} : null, direction, options.pageSize?.() ?? 10);
+		if (!next) return false;
+		event.preventDefault();
+		options.tableEdit.setFocusCell(next);
+		options.applyRowClickHighlight(next.rowKey);
+		nextTick(() => {
+			scrollFocusCellIntoView(options.scrollContainerRef?.value, next);
+		});
+		return true;
+	}
+	return { onGridKeydown };
+}
+//#endregion
+export { useRsTableGridKeyboard };

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

@@ -0,0 +1,138 @@
+/**
+ * RsTable 无头驱动入口（无模板也能跑 Engine / Features / Api）。
+ *
+ * 适用：服务端预计算、自定义渲染器、图表只消费 snapshot。
+ * 不含列宽 DOM / 右键 / 编辑交互（那些依赖视图壳）。
+ *
+ * 多表：每次调用产生独立 Core + FeatureHost；互不共享状态。
+ * 唯一全局点是 RsTableModuleRegistry（显式 register 才会影响所有实例）。
+ */
+import type { Ref } from 'vue';
+import type { RsTableColumn, RsTableRowData, RsTableRowKey } from '../utils/table-utils';
+import type { RsTableFeature } from '../features/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/components/table/src/composables/useRsTableHeadless.js

@@ -0,0 +1,105 @@
+import { useRsTableCore } from "./useRsTableCore.js";
+//#region src/components/table/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 };