@affino/datagrid-orchestration 0.1.0

package/dist/src/useDataGridMoveMutationPolicy.js

@@ -0,0 +1,81 @@
+function applyRecordValueForMove(record, columnKey, value) {
+    if (!(columnKey in record)) {
+        return false;
+    }
+    const current = record[columnKey];
+    if (typeof current === "number") {
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric)) {
+            return false;
+        }
+        record[columnKey] = numeric;
+        return true;
+    }
+    if (typeof current === "boolean") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1") {
+            record[columnKey] = true;
+            return true;
+        }
+        if (normalized === "false" || normalized === "0") {
+            record[columnKey] = false;
+            return true;
+        }
+        return false;
+    }
+    record[columnKey] = value;
+    return true;
+}
+function clearRecordValueForMove(record, columnKey) {
+    if (!(columnKey in record)) {
+        return false;
+    }
+    const current = record[columnKey];
+    if (typeof current === "number") {
+        if (current === 0) {
+            return false;
+        }
+        record[columnKey] = 0;
+        return true;
+    }
+    if (typeof current === "boolean") {
+        if (!current) {
+            return false;
+        }
+        record[columnKey] = false;
+        return true;
+    }
+    if (current == null || String(current) === "") {
+        return false;
+    }
+    record[columnKey] = "";
+    return true;
+}
+export function useDataGridMoveMutationPolicy(options) {
+    function isBlockedColumn(columnKey) {
+        return options.isBlockedColumn ? options.isBlockedColumn(columnKey) : false;
+    }
+    function applyValueForMove(row, columnKey, value) {
+        if (isBlockedColumn(columnKey)) {
+            return false;
+        }
+        if (!options.isEditableColumn(columnKey)) {
+            return false;
+        }
+        options.applyEditedValue(row, columnKey, value);
+        return true;
+    }
+    function clearValueForMove(row, columnKey) {
+        if (isBlockedColumn(columnKey)) {
+            return false;
+        }
+        if (!options.isEditableColumn(columnKey)) {
+            return false;
+        }
+        return options.clearEditedValue(row, columnKey);
+    }
+    return {
+        applyValueForMove,
+        clearValueForMove,
+    };
+}

package/dist/src/useDataGridMutationSnapshot.d.ts

@@ -0,0 +1,46 @@
+export interface DataGridMutationSnapshotCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridMutationSnapshotRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface DataGridMutationAffectedRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface DataGridMutationSnapshotState<TRow, TCoord extends DataGridMutationSnapshotCoord = DataGridMutationSnapshotCoord, TRange extends DataGridMutationSnapshotRange = DataGridMutationSnapshotRange> {
+    sourceRows: TRow[];
+    cellAnchor: TCoord | null;
+    cellFocus: TCoord | null;
+    activeCell: TCoord | null;
+    copiedSelectionRange: TRange | null;
+}
+export interface UseDataGridMutationSnapshotOptions<TRow, TCoord extends DataGridMutationSnapshotCoord = DataGridMutationSnapshotCoord, TRange extends DataGridMutationSnapshotRange = DataGridMutationSnapshotRange> {
+    resolveRows: () => readonly TRow[];
+    setRows: (rows: TRow[]) => void;
+    resolveCellAnchor: () => TCoord | null;
+    setCellAnchor: (coord: TCoord | null) => void;
+    resolveCellFocus: () => TCoord | null;
+    setCellFocus: (coord: TCoord | null) => void;
+    resolveActiveCell: () => TCoord | null;
+    setActiveCell: (coord: TCoord | null) => void;
+    resolveCopiedSelectionRange: () => TRange | null;
+    setCopiedSelectionRange: (range: TRange | null) => void;
+    cloneRow: (row: TRow) => TRow;
+    cloneCoord?: (coord: TCoord) => TCoord;
+    cloneRange?: (range: TRange) => TRange;
+}
+export interface UseDataGridMutationSnapshotResult<TRow, TCoord extends DataGridMutationSnapshotCoord = DataGridMutationSnapshotCoord, TRange extends DataGridMutationSnapshotRange = DataGridMutationSnapshotRange> {
+    captureGridMutationSnapshot: () => DataGridMutationSnapshotState<TRow, TCoord, TRange>;
+    applyGridMutationSnapshot: (snapshot: DataGridMutationSnapshotState<TRow, TCoord, TRange>) => void;
+    toTransactionRange: (range: TRange | null) => DataGridMutationAffectedRange | null;
+    toSingleCellRange: (coord: TCoord | null) => TRange | null;
+}
+export declare function useDataGridMutationSnapshot<TRow, TCoord extends DataGridMutationSnapshotCoord = DataGridMutationSnapshotCoord, TRange extends DataGridMutationSnapshotRange = DataGridMutationSnapshotRange>(options: UseDataGridMutationSnapshotOptions<TRow, TCoord, TRange>): UseDataGridMutationSnapshotResult<TRow, TCoord, TRange>;
+//# sourceMappingURL=useDataGridMutationSnapshot.d.ts.map

