@affino/datagrid-orchestration 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridTabTargetResolver.d.ts","sourceRoot":"","sources":["../../src/useDataGridTabTargetResolver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,mCAAmC,CAAC,MAAM,SAAS,sBAAsB;IACxF,6BAA6B,EAAE,MAAM,SAAS,MAAM,EAAE,CAAA;IACtD,kBAAkB,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,MAAM,GAAG,IAAI,CAAA;CACxE;AAED,MAAM,WAAW,kCAAkC,CAAC,MAAM,SAAS,sBAAsB;IACvF,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAA;CACzE;AAED,wBAAgB,4BAA4B,CAAC,MAAM,SAAS,sBAAsB,EAChF,OAAO,EAAE,mCAAmC,CAAC,MAAM,CAAC,GACnD,kCAAkC,CAAC,MAAM,CAAC,CAgC5C"}

package/dist/src/useDataGridTabTargetResolver.js

@@ -0,0 +1,30 @@
+export function useDataGridTabTargetResolver(options) {
+    function resolveTabTarget(current, backwards) {
+        const columns = options.resolveNavigableColumnIndexes();
+        if (!columns.length) {
+            return null;
+        }
+        const currentPos = columns.indexOf(current.columnIndex);
+        const resolvedPos = currentPos === -1
+            ? columns.findIndex(index => index >= current.columnIndex)
+            : currentPos;
+        const startPos = resolvedPos === -1 ? (backwards ? columns.length - 1 : 0) : resolvedPos;
+        let rowIndex = current.rowIndex;
+        let columnPos = startPos + (backwards ? -1 : 1);
+        if (columnPos < 0) {
+            columnPos = columns.length - 1;
+            rowIndex -= 1;
+        }
+        else if (columnPos >= columns.length) {
+            columnPos = 0;
+            rowIndex += 1;
+        }
+        return options.normalizeCellCoord({
+            rowIndex,
+            columnIndex: columns[columnPos] ?? columns[0] ?? 0,
+        });
+    }
+    return {
+        resolveTabTarget,
+    };
+}

package/dist/src/useDataGridViewportBlurHandler.d.ts

@@ -0,0 +1,16 @@
+export interface UseDataGridViewportBlurHandlerOptions {
+    resolveViewportElement: () => HTMLElement | null;
+    resolveContextMenuElement: () => HTMLElement | null;
+    stopDragSelection: () => void;
+    stopFillSelection: (commit: boolean) => void;
+    stopRangeMove: (commit: boolean) => void;
+    stopColumnResize: () => void;
+    closeContextMenu: () => void;
+    hasInlineEditor: () => boolean;
+    commitInlineEdit: () => boolean;
+}
+export interface UseDataGridViewportBlurHandlerResult {
+    handleViewportBlur: (event: FocusEvent) => boolean;
+}
+export declare function useDataGridViewportBlurHandler(options: UseDataGridViewportBlurHandlerOptions): UseDataGridViewportBlurHandlerResult;
+//# sourceMappingURL=useDataGridViewportBlurHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridViewportBlurHandler.d.ts","sourceRoot":"","sources":["../../src/useDataGridViewportBlurHandler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qCAAqC;IACpD,sBAAsB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IAChD,yBAAyB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IACnD,iBAAiB,EAAE,MAAM,IAAI,CAAA;IAC7B,iBAAiB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IAC5C,aAAa,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACxC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,gBAAgB,EAAE,MAAM,OAAO,CAAA;CAChC;AAED,MAAM,WAAW,oCAAoC;IACnD,kBAAkB,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAA;CACnD;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qCAAqC,GAC7C,oCAAoC,CAiEtC"}

package/dist/src/useDataGridViewportBlurHandler.js

