ensis-ui 0.0.0-stage → 3.0.1

package/dist/components/table/src/RsTable.impl.js

@@ -0,0 +1,679 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import RsContextMenu_default from "../../context-menu/src/RsContextMenu.js";
+import { assembleRsTableApi } from "./assembleRsTableApi.js";
+import { bindRsTableViewContext } from "./bindRsTableViewContext.js";
+import { createRsTableEditEmitBridge } from "./createRsTableEditEmitBridge.js";
+import { useTableCellTooltip } from "./composables/useTableCellTooltip.js";
+import { useRsTableCore } from "./composables/useRsTableCore.js";
+import { useRsTableEditLayer } from "./composables/useRsTableEditLayer.js";
+import { useRsTableScrollHost } from "./composables/useRsTableScrollHost.js";
+import { useRsTableShell } from "./composables/useRsTableShell.js";
+import { useRsTableShellChrome } from "./composables/useRsTableShellChrome.js";
+import { hasTableSummaryConfig } from "./utils/table-summary-utils.js";
+import { useRsTableSummary } from "./composables/useRsTableSummary.js";
+import RsTableBody_default from "./table-body/RsTableBody.js";
+import RsTableColGroup_default from "./table-body/RsTableColGroup.js";
+import RsTableHeader_default from "./table-header/RsTableHeader.js";
+import { RS_TABLE_PROP_DEFAULTS } from "./rs-table-props.js";
+import RsTableSummaryRow_default from "./table-footer/RsTableSummaryRow.js";
+/* empty css                */
+import { Fragment, Teleport, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, guardReactiveProps, mergeDefaults, mergeProps, normalizeClass, normalizeProps, normalizeStyle, openBlock, ref, renderList, renderSlot, toDisplayString, unref, useSlots, withCtx } from "vue";
+//#region src/components/table/src/RsTable.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "rs-table__head rs-table__head--sr-only"
+};
+var _hoisted_2 = { role: "row" };
+var _hoisted_3 = {
+	key: 2,
+	class: "rs-table__foot"
+};
+var _hoisted_4 = { key: 0 };
+var _hoisted_5 = ["colspan"];
+var RsTable_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsTable",
+	inheritAttrs: false,
+	__name: "RsTable",
+	props: /*@__PURE__*/ mergeDefaults({
+		columns: {},
+		data: {},
+		rowKey: { type: [String, Function] },
+		loading: { type: Boolean },
+		bordered: { type: Boolean },
+		columnBordered: { type: Boolean },
+		rounded: { type: Boolean },
+		fill: { type: Boolean },
+		compact: { type: Boolean },
+		size: {},
+		scrollX: {},
+		selectable: { type: Boolean },
+		selectionType: {},
+		selectedRowKeys: {},
+		defaultSelectedRowKeys: {},
+		rowSelectable: { type: Function },
+		expandable: { type: Boolean },
+		expandedRowKeys: {},
+		defaultExpandedRowKeys: {},
+		rowExpandable: { type: Function },
+		expandRowHeight: {},
+		treeConfig: {},
+		striped: { type: Boolean },
+		showIndex: { type: Boolean },
+		indexWidth: {},
+		showHeader: { type: Boolean },
+		remoteSort: { type: Boolean },
+		filterText: {},
+		filterKeys: {},
+		columnFilters: {},
+		defaultColumnFilters: {},
+		groupBy: { type: [String, Function] },
+		groupLabel: { type: Function },
+		sort: {},
+		defaultSort: {},
+		multiSort: { type: Boolean },
+		maxSort: {},
+		sorts: {},
+		defaultSorts: {},
+		columnDraggable: { type: Boolean },
+		columnOrder: {},
+		defaultColumnOrder: {},
+		rowDraggable: { type: Boolean },
+		rowDragTrigger: {},
+		rowDropMode: {},
+		rowDraggableWhen: { type: Function },
+		rowDropTargetWhen: { type: Function },
+		canRowDrop: { type: Function },
+		virtual: { type: Boolean },
+		virtualAutoThreshold: {},
+		virtualColumns: { type: [Boolean, String] },
+		virtualColumnsAutoThreshold: {},
+		virtualColumnOverscan: {},
+		height: {},
+		rowHeight: {},
+		overscan: {},
+		infinite: { type: Boolean },
+		hasMore: { type: Boolean },
+		loadingMore: { type: Boolean },
+		infiniteDistance: {},
+		virtualOnInfinite: { type: Boolean },
+		resizable: { type: Boolean },
+		columnLayout: {},
+		initialColumnWidths: {},
+		minColumnWidth: {},
+		maxColumnWidth: {},
+		selectOnContextmenu: { type: Boolean },
+		contextMenuItems: { type: Function },
+		contextMenu: { type: Boolean },
+		cellTooltip: { type: Boolean },
+		cellTooltipDelay: {},
+		headerTooltip: { type: Boolean },
+		cellFocus: {},
+		editable: { type: Boolean },
+		editTrigger: {},
+		editGutter: { type: Boolean },
+		editGutterWidth: {},
+		highlightRow: { type: Boolean },
+		highlightedRowKey: {},
+		defaultHighlightedRowKey: {},
+		highlightRowOnClick: { type: Boolean },
+		rowCommit: { type: Boolean },
+		rowPending: { type: Function },
+		showRowStatus: { type: Boolean },
+		allowNull: { type: Boolean },
+		nullLabel: {},
+		editFocusMode: {},
+		editKeyboard: { type: Boolean },
+		editUndo: { type: Boolean },
+		editUndoLimit: {},
+		editPaste: { type: Boolean },
+		editBatch: { type: Boolean },
+		summaryMode: {},
+		summaryData: {},
+		showSummary: { type: Boolean },
+		features: {},
+		viewKey: {},
+		layoutActive: { type: Boolean },
+		ariaLabel: {}
+	}, RS_TABLE_PROP_DEFAULTS),
+	emits: [
+		"rowClick",
+		"rowDblclick",
+		"cellView",
+		"rowContextmenu",
+		"contextMenuSelect",
+		"update:sort",
+		"update:sorts",
+		"sortsChange",
+		"update:columnOrder",
+		"columnOrderChange",
+		"update:columnFilters",
+		"columnFiltersChange",
+		"rowDrop",
+		"rowDragStart",
+		"update:selectedRowKeys",
+		"update:expandedRowKeys",
+		"selectionChange",
+		"expandChange",
+		"loadMore",
+		"columnResize",
+		"update:highlightedRowKey",
+		"highlightChange",
+		"cellEditStart",
+		"cellEditDialog",
+		"cellEditCommit",
+		"cellEditCancel",
+		"cellEditInvalid",
+		"cellEditBatchCommit",
+		"cellEditUndo",
+		"cellEditRedo",
+		"cellEditReject",
+		"rowEditCommit",
+		"rowEditRollback"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const { t } = useRsI18n();
+		const resolvedNullLabel = computed(() => props.nullLabel ?? t("table.nullValue"));
+		const sharedTipRef = ref(null);
+		const { state: cellTipState, onPointerOver: onCellTipOver, onPointerOut: onCellTipOut, hide: hideCellTooltip } = useTableCellTooltip({
+			enabled: () => props.cellTooltip,
+			headerEnabled: () => props.headerTooltip,
+			delay: () => props.cellTooltipDelay,
+			tipRef: sharedTipRef
+		});
+		const contextMenuEnabled = computed(() => props.contextMenu !== false);
+		/** 编辑层（早期）：须在 Shell 前，供 isEditingAny / 前缀列几何 */
+		const { tableEdit, rowHighlight, showEditGutterColumn, showIndexColumn, showRowStatusColumn, resolvedGutterWidth, resolvedIndexWidth, activeEditCellKey, activeFocusCellKey, activeErrorMapSize, activeValidatingMapSize, isEditingAny, cellTooltipEnabled, cellTooltipMode, cellTooltipText, cellTooltipFallbackTitle, bindActions: bindEditActions } = useRsTableEditLayer({
+			editable: () => props.editable,
+			editGutter: () => props.editGutter,
+			editGutterWidth: () => props.editGutterWidth,
+			showIndex: () => props.showIndex,
+			indexWidth: () => props.indexWidth,
+			rowCommit: () => props.rowCommit,
+			showRowStatus: () => props.showRowStatus,
+			editUndoLimit: () => props.editUndoLimit,
+			highlightRow: () => props.highlightRow,
+			highlightRowOnClick: () => props.highlightRowOnClick,
+			highlightedRowKey: () => props.highlightedRowKey,
+			defaultHighlightedRowKey: () => props.defaultHighlightedRowKey,
+			onHighlightUpdate: (value) => {
+				if (props.highlightedRowKey !== void 0) emit("update:highlightedRowKey", value);
+				emit("highlightChange", value);
+			},
+			cellTooltip: () => props.cellTooltip,
+			hasColumnSlot: (key) => Boolean(slots[key])
+		});
+		/**
+		* 汇总 feature 轻量判定（先于 Core，避免与 Summary 循环依赖）。
+		* 不构建 summaryCells，仅影响 feature id 登记。
+		*/
+		const summaryFeatureEnabledEarly = computed(() => Boolean(props.showSummary) || hasTableSummaryConfig({
+			columns: props.columns,
+			mode: props.summaryMode,
+			summaryData: props.summaryData
+		}));
+		/** 内核：Columns + Engine + Scroll + Virtual + Analytics + Features（浅层 data，签名重绑） */
+		const { columnOrderState, columnFiltersState, displayColumns, resolvedColumnWidths, useStableColumnWidths, updateColumnFilter, columnFilterValue, resolvedSize, sortState, sortsState, selectedRowKeys, selectedKeySet, expandedRowKeys, expandedKeySet, treeMode, detailExpandable, treeChildrenField, treeIsLeafField, treeLazy, treeCheckStrictly, treeIndentPx, treeExpandColumnKey, treeFixExpandColumn, treeLoadingKeys, treeLoadingKeySet, tableTreeNodeIndex, tableEntries, dataRows, selectableRowKeys, rowKeyByIndex, selectedRows, selectAllState, viewRows, internalSelectedRowKeys, internalExpandedRowKeys, isExpandedControlled, isSelectionControlled, scrollTop, scrollLeft, scrollContainerRef, measuredViewportHeight, measuredViewportWidth, viewportHeight, captureScrollFromDom, scheduleVirtualLayoutSync, onScrollFrame, bindScrollElement, fixedRowHeight, virtualScrollEnabled, virtualHeightModel, virtualSlice, visibleEntries, analyticsSource, tableSurface } = useRsTableCore({
+			columns: () => props.columns,
+			data: () => props.data,
+			rowKey: () => props.rowKey,
+			compact: () => props.compact,
+			size: () => props.size,
+			columnOrder: () => props.columnOrder,
+			defaultColumnOrder: props.defaultColumnOrder,
+			columnFilters: () => props.columnFilters,
+			defaultColumnFilters: props.defaultColumnFilters ?? {},
+			initialColumnWidths: () => props.initialColumnWidths,
+			resizable: () => props.resizable,
+			columnLayout: () => props.columnLayout,
+			sort: () => props.sort,
+			defaultSort: props.defaultSort ?? null,
+			sorts: () => props.sorts,
+			defaultSorts: props.defaultSorts,
+			multiSort: () => props.multiSort,
+			remoteSort: () => props.remoteSort,
+			filterText: () => props.filterText,
+			filterKeys: () => props.filterKeys,
+			groupBy: () => props.groupBy,
+			groupLabel: () => props.groupLabel,
+			treeConfig: () => props.treeConfig,
+			expandable: () => props.expandable,
+			rowExpandable: () => props.rowExpandable,
+			selectedRowKeys: () => props.selectedRowKeys,
+			defaultSelectedRowKeys: props.defaultSelectedRowKeys,
+			expandedRowKeys: () => props.expandedRowKeys,
+			defaultExpandedRowKeys: props.defaultExpandedRowKeys,
+			rowSelectable: () => props.rowSelectable,
+			height: () => props.height,
+			layoutActive: () => props.layoutActive,
+			viewKey: () => props.viewKey,
+			virtual: () => props.virtual,
+			virtualAutoThreshold: () => props.virtualAutoThreshold ?? 0,
+			fill: () => props.fill,
+			infinite: () => Boolean(props.infinite),
+			virtualOnInfinite: () => props.virtualOnInfinite !== false,
+			overscan: () => props.overscan,
+			expandRowHeight: () => props.expandRowHeight,
+			rowHeight: () => props.rowHeight,
+			selectable: () => props.selectable,
+			editable: () => props.editable,
+			contextMenu: () => props.contextMenu !== false,
+			summaryFeatureEnabled: () => summaryFeatureEnabledEarly.value,
+			features: () => props.features,
+			emit
+		});
+		/** 壳层：列宽 DOM 直写 + 列虚拟/布局 + 交互 + 右键（不碰 data deep watch） */
+		const { PREFIX_COL_WIDTH, showRowDragHandle, showSelectColumn, isRowSelection, isRadioSelection, tableRef, onResizeStart, virtualColumnsEnabled, visibleDataColumns, columnPadLeft, columnPadRight, useFixedColumnLayout, tableInlineStyle, overflowXEnabled, resolvedDataColumnWidth, columnStyleMap, columnHeaderStyleMap, columnTdClassMap, dragLeadStyle, expandLeadStyle, selectLeadStyle, indexLeadStyle, gutterLeadStyle, dragLeadHeaderStyle, expandLeadHeaderStyle, selectLeadHeaderStyle, indexLeadHeaderStyle, gutterLeadHeaderStyle, scrollContainerStyle, bodyColspan, emptyContentStyle, dragColumnKey, dropColumnKey, 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, ctxMenuItems, onCtxMenuSelect, onContextmenuCapture, onTableContextmenu, onRowContextmenu, onCellContextmenu } = useRsTableShell({
+			core: {
+				displayColumns,
+				resolvedColumnWidths,
+				useStableColumnWidths,
+				scrollLeft,
+				measuredViewportWidth,
+				virtualScrollEnabled,
+				dataRows,
+				selectedRows,
+				rowKeyByIndex,
+				selectedRowKeys,
+				selectedKeySet,
+				selectableRowKeys,
+				selectAllState,
+				expandedRowKeys,
+				expandedKeySet,
+				detailExpandable,
+				treeMode,
+				treeCheckStrictly,
+				treeLazy,
+				treeChildrenField,
+				treeIsLeafField,
+				treeLoadingKeys,
+				treeLoadingKeySet,
+				tableTreeNodeIndex,
+				sortState,
+				sortsState,
+				columnOrderState
+			},
+			rowDraggable: () => props.rowDraggable,
+			rowDragTrigger: () => props.rowDragTrigger,
+			selectable: () => props.selectable,
+			selectionType: () => props.selectionType,
+			scrollX: () => props.scrollX,
+			resizable: () => props.resizable,
+			minColumnWidth: () => props.minColumnWidth,
+			maxColumnWidth: () => props.maxColumnWidth,
+			columnLayout: () => props.columnLayout,
+			virtualColumns: () => props.virtualColumns,
+			virtualColumnsAutoThreshold: () => props.virtualColumnsAutoThreshold,
+			virtualColumnOverscan: () => props.virtualColumnOverscan,
+			fill: () => props.fill,
+			infinite: () => Boolean(props.infinite),
+			height: () => props.height,
+			showEditGutterColumn: () => showEditGutterColumn.value,
+			showIndexColumn: () => showIndexColumn.value,
+			showRowStatusColumn: () => showRowStatusColumn.value,
+			resolvedGutterWidth: () => resolvedGutterWidth.value,
+			resolvedIndexWidth: () => resolvedIndexWidth.value,
+			multiSort: () => props.multiSort,
+			maxSort: () => props.maxSort,
+			columnDraggable: () => props.columnDraggable,
+			rowSelectable: props.rowSelectable,
+			rowDropMode: () => props.rowDropMode,
+			rowDraggableWhen: props.rowDraggableWhen,
+			rowDropTargetWhen: props.rowDropTargetWhen,
+			canRowDrop: props.canRowDrop,
+			rowKey: () => props.rowKey,
+			treeConfig: () => props.treeConfig,
+			expandable: () => props.expandable,
+			rowExpandable: props.rowExpandable,
+			isEditingAny,
+			applyRowClickHighlight: (key) => rowHighlight.applyRowClickHighlight(key),
+			onRowClickEmit: (row, index) => emit("rowClick", row, index),
+			onRowDblclickEmit: (row, index) => emit("rowDblclick", row, index),
+			onRowDragStartEmit: (dragKeys, event) => emit("rowDragStart", dragKeys, event),
+			onRowDropEmit: (dragKeys, dropKey, position) => emit("rowDrop", dragKeys, dropKey, position),
+			onColumnResize: (key, width) => emit("columnResize", key, width),
+			contextMenuEnabled,
+			copyCellLabel: () => t("table.copyCell"),
+			copyRowLabel: () => t("table.copyRow"),
+			contextMenuItems: (row, selected) => props.contextMenuItems?.(row, selected) ?? [],
+			mergeFeatureMenuItems: (items, menuCtx) => tableSurface.mergeContextMenuItems(items, menuCtx),
+			selectOnContextmenu: () => props.selectOnContextmenu ?? props.selectable,
+			getDraft: tableEdit.getDraft,
+			onContextMenuSelect: (key, row, selected) => emit("contextMenuSelect", key, row, selected),
+			onRowContextmenuEmit: (row, rowIndex, event) => emit("rowContextmenu", row, rowIndex, event)
+		});
+		const { summaryFeatureEnabled, summaryCells, showBuiltinSummaryRow, summaryPrefixColspan } = useRsTableSummary({
+			showSummary: () => props.showSummary,
+			summaryMode: () => props.summaryMode,
+			summaryData: () => props.summaryData,
+			columns: () => props.columns,
+			displayColumns: () => displayColumns.value,
+			viewRows: () => viewRows.value,
+			hasSummarySlot: () => Boolean(slots.summary),
+			treeMode,
+			detailExpandable,
+			showRowDragHandle,
+			showSelectColumn,
+			showEditGutterOrIndex: () => showEditGutterColumn.value || showIndexColumn.value,
+			showRowStatusColumn
+		});
+		const { onCellStartEdit, onCellUpdateDraft, onCellCancelEdit, onCellCommitEdit, onCellNavigate, onCellClick, onCellDblclick, onTableKeydown, onTablePaste, onRowCommitEdit, onRowRollbackEdit, isExternalRowPending, rowEditPending, onGutterCommit, getRowByKey, getRowByIndex, getColumnValues, getCellValue, toApiEditSlice } = bindEditActions({
+			editable: () => props.editable,
+			editTrigger: () => props.editTrigger,
+			editKeyboard: () => props.editKeyboard,
+			editUndo: () => props.editUndo,
+			editPaste: () => props.editPaste,
+			editBatch: () => props.editBatch,
+			allowNull: () => props.allowNull,
+			rowCommit: () => props.rowCommit,
+			selectable: () => props.selectable,
+			selectionType: () => props.selectionType,
+			selectedRowKeys: () => selectedRowKeys.value,
+			displayColumns: () => displayColumns.value,
+			dataRows: () => dataRows.value,
+			rowKeyFor,
+			rowPending: props.rowPending,
+			onRowClick,
+			onRowDblclick,
+			emit: createRsTableEditEmitBridge(emit)
+		});
+		const { hasData, headerLabels, bodyLabels, hasColumnSlot, hasEditSlot, tableA11y, shellBind, onShellKeydown, scrollHostClass } = useRsTableShellChrome({
+			ariaLabel: () => props.ariaLabel,
+			loading: () => Boolean(props.loading),
+			dataRows,
+			visibleDataColumns,
+			displayColumns: () => displayColumns.value,
+			tableEdit,
+			rowKeyFor,
+			applyRowClickHighlight: (key) => rowHighlight.applyRowClickHighlight(key),
+			pageSize: () => Math.max(5, Math.floor((Number(props.height) || 320) / (fixedRowHeight.value || 36))),
+			onTableKeydown,
+			scrollContainerRef,
+			hostClass: {
+				bordered: () => props.bordered,
+				columnBordered: () => props.columnBordered,
+				rounded: () => props.rounded,
+				fill: () => props.fill,
+				compact: () => props.compact,
+				resolvedSize: () => resolvedSize.value,
+				virtualScrollEnabled: () => virtualScrollEnabled.value,
+				virtualColumnsEnabled: () => virtualColumnsEnabled.value,
+				dataLength: () => props.data.length,
+				infinite: () => Boolean(props.infinite),
+				resizable: () => props.resizable,
+				columnLayout: () => props.columnLayout,
+				useFixedColumnLayout: () => useFixedColumnLayout.value,
+				striped: () => props.striped,
+				selectable: () => props.selectable,
+				isRowSelection: () => isRowSelection.value,
+				detailExpandable: () => detailExpandable.value,
+				treeMode: () => treeMode.value,
+				rowDraggable: () => props.rowDraggable,
+				columnDraggable: () => props.columnDraggable,
+				scrollX: () => props.scrollX,
+				overflowXEnabled: () => overflowXEnabled.value,
+				contextMenuEnabled: () => contextMenuEnabled.value,
+				showEditGutterColumn: () => showEditGutterColumn.value
+			}
+		});
+		const { onScroll } = useRsTableScrollHost({
+			scrollContainerRef,
+			scheduleVirtualLayoutSync,
+			bindScrollElement,
+			captureScrollFromDom,
+			onScrollFrame,
+			hideCellTooltip,
+			infinite: () => Boolean(props.infinite),
+			loading: () => Boolean(props.loading),
+			loadingMore: () => Boolean(props.loadingMore),
+			hasMore: () => Boolean(props.hasMore),
+			infiniteDistance: () => props.infiniteDistance ?? 80,
+			onLoadMore: () => emit("loadMore")
+		});
+		const tableApi = assembleRsTableApi({
+			tableSurface,
+			dataRows,
+			rowKeyByIndex,
+			viewRows,
+			selectedRows,
+			selectedRowKeys,
+			getAnalyticsSnapshot: () => analyticsSource.getSnapshot(),
+			subscribeAnalytics: (listener) => analyticsSource.subscribe(listener),
+			getRowByKey,
+			getRowByIndex,
+			getColumnValues,
+			getCellValue,
+			toApiEditSlice
+		});
+		/** 实例级 ViewContext（多表 provide 互不串扰） */
+		bindRsTableViewContext({
+			props: {
+				columnDraggable: () => props.columnDraggable,
+				resizable: () => props.resizable,
+				multiSort: () => props.multiSort,
+				loading: () => Boolean(props.loading),
+				loadingMore: () => Boolean(props.loadingMore),
+				infinite: () => Boolean(props.infinite),
+				rowKey: () => props.rowKey,
+				striped: () => props.striped,
+				selectionType: () => props.selectionType,
+				editable: () => props.editable,
+				editTrigger: () => props.editTrigger,
+				rowCommit: () => props.rowCommit,
+				allowNull: () => props.allowNull,
+				editFocusMode: () => props.editFocusMode,
+				nullLabel: () => resolvedNullLabel.value
+			},
+			layout: {
+				useFixedColumnLayout,
+				showRowDragHandle,
+				detailExpandable,
+				showSelectColumn,
+				showEditGutterColumn,
+				showIndexColumn,
+				showRowStatusColumn,
+				columnPadLeft,
+				columnPadRight,
+				visibleDataColumns,
+				prefixWidths: PREFIX_COL_WIDTH,
+				resolvedGutterWidth,
+				resolvedIndexWidth,
+				isRadioSelection,
+				selectAllState,
+				columnFiltersState,
+				dragColumnKey,
+				dropColumnKey,
+				dragLeadHeaderStyle,
+				expandLeadHeaderStyle,
+				selectLeadHeaderStyle,
+				gutterLeadHeaderStyle,
+				indexLeadHeaderStyle,
+				columnHeaderStyleMap,
+				bodyColspan,
+				emptyContentStyle,
+				virtualScrollEnabled,
+				virtualSlice,
+				visibleEntries,
+				treeMode,
+				treeIndentPx,
+				treeExpandColumnKey,
+				treeLoadingKeySet,
+				dragLeadStyle,
+				expandLeadStyle,
+				selectLeadStyle,
+				indexLeadStyle,
+				gutterLeadStyle,
+				columnTdClassMap,
+				columnStyleMap,
+				dragRowKeys,
+				dropRowTargetKey,
+				dropRowPosition
+			},
+			chrome: {
+				hasData,
+				headerLabels,
+				bodyLabels,
+				hasColumnSlot,
+				hasEditSlot
+			},
+			edit: {
+				tableEdit,
+				activeEditCellKey,
+				activeFocusCellKey,
+				activeErrorMapSize,
+				activeValidatingMapSize,
+				cellTooltipEnabled,
+				cellTooltipMode,
+				cellTooltipText,
+				cellTooltipFallbackTitle,
+				rowEditPending,
+				isExternalRowPending,
+				onCellStartEdit,
+				onCellCommit: onCellCommitEdit,
+				onCellCancel: onCellCancelEdit,
+				onCellUpdateDraft,
+				onCellNavigate,
+				onRowCommit: onRowCommitEdit,
+				onRowRollback: onRowRollbackEdit,
+				onGutterCommit,
+				onCellClick,
+				onCellDblclick
+			},
+			interaction: {
+				isHighlighted: (key) => rowHighlight.isHighlighted(key),
+				onCellTipOver,
+				onCellTipOut,
+				resolvedDataColumnWidth,
+				columnFilterValue,
+				sortOrderFor,
+				sortPriorityFor,
+				sortIconName,
+				onToggleSelectAll,
+				onColumnDragOver,
+				onColumnDrop,
+				onColumnDragStart,
+				onColumnDragEnd,
+				updateColumnFilter,
+				onHeaderClick,
+				onResizeStart,
+				rowKeyFor,
+				isRowSelected,
+				isRowIndeterminate,
+				isRowExpanded,
+				treeDepthOf,
+				canExpandRow,
+				canSelectRow,
+				isRowDragByRow,
+				isRowDragging,
+				isRowDropTarget,
+				onRowClick,
+				onRowSelectMouseDown,
+				onCellContextmenu,
+				onRowDblclick,
+				onRowContextmenu,
+				onRowDragOver,
+				onRowDragLeave,
+				onRowDrop,
+				onRowDragStart,
+				onRowDragEnd,
+				onToggleExpand,
+				onToggleSelect: onToggleRow
+			}
+		});
+		__expose(tableApi);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(RsContextMenu_default, {
+				disabled: !contextMenuEnabled.value,
+				items: unref(ctxMenuItems),
+				onSelect: unref(onCtxMenuSelect)
+			}, {
+				default: withCtx(() => [createElementVNode("div", mergeProps({ class: ["rs-table-shell rs-motion-reduce", {
+					"rs-table-shell--ctx": contextMenuEnabled.value,
+					"rs-table-shell--fill": __props.fill
+				}] }, unref(shellBind), { onContextmenu: _cache[4] || (_cache[4] = (...args) => unref(onTableContextmenu) && unref(onTableContextmenu)(...args)) }), [createElementVNode("div", {
+					ref_key: "scrollContainerRef",
+					ref: scrollContainerRef,
+					class: normalizeClass(["rs-table rs-native-scrollbar", unref(scrollHostClass)]),
+					onContextmenuCapture: _cache[2] || (_cache[2] = (...args) => unref(onContextmenuCapture) && unref(onContextmenuCapture)(...args)),
+					style: normalizeStyle(unref(scrollContainerStyle)),
+					onScrollPassive: _cache[3] || (_cache[3] = (...args) => unref(onScroll) && unref(onScroll)(...args))
+				}, [createElementVNode("table", mergeProps({
+					ref_key: "tableRef",
+					ref: tableRef,
+					class: ["rs-table__table", `rs-table__table--cell-focus-${__props.cellFocus}`],
+					style: unref(tableInlineStyle)
+				}, unref(tableA11y), {
+					onKeydown: _cache[0] || (_cache[0] = (...args) => unref(onShellKeydown) && unref(onShellKeydown)(...args)),
+					onPaste: _cache[1] || (_cache[1] = (...args) => unref(onTablePaste) && unref(onTablePaste)(...args))
+				}), [
+					createVNode(RsTableColGroup_default),
+					!__props.showHeader ? (openBlock(), createElementBlock("thead", _hoisted_1, [createElementVNode("tr", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(visibleDataColumns), (column) => {
+						return openBlock(), createElementBlock("th", {
+							key: column.key,
+							scope: "col",
+							role: "columnheader",
+							class: "rs-table__th"
+						}, toDisplayString(column.title), 1);
+					}), 128))])])) : (openBlock(), createBlock(RsTableHeader_default, { key: 1 }, createSlots({ _: 2 }, [renderList(unref(visibleDataColumns), (column) => {
+						return {
+							name: `header-${column.key}`,
+							fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, `header-${column.key}`, normalizeProps(guardReactiveProps(slotProps)))])
+						};
+					})]), 1024)),
+					createVNode(RsTableBody_default, null, createSlots({
+						empty: withCtx(() => [renderSlot(_ctx.$slots, "empty", {}, () => [createTextVNode(toDisplayString(unref(t)("table.empty")), 1)])]),
+						group: withCtx((slotProps) => [renderSlot(_ctx.$slots, "group", normalizeProps(guardReactiveProps(slotProps)))]),
+						expand: withCtx((slotProps) => [renderSlot(_ctx.$slots, "expand", normalizeProps(guardReactiveProps(slotProps)))]),
+						_: 2
+					}, [renderList(unref(visibleDataColumns), (column) => {
+						return {
+							name: column.key,
+							fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, column.key, normalizeProps(guardReactiveProps(slotProps)))])
+						};
+					}), renderList(unref(visibleDataColumns), (column) => {
+						return {
+							name: `edit-${column.key}`,
+							fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, `edit-${column.key}`, normalizeProps(guardReactiveProps(slotProps)))])
+						};
+					})]), 1024),
+					_ctx.$slots.summary || unref(showBuiltinSummaryRow) ? (openBlock(), createElementBlock("tfoot", _hoisted_3, [_ctx.$slots.summary ? (openBlock(), createElementBlock("tr", _hoisted_4, [createElementVNode("td", {
+						class: "rs-table__summary",
+						colspan: unref(bodyColspan)
+					}, [renderSlot(_ctx.$slots, "summary")], 8, _hoisted_5)])) : (openBlock(), createBlock(RsTableSummaryRow_default, {
+						key: 1,
+						columns: unref(visibleDataColumns),
+						cells: unref(summaryCells),
+						"prefix-colspan": unref(summaryPrefixColspan),
+						"pad-left": unref(columnPadLeft),
+						"pad-right": unref(columnPadRight)
+					}, null, 8, [
+						"columns",
+						"cells",
+						"prefix-colspan",
+						"pad-left",
+						"pad-right"
+					]))])) : createCommentVNode("", true)
+				], 16)], 38), (openBlock(), createBlock(Teleport, { to: "body" }, [unref(cellTipState).visible ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					ref_key: "sharedTipRef",
+					ref: sharedTipRef,
+					class: normalizeClass(["rs-table__shared-tip", {
+						"rs-table__shared-tip--ready": unref(cellTipState).ready,
+						"rs-table__shared-tip--header": unref(cellTipState).kind === "header"
+					}]),
+					style: normalizeStyle(unref(cellTipState).style),
+					role: "tooltip"
+				}, toDisplayString(unref(cellTipState).text), 7)) : createCommentVNode("", true)]))], 16)]),
+				_: 3
+			}, 8, [
+				"disabled",
+				"items",
+				"onSelect"
+			]);
+		};
+	}
+});
+//#endregion
+export { RsTable_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/table/src/RsTable.js

@@ -0,0 +1,6 @@
+import '../style/rs-table.css'
+import RsTable_vue_vue_type_script_setup_true_lang_default from "./RsTable.impl.js";
+//#region src/components/table/src/RsTable.vue
+var RsTable_default = RsTable_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsTable_default as default };