package/dist/src/useDataGridMutationSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridMutationSnapshot.d.ts","sourceRoot":"","sources":["../../src/useDataGridMutationSnapshot.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,6BAA6B,CAC5C,IAAI,EACJ,MAAM,SAAS,6BAA6B,GAAG,6BAA6B,EAC5E,MAAM,SAAS,6BAA6B,GAAG,6BAA6B;IAE5E,UAAU,EAAE,IAAI,EAAE,CAAA;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC;AAED,MAAM,WAAW,kCAAkC,CACjD,IAAI,EACJ,MAAM,SAAS,6BAA6B,GAAG,6BAA6B,EAC5E,MAAM,SAAS,6BAA6B,GAAG,6BAA6B;IAE5E,WAAW,EAAE,MAAM,SAAS,IAAI,EAAE,CAAA;IAClC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,IAAI,CAAA;IAC/B,iBAAiB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACtC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC7C,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACrC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC5C,iBAAiB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACtC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC7C,2BAA2B,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAChD,uBAAuB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IACvD,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACtC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACvC;AAED,MAAM,WAAW,iCAAiC,CAChD,IAAI,EACJ,MAAM,SAAS,6BAA6B,GAAG,6BAA6B,EAC5E,MAAM,SAAS,6BAA6B,GAAG,6BAA6B;IAE5E,2BAA2B,EAAE,MAAM,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACtF,yBAAyB,EAAE,CAAC,QAAQ,EAAE,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAA;IAClG,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,6BAA6B,GAAG,IAAI,CAAA;IAClF,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,IAAI,CAAA;CAC3D;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EACJ,MAAM,SAAS,6BAA6B,GAAG,6BAA6B,EAC5E,MAAM,SAAS,6BAA6B,GAAG,6BAA6B,EAE5E,OAAO,EAAE,kCAAkC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAChE,iCAAiC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAgEzD"}

package/dist/src/useDataGridMutationSnapshot.js

@@ -0,0 +1,57 @@
+export function useDataGridMutationSnapshot(options) {
+    const cloneCoord = options.cloneCoord ?? ((coord) => ({ ...coord }));
+    const cloneRange = options.cloneRange ?? ((range) => ({ ...range }));
+    function cloneRows(rows) {
+        return rows.map(row => options.cloneRow(row));
+    }
+    function cloneCoordOrNull(coord) {
+        return coord ? cloneCoord(coord) : null;
+    }
+    function cloneRangeOrNull(range) {
+        return range ? cloneRange(range) : null;
+    }
+    function captureGridMutationSnapshot() {
+        return {
+            sourceRows: cloneRows(options.resolveRows()),
+            cellAnchor: cloneCoordOrNull(options.resolveCellAnchor()),
+            cellFocus: cloneCoordOrNull(options.resolveCellFocus()),
+            activeCell: cloneCoordOrNull(options.resolveActiveCell()),
+            copiedSelectionRange: cloneRangeOrNull(options.resolveCopiedSelectionRange()),
+        };
+    }
+    function applyGridMutationSnapshot(snapshot) {
+        options.setRows(cloneRows(snapshot.sourceRows));
+        options.setCellAnchor(cloneCoordOrNull(snapshot.cellAnchor));
+        options.setCellFocus(cloneCoordOrNull(snapshot.cellFocus));
+        options.setActiveCell(cloneCoordOrNull(snapshot.activeCell));
+        options.setCopiedSelectionRange(cloneRangeOrNull(snapshot.copiedSelectionRange));
+    }
+    function toTransactionRange(range) {
+        if (!range) {
+            return null;
+        }
+        return {
+            startRow: range.startRow,
+            endRow: range.endRow,
+            startColumn: range.startColumn,
+            endColumn: range.endColumn,
+        };
+    }
+    function toSingleCellRange(coord) {
+        if (!coord) {
+            return null;
+        }
+        return {
+            startRow: coord.rowIndex,
+            endRow: coord.rowIndex,
+            startColumn: coord.columnIndex,
+            endColumn: coord.columnIndex,
+        };
+    }
+    return {
+        captureGridMutationSnapshot,
+        applyGridMutationSnapshot,
+        toTransactionRange,
+        toSingleCellRange,
+    };
+}