@@ -0,0 +1,62 @@
+export function useDataGridViewportBlurHandler(options) {
+    function finalizeBlurCleanup() {
+        options.stopDragSelection();
+        options.stopFillSelection(false);
+        options.stopRangeMove(false);
+        options.stopColumnResize();
+        options.closeContextMenu();
+        if (options.hasInlineEditor()) {
+            options.commitInlineEdit();
+        }
+    }
+    function handleViewportBlur(event) {
+        const viewport = options.resolveViewportElement();
+        const nextFocused = event.relatedTarget;
+        if (viewport && nextFocused && viewport.contains(nextFocused)) {
+            return false;
+        }
+        const menu = options.resolveContextMenuElement();
+        if (nextFocused && menu?.contains(nextFocused)) {
+            return false;
+        }
+        if (nextFocused && nextFocused instanceof HTMLElement) {
+            if (nextFocused.closest("[data-datagrid-menu-action],[data-datagrid-copy-menu],.datagrid-sugar-context")) {
+                return false;
+            }
+        }
+        if (!nextFocused && viewport) {
+            const runDeferred = () => {
+                const active = viewport.ownerDocument?.activeElement;
+                if (active && viewport.contains(active)) {
+                    return;
+                }
+                const menuElement = options.resolveContextMenuElement();
+                if (active && menuElement?.contains(active)) {
+                    return;
+                }
+                if (active && active instanceof HTMLElement) {
+                    if (active.closest("[data-datagrid-menu-action],[data-datagrid-copy-menu],.datagrid-sugar-context")) {
+                        return;
+                    }
+                }
+                finalizeBlurCleanup();
+            };
+            const view = viewport.ownerDocument?.defaultView;
+            if (typeof view?.requestAnimationFrame === "function") {
+                view.requestAnimationFrame(() => view.requestAnimationFrame(runDeferred));
+            }
+            else if (typeof view?.setTimeout === "function") {
+                view.setTimeout(runDeferred, 0);
+            }
+            else {
+                setTimeout(runDeferred, 0);
+            }
+            return true;
+        }
+        finalizeBlurCleanup();
+        return true;
+    }
+    return {
+        handleViewportBlur,
+    };
+}

package/dist/src/useDataGridViewportContextMenuRouter.d.ts

