@1771technologies/lytenyte-pro 1.0.0-beta.36 → 1.0.0-beta.38

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

@@ -2,83 +2,85 @@ import { getSpanFn } from "../state/helpers/get-span-callback.js";
 import { getFullWidthCallback } from "../state/helpers/get-full-width-callback.js";
 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)
+    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: columnIndex,
-      colSpan: 1,
-      rowIndex: rowIndex,
-      rowSpan: 1,
+        colIndex: cell[2],
+        rowIndex: cell[1],
+        rowSpan: rootCell[0],
+        colSpan: rootCell[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/is-bottom-rect.js

@@ -1,7 +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;
+    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

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

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

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

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

@@ -1,5 +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();
+    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

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

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

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

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

@@ -1,8 +1,6 @@
 export function isOverlappingRect(rect1, rect2) {
-  return !(
-    rect1.rowEnd < rect2.rowStart ||
-    rect1.rowStart > rect2.rowEnd ||
-    rect1.columnEnd < rect2.columnStart ||
-    rect1.columnStart > rect2.columnEnd
-  );
+    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

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

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

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

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

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

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

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

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

@@ -1,10 +1,10 @@
 import type { DataRect } from "../+types.js";
 interface SplitCellSelectionRectArgs {
-  readonly rect: DataRect;
-  readonly colStartCount: number;
-  readonly colCenterCount: number;
-  readonly rowTopCount: number;
-  readonly rowCenterCount: number;
+    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.
@@ -35,11 +35,5 @@ interface SplitCellSelectionRectArgs {
  * @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 declare function splitCellSelectionRect({ rect, colStartCount, colCenterCount, rowTopCount, rowCenterCount, }: SplitCellSelectionRectArgs): DataRect[];
 export {};

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

@@ -27,59 +27,53 @@
  * @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);
+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 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);
+    // 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);
     }
-    rowSplits.push(split);
-  }
-  return rowSplits.sort((l, r) => {
-    return l.rowStart - r.rowStart || l.columnStart - r.columnStart;
-  });
+    // 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

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

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

@@ -3,20 +3,21 @@ import { adjustRectForRowAndCellSpan } from "./adjust-rect-for-row-and-cell-span
 import { areRectsEqual } from "./are-rects-equal.js";
 import { splitCellSelectionRect } from "./split-cell-selection-rect.js";
 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);
-  const rects = splitCellSelectionRect({
-    rect: boundSelectionRect(grid, adjustedRect),
-    colCenterCount: s.columnVisibleCenterCount,
-    colStartCount: s.columnVisibleStartCount,
-    rowCenterCount: ds.rowCenterCount.get(),
-    rowTopCount: rowTopCount,
-  });
-  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);
+    const s = grid.state.columnMeta.get();
+    const ds = grid.state.rowDataStore;
+    const rowTopCount = ds.rowTopCount.get();
+    const adjustedRect = adjustRectForRowAndCellSpan(grid, rect);
+    const rects = splitCellSelectionRect({
+        rect: boundSelectionRect(grid, adjustedRect),
+        colCenterCount: s.columnVisibleCenterCount,
+        colStartCount: s.columnVisibleStartCount,
+        rowCenterCount: ds.rowCenterCount.get(),
+        rowTopCount: rowTopCount,
+    });
+    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

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

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

@@ -1,68 +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 };
+    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

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