package/dist/src/useDataGridNavigationPrimitives.d.ts

@@ -0,0 +1,42 @@
+import type { DataGridRowNode } from "@affino/datagrid-core";
+export interface DataGridNavigationPrimitiveCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridNavigationPrimitiveRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface DataGridNavigationPrimitiveColumn {
+    key: string;
+}
+export interface UseDataGridNavigationPrimitivesOptions<TCoord extends DataGridNavigationPrimitiveCoord = DataGridNavigationPrimitiveCoord, TRange extends DataGridNavigationPrimitiveRange = DataGridNavigationPrimitiveRange, TColumn extends DataGridNavigationPrimitiveColumn = DataGridNavigationPrimitiveColumn> {
+    resolveColumns: () => readonly TColumn[];
+    resolveRowsLength: () => number;
+    resolveNavigableColumnIndexes: () => readonly number[];
+    normalizeCellCoord: (coord: TCoord) => TCoord | null;
+    resolveCellAnchor: () => TCoord | null;
+    resolveCellFocus: () => TCoord | null;
+    resolveActiveCell: () => TCoord | null;
+    setCellAnchor: (coord: TCoord) => void;
+    setCellFocus: (coord: TCoord) => void;
+    setActiveCell: (coord: TCoord) => void;
+    ensureCellVisible: (coord: TCoord) => void;
+    coordsEqual: (left: TCoord | null, right: TCoord | null) => boolean;
+}
+export interface UseDataGridNavigationPrimitivesResult<TCoord extends DataGridNavigationPrimitiveCoord = DataGridNavigationPrimitiveCoord, TRange extends DataGridNavigationPrimitiveRange = DataGridNavigationPrimitiveRange> {
+    resolveRowIndex: (row: DataGridRowNode<unknown>) => number;
+    resolveColumnIndex: (columnKey: string) => number;
+    clampRowIndex: (rowIndex: number) => number;
+    getFirstNavigableColumnIndex: () => number;
+    getLastNavigableColumnIndex: () => number;
+    resolveNearestNavigableColumnIndex: (columnIndex: number, direction?: 1 | -1) => number;
+    getAdjacentNavigableColumnIndex: (columnIndex: number, direction: 1 | -1) => number;
+    positiveModulo: (value: number, divisor: number) => number;
+    applyCellSelection: (nextCoord: TCoord, extend: boolean, fallbackAnchor?: TCoord, ensureVisible?: boolean) => void;
+    isCoordInsideRange: (coord: TCoord, range: TRange) => boolean;
+}
+export declare function useDataGridNavigationPrimitives<TCoord extends DataGridNavigationPrimitiveCoord = DataGridNavigationPrimitiveCoord, TRange extends DataGridNavigationPrimitiveRange = DataGridNavigationPrimitiveRange, TColumn extends DataGridNavigationPrimitiveColumn = DataGridNavigationPrimitiveColumn>(options: UseDataGridNavigationPrimitivesOptions<TCoord, TRange, TColumn>): UseDataGridNavigationPrimitivesResult<TCoord, TRange>;
+//# sourceMappingURL=useDataGridNavigationPrimitives.d.ts.map

package/dist/src/useDataGridNavigationPrimitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridNavigationPrimitives.d.ts","sourceRoot":"","sources":["../../src/useDataGridNavigationPrimitives.ts"],"names":[],"mappings":"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"}

package/dist/src/useDataGridNavigationPrimitives.js

@@ -0,0 +1,105 @@
+export function useDataGridNavigationPrimitives(options) {
+    function resolveRowIndex(row) {
+        const candidate = [row.displayIndex, row.sourceIndex, row.originalIndex].find(Number.isFinite) ?? 0;
+        return Math.max(0, Math.trunc(candidate));
+    }
+    function resolveColumnIndex(columnKey) {
+        return options.resolveColumns().findIndex(column => column.key === columnKey);
+    }
+    function clampRowIndex(rowIndex) {
+        const maxRowIndex = Math.max(0, options.resolveRowsLength() - 1);
+        return Math.max(0, Math.min(maxRowIndex, Math.trunc(rowIndex)));
+    }
+    function getFirstNavigableColumnIndex() {
+        return options.resolveNavigableColumnIndexes()[0] ?? -1;
+    }
+    function getLastNavigableColumnIndex() {
+        const indexes = options.resolveNavigableColumnIndexes();
+        return indexes[indexes.length - 1] ?? -1;
+    }
+    function resolveNearestNavigableColumnIndex(columnIndex, direction = 1) {
+        const indexes = options.resolveNavigableColumnIndexes();
+        if (!indexes.length) {
+            return -1;
+        }
+        if (indexes.includes(columnIndex)) {
+            return columnIndex;
+        }
+        if (direction > 0) {
+            return indexes.find(index => index >= columnIndex) ?? getLastNavigableColumnIndex();
+        }
+        for (let index = indexes.length - 1; index >= 0; index -= 1) {
+            const candidate = indexes[index];
+            if (candidate !== undefined && candidate <= columnIndex) {
+                return candidate;
+            }
+        }
+        return getFirstNavigableColumnIndex();
+    }
+    function getAdjacentNavigableColumnIndex(columnIndex, direction) {
+        const indexes = options.resolveNavigableColumnIndexes();
+        if (!indexes.length) {
+            return -1;
+        }
+        const currentPos = indexes.indexOf(columnIndex);
+        if (currentPos === -1) {
+            return resolveNearestNavigableColumnIndex(columnIndex, direction);
+        }
+        const nextPos = Math.max(0, Math.min(indexes.length - 1, currentPos + direction));
+        return indexes[nextPos] ?? columnIndex;
+    }
+    function positiveModulo(value, divisor) {
+        if (divisor <= 0) {
+            return 0;
+        }
+        const remainder = value % divisor;
+        return remainder < 0 ? remainder + divisor : remainder;
+    }
+    function applyCellSelection(nextCoord, extend, fallbackAnchor, ensureVisible = true) {
+        const normalized = options.normalizeCellCoord(nextCoord);
+        if (!normalized) {
+            return;
+        }
+        let nextAnchor;
+        let nextFocus;
+        if (extend) {
+            const anchor = options.resolveCellAnchor() ?? fallbackAnchor ?? options.resolveActiveCell() ?? normalized;
+            nextAnchor = options.normalizeCellCoord(anchor) ?? normalized;
+            nextFocus = normalized;
+        }
+        else {
+            nextAnchor = normalized;
+            nextFocus = normalized;
+        }
+        if (!options.coordsEqual(options.resolveCellAnchor(), nextAnchor)) {
+            options.setCellAnchor(nextAnchor);
+        }
+        if (!options.coordsEqual(options.resolveCellFocus(), nextFocus)) {
+            options.setCellFocus(nextFocus);
+        }
+        if (!options.coordsEqual(options.resolveActiveCell(), normalized)) {
+            options.setActiveCell(normalized);
+        }
+        if (ensureVisible) {
+            options.ensureCellVisible(normalized);
+        }
+    }
+    function isCoordInsideRange(coord, range) {
+        return (coord.rowIndex >= range.startRow &&
+            coord.rowIndex <= range.endRow &&
+            coord.columnIndex >= range.startColumn &&
+            coord.columnIndex <= range.endColumn);
+    }
+    return {
+        resolveRowIndex,
+        resolveColumnIndex,
+        clampRowIndex,
+        getFirstNavigableColumnIndex,
+        getLastNavigableColumnIndex,
+        resolveNearestNavigableColumnIndex,
+        getAdjacentNavigableColumnIndex,
+        positiveModulo,
+        applyCellSelection,
+        isCoordInsideRange,
+    };
+}

