@affino/datagrid-vue-app 0.1.1

package/dist/stage/useDataGridTableStageCellIo.js

@@ -0,0 +1,62 @@
+import { resolveDataGridCellClickAction, toggleDataGridCellValue, } from "@affino/datagrid-vue";
+export function useDataGridTableStageCellIo(options) {
+    const readStageCell = (row, columnKey) => {
+        if (options.isRowSelectionColumnKey(columnKey)) {
+            return options.readRowSelectionCell(row);
+        }
+        return options.readCell(row, columnKey);
+    };
+    const readStageDisplayCell = (row, columnKey) => {
+        if (options.isRowSelectionColumnKey(columnKey)) {
+            return options.readRowSelectionDisplayCell(row);
+        }
+        return options.readDisplayCell(row, columnKey);
+    };
+    const handleCellClick = (row, rowOffset, column, columnIndex) => {
+        if (options.isRowSelectionColumn(column)) {
+            options.toggleRowCheckboxSelected(row);
+            return;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        const editable = options.isCellEditableByKey(row, rowIndex, column.key, columnIndex);
+        const clickAction = resolveDataGridCellClickAction({
+            column: column.column,
+            row: row.kind !== "group" ? row.data : undefined,
+            editable,
+        });
+        if (clickAction !== "toggle") {
+            return;
+        }
+        if (row.kind === "group" || row.rowId == null) {
+            return;
+        }
+        const beforeSnapshot = options.captureHistorySnapshot();
+        options.runtime.api.rows.applyEdits([
+            {
+                rowId: row.rowId,
+                data: {
+                    [column.key]: toggleDataGridCellValue({
+                        column: column.column,
+                        row: row.data,
+                    }),
+                },
+            },
+        ]);
+        options.recordHistoryIntentTransaction({
+            intent: "edit",
+            label: `Toggle ${column.key}`,
+            affectedRange: {
+                startRow: rowIndex,
+                endRow: rowIndex,
+                startColumn: columnIndex,
+                endColumn: columnIndex,
+            },
+        }, beforeSnapshot);
+        options.syncViewport();
+    };
+    return {
+        readStageCell,
+        readStageDisplayCell,
+        handleCellClick,
+    };
+}

package/dist/stage/useDataGridTableStageColumns.d.ts

@@ -0,0 +1,22 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridColumnSnapshot } from "@affino/datagrid-vue";
+import type { DataGridCellEditablePredicate } from "../dataGridEditability";
+import type { DataGridTableRow } from "./dataGridTableStage.types";
+export interface UseDataGridTableStageColumnsOptions<TRow extends Record<string, unknown>> {
+    runtime: Pick<import("@affino/datagrid-vue").UseDataGridRuntimeResult<TRow>, "api">;
+    visibleColumns: Ref<readonly DataGridColumnSnapshot[]>;
+    showRowSelection?: Ref<boolean>;
+    isCellEditable?: DataGridCellEditablePredicate<TRow>;
+}
+export interface UseDataGridTableStageColumnsResult<TRow extends Record<string, unknown>> {
+    orderedVisibleColumns: ComputedRef<readonly DataGridColumnSnapshot[]>;
+    centerColumns: ComputedRef<readonly DataGridColumnSnapshot[]>;
+    resolveColumnWidth: (column: DataGridColumnSnapshot) => number;
+    stageColumnStyle: (columnKey: string) => Record<string, string>;
+    isRowSelectionColumnKey: (columnKey: string) => boolean;
+    isRowSelectionColumn: (column: DataGridColumnSnapshot) => boolean;
+    isCellEditable: (row: DataGridTableRow<TRow>, rowIndex: number, column: DataGridColumnSnapshot) => boolean;
+    isCellEditableByKey: (row: DataGridTableRow<TRow>, rowIndex: number, columnKey: string, columnIndex: number) => boolean;
+    rowSelectionColumn: ComputedRef<DataGridColumnSnapshot | null>;
+}
+export declare function useDataGridTableStageColumns<TRow extends Record<string, unknown>>(options: UseDataGridTableStageColumnsOptions<TRow>): UseDataGridTableStageColumnsResult<TRow>;

