@affino/datagrid-orchestration 0.1.0

package/dist/src/useDataGridRowsProjection.js

@@ -0,0 +1,69 @@
+export function normalizeDataGridQuickFilter(query) {
+    return query.trim().toLowerCase();
+}
+function compareSortableValues(left, right) {
+    if (left == null && right == null) {
+        return 0;
+    }
+    if (left == null) {
+        return 1;
+    }
+    if (right == null) {
+        return -1;
+    }
+    if (typeof left === "number" && typeof right === "number") {
+        if (left === right)
+            return 0;
+        return left < right ? -1 : 1;
+    }
+    const leftValue = String(left).toLowerCase();
+    const rightValue = String(right).toLowerCase();
+    return leftValue.localeCompare(rightValue);
+}
+export function sortDataGridRows(rows, model, resolveCellValue) {
+    if (!model.length) {
+        return rows;
+    }
+    return rows
+        .map((row, index) => ({ row, index }))
+        .sort((left, right) => {
+        for (const sortEntry of model) {
+            const next = compareSortableValues(resolveCellValue(left.row, sortEntry.key), resolveCellValue(right.row, sortEntry.key));
+            if (next === 0) {
+                continue;
+            }
+            return sortEntry.direction === "asc" ? next : -next;
+        }
+        return left.index - right.index;
+    })
+        .map(entry => entry.row);
+}
+export function rowMatchesDataGridQuickFilter(row, normalizedQuery, columnKeys, fallbackQueryColumnKeys, resolveCellValue) {
+    if (!normalizedQuery) {
+        return true;
+    }
+    const keys = columnKeys.length ? columnKeys : fallbackQueryColumnKeys;
+    for (const key of keys) {
+        const value = resolveCellValue(row, key);
+        if (typeof value === "undefined" || value === null) {
+            continue;
+        }
+        if (String(value).toLowerCase().includes(normalizedQuery)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function useDataGridRowsProjection(options) {
+    const normalizedQuickFilter = normalizeDataGridQuickFilter(options.query);
+    const quickFilteredRows = normalizedQuickFilter
+        ? options.rows.filter(row => rowMatchesDataGridQuickFilter(row, normalizedQuickFilter, options.searchableColumnKeys, options.fallbackQueryColumnKeys ?? [], options.resolveCellValue))
+        : options.rows;
+    const columnFilteredRows = options.hasColumnFilters
+        ? quickFilteredRows.filter(row => options.rowMatchesColumnFilters(row, options.appliedColumnFilters))
+        : quickFilteredRows;
+    return {
+        normalizedQuickFilter,
+        filteredAndSortedRows: sortDataGridRows(columnFilteredRows, options.sortModel, options.resolveCellValue),
+    };
+}

package/dist/src/useDataGridRuntimeService.d.ts

@@ -0,0 +1,33 @@
+import type { DataGridColumnDef, DataGridColumnModelSnapshot, DataGridRowNode, DataGridViewportRange } from "@affino/datagrid-core";
+import { type CreateDataGridRuntimeOptions, type DataGridRuntime } from "./createDataGridRuntime";
+export interface UseDataGridRuntimeServiceOptions<TRow = unknown> extends CreateDataGridRuntimeOptions<TRow> {
+}
+export interface DataGridRuntimeVirtualWindowSnapshot {
+    rowStart: number;
+    rowEnd: number;
+    rowTotal: number;
+    colStart: number;
+    colEnd: number;
+    colTotal: number;
+    overscan: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+}
+export interface UseDataGridRuntimeServiceResult<TRow = unknown> extends DataGridRuntime<TRow> {
+    getColumnSnapshot: () => DataGridColumnModelSnapshot;
+    subscribeColumnSnapshot: (listener: (snapshot: DataGridColumnModelSnapshot) => void) => () => void;
+    getVirtualWindowSnapshot: () => DataGridRuntimeVirtualWindowSnapshot | null;
+    subscribeVirtualWindow: (listener: (snapshot: DataGridRuntimeVirtualWindowSnapshot | null) => void) => () => void;
+    setRows: (rows: readonly TRow[]) => void;
+    setColumns: (columns: readonly DataGridColumnDef[]) => void;
+    start: () => Promise<void>;
+    stop: () => void;
+    syncRowsInRange: (range: DataGridViewportRange) => readonly DataGridRowNode<TRow>[];
+    isStarted: () => boolean;
+    isDisposed: () => boolean;
+}
+export declare function useDataGridRuntimeService<TRow = unknown>(options: UseDataGridRuntimeServiceOptions<TRow>): UseDataGridRuntimeServiceResult<TRow>;
+//# sourceMappingURL=useDataGridRuntimeService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridRuntimeService.d.ts","sourceRoot":"","sources":["../../src/useDataGridRuntimeService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,eAAe,EAEf,qBAAqB,EACtB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAyB,KAAK,4BAA4B,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAUxH,MAAM,WAAW,gCAAgC,CAAC,IAAI,GAAG,OAAO,CAAE,SAAQ,4BAA4B,CAAC,IAAI,CAAC;CAAG;AAE/G,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE;QACR,GAAG,EAAE,MAAM,CAAA;QACX,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;CACF;AAED,MAAM,WAAW,+BAA+B,CAAC,IAAI,GAAG,OAAO,CAAE,SAAQ,eAAe,CAAC,IAAI,CAAC;IAC5F,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;IACpD,uBAAuB,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,2BAA2B,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;IAClG,wBAAwB,EAAE,MAAM,oCAAoC,GAAG,IAAI,CAAA;IAC3E,sBAAsB,EAAE,CACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,oCAAoC,GAAG,IAAI,KAAK,IAAI,KACtE,MAAM,IAAI,CAAA;IACf,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,KAAK,IAAI,CAAA;IACxC,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,KAAK,IAAI,CAAA;IAC3D,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,eAAe,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,SAAS,eAAe,CAAC,IAAI,CAAC,EAAE,CAAA;IACnF,SAAS,EAAE,MAAM,OAAO,CAAA;IACxB,UAAU,EAAE,MAAM,OAAO,CAAA;CAC1B;AAmED,wBAAgB,yBAAyB,CAAC,IAAI,GAAG,OAAO,EACtD,OAAO,EAAE,gCAAgC,CAAC,IAAI,CAAC,GAC9C,+BAA+B,CAAC,IAAI,CAAC,CA8KvC"}

package/dist/src/useDataGridRuntimeService.js

@@ -0,0 +1,209 @@
+import { createDataGridRuntime } from "./createDataGridRuntime";
+function isMutableRowsModel(model) {
+    return typeof model.setRows === "function";
+}
+function normalizeCount(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(value));
+}
+function normalizeRange(start, end, total) {
+    if (total <= 0) {
+        return { start: 0, end: 0 };
+    }
+    const safeStart = Math.max(0, Math.min(total - 1, normalizeCount(start)));
+    const safeEnd = Math.max(safeStart, Math.min(total - 1, normalizeCount(end)));
+    return {
+        start: safeStart,
+        end: safeEnd,
+    };
+}
+function cloneVirtualWindow(snapshot) {
+    if (!snapshot) {
+        return null;
+    }
+    return {
+        rowStart: snapshot.rowStart,
+        rowEnd: snapshot.rowEnd,
+        rowTotal: snapshot.rowTotal,
+        colStart: snapshot.colStart,
+        colEnd: snapshot.colEnd,
+        colTotal: snapshot.colTotal,
+        overscan: {
+            top: snapshot.overscan.top,
+            bottom: snapshot.overscan.bottom,
+            left: snapshot.overscan.left,
+            right: snapshot.overscan.right,
+        },
+    };
+}
+function isSameVirtualWindow(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (!left || !right) {
+        return false;
+    }
+    return (left.rowStart === right.rowStart &&
+        left.rowEnd === right.rowEnd &&
+        left.rowTotal === right.rowTotal &&
+        left.colStart === right.colStart &&
+        left.colEnd === right.colEnd &&
+        left.colTotal === right.colTotal &&
+        left.overscan.top === right.overscan.top &&
+        left.overscan.bottom === right.overscan.bottom &&
+        left.overscan.left === right.overscan.left &&
+        left.overscan.right === right.overscan.right);
+}
+export function useDataGridRuntimeService(options) {
+    const runtime = createDataGridRuntime(options);
+    const { rowModel, columnModel, core, api } = runtime;
+    let started = false;
+    let disposed = false;
+    const virtualWindowListeners = new Set();
+    const resolveVirtualWindowFromViewportService = () => {
+        const viewportService = core.getService("viewport");
+        const rawWindow = viewportService.getVirtualWindow?.();
+        if (!rawWindow || typeof rawWindow !== "object") {
+            return null;
+        }
+        const value = rawWindow;
+        const rowTotal = normalizeCount(value.rowTotal);
+        const colTotal = normalizeCount(value.colTotal);
+        const rowRange = normalizeRange(value.rowStart, value.rowEnd, rowTotal);
+        const colRange = normalizeRange(value.colStart, value.colEnd, colTotal);
+        const overscanSource = value.overscan;
+        return {
+            rowStart: rowRange.start,
+            rowEnd: rowRange.end,
+            rowTotal,
+            colStart: colRange.start,
+            colEnd: colRange.end,
+            colTotal,
+            overscan: {
+                top: normalizeCount(overscanSource?.top),
+                bottom: normalizeCount(overscanSource?.bottom),
+                left: normalizeCount(overscanSource?.left),
+                right: normalizeCount(overscanSource?.right),
+            },
+        };
+    };
+    const buildFallbackVirtualWindow = () => {
+        const rowSnapshot = rowModel.getSnapshot();
+        const rowTotal = normalizeCount(rowSnapshot.rowCount);
+        const rowRange = normalizeRange(rowSnapshot.viewportRange.start, rowSnapshot.viewportRange.end, rowTotal);
+        const colTotal = normalizeCount(columnModel.getSnapshot().visibleColumns.length);
+        const colRange = normalizeRange(0, Math.max(0, colTotal - 1), colTotal);
+        return {
+            rowStart: rowRange.start,
+            rowEnd: rowRange.end,
+            rowTotal,
+            colStart: colRange.start,
+            colEnd: colRange.end,
+            colTotal,
+            overscan: {
+                top: 0,
+                bottom: 0,
+                left: 0,
+                right: 0,
+            },
+        };
+    };
+    const resolveVirtualWindowSnapshot = () => (resolveVirtualWindowFromViewportService() ?? buildFallbackVirtualWindow());
+    let virtualWindowSnapshot = resolveVirtualWindowSnapshot();
+    const emitVirtualWindow = () => {
+        for (const listener of virtualWindowListeners) {
+            listener(cloneVirtualWindow(virtualWindowSnapshot));
+        }
+    };
+    const recomputeVirtualWindow = () => {
+        const nextSnapshot = resolveVirtualWindowSnapshot();
+        if (isSameVirtualWindow(virtualWindowSnapshot, nextSnapshot)) {
+            return;
+        }
+        virtualWindowSnapshot = nextSnapshot;
+        emitVirtualWindow();
+    };
+    const unsubscribeRowModel = rowModel.subscribe(() => {
+        recomputeVirtualWindow();
+    });
+    const unsubscribeColumnModelForWindow = columnModel.subscribe(() => {
+        recomputeVirtualWindow();
+    });
+    function getColumnSnapshot() {
+        return api.getColumnModelSnapshot();
+    }
+    function subscribeColumnSnapshot(listener) {
+        listener(getColumnSnapshot());
+        const unsubscribe = columnModel.subscribe(next => {
+            listener(next);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }
+    function setRows(rows) {
+        if (!isMutableRowsModel(rowModel)) {
+            return;
+        }
+        rowModel.setRows(rows);
+        recomputeVirtualWindow();
+    }
+    function setColumns(columns) {
+        columnModel.setColumns(columns);
+        recomputeVirtualWindow();
+    }
+    async function start() {
+        if (disposed || started) {
+            return;
+        }
+        await api.start();
+        started = true;
+        recomputeVirtualWindow();
+    }
+    function stop() {
+        if (disposed) {
+            return;
+        }
+        unsubscribeRowModel();
+        unsubscribeColumnModelForWindow();
+        virtualWindowListeners.clear();
+        void core.dispose();
+        started = false;
+        disposed = true;
+    }
+    function syncRowsInRange(range) {
+        api.setViewportRange(range);
+        const rows = api.getRowsInRange(range);
+        recomputeVirtualWindow();
+        return rows;
+    }
+    function getVirtualWindowSnapshot() {
+        return cloneVirtualWindow(virtualWindowSnapshot);
+    }
+    function subscribeVirtualWindow(listener) {
+        listener(getVirtualWindowSnapshot());
+        virtualWindowListeners.add(listener);
+        return () => {
+            virtualWindowListeners.delete(listener);
+        };
+    }
+    return {
+        rowModel,
+        columnModel,
+        core,
+        api,
+        getColumnSnapshot,
+        subscribeColumnSnapshot,
+        getVirtualWindowSnapshot,
+        subscribeVirtualWindow,
+        setRows,
+        setColumns,
+        start,
+        stop,
+        syncRowsInRange,
+        isStarted: () => started,
+        isDisposed: () => disposed,
+    };
+}

package/dist/src/useDataGridSelectionComparators.d.ts

@@ -0,0 +1,16 @@
+export interface DataGridSelectionComparatorCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridSelectionComparatorRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface UseDataGridSelectionComparatorsResult<TCoord extends DataGridSelectionComparatorCoord = DataGridSelectionComparatorCoord, TRange extends DataGridSelectionComparatorRange = DataGridSelectionComparatorRange> {
+    cellCoordsEqual: (a: TCoord | null, b: TCoord | null) => boolean;
+    rangesEqual: (a: TRange | null, b: TRange | null) => boolean;
+}
+export declare function useDataGridSelectionComparators<TCoord extends DataGridSelectionComparatorCoord = DataGridSelectionComparatorCoord, TRange extends DataGridSelectionComparatorRange = DataGridSelectionComparatorRange>(): UseDataGridSelectionComparatorsResult<TCoord, TRange>;
+//# sourceMappingURL=useDataGridSelectionComparators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridSelectionComparators.d.ts","sourceRoot":"","sources":["../../src/useDataGridSelectionComparators.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qCAAqC,CACpD,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC;IAElF,eAAe,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAA;IAChE,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAA;CAC7D;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,KAC/E,qCAAqC,CAAC,MAAM,EAAE,MAAM,CAAC,CAwBzD"}

package/dist/src/useDataGridSelectionComparators.js

@@ -0,0 +1,21 @@
+export function useDataGridSelectionComparators() {
+    function cellCoordsEqual(a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        return a.rowIndex === b.rowIndex && a.columnIndex === b.columnIndex;
+    }
+    function rangesEqual(a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        return (a.startRow === b.startRow &&
+            a.endRow === b.endRow &&
+            a.startColumn === b.startColumn &&
+            a.endColumn === b.endColumn);
+    }
+    return {
+        cellCoordsEqual,
+        rangesEqual,
+    };
+}

package/dist/src/useDataGridSelectionMoveHandle.d.ts

@@ -0,0 +1,38 @@
+export interface DataGridSelectionMoveHandleCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridSelectionMoveHandleRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface DataGridSelectionMoveHandleSides {
+    top: boolean;
+    right: boolean;
+    bottom: boolean;
+    left: boolean;
+}
+export interface UseDataGridSelectionMoveHandleOptions<TRow, TCoord extends DataGridSelectionMoveHandleCoord = DataGridSelectionMoveHandleCoord, TRange extends DataGridSelectionMoveHandleRange = DataGridSelectionMoveHandleRange> {
+    resolveSelectionRange: () => TRange | null;
+    resolveRowIndex: (row: TRow) => number;
+    resolveColumnIndex: (columnKey: string) => number;
+    isCellWithinRange: (rowIndex: number, columnIndex: number, range: TRange) => boolean;
+    resolveCellCoord: (row: TRow, columnKey: string) => TCoord | null;
+    startRangeMove: (coord: TCoord, pointer: {
+        clientX: number;
+        clientY: number;
+    }) => boolean;
+    isRangeMoving: () => boolean;
+    isFillDragging: () => boolean;
+    isInlineEditorOpen: () => boolean;
+    selectColumnKey?: string;
+}
+export interface UseDataGridSelectionMoveHandleResult<TRow> {
+    getSelectionEdgeSides: (row: TRow, columnKey: string) => DataGridSelectionMoveHandleSides;
+    shouldShowSelectionMoveHandle: (row: TRow, columnKey: string, side: keyof DataGridSelectionMoveHandleSides) => boolean;
+    onSelectionMoveHandleMouseDown: (row: TRow, columnKey: string, event: MouseEvent) => boolean;
+}
+export declare function useDataGridSelectionMoveHandle<TRow, TCoord extends DataGridSelectionMoveHandleCoord = DataGridSelectionMoveHandleCoord, TRange extends DataGridSelectionMoveHandleRange = DataGridSelectionMoveHandleRange>(options: UseDataGridSelectionMoveHandleOptions<TRow, TCoord, TRange>): UseDataGridSelectionMoveHandleResult<TRow>;
+//# sourceMappingURL=useDataGridSelectionMoveHandle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridSelectionMoveHandle.d.ts","sourceRoot":"","sources":["../../src/useDataGridSelectionMoveHandle.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,gCAAgC;IAC/C,GAAG,EAAE,OAAO,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,qCAAqC,CACpD,IAAI,EACJ,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC;IAElF,qBAAqB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAC1C,eAAe,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,MAAM,CAAA;IACtC,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACjD,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACpF,gBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACjE,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAA;IACzF,aAAa,EAAE,MAAM,OAAO,CAAA;IAC5B,cAAc,EAAE,MAAM,OAAO,CAAA;IAC7B,kBAAkB,EAAE,MAAM,OAAO,CAAA;IACjC,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,oCAAoC,CAAC,IAAI;IACxD,qBAAqB,EAAE,CACrB,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,KACd,gCAAgC,CAAA;IACrC,6BAA6B,EAAE,CAC7B,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,gCAAgC,KACzC,OAAO,CAAA;IACZ,8BAA8B,EAAE,CAC9B,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,UAAU,KACd,OAAO,CAAA;CACb;AASD,wBAAgB,8BAA8B,CAC5C,IAAI,EACJ,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAElF,OAAO,EAAE,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GACnE,oCAAoC,CAAC,IAAI,CAAC,CAyD5C"}

package/dist/src/useDataGridSelectionMoveHandle.js

@@ -0,0 +1,49 @@
+const EMPTY_SIDES = {
+    top: false,
+    right: false,
+    bottom: false,
+    left: false,
+};
+export function useDataGridSelectionMoveHandle(options) {
+    const selectColumnKey = options.selectColumnKey ?? "select";
+    function getSelectionEdgeSides(row, columnKey) {
+        const range = options.resolveSelectionRange();
+        if (!range || columnKey === selectColumnKey) {
+            return EMPTY_SIDES;
+        }
+        const rowIndex = options.resolveRowIndex(row);
+        const columnIndex = options.resolveColumnIndex(columnKey);
+        if (columnIndex < 0 || !options.isCellWithinRange(rowIndex, columnIndex, range)) {
+            return EMPTY_SIDES;
+        }
+        return {
+            top: rowIndex === range.startRow,
+            right: columnIndex === range.endColumn,
+            bottom: rowIndex === range.endRow,
+            left: columnIndex === range.startColumn,
+        };
+    }
+    function shouldShowSelectionMoveHandle(row, columnKey, side) {
+        if (options.isRangeMoving() || options.isFillDragging() || options.isInlineEditorOpen()) {
+            return false;
+        }
+        return getSelectionEdgeSides(row, columnKey)[side];
+    }
+    function onSelectionMoveHandleMouseDown(row, columnKey, event) {
+        if (event.button !== 0) {
+            return false;
+        }
+        const coord = options.resolveCellCoord(row, columnKey);
+        if (!coord) {
+            return false;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        return options.startRangeMove(coord, event);
+    }
+    return {
+        getSelectionEdgeSides,
+        shouldShowSelectionMoveHandle,
+        onSelectionMoveHandleMouseDown,
+    };
+}

package/dist/src/useDataGridSelectionOverlayOrchestration.d.ts

@@ -0,0 +1,60 @@
+export interface DataGridOverlayRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface DataGridOverlayColumnLike {
+    pin?: string | null;
+}
+export interface DataGridOverlayColumnMetricLike {
+    start: number;
+    end: number;
+}
+export interface DataGridSelectionOverlaySegment {
+    key: string;
+    mode: "scroll";
+    style: {
+        top: string;
+        left: string;
+        width: string;
+        height: string;
+    };
+}
+export interface DataGridSelectionOverlayVirtualWindow {
+    rowStart?: number;
+    rowEnd?: number;
+    rowTotal: number;
+    colStart?: number;
+    colEnd?: number;
+    colTotal: number;
+    overscan?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+}
+export interface UseDataGridSelectionOverlayOrchestrationOptions {
+    headerHeight: number;
+    rowHeight: number;
+    resolveRowHeight?: (rowIndex: number) => number;
+    resolveRowOffset?: (rowIndex: number) => number;
+    orderedColumns: readonly DataGridOverlayColumnLike[];
+    orderedColumnMetrics: readonly DataGridOverlayColumnMetricLike[];
+    cellSelectionRange: DataGridOverlayRange | null;
+    fillPreviewRange: DataGridOverlayRange | null;
+    fillBaseRange: DataGridOverlayRange | null;
+    rangeMovePreviewRange: DataGridOverlayRange | null;
+    rangeMoveBaseRange: DataGridOverlayRange | null;
+    isRangeMoving: boolean;
+    virtualWindow: DataGridSelectionOverlayVirtualWindow;
+    resolveDevicePixelRatio?: () => number;
+}
+export interface DataGridSelectionOverlaySnapshot {
+    cellSelectionOverlaySegments: readonly DataGridSelectionOverlaySegment[];
+    fillPreviewOverlaySegments: readonly DataGridSelectionOverlaySegment[];
+    rangeMoveOverlaySegments: readonly DataGridSelectionOverlaySegment[];
+}
+export declare function useDataGridSelectionOverlayOrchestration(options: UseDataGridSelectionOverlayOrchestrationOptions): DataGridSelectionOverlaySnapshot;
+//# sourceMappingURL=useDataGridSelectionOverlayOrchestration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridSelectionOverlayOrchestration.d.ts","sourceRoot":"","sources":["../../src/useDataGridSelectionOverlayOrchestration.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,+BAA+B;IAC9C,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE;QACL,GAAG,EAAE,MAAM,CAAA;QACX,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,MAAM,WAAW,qCAAqC;IACpD,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,+CAA+C;IAC9D,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/C,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/C,cAAc,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACpD,oBAAoB,EAAE,SAAS,+BAA+B,EAAE,CAAA;IAChE,kBAAkB,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAC/C,gBAAgB,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAC7C,aAAa,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAC1C,qBAAqB,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAClD,kBAAkB,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAC/C,aAAa,EAAE,OAAO,CAAA;IACtB,aAAa,EAAE,qCAAqC,CAAA;IACpD,uBAAuB,CAAC,EAAE,MAAM,MAAM,CAAA;CACvC;AAED,MAAM,WAAW,gCAAgC;IAC/C,4BAA4B,EAAE,SAAS,+BAA+B,EAAE,CAAA;IACxE,0BAA0B,EAAE,SAAS,+BAA+B,EAAE,CAAA;IACtE,wBAAwB,EAAE,SAAS,+BAA+B,EAAE,CAAA;CACrE;AA8ID,wBAAgB,wCAAwC,CACtD,OAAO,EAAE,+CAA+C,GACvD,gCAAgC,CAkElC"}

package/dist/src/useDataGridSelectionOverlayOrchestration.js

@@ -0,0 +1,137 @@
+function rangesEqual(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    return (a.startRow === b.startRow &&
+        a.endRow === b.endRow &&
+        a.startColumn === b.startColumn &&
+        a.endColumn === b.endColumn);
+}
+function snapOverlayValue(value, resolveDevicePixelRatio) {
+    const rawDpr = resolveDevicePixelRatio?.() ?? 1;
+    const dpr = Number.isFinite(rawDpr) && rawDpr > 0 ? rawDpr : 1;
+    return Math.round(value * dpr) / dpr;
+}
+function clampOverlayRange(range, options) {
+    if (!range) {
+        return null;
+    }
+    const maxRow = options.rowTotal - 1;
+    const maxColumn = options.colTotal - 1;
+    if (maxRow < 0 || maxColumn < 0) {
+        return null;
+    }
+    const startRow = Math.max(0, Math.min(maxRow, Math.trunc(range.startRow)));
+    const endRow = Math.max(startRow, Math.min(maxRow, Math.trunc(range.endRow)));
+    const startColumn = Math.max(0, Math.min(maxColumn, Math.trunc(range.startColumn)));
+    const endColumn = Math.max(startColumn, Math.min(maxColumn, Math.trunc(range.endColumn)));
+    return {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn,
+    };
+}
+function buildScrollOverlaySegments(range, keyPrefix, headerHeight, rowHeight, resolveRowHeight, resolveRowOffset, orderedColumns, orderedColumnMetrics, resolveDevicePixelRatio) {
+    if (!range) {
+        return [];
+    }
+    const resolveOffset = (rowIndex) => {
+        if (resolveRowOffset) {
+            return resolveRowOffset(rowIndex);
+        }
+        if (resolveRowHeight) {
+            let offset = 0;
+            for (let index = 0; index < rowIndex; index += 1) {
+                offset += resolveRowHeight(index);
+            }
+            return offset;
+        }
+        return rowIndex * rowHeight;
+    };
+    const resolveSpanHeight = (start, end) => {
+        if (!resolveRowHeight) {
+            return (end - start + 1) * rowHeight;
+        }
+        let height = 0;
+        for (let index = start; index <= end; index += 1) {
+            height += resolveRowHeight(index);
+        }
+        return height;
+    };
+    const top = headerHeight + resolveOffset(range.startRow);
+    const height = resolveSpanHeight(range.startRow, range.endRow);
+    const segments = [];
+    let currentMode = null;
+    let currentStart = range.startColumn;
+    for (let index = range.startColumn; index <= range.endColumn; index += 1) {
+        const column = orderedColumns[index];
+        const mode = column?.pin === "left" ? "pinned-left" : "scroll";
+        if (!currentMode) {
+            currentMode = mode;
+            currentStart = index;
+            continue;
+        }
+        if (mode === currentMode) {
+            continue;
+        }
+        segments.push({ start: currentStart, end: index - 1, mode: currentMode });
+        currentMode = mode;
+        currentStart = index;
+    }
+    if (currentMode) {
+        segments.push({ start: currentStart, end: range.endColumn, mode: currentMode });
+    }
+    return segments
+        .map(segment => {
+        if (segment.mode !== "scroll") {
+            return null;
+        }
+        const startMetric = orderedColumnMetrics[segment.start];
+        const endMetric = orderedColumnMetrics[segment.end];
+        if (!startMetric || !endMetric) {
+            return null;
+        }
+        const left = snapOverlayValue(startMetric.start, resolveDevicePixelRatio);
+        const width = snapOverlayValue(endMetric.end - startMetric.start, resolveDevicePixelRatio);
+        const snappedTop = snapOverlayValue(top, resolveDevicePixelRatio);
+        const snappedHeight = snapOverlayValue(height, resolveDevicePixelRatio);
+        return {
+            key: `${keyPrefix}-${segment.mode}-${segment.start}-${segment.end}`,
+            mode: "scroll",
+            style: {
+                top: `${Math.max(0, snappedTop)}px`,
+                left: `${Math.max(0, left)}px`,
+                width: `${Math.max(1, width)}px`,
+                height: `${Math.max(1, snappedHeight)}px`,
+            },
+        };
+    })
+        .filter((segment) => segment !== null);
+}
+export function useDataGridSelectionOverlayOrchestration(options) {
+    const rowTotal = Math.max(0, Math.trunc(options.virtualWindow.rowTotal));
+    const colTotal = Math.max(0, Math.min(options.orderedColumns.length, Math.trunc(options.virtualWindow.colTotal)));
+    const cellSelectionRange = clampOverlayRange(options.cellSelectionRange, { rowTotal, colTotal });
+    const fillPreviewRange = clampOverlayRange(options.fillPreviewRange, { rowTotal, colTotal });
+    const fillBaseRange = clampOverlayRange(options.fillBaseRange, { rowTotal, colTotal });
+    const rangeMovePreviewRange = clampOverlayRange(options.rangeMovePreviewRange, { rowTotal, colTotal });
+    const rangeMoveBaseRange = clampOverlayRange(options.rangeMoveBaseRange, { rowTotal, colTotal });
+    const cellSelectionOverlaySegments = buildScrollOverlaySegments(cellSelectionRange, "selection", options.headerHeight, options.rowHeight, options.resolveRowHeight, options.resolveRowOffset, options.orderedColumns, options.orderedColumnMetrics, options.resolveDevicePixelRatio);
+    const fillPreviewOverlaySegments = !fillPreviewRange ||
+        !fillBaseRange ||
+        rangesEqual(fillPreviewRange, fillBaseRange)
+        ? []
+        : buildScrollOverlaySegments(fillPreviewRange, "fill-preview", options.headerHeight, options.rowHeight, options.resolveRowHeight, options.resolveRowOffset, options.orderedColumns, options.orderedColumnMetrics, options.resolveDevicePixelRatio);
+    const rangeMoveOverlaySegments = !options.isRangeMoving ||
+        !rangeMovePreviewRange ||
+        !rangeMoveBaseRange ||
+        rangesEqual(rangeMovePreviewRange, rangeMoveBaseRange)
+        ? []
+        : buildScrollOverlaySegments(rangeMovePreviewRange, "move-preview", options.headerHeight, options.rowHeight, options.resolveRowHeight, options.resolveRowOffset, options.orderedColumns, options.orderedColumnMetrics, options.resolveDevicePixelRatio);
+    return {
+        cellSelectionOverlaySegments,
+        fillPreviewOverlaySegments,
+        rangeMoveOverlaySegments,
+    };
+}

package/dist/src/useDataGridTabTargetResolver.d.ts

@@ -0,0 +1,17 @@
+export interface DataGridTabTargetCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridTabTargetNextCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface UseDataGridTabTargetResolverOptions<TCoord extends DataGridTabTargetCoord> {
+    resolveNavigableColumnIndexes: () => readonly number[];
+    normalizeCellCoord: (next: DataGridTabTargetNextCoord) => TCoord | null;
+}
+export interface UseDataGridTabTargetResolverResult<TCoord extends DataGridTabTargetCoord> {
+    resolveTabTarget: (current: TCoord, backwards: boolean) => TCoord | null;
+}
+export declare function useDataGridTabTargetResolver<TCoord extends DataGridTabTargetCoord>(options: UseDataGridTabTargetResolverOptions<TCoord>): UseDataGridTabTargetResolverResult<TCoord>;
+//# sourceMappingURL=useDataGridTabTargetResolver.d.ts.map