package/dist/src/useDataGridPointerAutoScroll.d.ts

@@ -0,0 +1,32 @@
+import type { DataGridPointerCoordinates } from "./dataGridPointerContracts";
+export interface DataGridPointerAutoScrollInteractionState {
+    isDragSelecting: boolean;
+    isFillDragging: boolean;
+    isRangeMoving: boolean;
+}
+export interface DataGridPointerAutoScrollPosition {
+    top: number;
+    left: number;
+}
+export interface UseDataGridPointerAutoScrollOptions {
+    resolveInteractionState: () => DataGridPointerAutoScrollInteractionState;
+    resolveRangeMovePointer: () => DataGridPointerCoordinates | null;
+    resolveFillPointer: () => DataGridPointerCoordinates | null;
+    resolveDragPointer: () => DataGridPointerCoordinates | null;
+    resolveViewportElement: () => HTMLElement | null;
+    resolveHeaderHeight: () => number;
+    resolveAxisAutoScrollDelta: (pointer: number, min: number, max: number) => number;
+    setScrollPosition: (next: DataGridPointerAutoScrollPosition) => void;
+    applyRangeMovePreviewFromPointer: () => void;
+    applyFillPreviewFromPointer: () => void;
+    applyDragSelectionFromPointer: () => void;
+    requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame?: (handle: number) => void;
+}
+export interface UseDataGridPointerAutoScrollResult {
+    startInteractionAutoScroll: () => void;
+    stopAutoScrollFrameIfIdle: () => void;
+    dispose: () => void;
+}
+export declare function useDataGridPointerAutoScroll(options: UseDataGridPointerAutoScrollOptions): UseDataGridPointerAutoScrollResult;
+//# sourceMappingURL=useDataGridPointerAutoScroll.d.ts.map

package/dist/src/useDataGridPointerAutoScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridPointerAutoScroll.d.ts","sourceRoot":"","sources":["../../src/useDataGridPointerAutoScroll.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AAE5E,MAAM,WAAW,yCAAyC;IACxD,eAAe,EAAE,OAAO,CAAA;IACxB,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,iCAAiC;IAChD,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,mCAAmC;IAClD,uBAAuB,EAAE,MAAM,yCAAyC,CAAA;IACxE,uBAAuB,EAAE,MAAM,0BAA0B,GAAG,IAAI,CAAA;IAChE,kBAAkB,EAAE,MAAM,0BAA0B,GAAG,IAAI,CAAA;IAC3D,kBAAkB,EAAE,MAAM,0BAA0B,GAAG,IAAI,CAAA;IAC3D,sBAAsB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IAChD,mBAAmB,EAAE,MAAM,MAAM,CAAA;IACjC,0BAA0B,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACjF,iBAAiB,EAAE,CAAC,IAAI,EAAE,iCAAiC,KAAK,IAAI,CAAA;IACpE,gCAAgC,EAAE,MAAM,IAAI,CAAA;IAC5C,2BAA2B,EAAE,MAAM,IAAI,CAAA;IACvC,6BAA6B,EAAE,MAAM,IAAI,CAAA;IACzC,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAAM,CAAA;IAClE,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAChD;AAED,MAAM,WAAW,kCAAkC;IACjD,0BAA0B,EAAE,MAAM,IAAI,CAAA;IACtC,yBAAyB,EAAE,MAAM,IAAI,CAAA;IACrC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAsBD,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mCAAmC,GAC3C,kCAAkC,CA+EpC"}

package/dist/src/useDataGridPointerAutoScroll.js