package/dist/stage/useDataGridTableStageColumns.js

@@ -0,0 +1,124 @@
+import { computed } from "vue";
+const DEFAULT_COLUMN_WIDTH = 140;
+const ROW_SELECTION_COLUMN_WIDTH = 108;
+const ROW_SELECTION_COLUMN_KEY = "__datagrid_row_selection__";
+export function useDataGridTableStageColumns(options) {
+    const hasRowSelectionSupport = computed(() => {
+        return (options.showRowSelection?.value ?? true) && options.runtime.api.rowSelection.hasSupport();
+    });
+    const rowSelectionColumn = computed(() => {
+        if (!hasRowSelectionSupport.value) {
+            return null;
+        }
+        return {
+            key: ROW_SELECTION_COLUMN_KEY,
+            state: {
+                visible: true,
+                pin: "left",
+                width: ROW_SELECTION_COLUMN_WIDTH,
+            },
+            visible: true,
+            pin: "left",
+            width: ROW_SELECTION_COLUMN_WIDTH,
+            column: {
+                key: ROW_SELECTION_COLUMN_KEY,
+                label: "",
+                cellType: "checkbox",
+                minWidth: ROW_SELECTION_COLUMN_WIDTH,
+                maxWidth: ROW_SELECTION_COLUMN_WIDTH,
+                capabilities: {
+                    editable: true,
+                    sortable: false,
+                    filterable: false,
+                    groupable: false,
+                    pivotable: false,
+                    aggregatable: false,
+                },
+                presentation: {
+                    align: "center",
+                    headerAlign: "center",
+                },
+                meta: {
+                    isSystem: true,
+                    rowSelection: true,
+                },
+            },
+        };
+    });
+    const isRowSelectionColumnKey = (columnKey) => columnKey === ROW_SELECTION_COLUMN_KEY;
+    const isRowSelectionColumn = (column) => isRowSelectionColumnKey(column.key);
+    const orderedVisibleColumns = computed(() => {
+        const selectionColumn = rowSelectionColumn.value;
+        const left = options.visibleColumns.value.filter((column) => column.pin === "left");
+        const center = options.visibleColumns.value.filter((column) => column.pin !== "left" && column.pin !== "right");
+        const right = options.visibleColumns.value.filter((column) => column.pin === "right");
+        return selectionColumn ? [selectionColumn, ...left, ...center, ...right] : [...left, ...center, ...right];
+    });
+    const centerColumns = computed(() => (orderedVisibleColumns.value.filter((column) => column.pin !== "left" && column.pin !== "right")));
+    const resolveColumnWidth = (column) => {
+        return column.width ?? DEFAULT_COLUMN_WIDTH;
+    };
+    const stageColumnStyle = (columnKey) => {
+        const column = orderedVisibleColumns.value.find((candidate) => candidate.key === columnKey);
+        const width = column ? resolveColumnWidth(column) : DEFAULT_COLUMN_WIDTH;
+        const px = `${width}px`;
+        return {
+            width: px,
+            minWidth: px,
+            maxWidth: px,
+        };
+    };
+    const isColumnEditable = (column) => {
+        return column.column.capabilities?.editable !== false;
+    };
+    const isCellEditable = (row, rowIndex, column) => {
+        if (isRowSelectionColumn(column)) {
+            return row.kind !== "group" && row.rowId != null;
+        }
+        if (row.kind === "group" || row.rowId == null || !isColumnEditable(column)) {
+            return false;
+        }
+        if (!options.isCellEditable) {
+            return true;
+        }
+        return options.isCellEditable({
+            row: row.data,
+            rowId: row.rowId,
+            rowIndex,
+            column: column.column,
+            columnKey: column.key,
+        });
+    };
+    const resolveEditableColumn = (columnKey, columnIndex) => {
+        const columnAtIndex = orderedVisibleColumns.value[columnIndex];
+        if (columnAtIndex?.key === columnKey) {
+            return { column: columnAtIndex, columnIndex };
+        }
+        const resolvedColumnIndex = orderedVisibleColumns.value.findIndex((column) => column.key === columnKey);
+        if (resolvedColumnIndex < 0) {
+            return null;
+        }
+        return {
+            column: orderedVisibleColumns.value[resolvedColumnIndex],
+            columnIndex: resolvedColumnIndex,
+        };
+    };
+    const isCellEditableByKey = (row, rowIndex, columnKey, columnIndex) => {
+        const resolved = resolveEditableColumn(columnKey, columnIndex);
+        if (!resolved) {
+            return false;
+        }
+        return isCellEditable(row, rowIndex, resolved.column);
+    };
+    return {
+        orderedVisibleColumns,
+        centerColumns,
+        resolveColumnWidth,
+        stageColumnStyle,
+        isRowSelectionColumnKey,
+        isRowSelectionColumn,
+        isCellEditable,
+        isCellEditableByKey,
+        rowSelectionColumn,
+    };
+}