@@ -0,0 +1,31 @@
+import type { OpenDataGridContextMenuInput } from "./dataGridContextMenuContracts";
+export interface DataGridViewportContextMenuCoord {
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface DataGridViewportContextMenuRange {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}
+export interface UseDataGridViewportContextMenuRouterOptions<TCoord extends DataGridViewportContextMenuCoord = DataGridViewportContextMenuCoord, TRange extends DataGridViewportContextMenuRange = DataGridViewportContextMenuRange> {
+    isInteractionBlocked: () => boolean;
+    isRangeMoveModifierActive: (event: MouseEvent) => boolean;
+    resolveSelectionRange: () => TRange | null;
+    resolveCellCoordFromDataset: (rowId: string, columnKey: string) => TCoord | null;
+    applyCellSelection: (coord: TCoord, extend: boolean, fallbackAnchor?: TCoord, ensureVisible?: boolean) => void;
+    resolveActiveCellCoord: () => TCoord | null;
+    setActiveCellCoord: (coord: TCoord) => void;
+    cellCoordsEqual: (a: TCoord | null, b: TCoord | null) => boolean;
+    isMultiCellSelection: (range: TRange | null) => boolean;
+    isCoordInsideRange: (coord: TCoord, range: TRange) => boolean;
+    openContextMenu: (clientX: number, clientY: number, context: OpenDataGridContextMenuInput) => void;
+    closeContextMenu: () => void;
+    isColumnContextEnabled?: (columnKey: string) => boolean;
+}
+export interface UseDataGridViewportContextMenuRouterResult {
+    dispatchViewportContextMenu: (event: MouseEvent) => boolean;
+}
+export declare function useDataGridViewportContextMenuRouter<TCoord extends DataGridViewportContextMenuCoord = DataGridViewportContextMenuCoord, TRange extends DataGridViewportContextMenuRange = DataGridViewportContextMenuRange>(options: UseDataGridViewportContextMenuRouterOptions<TCoord, TRange>): UseDataGridViewportContextMenuRouterResult;
+//# sourceMappingURL=useDataGridViewportContextMenuRouter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridViewportContextMenuRouter.d.ts","sourceRoot":"","sources":["../../src/useDataGridViewportContextMenuRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,4BAA4B,EAC7B,MAAM,gCAAgC,CAAA;AAEvC,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,2CAA2C,CAC1D,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC;IAElF,oBAAoB,EAAE,MAAM,OAAO,CAAA;IACnC,yBAAyB,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAA;IACzD,qBAAqB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAC1C,2BAA2B,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAChF,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;IAC9G,sBAAsB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IAC3C,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,eAAe,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAA;IAChE,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAA;IACvD,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IAC7D,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,4BAA4B,KAAK,IAAI,CAAA;IAClG,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,sBAAsB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;CACxD;AAED,MAAM,WAAW,0CAA0C;IACzD,2BAA2B,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAA;CAC5D;AAYD,wBAAgB,oCAAoC,CAClD,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAClF,MAAM,SAAS,gCAAgC,GAAG,gCAAgC,EAElF,OAAO,EAAE,2CAA2C,CAAC,MAAM,EAAE,MAAM,CAAC,GACnE,0CAA0C,CAkF5C"}

package/dist/src/useDataGridViewportContextMenuRouter.js

@@ -0,0 +1,78 @@
+function isContextEnabled(columnKey, options) {
+    return options.isColumnContextEnabled?.(columnKey) ?? columnKey !== "select";
+}
+export function useDataGridViewportContextMenuRouter(options) {
+    function dispatchViewportContextMenu(event) {
+        if (options.isInteractionBlocked()) {
+            event.preventDefault();
+            return true;
+        }
+        const currentRange = options.resolveSelectionRange();
+        if (options.isRangeMoveModifierActive(event) && currentRange) {
+            event.preventDefault();
+            return true;
+        }
+        const targetNode = event.target;
+        if (!targetNode) {
+            return false;
+        }
+        const cell = targetNode.closest(".datagrid-stage__cell[data-row-id][data-column-key]");
+        if (cell) {
+            const rowId = cell.dataset.rowId ?? "";
+            const columnKey = cell.dataset.columnKey ?? "";
+            if (columnKey && isContextEnabled(columnKey, options)) {
+                let coord = null;
+                const rowIndex = cell.dataset.rowIndex;
+                const columnIndex = cell.dataset.columnIndex;
+                if (rowIndex !== undefined && columnIndex !== undefined) {
+                    const parsedRow = Number(rowIndex);
+                    const parsedColumn = Number(columnIndex);
+                    if (Number.isFinite(parsedRow) && Number.isFinite(parsedColumn)) {
+                        coord = { rowIndex: parsedRow, columnIndex: parsedColumn };
+                    }
+                }
+                if (!coord) {
+                    coord = options.resolveCellCoordFromDataset(rowId, columnKey);
+                }
+                if (!coord) {
+                    event.preventDefault();
+                    options.openContextMenu(event.clientX, event.clientY, { zone: "cell", columnKey, rowId });
+                    return true;
+                }
+                if (coord) {
+                    if (!currentRange || !options.isCoordInsideRange(coord, currentRange)) {
+                        options.applyCellSelection(coord, false, coord, false);
+                    }
+                    else if (!options.cellCoordsEqual(options.resolveActiveCellCoord(), coord)) {
+                        options.setActiveCellCoord(coord);
+                    }
+                    const nextRange = options.resolveSelectionRange();
+                    const zone = options.isMultiCellSelection(nextRange) &&
+                        !!nextRange &&
+                        options.isCoordInsideRange(coord, nextRange)
+                        ? "range"
+                        : "cell";
+                    event.preventDefault();
+                    options.openContextMenu(event.clientX, event.clientY, { zone, columnKey, rowId });
+                    return true;
+                }
+            }
+        }
+        const headerCell = targetNode.closest(".datagrid-stage__cell--header[data-column-key]");
+        if (headerCell) {
+            const columnKey = headerCell.dataset.columnKey ?? "";
+            if (columnKey && isContextEnabled(columnKey, options)) {
+                event.preventDefault();
+                options.openContextMenu(event.clientX, event.clientY, { zone: "header", columnKey });
+                return true;
+            }
+            return false;
+        }
+        event.preventDefault();
+        options.closeContextMenu();
+        return true;
+    }
+    return {
+        dispatchViewportContextMenu,
+    };
+}

package/dist/src/useDataGridViewportMeasureScheduler.d.ts

@@ -0,0 +1,22 @@
+export interface DataGridViewportMeasuredState {
+    viewportHeight: number;
+    viewportWidth: number;
+    headerHeight: number;
+}
+export interface UseDataGridViewportMeasureSchedulerOptions {
+    resolveViewportElement: () => HTMLElement | null;
+    resolveHeaderElement: () => HTMLElement | null;
+    resolveCurrentState: () => DataGridViewportMeasuredState;
+    applyMeasuredState: (next: DataGridViewportMeasuredState) => void;
+    rowHeight: number;
+    minViewportBodyHeight?: number;
+    requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame?: (handle: number) => void;
+}
+export interface UseDataGridViewportMeasureSchedulerResult {
+    syncViewportHeight: () => void;
+    scheduleViewportMeasure: () => void;
+    dispose: () => void;
+}
+export declare function useDataGridViewportMeasureScheduler(options: UseDataGridViewportMeasureSchedulerOptions): UseDataGridViewportMeasureSchedulerResult;
+//# sourceMappingURL=useDataGridViewportMeasureScheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridViewportMeasureScheduler.d.ts","sourceRoot":"","sources":["../../src/useDataGridViewportMeasureScheduler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,6BAA6B;IAC5C,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,0CAA0C;IACzD,sBAAsB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IAChD,oBAAoB,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IAC9C,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;IACxD,kBAAkB,EAAE,CAAC,IAAI,EAAE,6BAA6B,KAAK,IAAI,CAAA;IACjE,SAAS,EAAE,MAAM,CAAA;IACjB,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,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,yCAAyC;IACxD,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,0CAA0C,GAClD,yCAAyC,CA4E3C"}

package/dist/src/useDataGridViewportMeasureScheduler.js

@@ -0,0 +1,65 @@
+export function useDataGridViewportMeasureScheduler(options) {
+    const requestFrame = options.requestAnimationFrame ?? (callback => window.requestAnimationFrame(callback));
+    const cancelFrame = options.cancelAnimationFrame ?? (handle => window.cancelAnimationFrame(handle));
+    const minViewportBodyHeight = options.minViewportBodyHeight ?? 200;
+    let frame = null;
+    let pending = false;
+    function syncViewportHeight() {
+        const viewport = options.resolveViewportElement();
+        if (!viewport) {
+            return;
+        }
+        const current = options.resolveCurrentState();
+        const resolvedRowHeight = Number.isFinite(options.rowHeight) && options.rowHeight > 0
+            ? options.rowHeight
+            : 1;
+        const nextViewportWidth = viewport.clientWidth;
+        const header = options.resolveHeaderElement();
+        const nextHeaderHeight = header
+            ? Math.max(1, Math.round(header.getBoundingClientRect().height))
+            : current.headerHeight;
+        const bodyHeight = Math.max(minViewportBodyHeight, viewport.clientHeight - nextHeaderHeight);
+        const rowCount = Math.max(1, Math.ceil(bodyHeight / resolvedRowHeight));
+        const nextViewportHeight = rowCount * resolvedRowHeight;
+        if (nextViewportHeight === current.viewportHeight &&
+            nextViewportWidth === current.viewportWidth &&
+            nextHeaderHeight === current.headerHeight) {
+            return;
+        }
+        options.applyMeasuredState({
+            viewportHeight: nextViewportHeight,
+            viewportWidth: nextViewportWidth,
+            headerHeight: nextHeaderHeight,
+        });
+    }
+    function flushViewportMeasure() {
+        frame = null;
+        pending = false;
+        syncViewportHeight();
+    }
+    function scheduleViewportMeasure() {
+        if (pending) {
+            return;
+        }
+        pending = true;
+        if (typeof window === "undefined") {
+            flushViewportMeasure();
+            return;
+        }
+        frame = requestFrame(() => flushViewportMeasure());
+    }
+    function dispose() {
+        if (frame === null) {
+            pending = false;
+            return;
+        }
+        cancelFrame(frame);
+        frame = null;
+        pending = false;
+    }
+    return {
+        syncViewportHeight,
+        scheduleViewportMeasure,
+        dispose,
+    };
+}

package/dist/src/useDataGridViewportScrollLifecycle.d.ts

@@ -0,0 +1,16 @@
+export interface UseDataGridViewportScrollLifecycleOptions {
+    isContextMenuVisible: () => boolean;
+    shouldCloseContextMenuOnScroll?: () => boolean;
+    closeContextMenu: () => void;
+    resolveScrollTop: () => number;
+    resolveScrollLeft: () => number;
+    setScrollTop: (value: number) => void;
+    setScrollLeft: (value: number) => void;
+    hasInlineEditor: () => boolean;
+    commitInlineEdit: () => void;
+}
+export interface UseDataGridViewportScrollLifecycleResult {
+    onViewportScroll: (event: Event) => void;
+}
+export declare function useDataGridViewportScrollLifecycle(options: UseDataGridViewportScrollLifecycleOptions): UseDataGridViewportScrollLifecycleResult;
+//# sourceMappingURL=useDataGridViewportScrollLifecycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridViewportScrollLifecycle.d.ts","sourceRoot":"","sources":["../../src/useDataGridViewportScrollLifecycle.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yCAAyC;IACxD,oBAAoB,EAAE,MAAM,OAAO,CAAA;IACnC,8BAA8B,CAAC,EAAE,MAAM,OAAO,CAAA;IAC9C,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,iBAAiB,EAAE,MAAM,MAAM,CAAA;IAC/B,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,gBAAgB,EAAE,MAAM,IAAI,CAAA;CAC7B;AAED,MAAM,WAAW,wCAAwC;IACvD,gBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACzC;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,yCAAyC,GACjD,wCAAwC,CA4B1C"}

package/dist/src/useDataGridViewportScrollLifecycle.js

@@ -0,0 +1,28 @@
+export function useDataGridViewportScrollLifecycle(options) {
+    function onViewportScroll(event) {
+        const target = event.currentTarget;
+        if (!target) {
+            return;
+        }
+        const shouldCloseContextMenu = options.shouldCloseContextMenuOnScroll
+            ? options.shouldCloseContextMenuOnScroll()
+            : true;
+        if (options.isContextMenuVisible() && shouldCloseContextMenu) {
+            options.closeContextMenu();
+        }
+        const nextTop = target.scrollTop;
+        const nextLeft = target.scrollLeft;
+        if (nextTop !== options.resolveScrollTop()) {
+            options.setScrollTop(nextTop);
+        }
+        if (nextLeft !== options.resolveScrollLeft()) {
+            options.setScrollLeft(nextLeft);
+        }
+        if (options.hasInlineEditor()) {
+            options.commitInlineEdit();
+        }
+    }
+    return {
+        onViewportScroll,
+    };
+}

package/dist/src/useDataGridVirtualRangeMetrics.d.ts

@@ -0,0 +1,32 @@
+export interface DataGridVirtualRange {
+    start: number;
+    end: number;
+}
+export interface DataGridVirtualWindowRowSnapshot {
+    colStart?: number;
+    colEnd?: number;
+    colTotal?: number;
+    rowStart: number;
+    rowEnd: number;
+    rowTotal: number;
+    overscan?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+}
+export interface UseDataGridVirtualRangeMetricsWindowOptions {
+    virtualWindow: DataGridVirtualWindowRowSnapshot;
+    rowHeight: number;
+}
+export type UseDataGridVirtualRangeMetricsOptions = UseDataGridVirtualRangeMetricsWindowOptions;
+export interface DataGridVirtualRangeMetricsSnapshot {
+    virtualRange: DataGridVirtualRange;
+    spacerTopHeight: number;
+    spacerBottomHeight: number;
+    rangeLabel: string;
+}
+export declare function computeDataGridVirtualRange(options: UseDataGridVirtualRangeMetricsOptions): DataGridVirtualRange;
+export declare function useDataGridVirtualRangeMetrics(options: UseDataGridVirtualRangeMetricsOptions): DataGridVirtualRangeMetricsSnapshot;
+//# sourceMappingURL=useDataGridVirtualRangeMetrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridVirtualRangeMetrics.d.ts","sourceRoot":"","sources":["../../src/useDataGridVirtualRangeMetrics.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,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,2CAA2C;IAC1D,aAAa,EAAE,gCAAgC,CAAA;IAC/C,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,qCAAqC,GAAG,2CAA2C,CAAA;AAE/F,MAAM,WAAW,mCAAmC;IAClD,YAAY,EAAE,oBAAoB,CAAA;IAClC,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qCAAqC,GAC7C,oBAAoB,CAQtB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qCAAqC,GAC7C,mCAAmC,CAiBrC"}

package/dist/src/useDataGridVirtualRangeMetrics.js

@@ -0,0 +1,26 @@
+export function computeDataGridVirtualRange(options) {
+    const total = Math.max(0, Math.trunc(options.virtualWindow.rowTotal));
+    if (total === 0) {
+        return { start: 0, end: -1 };
+    }
+    const start = Math.max(0, Math.min(total - 1, Math.trunc(options.virtualWindow.rowStart)));
+    const end = Math.max(start, Math.min(total - 1, Math.trunc(options.virtualWindow.rowEnd)));
+    return { start, end };
+}
+export function useDataGridVirtualRangeMetrics(options) {
+    const virtualRange = computeDataGridVirtualRange(options);
+    const totalRows = Math.max(0, Math.trunc(options.virtualWindow.rowTotal));
+    const spacerTopHeight = Math.max(0, virtualRange.start * options.rowHeight);
+    const spacerBottomHeight = totalRows === 0 || virtualRange.end < virtualRange.start
+        ? 0
+        : Math.max(0, (totalRows - (virtualRange.end + 1)) * options.rowHeight);
+    const rangeLabel = totalRows === 0 || virtualRange.end < virtualRange.start
+        ? "0-0"
+        : `${virtualRange.start + 1}-${virtualRange.end + 1}`;
+    return {
+        virtualRange,
+        spacerTopHeight,
+        spacerBottomHeight,
+        rangeLabel,
+    };
+}

package/dist/src/useDataGridVisibleRowsSyncScheduler.d.ts

@@ -0,0 +1,21 @@
+export interface DataGridVisibleRowsRange {
+    start: number;
+    end: number;
+}
+export interface UseDataGridVisibleRowsSyncSchedulerOptions<TRowSource, TVisibleRow> {
+    resolveRows: () => readonly TRowSource[];
+    resolveRange: () => DataGridVisibleRowsRange;
+    setRows: (rows: readonly TRowSource[]) => void;
+    syncRowsInRange: (range: DataGridVisibleRowsRange) => readonly TVisibleRow[];
+    applyVisibleRows: (rows: readonly TVisibleRow[]) => void;
+    requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame?: (handle: number) => void;
+}
+export interface UseDataGridVisibleRowsSyncSchedulerResult {
+    syncVisibleRows: () => void;
+    scheduleVisibleRowsSync: () => void;
+    resetVisibleRowsSyncCache: () => void;
+    dispose: () => void;
+}
+export declare function useDataGridVisibleRowsSyncScheduler<TRowSource, TVisibleRow>(options: UseDataGridVisibleRowsSyncSchedulerOptions<TRowSource, TVisibleRow>): UseDataGridVisibleRowsSyncSchedulerResult;
+//# sourceMappingURL=useDataGridVisibleRowsSyncScheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridVisibleRowsSyncScheduler.d.ts","sourceRoot":"","sources":["../../src/useDataGridVisibleRowsSyncScheduler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,0CAA0C,CAAC,UAAU,EAAE,WAAW;IACjF,WAAW,EAAE,MAAM,SAAS,UAAU,EAAE,CAAA;IACxC,YAAY,EAAE,MAAM,wBAAwB,CAAA;IAC5C,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,KAAK,IAAI,CAAA;IAC9C,eAAe,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,SAAS,WAAW,EAAE,CAAA;IAC5E,gBAAgB,EAAE,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,KAAK,IAAI,CAAA;IACxD,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,yCAAyC;IACxD,eAAe,EAAE,MAAM,IAAI,CAAA;IAC3B,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,yBAAyB,EAAE,MAAM,IAAI,CAAA;IACrC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,mCAAmC,CAAC,UAAU,EAAE,WAAW,EACzE,OAAO,EAAE,0CAA0C,CAAC,UAAU,EAAE,WAAW,CAAC,GAC3E,yCAAyC,CA+E3C"}

package/dist/src/useDataGridVisibleRowsSyncScheduler.js

@@ -0,0 +1,70 @@
+export function useDataGridVisibleRowsSyncScheduler(options) {
+    const requestFrame = options.requestAnimationFrame ?? (callback => window.requestAnimationFrame(callback));
+    const cancelFrame = options.cancelAnimationFrame ?? (handle => window.cancelAnimationFrame(handle));
+    let frame = null;
+    let pending = false;
+    let lastSyncedRowsRef = null;
+    let lastSyncedRangeStart = Number.NaN;
+    let lastSyncedRangeEnd = Number.NaN;
+    function syncVisibleRows() {
+        const rows = options.resolveRows();
+        const range = options.resolveRange();
+        const hasSameRowsRef = lastSyncedRowsRef === rows;
+        const hasSameRange = lastSyncedRangeStart === range.start && lastSyncedRangeEnd === range.end;
+        if (hasSameRowsRef && hasSameRange) {
+            return;
+        }
+        if (!hasSameRowsRef) {
+            options.setRows(rows);
+        }
+        if (range.end < range.start) {
+            options.applyVisibleRows([]);
+            lastSyncedRowsRef = rows;
+            lastSyncedRangeStart = range.start;
+            lastSyncedRangeEnd = range.end;
+            return;
+        }
+        const nextVisibleRows = options.syncRowsInRange({
+            start: range.start,
+            end: range.end,
+        });
+        options.applyVisibleRows(nextVisibleRows);
+        lastSyncedRowsRef = rows;
+        lastSyncedRangeStart = range.start;
+        lastSyncedRangeEnd = range.end;
+    }
+    function flushVisibleRowsSync() {
+        frame = null;
+        pending = false;
+        syncVisibleRows();
+    }
+    function scheduleVisibleRowsSync() {
+        if (pending) {
+            return;
+        }
+        pending = true;
+        if (typeof window === "undefined") {
+            flushVisibleRowsSync();
+            return;
+        }
+        frame = requestFrame(() => flushVisibleRowsSync());
+    }
+    function resetVisibleRowsSyncCache() {
+        lastSyncedRowsRef = null;
+        lastSyncedRangeStart = Number.NaN;
+        lastSyncedRangeEnd = Number.NaN;
+    }
+    function dispose() {
+        if (frame !== null) {
+            cancelFrame(frame);
+            frame = null;
+        }
+        pending = false;
+    }
+    return {
+        syncVisibleRows,
+        scheduleVisibleRowsSync,
+        resetVisibleRowsSyncCache,
+        dispose,
+    };
+}