@@ -0,0 +1,85 @@
+function isPointerInteractionActive(state) {
+    return state.isDragSelecting || state.isFillDragging || state.isRangeMoving;
+}
+function resolveActiveInteractionPointer(options, state) {
+    if (state.isRangeMoving) {
+        return options.resolveRangeMovePointer();
+    }
+    if (state.isFillDragging) {
+        return options.resolveFillPointer();
+    }
+    if (state.isDragSelecting) {
+        return options.resolveDragPointer();
+    }
+    return null;
+}
+export function useDataGridPointerAutoScroll(options) {
+    const requestFrame = options.requestAnimationFrame ?? ((callback) => window.requestAnimationFrame(callback));
+    const cancelFrame = options.cancelAnimationFrame ?? ((handle) => window.cancelAnimationFrame(handle));
+    let frameHandle = null;
+    const runFrame = () => {
+        const interactionState = options.resolveInteractionState();
+        if (!isPointerInteractionActive(interactionState)) {
+            frameHandle = null;
+            return;
+        }
+        const viewport = options.resolveViewportElement();
+        const pointer = resolveActiveInteractionPointer(options, interactionState);
+        if (viewport && pointer) {
+            const rect = viewport.getBoundingClientRect();
+            const topBoundary = rect.top + options.resolveHeaderHeight();
+            const deltaY = options.resolveAxisAutoScrollDelta(pointer.clientY, topBoundary, rect.bottom);
+            const deltaX = options.resolveAxisAutoScrollDelta(pointer.clientX, rect.left, rect.right);
+            if (deltaX !== 0 || deltaY !== 0) {
+                const maxScrollTop = Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+                const maxScrollLeft = Math.max(0, viewport.scrollWidth - viewport.clientWidth);
+                const nextTop = Math.max(0, Math.min(maxScrollTop, viewport.scrollTop + deltaY));
+                const nextLeft = Math.max(0, Math.min(maxScrollLeft, viewport.scrollLeft + deltaX));
+                if (nextTop !== viewport.scrollTop) {
+                    viewport.scrollTop = nextTop;
+                }
+                if (nextLeft !== viewport.scrollLeft) {
+                    viewport.scrollLeft = nextLeft;
+                }
+                options.setScrollPosition({
+                    top: viewport.scrollTop,
+                    left: viewport.scrollLeft,
+                });
+            }
+            if (interactionState.isRangeMoving) {
+                options.applyRangeMovePreviewFromPointer();
+            }
+            else if (interactionState.isFillDragging) {
+                options.applyFillPreviewFromPointer();
+            }
+            else if (interactionState.isDragSelecting) {
+                options.applyDragSelectionFromPointer();
+            }
+        }
+        frameHandle = requestFrame(runFrame);
+    };
+    function startInteractionAutoScroll() {
+        if (frameHandle !== null) {
+            return;
+        }
+        frameHandle = requestFrame(runFrame);
+    }
+    function stopAutoScrollFrameIfIdle() {
+        if (!isPointerInteractionActive(options.resolveInteractionState()) && frameHandle !== null) {
+            cancelFrame(frameHandle);
+            frameHandle = null;
+        }
+    }
+    function dispose() {
+        if (frameHandle === null) {
+            return;
+        }
+        cancelFrame(frameHandle);
+        frameHandle = null;
+    }
+    return {
+        startInteractionAutoScroll,
+        stopAutoScrollFrameIfIdle,
+        dispose,
+    };
+}

package/dist/src/useDataGridPointerCellCoordResolver.d.ts