package/dist/stage/useDataGridTableStageFillAction.d.ts

@@ -0,0 +1,19 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridCopyRange, DataGridFillBehavior } from "@affino/datagrid-vue/advanced";
+import type { DataGridTableStageAnchorCell } from "./dataGridTableStage.types";
+interface DataGridTableStageLastAppliedFillSession {
+    previewRange: DataGridCopyRange;
+    behavior: DataGridFillBehavior;
+    allowBehaviorToggle: boolean;
+}
+export interface UseDataGridTableStageFillActionOptions {
+    lastAppliedFill: Ref<DataGridTableStageLastAppliedFillSession | null>;
+    selectionRange: ComputedRef<DataGridCopyRange | null>;
+    isFillDragging: Ref<boolean>;
+}
+export interface UseDataGridTableStageFillActionResult {
+    fillActionAnchorCell: ComputedRef<DataGridTableStageAnchorCell | null>;
+    fillActionBehavior: ComputedRef<DataGridFillBehavior | null>;
+}
+export declare function useDataGridTableStageFillAction(options: UseDataGridTableStageFillActionOptions): UseDataGridTableStageFillActionResult;
+export {};

package/dist/stage/useDataGridTableStageFillAction.js

@@ -0,0 +1,28 @@
+import { computed } from "vue";
+export function useDataGridTableStageFillAction(options) {
+    const fillActionAnchorCell = computed(() => {
+        const session = options.lastAppliedFill.value;
+        const activeSelectionRange = options.selectionRange.value;
+        if (!session || !activeSelectionRange || options.isFillDragging.value) {
+            return null;
+        }
+        if (session.allowBehaviorToggle === false) {
+            return null;
+        }
+        if (session.previewRange.startRow !== activeSelectionRange.startRow
+            || session.previewRange.endRow !== activeSelectionRange.endRow
+            || session.previewRange.startColumn !== activeSelectionRange.startColumn
+            || session.previewRange.endColumn !== activeSelectionRange.endColumn) {
+            return null;
+        }
+        return {
+            rowIndex: session.previewRange.endRow,
+            columnIndex: session.previewRange.endColumn,
+        };
+    });
+    const fillActionBehavior = computed(() => options.lastAppliedFill.value?.behavior ?? null);
+    return {
+        fillActionAnchorCell,
+        fillActionBehavior,
+    };
+}

package/dist/stage/useDataGridTableStageHistory.d.ts

@@ -0,0 +1,31 @@
+import type { DataGridCopyRange } from "@affino/datagrid-vue/advanced";
+export interface DataGridTableStageHistoryAdapter {
+    captureSnapshot: () => unknown;
+    recordIntentTransaction: (descriptor: {
+        intent: string;
+        label: string;
+        affectedRange?: DataGridCopyRange | null;
+    }, beforeSnapshot: unknown) => void | Promise<void>;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    runHistoryAction: (direction: "undo" | "redo") => Promise<string | null>;
+}
+export interface UseDataGridTableStageHistoryOptions<TRow extends Record<string, unknown>> {
+    runtime: Pick<import("@affino/datagrid-vue").UseDataGridRuntimeResult<TRow>, "api">;
+    cloneRowData: (row: TRow) => TRow;
+    syncViewport: () => void;
+    history?: DataGridTableStageHistoryAdapter;
+}
+export interface UseDataGridTableStageHistoryResult {
+    captureHistorySnapshot: () => unknown;
+    recordHistoryIntentTransaction: (descriptor: {
+        intent: string;
+        label: string;
+        affectedRange?: DataGridCopyRange | null;
+    }, beforeSnapshot: unknown) => void;
+    canUndoHistory: () => boolean;
+    canRedoHistory: () => boolean;
+    runHistoryAction: (direction: "undo" | "redo") => Promise<string | null>;
+    disposeIntentHistory: () => void;
+}
+export declare function useDataGridTableStageHistory<TRow extends Record<string, unknown>>(options: UseDataGridTableStageHistoryOptions<TRow>): UseDataGridTableStageHistoryResult;

