@affino/datagrid-vue-app 0.1.1 → 0.1.2

package/dist/overlays/dataGridFilterableCombobox.js

@@ -1,74 +0,0 @@
-const SCORE_EXACT_LABEL = 0;
-const SCORE_EXACT_VALUE = 1;
-const SCORE_PREFIX_LABEL = 2;
-const SCORE_PREFIX_VALUE = 3;
-const SCORE_WORD_PREFIX_LABEL = 4;
-const SCORE_WORD_PREFIX_VALUE = 5;
-const SCORE_CONTAINS_LABEL = 6;
-const SCORE_CONTAINS_VALUE = 7;
-const SCORE_NO_MATCH = 100;
-export function rankDataGridFilterableComboboxOptions(options, query) {
-    const normalizedQuery = normalizeSearchText(query);
-    if (normalizedQuery.length === 0) {
-        return [...options];
-    }
-    const ranked = options
-        .map((option, originalIndex) => ({
-        option,
-        score: resolveOptionScore(option, normalizedQuery),
-        originalIndex,
-    }))
-        .filter(entry => entry.score < SCORE_NO_MATCH);
-    ranked.sort((left, right) => {
-        if (left.score !== right.score) {
-            return left.score - right.score;
-        }
-        const leftLabelLength = left.option.label.length;
-        const rightLabelLength = right.option.label.length;
-        if (leftLabelLength !== rightLabelLength) {
-            return leftLabelLength - rightLabelLength;
-        }
-        return left.originalIndex - right.originalIndex;
-    });
-    return ranked.map(entry => entry.option);
-}
-function resolveOptionScore(option, normalizedQuery) {
-    const normalizedLabel = normalizeSearchText(option.label);
-    const normalizedValue = normalizeSearchText(option.value);
-    if (normalizedLabel === normalizedQuery) {
-        return SCORE_EXACT_LABEL;
-    }
-    if (normalizedValue === normalizedQuery) {
-        return SCORE_EXACT_VALUE;
-    }
-    if (normalizedLabel.startsWith(normalizedQuery)) {
-        return SCORE_PREFIX_LABEL;
-    }
-    if (normalizedValue.startsWith(normalizedQuery)) {
-        return SCORE_PREFIX_VALUE;
-    }
-    if (hasWordPrefixMatch(normalizedLabel, normalizedQuery)) {
-        return SCORE_WORD_PREFIX_LABEL;
-    }
-    if (hasWordPrefixMatch(normalizedValue, normalizedQuery)) {
-        return SCORE_WORD_PREFIX_VALUE;
-    }
-    if (normalizedLabel.includes(normalizedQuery)) {
-        return SCORE_CONTAINS_LABEL;
-    }
-    if (normalizedValue.includes(normalizedQuery)) {
-        return SCORE_CONTAINS_VALUE;
-    }
-    return SCORE_NO_MATCH;
-}
-function hasWordPrefixMatch(value, normalizedQuery) {
-    if (value.length === 0 || normalizedQuery.length === 0) {
-        return false;
-    }
-    return value
-        .split(/[^a-z0-9]+/i)
-        .some(token => token.length > 0 && token.startsWith(normalizedQuery));
-}
-function normalizeSearchText(value) {
-    return value.trim().toLocaleLowerCase();
-}

package/dist/overlays/dataGridOverlayThemeVars.js

@@ -1,32 +0,0 @@
-const DATA_GRID_OVERLAY_THEME_VAR_NAMES = [
-    "--datagrid-font-family",
-    "--datagrid-font-size",
-    "--datagrid-text-primary",
-    "--datagrid-text-muted",
-    "--datagrid-text-soft",
-    "--datagrid-accent-strong",
-    "--datagrid-glass-border",
-    "--datagrid-background-color",
-    "--datagrid-editor-bg",
-    "--datagrid-filter-trigger-border",
-    "--datagrid-column-menu-bg",
-    "--datagrid-column-menu-border",
-    "--datagrid-column-menu-shadow",
-    "--datagrid-column-menu-item-hover-bg",
-    "--datagrid-column-menu-muted-text",
-    "--datagrid-column-menu-focus-ring",
-    "--datagrid-column-menu-search-border",
-    "--datagrid-column-menu-search-bg",
-    "--datagrid-sort-indicator-color",
-];
-export function readDataGridOverlayThemeVars(rootElement) {
-    if (!rootElement || typeof window === "undefined") {
-        return {};
-    }
-    const computedStyle = window.getComputedStyle(rootElement);
-    const vars = {};
-    for (const name of DATA_GRID_OVERLAY_THEME_VAR_NAMES) {
-        vars[name] = computedStyle.getPropertyValue(name).trim();
-    }
-    return vars;
-}