@@ -0,0 +1,45 @@
+export interface DataGridPointerCellCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridPointerColumnMetric {
+    columnIndex: number;
+    start: number;
+    end: number;
+    width: number;
+}
+import type { DataGridColumnPin } from "@affino/datagrid-core";
+export interface DataGridPointerColumnSnapshot {
+    pin?: DataGridColumnPin | null;
+}
+export interface DataGridPointerVirtualWindowSnapshot {
+    rowStart?: number;
+    rowEnd?: number;
+    rowTotal: number;
+    colStart?: number;
+    colEnd?: number;
+    colTotal: number;
+    overscan?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+}
+export interface UseDataGridPointerCellCoordResolverOptions<TCoord extends DataGridPointerCellCoord> {
+    resolveViewportElement: () => HTMLElement | null;
+    resolveColumnMetrics: () => readonly DataGridPointerColumnMetric[];
+    resolveColumns: () => readonly DataGridPointerColumnSnapshot[];
+    resolveVirtualWindow: () => DataGridPointerVirtualWindowSnapshot | null | undefined;
+    resolveHeaderHeight: () => number;
+    resolveRowHeight: () => number;
+    resolveRowIndexAtOffset?: (offset: number) => number;
+    resolveNearestNavigableColumnIndex: (columnIndex: number) => number;
+    normalizeCellCoord: (coord: TCoord) => TCoord | null;
+}
+export interface UseDataGridPointerCellCoordResolverResult<TCoord extends DataGridPointerCellCoord> {
+    resolveColumnIndexByAbsoluteX: (absoluteX: number) => number;
+    resolveCellCoordFromPointer: (clientX: number, clientY: number) => TCoord | null;
+}
+export declare function useDataGridPointerCellCoordResolver<TCoord extends DataGridPointerCellCoord>(options: UseDataGridPointerCellCoordResolverOptions<TCoord>): UseDataGridPointerCellCoordResolverResult<TCoord>;
+//# sourceMappingURL=useDataGridPointerCellCoordResolver.d.ts.map

package/dist/src/useDataGridPointerCellCoordResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridPointerCellCoordResolver.d.ts","sourceRoot":"","sources":["../../src/useDataGridPointerCellCoordResolver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd;AAED,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D,MAAM,WAAW,6BAA6B;IAC5C,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAC/B;AAED,MAAM,WAAW,oCAAoC;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE;QACT,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,MAAM,WAAW,0CAA0C,CAAC,MAAM,SAAS,wBAAwB;IACjG,sBAAsB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IAChD,oBAAoB,EAAE,MAAM,SAAS,2BAA2B,EAAE,CAAA;IAClE,cAAc,EAAE,MAAM,SAAS,6BAA6B,EAAE,CAAA;IAC9D,oBAAoB,EAAE,MAAM,oCAAoC,GAAG,IAAI,GAAG,SAAS,CAAA;IACnF,mBAAmB,EAAE,MAAM,MAAM,CAAA;IACjC,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,uBAAuB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IACpD,kCAAkC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAA;IACnE,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;CACrD;AAED,MAAM,WAAW,yCAAyC,CAAC,MAAM,SAAS,wBAAwB;IAChG,6BAA6B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IAC5D,2BAA2B,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;CACjF;AAED,wBAAgB,mCAAmC,CAAC,MAAM,SAAS,wBAAwB,EACzF,OAAO,EAAE,0CAA0C,CAAC,MAAM,CAAC,GAC1D,yCAAyC,CAAC,MAAM,CAAC,CAkHnD"}

package/dist/src/useDataGridPointerCellCoordResolver.js