package/dist/stage/useDataGridTableStageHistory.js

@@ -0,0 +1,46 @@
+import { useDataGridAppIntentHistory } from "@affino/datagrid-vue";
+export function useDataGridTableStageHistory(options) {
+    const internalIntentHistory = options.history
+        ? null
+        : useDataGridAppIntentHistory({
+            runtime: options.runtime,
+            cloneRowData: options.cloneRowData,
+            syncViewport: options.syncViewport,
+        });
+    const captureHistorySnapshot = () => {
+        if (options.history) {
+            return options.history.captureSnapshot();
+        }
+        return internalIntentHistory?.captureRowsSnapshot() ?? null;
+    };
+    const recordHistoryIntentTransaction = (descriptor, beforeSnapshot) => {
+        if (options.history) {
+            void options.history.recordIntentTransaction(descriptor, beforeSnapshot);
+            return;
+        }
+        void internalIntentHistory?.recordIntentTransaction(descriptor, beforeSnapshot);
+    };
+    const canUndoHistory = () => {
+        return options.history ? options.history.canUndo() : (internalIntentHistory?.canUndo.value ?? false);
+    };
+    const canRedoHistory = () => {
+        return options.history ? options.history.canRedo() : (internalIntentHistory?.canRedo.value ?? false);
+    };
+    const runHistoryAction = (direction) => {
+        if (options.history) {
+            return options.history.runHistoryAction(direction);
+        }
+        return internalIntentHistory?.runHistoryAction(direction) ?? Promise.resolve(null);
+    };
+    const disposeIntentHistory = () => {
+        internalIntentHistory?.dispose();
+    };
+    return {
+        captureHistorySnapshot,
+        recordHistoryIntentTransaction,
+        canUndoHistory,
+        canRedoHistory,
+        runHistoryAction,
+        disposeIntentHistory,
+    };
+}

package/dist/stage/useDataGridTableStageRowSelection.d.ts

@@ -0,0 +1,28 @@
+import type { DataGridColumnSnapshot, DataGridRowId, DataGridRowSelectionSnapshot } from "@affino/datagrid-vue";
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridCopyRange } from "@affino/datagrid-vue/advanced";
+import type { DataGridTableRow, DataGridTableStageAnchorCell } from "./dataGridTableStage.types";
+export interface UseDataGridTableStageRowSelectionOptions<TRow extends Record<string, unknown>> {
+    runtime: Pick<import("@affino/datagrid-vue").UseDataGridRuntimeResult<TRow>, "api">;
+    rowSelectionColumn: ComputedRef<DataGridColumnSnapshot | null>;
+    orderedVisibleColumns: ComputedRef<readonly DataGridColumnSnapshot[]>;
+    displayRows: Ref<readonly DataGridTableRow<TRow>[]>;
+    rowSelectionSnapshot: Ref<DataGridRowSelectionSnapshot | null>;
+    viewportRowStart: Ref<number>;
+    selectionAnchorCell: ComputedRef<DataGridTableStageAnchorCell | null>;
+    applySelectionRange: (range: DataGridCopyRange) => void;
+}
+export interface UseDataGridTableStageRowSelectionResult<TRow extends Record<string, unknown>> {
+    rowSelectionSet: ComputedRef<Set<DataGridRowId>>;
+    isRowFocused: (row: DataGridTableRow<TRow>) => boolean;
+    isRowCheckboxSelected: (row: DataGridTableRow<TRow>) => boolean;
+    readRowSelectionCell: (row: DataGridTableRow<TRow>) => string;
+    readRowSelectionDisplayCell: (row: DataGridTableRow<TRow>) => string;
+    areAllVisibleRowsSelected: ComputedRef<boolean>;
+    areSomeVisibleRowsSelected: ComputedRef<boolean>;
+    focusRow: (row: DataGridTableRow<TRow>) => void;
+    toggleRowCheckboxSelected: (row: DataGridTableRow<TRow>) => void;
+    toggleVisibleRowsSelected: () => void;
+    selectRowRange: (row: DataGridTableRow<TRow>, rowOffset: number, extend: boolean) => void;
+}
+export declare function useDataGridTableStageRowSelection<TRow extends Record<string, unknown>>(options: UseDataGridTableStageRowSelectionOptions<TRow>): UseDataGridTableStageRowSelectionResult<TRow>;

