@1771technologies/lytenyte-pro 0.9.3 → 1.0.0-beta.0

package/dist/cell-selection/expand-cell-selection-end.js

@@ -0,0 +1,40 @@
+import { getRootCell } from "./get-root-cell";
+export function expandCellSelectionEnd(grid, meta) {
+    const selections = grid.state.cellSelections.get();
+    const cellSelectionPivot = grid.internal.cellSelectionPivot.get();
+    const rect = selections.at(-1);
+    const pivot = cellSelectionPivot;
+    if (!rect || !pivot)
+        return;
+    if (meta) {
+        const colCount = grid.state.columnMeta.get().columnsVisible.length;
+        if (pivot.columnStart === colCount - 1)
+            return;
+        const next = { ...rect, columnStart: pivot.columnStart, columnEnd: colCount };
+        const nextSelections = [...selections];
+        nextSelections[nextSelections.length - 1] = next;
+        grid.state.cellSelections.set(nextSelections);
+        return;
+    }
+    let next;
+    let focusColumn;
+    if (rect.columnStart < pivot.columnStart) {
+        let colOffset = 1;
+        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
+            const cell = getRootCell(grid, i, rect.columnStart);
+            if (cell)
+                colOffset = Math.max(colOffset, cell.colSpan);
+        }
+        focusColumn = rect.columnStart + colOffset;
+        next = { ...rect, columnStart: focusColumn };
+    }
+    else {
+        focusColumn = rect.columnEnd + 1;
+        next = { ...rect, columnEnd: focusColumn };
+        focusColumn -= 1;
+    }
+    grid.api.scrollIntoView({ column: focusColumn });
+    const nextSelections = [...selections];
+    nextSelections[nextSelections.length - 1] = next;
+    grid.state.cellSelections.set(nextSelections);
+}

package/dist/cell-selection/expand-cell-selection-start.d.ts

@@ -0,0 +1,5 @@
+import type { InternalAtoms } from "../state/+types";
+import type { Grid } from "../+types";
+export declare function expandCellSelectionStart(grid: Grid<any> & {
+    internal: InternalAtoms;
+}, meta: boolean): void;

package/dist/cell-selection/expand-cell-selection-start.js

@@ -0,0 +1,39 @@
+import { getRootCell } from "./get-root-cell";
+export function expandCellSelectionStart(grid, meta) {
+    const selections = grid.state.cellSelections.get();
+    const cellSelectionPivot = grid.internal.cellSelectionPivot.get();
+    const rect = selections.at(-1);
+    const pivot = cellSelectionPivot;
+    if (!rect || !pivot)
+        return;
+    if (meta) {
+        if (pivot.columnStart === 0)
+            return;
+        const next = { ...rect, columnStart: 0, columnEnd: pivot.columnEnd };
+        const nextSelections = [...selections];
+        nextSelections[nextSelections.length - 1] = next;
+        grid.state.cellSelections.set(nextSelections);
+        return;
+    }
+    let next;
+    let focusColumn;
+    if (rect.columnEnd > pivot.columnEnd) {
+        let colOffset = 1;
+        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
+            const cell = getRootCell(grid, i, rect.columnEnd - 1);
+            if (cell)
+                colOffset = Math.max(colOffset, cell.colSpan);
+        }
+        focusColumn = rect.columnEnd - colOffset;
+        next = { ...rect, columnEnd: focusColumn };
+        focusColumn -= 1;
+    }
+    else {
+        focusColumn = rect.columnStart - 1;
+        next = { ...rect, columnStart: focusColumn };
+    }
+    grid.api.scrollIntoView({ column: focusColumn });
+    const nextSelections = [...selections];
+    nextSelections[nextSelections.length - 1] = next;
+    grid.state.cellSelections.set(nextSelections);
+}

package/dist/cell-selection/expand-cell-selection-up.d.ts

@@ -0,0 +1,5 @@
+import type { InternalAtoms } from "../state/+types";
+import type { Grid } from "../+types";
+export declare function expandCellSelectionUp(grid: Grid<any> & {
+    internal: InternalAtoms;
+}, meta: boolean): void;

package/dist/cell-selection/expand-cell-selection-up.js

