@affino/datagrid-vue-app 0.1.1 → 0.1.2

package/dist/useDataGridTableStageColumns.js

@@ -1,122 +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(() => 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/useDataGridTableStageFillAction.d.ts

@@ -1,19 +0,0 @@
-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/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/useDataGridTableStageHistory.d.ts

@@ -1,31 +0,0 @@
-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" | "syncRowsInRange" | "virtualWindow" | "columnSnapshot">;
-    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/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,
-    };
-}

package/dist/useDataGridTableStageRowSelection.d.ts

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

@@ -1,103 +0,0 @@
-import { buildDataGridCellRenderModel } from "@affino/datagrid-core";
-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 resolveVisibleSelectableRowIds = () => {
-        return options.displayRows.value.flatMap(row => {
-            if (row.kind === "group" || row.rowId == null) {
-                return [];
-            }
-            return [row.rowId];
-        });
-    };
-    const areAllVisibleRowsSelected = computed(() => {
-        const rowIds = resolveVisibleSelectableRowIds();
-        return rowIds.length > 0 && rowIds.every(rowId => rowSelectionSet.value.has(rowId));
-    });
-    const areSomeVisibleRowsSelected = computed(() => {
-        const rowIds = resolveVisibleSelectableRowIds();
-        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 = resolveVisibleSelectableRowIds();
-        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/useDataGridTableStageRuntime.js

@@ -1 +0,0 @@
-export * from "./stage/useDataGridTableStageRuntime";

package/dist/useDataGridTableStageScrollSync.d.ts

@@ -1,17 +0,0 @@
-import type { Ref } from "vue";
-export interface UseDataGridTableStageScrollSyncOptions {
-    bodyViewportRef: Ref<HTMLElement | null>;
-    isColumnResizing: Ref<boolean>;
-    applyColumnResizeFromPointer: (clientX: number) => void;
-    stopColumnResize: () => void;
-    handleInteractionWindowMouseMove: (event: MouseEvent) => void;
-    handleInteractionWindowMouseUp: () => void;
-    syncViewport: () => void;
-}
-export interface UseDataGridTableStageScrollSyncResult {
-    handleWindowMouseMove: (event: MouseEvent) => void;
-    handleHeaderWheel: (event: WheelEvent) => void;
-    handleHeaderScroll: (event: Event) => void;
-    handleWindowMouseUp: () => void;
-}
-export declare function useDataGridTableStageScrollSync(options: UseDataGridTableStageScrollSyncOptions): UseDataGridTableStageScrollSyncResult;

package/dist/useDataGridTableStageScrollSync.js

@@ -1,49 +0,0 @@
-export function useDataGridTableStageScrollSync(options) {
-    const handleWindowMouseMove = (event) => {
-        if (options.isColumnResizing.value) {
-            options.applyColumnResizeFromPointer(event.clientX);
-            return;
-        }
-        options.handleInteractionWindowMouseMove(event);
-    };
-    const handleHeaderWheel = (event) => {
-        const bodyViewport = options.bodyViewportRef.value;
-        if (!bodyViewport) {
-            return;
-        }
-        const horizontalDelta = Math.abs(event.deltaX) > 0 ? event.deltaX : (event.shiftKey ? event.deltaY : 0);
-        const verticalDelta = horizontalDelta === 0 ? event.deltaY : 0;
-        if (horizontalDelta === 0 && verticalDelta === 0) {
-            return;
-        }
-        event.preventDefault();
-        if (horizontalDelta !== 0) {
-            bodyViewport.scrollLeft += horizontalDelta;
-        }
-        if (verticalDelta !== 0) {
-            bodyViewport.scrollTop += verticalDelta;
-        }
-        options.syncViewport();
-    };
-    const handleHeaderScroll = (event) => {
-        const headerViewport = event.target;
-        const bodyViewport = options.bodyViewportRef.value;
-        if (!headerViewport || !bodyViewport) {
-            return;
-        }
-        if (bodyViewport.scrollLeft !== headerViewport.scrollLeft) {
-            bodyViewport.scrollLeft = headerViewport.scrollLeft;
-        }
-        options.syncViewport();
-    };
-    const handleWindowMouseUp = () => {
-        options.stopColumnResize();
-        options.handleInteractionWindowMouseUp();
-    };
-    return {
-        handleWindowMouseMove,
-        handleHeaderWheel,
-        handleHeaderScroll,
-        handleWindowMouseUp,
-    };
-}

package/dist/useDataGridTableStageViewportKeyboard.d.ts

@@ -1,20 +0,0 @@
-import type { ComputedRef, Ref } from "vue";
-import type { DataGridColumnSnapshot, DataGridSelectionSnapshot } from "@affino/datagrid-vue";
-export interface UseDataGridTableStageViewportKeyboardOptions<TRow extends Record<string, unknown>> {
-    runtime: Pick<import("@affino/datagrid-vue").UseDataGridRuntimeResult<TRow>, "api">;
-    selectionSnapshot: Ref<DataGridSelectionSnapshot | null>;
-    totalRows: Ref<number>;
-    orderedVisibleColumns: ComputedRef<readonly DataGridColumnSnapshot[]>;
-    viewportRowStart: Ref<number>;
-    applySelectionRange: (range: {
-        startRow: number;
-        endRow: number;
-        startColumn: number;
-        endColumn: number;
-    }) => void;
-    handleCellKeydown: (event: KeyboardEvent, row: import("@affino/datagrid-vue").DataGridRowNode<TRow>, rowOffset: number, columnIndex: number) => void;
-}
-export interface UseDataGridTableStageViewportKeyboardResult {
-    handleViewportKeydown: (event: KeyboardEvent) => void;
-}
-export declare function useDataGridTableStageViewportKeyboard<TRow extends Record<string, unknown>>(options: UseDataGridTableStageViewportKeyboardOptions<TRow>): UseDataGridTableStageViewportKeyboardResult;

package/dist/useDataGridTableStageViewportKeyboard.js

@@ -1,58 +0,0 @@
-export function useDataGridTableStageViewportKeyboard(options) {
-    const isViewportOwnedKeyboardEvent = (event) => {
-        if (event.ctrlKey || event.metaKey || event.altKey) {
-            return false;
-        }
-        return (event.key.startsWith("Arrow")
-            || event.key === "Home"
-            || event.key === "End"
-            || event.key === "PageUp"
-            || event.key === "PageDown"
-            || event.key === "Tab"
-            || event.key === "Enter"
-            || event.key === " "
-            || event.key === "Spacebar"
-            || event.key === "F2"
-            || event.key === "Escape"
-            || event.key.length === 1);
-    };
-    const isViewportSelectAllKeyboardEvent = (event) => {
-        return (event.ctrlKey || event.metaKey)
-            && !event.altKey
-            && !event.shiftKey
-            && event.key.toLowerCase() === "a";
-    };
-    const selectAllVisibleCells = () => {
-        const lastRowIndex = options.totalRows.value - 1;
-        const lastColumnIndex = options.orderedVisibleColumns.value.length - 1;
-        if (lastRowIndex < 0 || lastColumnIndex < 0) {
-            return;
-        }
-        options.applySelectionRange({
-            startRow: 0,
-            endRow: lastRowIndex,
-            startColumn: 0,
-            endColumn: lastColumnIndex,
-        });
-    };
-    const handleViewportKeydown = (event) => {
-        if (isViewportOwnedKeyboardEvent(event) || isViewportSelectAllKeyboardEvent(event)) {
-            event.preventDefault();
-        }
-        const activeCell = options.selectionSnapshot.value?.activeCell;
-        if (!activeCell) {
-            if (isViewportSelectAllKeyboardEvent(event)) {
-                selectAllVisibleCells();
-            }
-            return;
-        }
-        const row = options.runtime.api.rows.get(activeCell.rowIndex);
-        if (!row) {
-            return;
-        }
-        options.handleCellKeydown(event, row, activeCell.rowIndex - options.viewportRowStart.value, activeCell.colIndex);
-    };
-    return {
-        handleViewportKeydown,
-    };
-}

package/dist/useDataGridTableStageVisualSelection.d.ts

@@ -1,24 +0,0 @@
-import { type ComputedRef, type Ref } from "vue";
-import type { DataGridCopyRange } from "@affino/datagrid-vue/advanced";
-import type { DataGridPendingEdge, DataGridTableMode, DataGridTableStageAnchorCell } from "./dataGridTableStage.types";
-export interface UseDataGridTableStageVisualSelectionOptions {
-    mode: Ref<DataGridTableMode>;
-    viewportRowStart: Ref<number>;
-    selectionAnchorCell: ComputedRef<DataGridTableStageAnchorCell | null>;
-    fillPreviewRange: Ref<DataGridCopyRange | null>;
-    isFillDragging: Ref<boolean>;
-    interactionSelectionRange: Ref<DataGridCopyRange | null>;
-    resolveCommittedSelectionRange: () => DataGridCopyRange | null;
-    isCommittedSelectionAnchorCell: (rowOffset: number, columnIndex: number) => boolean;
-    isCommittedCellSelected: (rowOffset: number, columnIndex: number) => boolean;
-    shouldHighlightCommittedSelectedCell: (rowOffset: number, columnIndex: number) => boolean;
-    isCommittedCellOnSelectionEdge: (rowOffset: number, columnIndex: number, edge: DataGridPendingEdge) => boolean;
-}
-export interface UseDataGridTableStageVisualSelectionResult {
-    selectionRange: ComputedRef<DataGridCopyRange | null>;
-    isSelectionAnchorCell: (rowOffset: number, columnIndex: number) => boolean;
-    isCellSelected: (rowOffset: number, columnIndex: number) => boolean;
-    shouldHighlightSelectedCell: (rowOffset: number, columnIndex: number) => boolean;
-    isCellOnSelectionEdge: (rowOffset: number, columnIndex: number, edge: DataGridPendingEdge) => boolean;
-}
-export declare function useDataGridTableStageVisualSelection(options: UseDataGridTableStageVisualSelectionOptions): UseDataGridTableStageVisualSelectionResult;

package/dist/useDataGridTableStageVisualSelection.js

@@ -1,70 +0,0 @@
-import { computed } from "vue";
-export function useDataGridTableStageVisualSelection(options) {
-    const selectionRange = computed(() => (options.interactionSelectionRange.value ?? options.resolveCommittedSelectionRange()));
-    const resolveVisualSelectionRange = () => selectionRange.value;
-    const isVisualFillSelectionActive = () => {
-        return options.mode.value === "base" && options.isFillDragging.value && Boolean(options.fillPreviewRange.value);
-    };
-    const isCellWithinRange = (range, rowOffset, columnIndex) => {
-        const rowIndex = options.viewportRowStart.value + rowOffset;
-        return (rowIndex >= range.startRow
-            && rowIndex <= range.endRow
-            && columnIndex >= range.startColumn
-            && columnIndex <= range.endColumn);
-    };
-    const isSelectionAnchorCell = (rowOffset, columnIndex) => {
-        if (options.selectionAnchorCell.value) {
-            return options.selectionAnchorCell.value.rowIndex === options.viewportRowStart.value + rowOffset
-                && options.selectionAnchorCell.value.columnIndex === columnIndex;
-        }
-        return options.isCommittedSelectionAnchorCell(rowOffset, columnIndex);
-    };
-    const isCellSelected = (rowOffset, columnIndex) => {
-        if (!isVisualFillSelectionActive()) {
-            return options.isCommittedCellSelected(rowOffset, columnIndex);
-        }
-        const range = resolveVisualSelectionRange();
-        return range ? isCellWithinRange(range, rowOffset, columnIndex) : false;
-    };
-    const shouldHighlightSelectedCell = (rowOffset, columnIndex) => {
-        if (!isVisualFillSelectionActive()) {
-            return options.shouldHighlightCommittedSelectedCell(rowOffset, columnIndex);
-        }
-        const range = resolveVisualSelectionRange();
-        if (!range || !isCellWithinRange(range, rowOffset, columnIndex)) {
-            return false;
-        }
-        const isSingleCell = range.startRow === range.endRow && range.startColumn === range.endColumn;
-        if (isSingleCell) {
-            return false;
-        }
-        return !isSelectionAnchorCell(rowOffset, columnIndex);
-    };
-    const isCellOnSelectionEdge = (rowOffset, columnIndex, edge) => {
-        if (!isVisualFillSelectionActive()) {
-            return options.isCommittedCellOnSelectionEdge(rowOffset, columnIndex, edge);
-        }
-        const range = resolveVisualSelectionRange();
-        if (!range || !isCellWithinRange(range, rowOffset, columnIndex)) {
-            return false;
-        }
-        const rowIndex = options.viewportRowStart.value + rowOffset;
-        switch (edge) {
-            case "top":
-                return rowIndex === range.startRow;
-            case "right":
-                return columnIndex === range.endColumn;
-            case "bottom":
-                return rowIndex === range.endRow;
-            case "left":
-                return columnIndex === range.startColumn;
-        }
-    };
-    return {
-        selectionRange,
-        isSelectionAnchorCell,
-        isCellSelected,
-        shouldHighlightSelectedCell,
-        isCellOnSelectionEdge,
-    };
-}