package/dist/stage/useDataGridTableStageRowSelection.js

@@ -0,0 +1,107 @@
+import { buildDataGridCellRenderModel } from "@affino/datagrid-vue";
+import { computed } from "vue";
+export function useDataGridTableStageRowSelection(options) {
+    const rowSelectionSet = computed(() => new Set(options.rowSelectionSnapshot.value?.selectedRows ?? []));
+    const isRowFocused = (row) => {
+        return row.rowId != null && options.rowSelectionSnapshot.value?.focusedRow === row.rowId;
+    };
+    const isRowCheckboxSelected = (row) => {
+        return row.kind !== "group" && row.rowId != null && rowSelectionSet.value.has(row.rowId);
+    };
+    const readRowSelectionValue = (row) => {
+        return isRowCheckboxSelected(row);
+    };
+    const readRowSelectionCell = (row) => {
+        return readRowSelectionValue(row) ? "true" : "false";
+    };
+    const readRowSelectionDisplayCell = (row) => {
+        const column = options.rowSelectionColumn.value?.column;
+        if (!column || row.kind === "group") {
+            return "";
+        }
+        return buildDataGridCellRenderModel({
+            column,
+            value: readRowSelectionValue(row),
+        }).displayValue;
+    };
+    const selectableRowIds = computed(() => {
+        const rowCount = options.runtime.api.rows.getCount();
+        const rowIds = [];
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+            const row = options.runtime.api.rows.get(rowIndex);
+            if (!row || row.kind === "group" || row.rowId == null) {
+                continue;
+            }
+            rowIds.push(row.rowId);
+        }
+        return rowIds;
+    });
+    const areAllVisibleRowsSelected = computed(() => {
+        const rowIds = selectableRowIds.value;
+        return rowIds.length > 0 && rowIds.every(rowId => rowSelectionSet.value.has(rowId));
+    });
+    const areSomeVisibleRowsSelected = computed(() => {
+        const rowIds = selectableRowIds.value;
+        return rowIds.some(rowId => rowSelectionSet.value.has(rowId));
+    });
+    const focusRow = (row) => {
+        if (row.rowId == null || !options.runtime.api.rowSelection.hasSupport()) {
+            return;
+        }
+        options.runtime.api.rowSelection.setFocusedRow(row.rowId);
+    };
+    const toggleRowCheckboxSelected = (row) => {
+        if (row.kind === "group" || row.rowId == null || !options.runtime.api.rowSelection.hasSupport()) {
+            return;
+        }
+        options.runtime.api.rowSelection.setSelected(row.rowId, !rowSelectionSet.value.has(row.rowId));
+    };
+    const toggleVisibleRowsSelected = () => {
+        if (!options.runtime.api.rowSelection.hasSupport()) {
+            return;
+        }
+        const rowIds = selectableRowIds.value;
+        if (!areAllVisibleRowsSelected.value) {
+            options.runtime.api.rowSelection.selectRows(rowIds);
+            return;
+        }
+        options.runtime.api.rowSelection.deselectRows(rowIds);
+    };
+    const selectRowRange = (row, rowOffset, extend) => {
+        focusRow(row);
+        const lastColumnIndex = options.orderedVisibleColumns.value.length - 1;
+        if (lastColumnIndex < 0) {
+            return;
+        }
+        const rowIndex = options.viewportRowStart.value + rowOffset;
+        if (!extend) {
+            options.applySelectionRange({
+                startRow: rowIndex,
+                endRow: rowIndex,
+                startColumn: 0,
+                endColumn: lastColumnIndex,
+            });
+            return;
+        }
+        const anchorRowIndex = options.selectionAnchorCell.value?.rowIndex ?? rowIndex;
+        options.applySelectionRange({
+            startRow: Math.min(anchorRowIndex, rowIndex),
+            endRow: Math.max(anchorRowIndex, rowIndex),
+            startColumn: 0,
+            endColumn: lastColumnIndex,
+        });
+    };
+    return {
+        rowSelectionSet,
+        isRowFocused,
+        isRowCheckboxSelected,
+        readRowSelectionCell,
+        readRowSelectionDisplayCell,
+        areAllVisibleRowsSelected,
+        areSomeVisibleRowsSelected,
+        focusRow,
+        toggleRowCheckboxSelected,
+        toggleVisibleRowsSelected,
+        selectRowRange,
+    };
+}