@@ -0,0 +1,39 @@
+import { getRootCell } from "./get-root-cell";
+export function expandCellSelectionUp(grid, meta) {
+    const selections = grid.state.cellSelections.get();
+    const cellSelectionPivot = grid.internal.cellSelectionPivot.get();
+    const rect = selections.at(-1);
+    const pivot = cellSelectionPivot;
+    if (!rect || !pivot)
+        return;
+    if (meta) {
+        if (pivot.rowStart === 0)
+            return;
+        const next = { ...rect, rowEnd: pivot.rowEnd, rowStart: 0 };
+        const nextSelections = [...selections];
+        nextSelections[nextSelections.length - 1] = next;
+        grid.state.cellSelections.set(nextSelections);
+        return;
+    }
+    let next;
+    let focusRow;
+    if (rect.rowEnd > pivot.rowEnd) {
+        let rowOffset = 1;
+        for (let i = rect.columnStart; i < rect.columnEnd; i++) {
+            const cell = getRootCell(grid, rect.rowEnd - 1, i);
+            if (cell)
+                rowOffset = Math.max(rowOffset, cell.rowSpan);
+        }
+        focusRow = rect.rowEnd - rowOffset;
+        next = { ...rect, rowEnd: focusRow };
+        focusRow -= 1;
+    }
+    else {
+        focusRow = rect.rowStart - 1;
+        next = { ...rect, rowStart: focusRow };
+    }
+    grid.api.scrollIntoView({ row: focusRow });
+    const nextSelections = [...selections];
+    nextSelections[nextSelections.length - 1] = next;
+    grid.state.cellSelections.set(nextSelections);
+}

package/dist/cell-selection/full-width-start-end-index.d.ts

@@ -0,0 +1,2 @@
+import type { Grid } from "../+types";
+export declare function fullWidthStartEndIndex(grid: Grid<any>): number[];

package/dist/cell-selection/full-width-start-end-index.js

@@ -0,0 +1,5 @@
+export function fullWidthStartEndIndex(grid) {
+    const meta = grid.state.columnMeta.get();
+    const lastIndex = meta.columnsVisible.length;
+    return [0, lastIndex];
+}

package/dist/cell-selection/get-root-cell.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, PositionGridCell } from "../+types";
+export declare const getRootCell: (grid: Grid<any>, rowIndex: number, columnIndex: number) => PositionGridCell["root"];

package/dist/cell-selection/get-root-cell.js

@@ -0,0 +1,86 @@
+import { getSpanFn } from "../state/helpers/get-span-callback";
+import { getFullWidthCallback } from "../state/helpers/get-full-width-callback";
+import { applyLayoutUpdate } from "@1771technologies/lytenyte-shared";
+export const getRootCell = (grid, rowIndex, columnIndex) => {
+    const rds = grid.state.rowDataSource.get();
+    const meta = grid.state.columnMeta.get();
+    const columns = meta.columnsVisible;
+    const rowScan = grid.state.rowScanDistance.get();
+    const colScan = grid.state.colScanDistance.get();
+    const fullWidth = grid.state.rowFullWidthPredicate.get().fn;
+    const layoutMap = new Map();
+    const topCount = grid.state.rowDataStore.rowTopCount.get();
+    const botCount = grid.state.rowDataStore.rowBottomCount.get();
+    const rowCenterCount = grid.state.rowDataStore.rowCenterCount.get();
+    const isTop = rowIndex < topCount;
+    const isBot = rowIndex >= topCount + rowCenterCount;
+    const isStart = columns[columnIndex].pin === "start";
+    const isEnd = columns[columnIndex].pin === "end";
+    applyLayoutUpdate({
+        computeColSpan: getSpanFn(rds, grid, columns, "col"),
+        computeRowSpan: getSpanFn(rds, grid, columns, "row"),
+        colScanDistance: colScan,
+        rowScanDistance: rowScan,
+        invalidated: true,
+        isFullWidth: getFullWidthCallback(rds, fullWidth, grid),
+        isRowCutoff: (r) => {
+            const row = rds.rowByIndex(r);
+            return !row || row.kind === "branch";
+        },
+        layoutMap,
+        nextLayout: {
+            rowTopStart: 0,
+            rowTopEnd: topCount,
+            rowBotStart: topCount + rowCenterCount,
+            rowBotEnd: topCount + rowCenterCount + botCount,
+            rowCenterStart: isTop || isBot ? 0 : rowIndex,
+            rowCenterEnd: isTop || isBot ? 0 : rowIndex + 1,
+            rowCenterLast: topCount + rowCenterCount,
+            colStartStart: 0,
+            colStartEnd: meta.columnVisibleStartCount,
+            colEndStart: meta.columnVisibleStartCount + meta.columnVisibleCenterCount,
+            colEndEnd: columns.length,
+            colCenterStart: isStart || isEnd ? 0 : columnIndex,
+            colCenterEnd: isStart || isEnd ? 0 : columnIndex + 1,
+            colCenterLast: meta.columnVisibleStartCount + meta.columnVisibleCenterCount,
+        },
+        prevLayout: {
+            colCenterEnd: -1,
+            colCenterLast: -1,
+            colCenterStart: -1,
+            colEndEnd: -1,
+            colEndStart: -1,
+            colStartEnd: -1,
+            colStartStart: -1,
+            rowBotEnd: -1,
+            rowBotStart: -1,
+            rowCenterEnd: -1,
+            rowCenterLast: -1,
+            rowCenterStart: -1,
+            rowTopEnd: -1,
+            rowTopStart: -1,
+        },
+    });
+    const row = layoutMap.get(rowIndex);
+    const cell = row?.get(columnIndex);
+    if (!cell)
+        return null;
+    if (cell?.length === 2)
+        return {
+            colIndex: columnIndex,
+            colSpan: 1,
+            rowIndex: rowIndex,
+            rowSpan: 1,
+        };
+    // Otherwise this is a spanning cell hence we need to find the spans layout.
+    const root = layoutMap.get(cell[1]);
+    const rootCell = root?.get(cell[2]);
+    if (!rootCell)
+        return null;
+    return {
+        colIndex: cell[2],
+        rowIndex: cell[1],
+        rowSpan: rootCell[0],
+        colSpan: rootCell[1],
+    };
+};