@@ -0,0 +1,107 @@
+export function useDataGridPointerCellCoordResolver(options) {
+    function resolveRowCount() {
+        const snapshot = options.resolveVirtualWindow();
+        return Math.max(0, Math.trunc(snapshot?.rowTotal ?? 0));
+    }
+    function resolveColumnCountFromWindow(metricsLength) {
+        const snapshot = options.resolveVirtualWindow();
+        if (!snapshot) {
+            return 0;
+        }
+        return Math.max(0, Math.min(metricsLength, Math.trunc(snapshot.colTotal)));
+    }
+    function resolveColumnIndexByAbsoluteX(absoluteX) {
+        const metrics = options.resolveColumnMetrics();
+        const lastMetric = metrics[metrics.length - 1];
+        if (!lastMetric) {
+            return -1;
+        }
+        const columnCount = resolveColumnCountFromWindow(metrics.length);
+        if (columnCount <= 0) {
+            return -1;
+        }
+        const lastAllowedMetric = metrics[Math.max(0, columnCount - 1)];
+        if (!lastAllowedMetric) {
+            return -1;
+        }
+        const clampedX = Math.max(0, Math.min(absoluteX, Math.max(0, lastMetric.end - 1)));
+        for (const metric of metrics) {
+            if (clampedX < metric.end) {
+                return Math.min(metric.columnIndex, lastAllowedMetric.columnIndex);
+            }
+        }
+        return lastAllowedMetric.columnIndex;
+    }
+    function resolveCellCoordFromPointer(clientX, clientY) {
+        const viewport = options.resolveViewportElement();
+        const rowCount = resolveRowCount();
+        if (!viewport || rowCount === 0) {
+            return null;
+        }
+        const rect = viewport.getBoundingClientRect();
+        if (rect.width <= 0 || rect.height <= 0) {
+            return null;
+        }
+        const metrics = options.resolveColumnMetrics();
+        const lastMetric = metrics[metrics.length - 1];
+        if (!lastMetric) {
+            return null;
+        }
+        const totalWidth = lastMetric.end;
+        if (totalWidth <= 0) {
+            return null;
+        }
+        let leftPinnedWidth = 0;
+        let rightPinnedWidth = 0;
+        const columns = options.resolveColumns();
+        for (const metric of metrics) {
+            const column = columns[metric.columnIndex];
+            if (column?.pin === "left") {
+                leftPinnedWidth = metric.end;
+            }
+            else if (column?.pin === "right") {
+                rightPinnedWidth += metric.width;
+            }
+        }
+        const pointerXInViewport = clientX - rect.left;
+        const pointerYInViewport = clientY - rect.top;
+        const clampedY = Math.max(0, Math.min(rect.height - 1, pointerYInViewport));
+        const rowOffset = viewport.scrollTop + clampedY - options.resolveHeaderHeight();
+        const rowRawIndex = options.resolveRowIndexAtOffset
+            ? options.resolveRowIndexAtOffset(rowOffset)
+            : Math.floor(rowOffset / options.resolveRowHeight());
+        let absoluteX;
+        if (pointerXInViewport <= leftPinnedWidth) {
+            absoluteX = pointerXInViewport;
+        }
+        else if (rightPinnedWidth > 0 && pointerXInViewport >= rect.width - rightPinnedWidth) {
+            absoluteX = totalWidth - rightPinnedWidth + (pointerXInViewport - (rect.width - rightPinnedWidth));
+        }
+        else {
+            absoluteX = viewport.scrollLeft + pointerXInViewport;
+        }
+        const columnRawIndex = resolveColumnIndexByAbsoluteX(absoluteX);
+        if (columnRawIndex < 0) {
+            return null;
+        }
+        const columnIndex = options.resolveNearestNavigableColumnIndex(columnRawIndex);
+        if (columnIndex < 0) {
+            return null;
+        }
+        const normalized = options.normalizeCellCoord({
+            rowIndex: rowRawIndex,
+            columnIndex,
+        });
+        if (!normalized) {
+            return null;
+        }
+        if (normalized.rowIndex < 0 || normalized.rowIndex >= rowCount) {
+            return null;
+        }
+        return normalized;
+    }
+    return {
+        resolveColumnIndexByAbsoluteX,
+        resolveCellCoordFromPointer,
+    };
+}

package/dist/src/useDataGridPointerModifierPolicy.d.ts

@@ -0,0 +1,5 @@
+export interface UseDataGridPointerModifierPolicyResult {
+    isRangeMoveModifierActive: (event: MouseEvent | KeyboardEvent) => boolean;
+}
+export declare function useDataGridPointerModifierPolicy(): UseDataGridPointerModifierPolicyResult;
+//# sourceMappingURL=useDataGridPointerModifierPolicy.d.ts.map

package/dist/src/useDataGridPointerModifierPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridPointerModifierPolicy.d.ts","sourceRoot":"","sources":["../../src/useDataGridPointerModifierPolicy.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sCAAsC;IACrD,yBAAyB,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,KAAK,OAAO,CAAA;CAC1E;AAED,wBAAgB,gCAAgC,IAAI,sCAAsC,CAQzF"}

package/dist/src/useDataGridPointerModifierPolicy.js

@@ -0,0 +1,8 @@
+export function useDataGridPointerModifierPolicy() {
+    function isRangeMoveModifierActive(event) {
+        return event.altKey || event.ctrlKey || event.metaKey;
+    }
+    return {
+        isRangeMoveModifierActive,
+    };
+}