package/dist/stage/dataGridTableStage.types.js

@@ -1 +0,0 @@
-export {};

package/dist/stage/dataGridTableStageBody.types.js

@@ -1 +0,0 @@
-export {};

package/dist/stage/dataGridTableStageContext.js

@@ -1,88 +0,0 @@
-import { inject, provide, toRef, } from "vue";
-export const dataGridTableStageContextKey = Symbol("data-grid-table-stage-context");
-export function createDataGridTableStageContext(source) {
-    return {
-        mode: source.mode,
-        rowHeightMode: source.rowHeightMode,
-        layout: source.layout,
-        viewport: source.viewport,
-        columns: source.columns,
-        rows: source.rows,
-        selection: source.selection,
-        editing: source.editing,
-        cells: source.cells,
-        interaction: source.interaction,
-    };
-}
-export function createDataGridTableStageContextFromProps(props) {
-    return createDataGridTableStageContext({
-        mode: toRef(props, "mode"),
-        rowHeightMode: toRef(props, "rowHeightMode"),
-        layout: toRef(props, "layout"),
-        viewport: toRef(props, "viewport"),
-        columns: toRef(props, "columns"),
-        rows: toRef(props, "rows"),
-        selection: toRef(props, "selection"),
-        editing: toRef(props, "editing"),
-        cells: toRef(props, "cells"),
-        interaction: toRef(props, "interaction"),
-    });
-}
-export function materializeDataGridTableStagePropsFromContext(context) {
-    return {
-        mode: context.mode.value,
-        rowHeightMode: context.rowHeightMode.value,
-        layout: context.layout.value,
-        viewport: context.viewport.value,
-        columns: context.columns.value,
-        rows: context.rows.value,
-        selection: context.selection.value,
-        editing: context.editing.value,
-        cells: context.cells.value,
-        interaction: context.interaction.value,
-    };
-}
-export function provideDataGridTableStageContext(context) {
-    provide(dataGridTableStageContextKey, context);
-    return context;
-}
-export function useDataGridTableStageContext() {
-    const context = inject(dataGridTableStageContextKey);
-    if (!context) {
-        throw new Error("DataGrid table stage context is not available outside of DataGridTableStage.");
-    }
-    return context;
-}
-export function useDataGridTableStageMode() {
-    return useDataGridTableStageContext().mode;
-}
-export function useDataGridTableStageRowHeightMode() {
-    return useDataGridTableStageContext().rowHeightMode;
-}
-export function useDataGridTableStageSection(sectionKey) {
-    return useDataGridTableStageContext()[sectionKey];
-}
-export function useDataGridTableStageLayoutSection() {
-    return useDataGridTableStageSection("layout");
-}
-export function useDataGridTableStageViewportSection() {
-    return useDataGridTableStageSection("viewport");
-}
-export function useDataGridTableStageColumnsSection() {
-    return useDataGridTableStageSection("columns");
-}
-export function useDataGridTableStageRowsSection() {
-    return useDataGridTableStageSection("rows");
-}
-export function useDataGridTableStageSelectionSection() {
-    return useDataGridTableStageSection("selection");
-}
-export function useDataGridTableStageEditingSection() {
-    return useDataGridTableStageSection("editing");
-}
-export function useDataGridTableStageCellsSection() {
-    return useDataGridTableStageSection("cells");
-}
-export function useDataGridTableStageInteractionSection() {
-    return useDataGridTableStageSection("interaction");
-}

package/dist/stage/useDataGridTableStageBindings.js