package/dist/cell-selection/index.d.ts

@@ -0,0 +1,19 @@
+export { isWithinSelectionRect } from "./is-within-selection-rect.js";
+export { splitCellSelectionRect } from "./split-cell-selection-rect.js";
+export { boundSelectionRect } from "./bound-selection-rect.js";
+export { fullWidthStartEndIndex } from "./full-width-start-end-index.js";
+export { areRectsEqual } from "./are-rects-equal.js";
+export { deselectRectRange } from "./deselect-rect-range.js";
+export { isOverlappingRect } from "./is-overlapping-rect.js";
+export { adjustRectForRowAndCellSpan } from "./adjust-rect-for-row-and-cell-span.js";
+export { updateAdditiveCellSelection } from "./update-additive-cell-selection.js";
+export { expandCellSelectionDown } from "./expand-cell-selection-down.js";
+export { expandCellSelectionUp } from "./expand-cell-selection-up.js";
+export { expandCellSelectionStart } from "./expand-cell-selection-start.js";
+export { expandCellSelectionEnd } from "./expand-cell-selection-end.js";
+export { isBottomRect } from "./is-bottom-rect.js";
+export { isCenterRect } from "./is-center-rect.js";
+export { isTopRect } from "./is-top-rect.js";
+export { isCenterColRect } from "./is-center-col-rect.js";
+export { isStartRect } from "./is-start-rect.js";
+export { isEndRect } from "./is-end-rect.js";

package/dist/cell-selection/index.js

@@ -0,0 +1,19 @@
+export { isWithinSelectionRect } from "./is-within-selection-rect.js";
+export { splitCellSelectionRect } from "./split-cell-selection-rect.js";
+export { boundSelectionRect } from "./bound-selection-rect.js";
+export { fullWidthStartEndIndex } from "./full-width-start-end-index.js";
+export { areRectsEqual } from "./are-rects-equal.js";
+export { deselectRectRange } from "./deselect-rect-range.js";
+export { isOverlappingRect } from "./is-overlapping-rect.js";
+export { adjustRectForRowAndCellSpan } from "./adjust-rect-for-row-and-cell-span.js";
+export { updateAdditiveCellSelection } from "./update-additive-cell-selection.js";
+export { expandCellSelectionDown } from "./expand-cell-selection-down.js";
+export { expandCellSelectionUp } from "./expand-cell-selection-up.js";
+export { expandCellSelectionStart } from "./expand-cell-selection-start.js";
+export { expandCellSelectionEnd } from "./expand-cell-selection-end.js";
+export { isBottomRect } from "./is-bottom-rect.js";
+export { isCenterRect } from "./is-center-rect.js";
+export { isTopRect } from "./is-top-rect.js";
+export { isCenterColRect } from "./is-center-col-rect.js";
+export { isStartRect } from "./is-start-rect.js";
+export { isEndRect } from "./is-end-rect.js";