package/dist/stage/useDataGridTableStageRuntime.d.ts

@@ -0,0 +1,92 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridColumnSnapshot, DataGridRowSelectionSnapshot, DataGridSelectionSnapshot } from "@affino/datagrid-vue";
+import type { DataGridCopyRange } from "@affino/datagrid-vue/advanced";
+import type { DataGridCellEditablePredicate } from "../dataGridEditability";
+import type { DataGridColumnMenuActionOptions, DataGridColumnMenuDisabledReasons, DataGridColumnMenuItemKey, DataGridColumnMenuItemLabels } from "../overlays/dataGridColumnMenu";
+import type { DataGridVirtualizationOptions } from "../config/dataGridVirtualization";
+import type { DataGridTableStageContext } from "./dataGridTableStageContext";
+import type { DataGridTableStageHistoryAdapter } from "./useDataGridTableStageHistory";
+import type { DataGridTableStageProps } from "./dataGridTableStage.types";
+export type { DataGridTableStageHistoryAdapter } from "./useDataGridTableStageHistory";
+type DataGridTableStageBodyRuntime<TRow extends Record<string, unknown>> = Pick<import("@affino/datagrid-vue").UseDataGridRuntimeResult<TRow>, "api" | "syncBodyRowsInRange" | "rowPartition" | "virtualWindow" | "columnSnapshot"> & {
+    getBodyRowAtIndex: (rowIndex: number) => import("@affino/datagrid-vue").DataGridRowNode<TRow> | null;
+    resolveBodyRowIndexById: (rowId: string | number) => number;
+};
+export interface UseDataGridTableStageRuntimeOptions<TRow extends Record<string, unknown>> {
+    mode: Ref<"base" | "tree" | "pivot" | "worker">;
+    rows: Ref<readonly TRow[]>;
+    sourceRows?: Ref<readonly TRow[]>;
+    runtime: DataGridTableStageBodyRuntime<TRow>;
+    rowVersion: Ref<number>;
+    totalRuntimeRows: Ref<number>;
+    visibleColumns: Ref<readonly DataGridColumnSnapshot[]>;
+    rowRenderMode: Ref<"virtualization" | "pagination">;
+    rowHeightMode: Ref<"fixed" | "auto">;
+    normalizedBaseRowHeight: Ref<number>;
+    selectionSnapshot: Ref<DataGridSelectionSnapshot | null>;
+    selectionAnchor: Ref<unknown>;
+    syncSelectionSnapshotFromRuntime: () => void;
+    rowSelectionSnapshot: Ref<DataGridRowSelectionSnapshot | null>;
+    rowHover?: Ref<boolean>;
+    stripedRows?: Ref<boolean>;
+    showRowIndex?: Ref<boolean>;
+    showRowSelection?: Ref<boolean>;
+    isRowInPendingClipboardCut?: (row: import("@affino/datagrid-vue").DataGridRowNode<TRow>) => boolean;
+    syncRowSelectionSnapshotFromRuntime?: () => void;
+    firstColumnKey: Ref<string>;
+    columnFilterTextByKey: Ref<Record<string, string>>;
+    virtualization: Ref<DataGridVirtualizationOptions>;
+    toggleSortForColumn: (columnKey: string, additive?: boolean) => void;
+    sortIndicator: (columnKey: string) => string;
+    setColumnFilterText: (columnKey: string, value: string) => void;
+    columnMenuEnabled?: Ref<boolean>;
+    columnMenuValueFilterEnabled?: Ref<boolean>;
+    columnMenuValueFilterRowLimit?: Ref<number>;
+    columnMenuMaxFilterValues?: Ref<number>;
+    resolveColumnMenuItems?: (columnKey: string) => readonly DataGridColumnMenuItemKey[];
+    resolveColumnMenuDisabledItems?: (columnKey: string) => readonly DataGridColumnMenuItemKey[];
+    resolveColumnMenuDisabledReasons?: (columnKey: string) => DataGridColumnMenuDisabledReasons;
+    resolveColumnMenuLabels?: (columnKey: string) => DataGridColumnMenuItemLabels;
+    resolveColumnMenuActionOptions?: (columnKey: string) => DataGridColumnMenuActionOptions;
+    isColumnFilterActive?: (columnKey: string) => boolean;
+    isColumnGrouped?: (columnKey: string) => boolean;
+    resolveColumnGroupOrder?: (columnKey: string) => number | null;
+    resolveColumnMenuSortDirection?: (columnKey: string) => "asc" | "desc" | null;
+    resolveColumnMenuSelectedTokens?: (columnKey: string) => readonly string[];
+    applyColumnMenuSort?: (columnKey: string, direction: "asc" | "desc" | null) => void;
+    applyColumnMenuPin?: (columnKey: string, pin: import("@affino/datagrid-vue").DataGridColumnPin) => void;
+    applyColumnMenuGroupBy?: (columnKey: string, grouped: boolean) => void;
+    applyColumnMenuFilter?: (columnKey: string, tokens: readonly string[]) => void;
+    clearColumnMenuFilter?: (columnKey: string) => void;
+    applyRowHeightSettings: () => void;
+    cloneRowData: (row: TRow) => TRow;
+    readClipboardCell?: (row: import("@affino/datagrid-core").DataGridRowNode<TRow>, columnKey: string) => string;
+    applyClipboardEdits?: (range: DataGridCopyRange, matrix: string[][], options?: {
+        recordHistory?: boolean;
+    }) => number;
+    buildFillMatrixFromRange?: (range: DataGridCopyRange) => string[][];
+    applyRangeMove?: (baseRange: DataGridCopyRange, targetRange: DataGridCopyRange) => boolean;
+    isCellEditable?: DataGridCellEditablePredicate<TRow>;
+    history?: DataGridTableStageHistoryAdapter;
+    isContextMenuVisible?: () => boolean;
+    closeContextMenu?: () => void;
+    openContextMenuFromCurrentCell?: () => void;
+    clearExternalPendingClipboardOperation?: () => boolean;
+    runRowIndexKeyboardAction?: (action: "insert-row-above" | "copy-row" | "cut-row" | "paste-row" | "delete-selected-rows" | "open-row-menu", rowId: string | number) => Promise<boolean> | boolean;
+}
+export interface UseDataGridTableStageRuntimeResult<TRow extends Record<string, unknown>> {
+    tableStageProps: ComputedRef<DataGridTableStageProps<TRow>>;
+    tableStageContext: DataGridTableStageContext<TRow>;
+    syncViewportFromDom: () => void;
+    copySelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    pasteSelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    cutSelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    clearSelectedCells: (trigger?: "keyboard" | "context-menu") => Promise<boolean>;
+    captureHistorySnapshot: () => unknown;
+    recordHistoryIntentTransaction: (descriptor: {
+        intent: string;
+        label: string;
+        affectedRange?: DataGridCopyRange | null;
+    }, beforeSnapshot: unknown) => void;
+}
+export declare function useDataGridTableStageRuntime<TRow extends Record<string, unknown>>(options: UseDataGridTableStageRuntimeOptions<TRow>): UseDataGridTableStageRuntimeResult<TRow>;