@@ -1,162 +0,0 @@
-import { computed, unref } from "vue";
-import { createDataGridTableStageContext } from "./dataGridTableStageContext";
-function createElementRefHandler(target) {
-    return value => {
-        target.value = value instanceof HTMLElement ? value : null;
-    };
-}
-export function useDataGridTableStageBindings(options) {
-    const captureHeaderViewportRef = createElementRefHandler(options.headerViewportRef);
-    const captureBodyViewportRef = createElementRefHandler(options.bodyViewportRef);
-    const updateEditingCellValue = (value) => {
-        options.editingCellValueRef.value = value;
-    };
-    const layoutSection = computed(() => ({
-        gridContentStyle: unref(options.gridContentStyle),
-        mainTrackStyle: unref(options.mainTrackStyle),
-        indexColumnStyle: unref(options.indexColumnStyle),
-        columnStyle: unref(options.columnStyle),
-    }));
-    const viewportSection = computed(() => ({
-        topSpacerHeight: unref(options.topSpacerHeight),
-        bottomSpacerHeight: unref(options.bottomSpacerHeight),
-        viewportRowStart: unref(options.viewportRowStart),
-        columnWindowStart: unref(options.columnWindowStart),
-        leftColumnSpacerWidth: unref(options.leftColumnSpacerWidth),
-        rightColumnSpacerWidth: unref(options.rightColumnSpacerWidth),
-        headerViewportRef: captureHeaderViewportRef,
-        bodyViewportRef: captureBodyViewportRef,
-        handleHeaderWheel: unref(options.handleHeaderWheel),
-        handleHeaderScroll: unref(options.handleHeaderScroll),
-        handleViewportScroll: unref(options.handleViewportScroll),
-        handleViewportKeydown: unref(options.handleViewportKeydown),
-    }));
-    const columnsSection = computed(() => ({
-        visibleColumns: unref(options.visibleColumns),
-        renderedColumns: unref(options.renderedColumns),
-        columnFilterTextByKey: unref(options.columnFilterTextByKey),
-        toggleSortForColumn: unref(options.toggleSortForColumn),
-        sortIndicator: unref(options.sortIndicator),
-        setColumnFilterText: unref(options.setColumnFilterText),
-        columnMenuEnabled: unref(options.columnMenuEnabled),
-        columnMenuValueFilterEnabled: unref(options.columnMenuValueFilterEnabled),
-        columnMenuValueFilterRowLimit: unref(options.columnMenuValueFilterRowLimit),
-        columnMenuMaxFilterValues: unref(options.columnMenuMaxFilterValues),
-        resolveColumnMenuItems: unref(options.resolveColumnMenuItems),
-        resolveColumnMenuDisabledItems: unref(options.resolveColumnMenuDisabledItems),
-        resolveColumnMenuDisabledReasons: unref(options.resolveColumnMenuDisabledReasons),
-        resolveColumnMenuLabels: unref(options.resolveColumnMenuLabels),
-        resolveColumnMenuActionOptions: unref(options.resolveColumnMenuActionOptions),
-        isColumnFilterActive: unref(options.isColumnFilterActive),
-        isColumnGrouped: unref(options.isColumnGrouped),
-        resolveColumnGroupOrder: unref(options.resolveColumnGroupOrder),
-        resolveColumnMenuSortDirection: unref(options.resolveColumnMenuSortDirection),
-        resolveColumnMenuSelectedTokens: unref(options.resolveColumnMenuSelectedTokens),
-        applyColumnMenuSort: unref(options.applyColumnMenuSort),
-        applyColumnMenuPin: unref(options.applyColumnMenuPin),
-        applyColumnMenuGroupBy: unref(options.applyColumnMenuGroupBy),
-        applyColumnMenuFilter: unref(options.applyColumnMenuFilter),
-        clearColumnMenuFilter: unref(options.clearColumnMenuFilter),
-        startResize: unref(options.startResize),
-        handleResizeDoubleClick: unref(options.handleResizeDoubleClick),
-    }));
-    const rowsSection = computed(() => ({
-        displayRows: unref(options.displayRows),
-        pinnedBottomRows: unref(options.pinnedBottomRows),
-        sourceRows: unref(options.sourceRows),
-        showRowIndex: unref(options.showRowIndex),
-        rowHover: unref(options.rowHover),
-        stripedRows: unref(options.stripedRows),
-        rowClass: unref(options.rowClass),
-        isRowAutosizeProbe: unref(options.isRowAutosizeProbe),
-        rowStyle: unref(options.rowStyle),
-        isRowInPendingClipboardCut: unref(options.isRowInPendingClipboardCut),
-        isRowFocused: unref(options.isRowFocused),
-        isRowCheckboxSelected: unref(options.isRowCheckboxSelected),
-        allVisibleRowsSelected: unref(options.allVisibleRowsSelected),
-        someVisibleRowsSelected: unref(options.someVisibleRowsSelected),
-        handleRowClick: unref(options.handleRowClick),
-        handleRowIndexClick: unref(options.handleRowIndexClick),
-        handleRowIndexKeydown: unref(options.handleRowIndexKeydown),
-        handleToggleAllVisibleRows: unref(options.handleToggleAllVisibleRows),
-        toggleGroupRow: unref(options.toggleGroupRow),
-        rowIndexLabel: unref(options.rowIndexLabel),
-        startRowResize: unref(options.startRowResize),
-        autosizeRow: unref(options.autosizeRow),
-    }));
-    const selectionSection = computed(() => ({
-        selectionRange: unref(options.selectionRange),
-        selectionAnchorCell: unref(options.selectionAnchorCell),
-        fillPreviewRange: unref(options.fillPreviewRange),
-        rangeMovePreviewRange: unref(options.rangeMovePreviewRange),
-        isFillDragging: unref(options.isFillDragging),
-        isRangeMoving: unref(options.isRangeMoving),
-        fillActionAnchorCell: unref(options.fillActionAnchorCell),
-        fillActionBehavior: unref(options.fillActionBehavior),
-        applyFillActionBehavior: unref(options.applyFillActionBehavior),
-        isFillHandleCell: unref(options.isFillHandleCell),
-        startFillHandleDrag: unref(options.startFillHandleDrag),
-        startFillHandleDoubleClick: unref(options.startFillHandleDoubleClick),
-    }));
-    const editingSection = computed(() => ({
-        editingCellValue: options.editingCellValueRef.value,
-        editingCellInitialFilter: unref(options.editingCellInitialFilter),
-        editingCellOpenOnMount: unref(options.editingCellOpenOnMount),
-        isEditingCell: unref(options.isEditingCell),
-        startInlineEdit: unref(options.startInlineEdit),
-        updateEditingCellValue,
-        handleEditorKeydown: unref(options.handleEditorKeydown),
-        commitInlineEdit: unref(options.commitInlineEdit),
-        cancelInlineEdit: unref(options.cancelInlineEdit),
-    }));
-    const cellsSection = computed(() => ({
-        cellClass: unref(options.cellClass),
-        cellStyle: unref(options.cellStyle),
-        isCellSelected: unref(options.isCellSelected),
-        isSelectionAnchorCell: unref(options.isSelectionAnchorCell),
-        shouldHighlightSelectedCell: unref(options.shouldHighlightSelectedCell),
-        isCellOnSelectionEdge: unref(options.isCellOnSelectionEdge),
-        isCellInFillPreview: unref(options.isCellInFillPreview),
-        isCellInPendingClipboardRange: unref(options.isCellInPendingClipboardRange),
-        isCellOnPendingClipboardEdge: unref(options.isCellOnPendingClipboardEdge),
-        isCellEditable: unref(options.isCellEditable),
-        readCell: unref(options.readCell),
-        readDisplayCell: unref(options.readDisplayCell),
-    }));
-    const interactionSection = computed(() => ({
-        handleCellMouseDown: unref(options.handleCellMouseDown),
-        handleCellClick: unref(options.handleCellClick),
-        handleCellKeydown: unref(options.handleCellKeydown),
-    }));
-    const tableStageProps = computed(() => ({
-        mode: unref(options.mode),
-        rowHeightMode: unref(options.rowHeightMode),
-        layout: layoutSection.value,
-        viewport: viewportSection.value,
-        columns: columnsSection.value,
-        rows: rowsSection.value,
-        selection: selectionSection.value,
-        editing: editingSection.value,
-        cells: cellsSection.value,
-        interaction: interactionSection.value,
-    }));
-    const tableStageContext = createDataGridTableStageContext({
-        mode: computed(() => unref(options.mode)),
-        rowHeightMode: computed(() => unref(options.rowHeightMode)),
-        layout: layoutSection,
-        viewport: viewportSection,
-        columns: columnsSection,
-        rows: rowsSection,
-        selection: selectionSection,
-        editing: editingSection,
-        cells: cellsSection,
-        interaction: interactionSection,
-    });
-    return {
-        tableStageProps,
-        tableStageContext,
-        captureHeaderViewportRef,
-        captureBodyViewportRef,
-        updateEditingCellValue,
-    };
-}

package/dist/stage/useDataGridTableStageCellIo.js

@@ -1,62 +0,0 @@
-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.js

@@ -1,124 +0,0 @@
-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.js

@@ -1,28 +0,0 @@
-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.js

@@ -1,46 +0,0 @@
-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,
-    };
-}