package/dist/cell-selection/is-bottom-rect.d.ts

@@ -0,0 +1,2 @@
+import type { DataRect, Grid } from "../+types";
+export declare function isBottomRect(grid: Grid<any>, rect: DataRect): boolean;

package/dist/cell-selection/is-bottom-rect.js

@@ -0,0 +1,7 @@
+export function isBottomRect(grid, rect) {
+    const s = grid.state.rowDataStore;
+    const rowCount = s.rowCount.get();
+    const botCount = s.rowBottomCount.get();
+    const bottomStart = rowCount - botCount;
+    return rect.rowStart >= bottomStart;
+}

package/dist/cell-selection/is-center-col-rect.d.ts

@@ -0,0 +1,5 @@
+import type { Grid } from "../+types";
+export declare function isCenterColRect(grid: Grid<any>, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

package/dist/cell-selection/is-center-col-rect.js

@@ -0,0 +1,5 @@
+export function isCenterColRect(grid, rect) {
+    const s = grid.state.columnMeta.get();
+    return (rect.columnStart >= s.columnVisibleStartCount &&
+        rect.columnStart < s.columnVisibleCenterCount + s.columnVisibleStartCount);
+}

package/dist/cell-selection/is-center-rect.d.ts

@@ -0,0 +1,2 @@
+import type { DataRect, Grid } from "../+types";
+export declare function isCenterRect(grid: Grid<any>, rect: DataRect): boolean;

package/dist/cell-selection/is-center-rect.js

@@ -0,0 +1,5 @@
+export function isCenterRect(grid, rect) {
+    const ds = grid.state.rowDataStore;
+    const bottomStart = ds.rowCount.get() - ds.rowBottomCount.get();
+    return rect.rowStart < bottomStart && rect.rowStart >= ds.rowTopCount.get();
+}

package/dist/cell-selection/is-end-rect.d.ts

@@ -0,0 +1,5 @@
+import type { Grid } from "../+types";
+export declare function isEndRect(grid: Grid<any>, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

package/dist/cell-selection/is-end-rect.js

@@ -0,0 +1,4 @@
+export function isEndRect(grid, rect) {
+    const meta = grid.state.columnMeta.get();
+    return rect.columnStart >= meta.columnVisibleStartCount + meta.columnVisibleCenterCount;
+}

package/dist/cell-selection/is-overlapping-rect.d.ts

@@ -0,0 +1,2 @@
+import type { DataRect } from "../+types";
+export declare function isOverlappingRect(rect1: DataRect, rect2: DataRect): boolean;

package/dist/cell-selection/is-overlapping-rect.js

@@ -0,0 +1,6 @@
+export function isOverlappingRect(rect1, rect2) {
+    return !(rect1.rowEnd < rect2.rowStart ||
+        rect1.rowStart > rect2.rowEnd ||
+        rect1.columnEnd < rect2.columnStart ||
+        rect1.columnStart > rect2.columnEnd);
+}

package/dist/cell-selection/is-start-rect.d.ts

@@ -0,0 +1,5 @@
+import type { Grid } from "../+types";
+export declare function isStartRect(grid: Grid<any>, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

package/dist/cell-selection/is-start-rect.js

@@ -0,0 +1,4 @@
+export function isStartRect(grid, rect) {
+    const meta = grid.state.columnMeta.get();
+    return rect.columnStart < meta.columnVisibleStartCount;
+}

package/dist/cell-selection/is-top-rect.d.ts

@@ -0,0 +1,2 @@
+import type { DataRect, Grid } from "../+types";
+export declare function isTopRect(grid: Grid<any>, rect: DataRect): boolean;

package/dist/cell-selection/is-top-rect.js

@@ -0,0 +1,4 @@
+export function isTopRect(grid, rect) {
+    const topCount = grid.state.rowDataStore.rowTopCount.get();
+    return rect.rowStart < topCount;
+}

package/dist/cell-selection/is-within-selection-rect.d.ts

@@ -0,0 +1,2 @@
+import type { DataRect } from "../+types";
+export declare function isWithinSelectionRect(rect: DataRect, r: number, c: number): boolean;

package/dist/cell-selection/is-within-selection-rect.js

@@ -0,0 +1,3 @@
+export function isWithinSelectionRect(rect, r, c) {
+    return r >= rect.rowStart && r < rect.rowEnd && c >= rect.columnStart && c < rect.columnEnd;
+}

package/dist/cell-selection/split-cell-selection-rect.d.ts

@@ -0,0 +1,39 @@
+import type { DataRect } from "../+types";
+interface SplitCellSelectionRectArgs {
+    readonly rect: DataRect;
+    readonly colStartCount: number;
+    readonly colCenterCount: number;
+    readonly rowTopCount: number;
+    readonly rowCenterCount: number;
+}
+/**
+ * Splits a cell selection rectangle into multiple rectangles when it crosses specified boundary regions.
+ * This is useful for handling selections that span across different grid sections (e.g., fixed columns/rows,
+ * scrollable areas).
+ *
+ * The splitting process happens in two phases:
+ * 1. Column-wise splitting: Splits rectangles that cross column section boundaries
+ * 2. Row-wise splitting: Further splits the resulting rectangles if they cross row section boundaries
+ *
+ * Splitting does not support full width rows. It is assumed that if full width rows are present then
+ * the cell selection will just be drawn over them
+ *
+ * @example
+ * // For a grid with 2 fixed start columns and 1 fixed top row:
+ * const splits = splitCellSelectionRect({
+ *   rect: { columnStart: 0, columnEnd: 3, rowStart: 0, rowEnd: 2 },
+ *   colStartCount: 2,    // Number of fixed start columns
+ *   colCenterCount: 10,  // Number of scrollable columns
+ *   rowTopCount: 1,      // Number of fixed top rows
+ *   rowCenterCount: 50   // Number of scrollable rows
+ * });
+ *
+ * @param rect - The original cell selection rectangle to split
+ * @param colStartCount - Number of columns in the start (usually fixed) section
+ * @param colCenterCount - Number of columns in the center (usually scrollable) section
+ * @param rowTopCount - Number of rows in the top (usually fixed) section
+ * @param rowCenterCount - Number of rows in the center (usually scrollable) section
+ * @returns An array of split rectangles. If no splits were necessary, returns an array with just the original rectangle
+ */
+export declare function splitCellSelectionRect({ rect, colStartCount, colCenterCount, rowTopCount, rowCenterCount, }: SplitCellSelectionRectArgs): DataRect[];
+export {};

package/dist/cell-selection/split-cell-selection-rect.js

@@ -0,0 +1,79 @@
+/**
+ * Splits a cell selection rectangle into multiple rectangles when it crosses specified boundary regions.
+ * This is useful for handling selections that span across different grid sections (e.g., fixed columns/rows,
+ * scrollable areas).
+ *
+ * The splitting process happens in two phases:
+ * 1. Column-wise splitting: Splits rectangles that cross column section boundaries
+ * 2. Row-wise splitting: Further splits the resulting rectangles if they cross row section boundaries
+ *
+ * Splitting does not support full width rows. It is assumed that if full width rows are present then
+ * the cell selection will just be drawn over them
+ *
+ * @example
+ * // For a grid with 2 fixed start columns and 1 fixed top row:
+ * const splits = splitCellSelectionRect({
+ *   rect: { columnStart: 0, columnEnd: 3, rowStart: 0, rowEnd: 2 },
+ *   colStartCount: 2,    // Number of fixed start columns
+ *   colCenterCount: 10,  // Number of scrollable columns
+ *   rowTopCount: 1,      // Number of fixed top rows
+ *   rowCenterCount: 50   // Number of scrollable rows
+ * });
+ *
+ * @param rect - The original cell selection rectangle to split
+ * @param colStartCount - Number of columns in the start (usually fixed) section
+ * @param colCenterCount - Number of columns in the center (usually scrollable) section
+ * @param rowTopCount - Number of rows in the top (usually fixed) section
+ * @param rowCenterCount - Number of rows in the center (usually scrollable) section
+ * @returns An array of split rectangles. If no splits were necessary, returns an array with just the original rectangle
+ */
+export function splitCellSelectionRect({ rect, colStartCount, colCenterCount, rowTopCount, rowCenterCount, }) {
+    // Calculate the boundary positions for columns
+    const colStartBound = colStartCount;
+    const colEndBound = colStartCount + colCenterCount;
+    const colSplits = [];
+    // Handle column splits first
+    // Case 1: Selection starts before the fixed columns and extends into the scrollable area
+    if (rect.columnStart < colStartBound && rect.columnEnd > colStartBound) {
+        const startSplit = {
+            ...rect,
+            columnEnd: colStartBound,
+        };
+        colSplits.push(startSplit);
+        rect = { ...rect, columnStart: colStartBound };
+    }
+    // Case 2: Selection starts in the scrollable area and extends into the end section
+    if (rect.columnStart < colEndBound && rect.columnEnd > colEndBound) {
+        const endSplit = {
+            ...rect,
+            columnStart: colEndBound,
+        };
+        rect = { ...rect, columnEnd: colEndBound };
+        colSplits.push(endSplit);
+    }
+    // Add the remaining rectangle after column splits
+    colSplits.push(rect);
+    // Calculate the boundary positions for rows
+    const topBound = rowTopCount;
+    const bottomBound = rowTopCount + rowCenterCount;
+    // Process row splits for each column-split rectangle
+    const rowSplits = [];
+    for (let split of colSplits) {
+        // Case 1: Selection spans from top section into center section
+        if (split.rowStart < topBound && split.rowEnd > topBound) {
+            const topSplit = { ...split, rowEnd: topBound };
+            split = { ...split, rowStart: topBound };
+            rowSplits.push(topSplit);
+        }
+        // Case 2: Selection spans from center section into bottom section
+        if (split.rowStart < bottomBound && split.rowEnd > bottomBound) {
+            const bottomSplit = { ...split, rowStart: bottomBound };
+            split = { ...split, rowEnd: bottomBound };
+            rowSplits.push(bottomSplit);
+        }
+        rowSplits.push(split);
+    }
+    return rowSplits.sort((l, r) => {
+        return l.rowStart - r.rowStart || l.columnStart - r.columnStart;
+    });
+}

package/dist/cell-selection/update-additive-cell-selection.d.ts

@@ -0,0 +1,5 @@
+import type { DataRect, Grid } from "../+types";
+import type { InternalAtoms } from "../state/+types";
+export declare function updateAdditiveCellSelection(grid: Grid<any> & {
+    internal: InternalAtoms;
+}, rect: DataRect): void;

package/dist/cell-selection/update-additive-cell-selection.js

@@ -0,0 +1,25 @@
+import { boundSelectionRect } from "./bound-selection-rect";
+import { adjustRectForRowAndCellSpan } from "./adjust-rect-for-row-and-cell-span";
+import { areRectsEqual } from "./are-rects-equal";
+import { splitCellSelectionRect } from "./split-cell-selection-rect";
+export function updateAdditiveCellSelection(grid, rect) {
+    const s = grid.state.columnMeta.get();
+    const ds = grid.state.rowDataStore;
+    const rowTopCount = ds.rowTopCount.get();
+    const adjustedRect = adjustRectForRowAndCellSpan(grid, rect);
+    console.log(adjustedRect);
+    const rects = splitCellSelectionRect({
+        rect: boundSelectionRect(grid, adjustedRect),
+        colCenterCount: s.columnVisibleCenterCount,
+        colStartCount: s.columnVisibleStartCount,
+        rowCenterCount: ds.rowCenterCount.get(),
+        rowTopCount: rowTopCount,
+    });
+    console.log(rects);
+    const current = grid.internal.cellSelectionAdditiveRects.get();
+    if (current && current.length === rects.length) {
+        if (current.every((c, i) => areRectsEqual(c, rects[i])))
+            return;
+    }
+    grid.internal.cellSelectionAdditiveRects.set(rects);
+}

package/dist/cell-selection/use-edge-scroll.d.ts

@@ -0,0 +1,10 @@
+import type { Grid } from "../+types";
+import type { InternalAtoms } from "../state/+types";
+export declare function useEdgeScroll(grid: Grid<any> & {
+    internal: InternalAtoms;
+}): {
+    cancelX: () => void;
+    edgeScrollX: (visualPositionX: number, isRtl: boolean) => void;
+    cancelY: () => void;
+    edgeScrollY: (visualPositionY: number) => void;
+};

package/dist/cell-selection/use-edge-scroll.js

@@ -0,0 +1,66 @@
+import { useCallback, useRef } from "react";
+export function useEdgeScroll(grid) {
+    const intervalIdX = useRef(null);
+    const intervalIdY = useRef(null);
+    const cancelX = useCallback(() => {
+        if (intervalIdX.current) {
+            clearInterval(intervalIdX.current);
+            intervalIdX.current = null;
+        }
+    }, []);
+    const cancelY = useCallback(() => {
+        if (intervalIdY.current) {
+            clearInterval(intervalIdY.current);
+            intervalIdY.current = null;
+        }
+    }, []);
+    const edgeScrollY = useCallback((visualPositionY) => {
+        const viewport = grid.state.viewport.get();
+        if (!viewport)
+            return;
+        const viewportClientHeight = grid.state.viewportHeightInner.get();
+        const viewportHeight = Math.min(viewportClientHeight * 0.1, 100);
+        const buffer = viewportHeight;
+        const topBound = buffer + grid.internal.headerHeightTotal.get();
+        const botBound = viewportClientHeight - buffer;
+        const speed = 6;
+        if (visualPositionY < topBound && !intervalIdY.current) {
+            intervalIdY.current = setInterval(() => {
+                viewport.scrollBy({ top: -speed });
+            }, 6);
+        }
+        else if (visualPositionY > botBound && !intervalIdY.current) {
+            intervalIdY.current = setInterval(() => {
+                viewport.scrollBy({ top: speed });
+            }, 6);
+        }
+        if (intervalIdY.current && visualPositionY > topBound && visualPositionY < botBound) {
+            cancelY();
+        }
+    }, [cancelY, grid.internal.headerHeightTotal, grid.state.viewport, grid.state.viewportHeightInner]);
+    const edgeScrollX = useCallback((visualPositionX, isRtl) => {
+        const viewport = grid.state.viewport.get();
+        if (!viewport)
+            return;
+        const viewportClientWidth = grid.state.viewportWidthInner.get();
+        const viewportWidth = Math.min(viewportClientWidth * 0.1, 100);
+        const buffer = viewportWidth;
+        const leftBound = buffer;
+        const rightBound = viewportClientWidth - buffer;
+        const speed = 3;
+        if (visualPositionX < leftBound && !intervalIdX.current) {
+            intervalIdX.current = setInterval(() => {
+                viewport.scrollBy({ left: isRtl ? speed : -speed });
+            }, 6);
+        }
+        else if (visualPositionX > rightBound && !intervalIdX.current) {
+            intervalIdX.current = setInterval(() => {
+                viewport.scrollBy({ left: isRtl ? -speed : speed });
+            }, 6);
+        }
+        if (intervalIdX.current && visualPositionX > leftBound && visualPositionX < rightBound) {
+            cancelX();
+        }
+    }, [cancelX, grid.state.viewport, grid.state.viewportWidthInner]);
+    return { cancelX, edgeScrollX, cancelY, edgeScrollY };
+}

package/dist/cells/cell-default.d.ts

@@ -0,0 +1,2 @@
+import type { CellRendererParams } from "../+types";
+export declare function CellDefault<T>({ grid, column, row }: CellRendererParams<T>): import("react/jsx-runtime").JSX.Element;

package/dist/cells/cell-default.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function CellDefault({ grid, column, row }) {
+    const r = grid.api.columnField(column, row);
+    if (row.data == null && row.loading) {
+        return _jsx("div", { children: "Loading..." });
+    }
+    return _jsx("div", { children: `${r ?? ""}` });
+}

package/dist/cells/cell-editor.d.ts

@@ -0,0 +1,6 @@
+import type { RowCellLayout } from "../+types";
+interface CellEditorParams<T> {
+    readonly cell: RowCellLayout<T>;
+}
+export declare function CellEditor<T>({ cell }: CellEditorParams<T>): import("react/jsx-runtime").JSX.Element;
+export {};