@1771technologies/lytenyte-pro 2.0.0-dev.0 → 2.0.0-dev.2

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

@@ -0,0 +1,73 @@
+import { dataRectFromCellPosition } from "./data-rect-from-cell-position.js";
+import { isOverlappingRect } from "./is-overlapping-rect.js";
+import { isFullyWithinRect } from "./is-fully-within-rect.js";
+export function expandSelectionStart(api, selections, setSelections, meta, position, excludeMarker, view) {
+    const pos = dataRectFromCellPosition(position);
+    const rect = selections.at(-1);
+    if (!rect || !isOverlappingRect(rect, pos) || isFullyWithinRect(pos, rect))
+        return;
+    const first = excludeMarker ? 1 : 0;
+    if (meta) {
+        const next = { ...rect, columnStart: first, columnEnd: pos.columnStart + 1 };
+        const nextSelections = [...selections];
+        nextSelections[nextSelections.length - 1] = next;
+        setSelections(nextSelections);
+        if (pos.columnStart !== view.visibleColumns.length - 1)
+            api.scrollIntoView({ column: first });
+        return;
+    }
+    const isAtEdge = pos.columnStart == rect.columnStart || pos.columnEnd === rect.columnEnd;
+    let pivotStart = pos.columnStart;
+    let pivotEnd = pos.columnEnd;
+    // Our cell some how is spanned over. so for the current rowIndex, find the maximum span along the columns
+    if (!isAtEdge) {
+        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(pos.columnStart, i));
+            pivotStart = Math.min(pivotStart, cell.columnStart);
+            pivotEnd = Math.max(pivotEnd, cell.columnEnd);
+        }
+    }
+    let next;
+    if (rect.columnEnd <= pivotEnd) {
+        if (rect.columnStart === first)
+            return;
+        let highestColEnd = -Infinity;
+        let setCell = rect;
+        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(i, rect.columnStart - 1));
+            if (cell.columnStart > highestColEnd) {
+                highestColEnd = cell.columnStart;
+                setCell = cell;
+            }
+        }
+        next = {
+            ...rect,
+            columnStart: highestColEnd,
+            rowStart: Math.min(setCell.rowStart, rect.rowStart),
+            rowEnd: Math.max(setCell.rowEnd, rect.rowEnd),
+        };
+        api.scrollIntoView({ column: highestColEnd });
+    }
+    else {
+        let highestColEnd = -Infinity;
+        let setCell = rect;
+        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(i, rect.columnEnd - 1));
+            if (cell.columnStart > highestColEnd) {
+                highestColEnd = cell.columnStart;
+                setCell = cell;
+            }
+        }
+        next = {
+            ...rect,
+            columnEnd: highestColEnd,
+            rowStart: Math.min(setCell.rowStart, rect.rowStart),
+            rowEnd: Math.max(setCell.rowEnd, rect.rowEnd),
+        };
+        api.scrollIntoView({ column: highestColEnd - 1 });
+    }
+    const nextSelections = [...selections];
+    nextSelections[nextSelections.length - 1] = next;
+    setSelections(nextSelections);
+    return;
+}

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

@@ -0,0 +1,3 @@
+import type { PositionGridCell } from "@1771technologies/lytenyte-shared";
+import type { API, DataRect } from "../types/api.js";
+export declare function expandSelectionUp(api: API, selections: DataRect[], setSelections: (d: DataRect[]) => void, meta: boolean, position: PositionGridCell, rowCount: number): void;

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

@@ -0,0 +1,74 @@
+import { dataRectFromCellPosition } from "./data-rect-from-cell-position.js";
+import { isOverlappingRect } from "./is-overlapping-rect.js";
+import { isFullyWithinRect } from "./is-fully-within-rect.js";
+export function expandSelectionUp(api, selections, setSelections, meta, position, rowCount) {
+    const pos = dataRectFromCellPosition(position);
+    const rect = selections.at(-1);
+    if (!rect || !isOverlappingRect(rect, pos) || isFullyWithinRect(pos, rect))
+        return;
+    if (meta) {
+        const next = { ...rect, rowStart: 0, rowEnd: pos.rowStart + 1 };
+        const nextSelections = [...selections];
+        nextSelections[nextSelections.length - 1] = next;
+        setSelections(nextSelections);
+        if (pos.rowStart !== rowCount - 1)
+            api.scrollIntoView({ row: 0 });
+        return;
+    }
+    const isAtEdge = pos.rowStart == rect.rowStart || pos.rowEnd === rect.rowEnd;
+    let pivotStart = pos.rowStart;
+    let pivotEnd = pos.rowEnd;
+    // Our cell some how is spanned over. so for the current rowIndex, find the maximum span along the columns
+    if (!isAtEdge) {
+        for (let i = rect.columnStart; i < rect.columnEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(pos.rowStart, i));
+            pivotStart = Math.min(pivotStart, cell.rowStart);
+            pivotEnd = Math.max(pivotEnd, cell.rowEnd);
+        }
+    }
+    let next;
+    if (rect.rowEnd > pivotEnd) {
+        let lowestRowStart = Infinity;
+        let c = rect;
+        for (let i = rect.columnStart; i < rect.columnEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(rect.rowEnd - 1, i));
+            lowestRowStart = Math.min(cell.rowStart, lowestRowStart);
+            if (cell.rowStart < lowestRowStart) {
+                lowestRowStart = cell.rowStart;
+                c = cell;
+            }
+        }
+        api.scrollIntoView({ row: lowestRowStart - 1 });
+        next = {
+            ...rect,
+            rowEnd: lowestRowStart,
+            columnStart: Math.min(c.columnStart, rect.columnStart),
+            columnEnd: Math.max(c.columnEnd, rect.columnEnd),
+        };
+    }
+    else {
+        if (rect.rowStart === 0)
+            return;
+        let lowestRowStart = Infinity;
+        let c = rect;
+        for (let i = rect.columnStart; i < rect.columnEnd; i++) {
+            const cell = dataRectFromCellPosition(api.cellRoot(rect.rowStart - 1, i));
+            lowestRowStart = Math.min(cell.rowStart, lowestRowStart);
+            if (cell.rowStart < lowestRowStart) {
+                lowestRowStart = cell.rowStart;
+                c = cell;
+            }
+        }
+        api.scrollIntoView({ row: lowestRowStart });
+        next = {
+            ...rect,
+            rowStart: lowestRowStart,
+            columnStart: Math.min(c.columnStart, rect.columnStart),
+            columnEnd: Math.max(c.columnEnd, rect.columnEnd),
+        };
+    }
+    const nextSelections = [...selections];
+    nextSelections[nextSelections.length - 1] = next;
+    setSelections(nextSelections);
+    return;
+}

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

@@ -0,0 +1,2 @@
+import type { ColumnView } from "@1771technologies/lytenyte-shared";
+export declare function fullWidthStartEndIndex(view: ColumnView): number[];

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

@@ -0,0 +1,4 @@
+export function fullWidthStartEndIndex(view) {
+    const lastIndex = view.visibleColumns.length;
+    return [0, lastIndex];
+}

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

@@ -0,0 +1,3 @@
+import type { PositionGridCell } from "@1771technologies/lytenyte-shared";
+import type { API } from "../types/api.js";
+export declare const getRootCell: (cellRoot: API["cellRoot"], rowIndex: number, columnIndex: number) => PositionGridCell["root"];

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

@@ -0,0 +1,6 @@
+export const getRootCell = (cellRoot, rowIndex, columnIndex) => {
+    const c = cellRoot(rowIndex, columnIndex);
+    if (!c || c.kind === "full-width")
+        return null;
+    return c.root;
+};

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

@@ -0,0 +1,13 @@
+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 { updateAdditiveCellSelection } from "./update-additive-cell-selection.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,13 @@
+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 { updateAdditiveCellSelection } from "./update-additive-cell-selection.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 } from "../types/api.js";
+export declare function isBottomRect(rowCount: number, botCount: number, rect: DataRect): boolean;

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

@@ -0,0 +1,4 @@
+export function isBottomRect(rowCount, botCount, rect) {
+    const bottomStart = rowCount - botCount;
+    return rect.rowStart >= bottomStart;
+}

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

@@ -0,0 +1,5 @@
+import type { ColumnView } from "@1771technologies/lytenyte-shared";
+export declare function isCenterColRect(view: ColumnView, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

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

@@ -0,0 +1,3 @@
+export function isCenterColRect(view, rect) {
+    return rect.columnStart >= view.startCount && rect.columnStart < view.centerCount + view.startCount;
+}

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

@@ -0,0 +1,2 @@
+import type { DataRect } from "../types/api";
+export declare function isCenterRect(rowCount: number, rowBottomCount: number, rowTopCount: number, rect: DataRect): boolean;

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

@@ -0,0 +1,4 @@
+export function isCenterRect(rowCount, rowBottomCount, rowTopCount, rect) {
+    const bottomStart = rowCount - rowBottomCount;
+    return rect.rowStart < bottomStart && rect.rowStart >= rowTopCount;
+}

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

@@ -0,0 +1,5 @@
+import type { ColumnView } from "@1771technologies/lytenyte-shared";
+export declare function isEndRect(view: ColumnView, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

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

@@ -0,0 +1,3 @@
+export function isEndRect(view, rect) {
+    return rect.columnStart >= view.startCount + view.centerCount;
+}

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

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

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

@@ -0,0 +1,6 @@
+export function isFullyWithinRect(pos, rect) {
+    return (pos.rowStart !== rect.rowStart &&
+        pos.rowEnd !== rect.rowEnd &&
+        pos.columnStart !== rect.columnStart &&
+        pos.columnEnd !== rect.columnEnd);
+}

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

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

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

@@ -0,0 +1,5 @@
+export function isOverlappingRect(a, b) {
+    const rowsOverlap = a.rowStart < b.rowEnd && b.rowStart < a.rowEnd;
+    const columnsOverlap = a.columnStart < b.columnEnd && b.columnStart < a.columnEnd;
+    return rowsOverlap && columnsOverlap;
+}

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

@@ -0,0 +1,5 @@
+import type { ColumnView } from "@1771technologies/lytenyte-shared";
+export declare function isStartRect(view: ColumnView, rect: {
+    columnStart: number;
+    columnEnd: number;
+}): boolean;

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

@@ -0,0 +1,3 @@
+export function isStartRect(view, rect) {
+    return rect.columnStart < view.startCount;
+}

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

@@ -0,0 +1,2 @@
+import type { DataRect } from "../types/api.js";
+export declare function isTopRect(topCount: number, rect: DataRect): boolean;

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

@@ -0,0 +1,3 @@
+export function isTopRect(topCount, rect) {
+    return rect.rowStart < topCount;
+}

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

@@ -0,0 +1,2 @@
+import type { DataRect } from "../types/api.js";
+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,47 @@
+import type { DataRect } from "../types/api.js";
+interface SplitCellSelectionRectArgs {
+    readonly rect: DataRect;
+    readonly colStartCount: number;
+    readonly colCenterCount: number;
+    readonly rowTopCount: number;
+    readonly rowCenterCount: number;
+    readonly isDeselect?: boolean;
+}
+export interface DataRectSplit extends DataRect {
+    readonly isUnit: boolean;
+    readonly borderTop?: boolean;
+    readonly borderBottom?: boolean;
+    readonly borderStart?: boolean;
+    readonly borderEnd?: boolean;
+}
+/**
+ * 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): DataRectSplit[];
+export {};

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

@@ -0,0 +1,88 @@
+/**
+ * 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 isUnit = rect.rowEnd - rect.rowStart === 1 && rect.columnEnd - rect.columnStart === 1;
+    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,
+            isUnit,
+        };
+        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,
+            isUnit,
+        };
+        rect = { ...rect, columnEnd: colEndBound };
+        colSplits.push(endSplit);
+    }
+    // Add the remaining rectangle after column splits
+    colSplits.push({ ...rect, isUnit });
+    // 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, isUnit };
+            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,
+                isUnit,
+            };
+            split = { ...split, rowEnd: bottomBound };
+            rowSplits.push(bottomSplit);
+        }
+        rowSplits.push(split);
+    }
+    return rowSplits
+        .map((c) => ({ ...c, borderTop: true, borderBottom: true, borderEnd: true, borderStart: true }))
+        .sort((l, r) => {
+        return l.rowStart - r.rowStart || l.columnStart - r.columnStart;
+    });
+}

package/dist/cell-selection/split-on-pivot.d.ts

@@ -0,0 +1,3 @@
+import type { DataRectSplit } from "./split-cell-selection-rect";
+import type { DataRect } from "../types/api.js";
+export declare function splitOnPivot(rect: DataRectSplit, pivot: DataRect): DataRectSplit[] | null;

package/dist/cell-selection/split-on-pivot.js

@@ -0,0 +1,50 @@
+import { areRectsEqual } from "./are-rects-equal.js";
+export function splitOnPivot(rect, pivot) {
+    if (rect.isUnit || areRectsEqual(rect, pivot))
+        return null;
+    const splits = [];
+    const isAfter = pivot.columnStart > rect.columnStart;
+    const isSame = pivot.columnStart === rect.columnStart && pivot.columnEnd === rect.columnEnd;
+    // The pivot is on the right side of the rect. So we split by end
+    if (isAfter) {
+        const split = { ...rect, columnEnd: rect.columnEnd - 1, borderEnd: false };
+        if (split.columnStart !== split.columnEnd)
+            splits.push(split);
+    }
+    else {
+        const split = {
+            ...rect,
+            columnStart: rect.columnStart + 1,
+            borderStart: false,
+        };
+        if (split.columnStart !== split.columnEnd)
+            splits.push(split);
+    }
+    if (pivot.rowStart > rect.rowStart) {
+        const split = {
+            ...rect,
+            columnStart: pivot.columnStart,
+            columnEnd: pivot.columnEnd,
+            rowEnd: rect.rowEnd - 1,
+            borderBottom: false,
+            borderStart: !isAfter,
+            borderEnd: isSame || isAfter,
+        };
+        if (split.rowStart !== split.rowEnd)
+            splits.push(split);
+    }
+    else {
+        const split = {
+            ...rect,
+            columnStart: pivot.columnStart,
+            columnEnd: pivot.columnEnd,
+            rowStart: rect.rowStart + 1,
+            borderTop: false,
+            borderStart: !isAfter,
+            borderEnd: isSame || isAfter,
+        };
+        if (split.rowStart !== split.rowEnd)
+            splits.push(split);
+    }
+    return splits;
+}

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

@@ -0,0 +1,4 @@
+import { type DataRectSplit } from "./split-cell-selection-rect.js";
+import type { ColumnView } from "@1771technologies/lytenyte-shared";
+import type { API, DataRect } from "../types/api.js";
+export declare function updateAdditiveCellSelection(api: API, view: ColumnView, rowTopCount: number, rowCount: number, rowBottomCount: number, rect: DataRect, cellSelectionAdditiveRects: DataRectSplit[] | null, setSelectionAdditiveRects: (d: DataRectSplit[] | null) => void): void;

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

@@ -0,0 +1,21 @@
+import { boundSelectionRect } from "./bound-selection-rect.js";
+import { adjustRectForRowAndCellSpan } from "./adjust-rect-for-row-and-cell-span.js";
+import { areRectsEqual } from "./are-rects-equal.js";
+import { splitCellSelectionRect } from "./split-cell-selection-rect.js";
+export function updateAdditiveCellSelection(api, view, rowTopCount, rowCount, rowBottomCount, rect, cellSelectionAdditiveRects, setSelectionAdditiveRects) {
+    const s = view;
+    const adjustedRect = adjustRectForRowAndCellSpan(api.cellRoot, rect);
+    const rects = splitCellSelectionRect({
+        rect: boundSelectionRect(view, rowCount, adjustedRect),
+        colCenterCount: s.centerCount,
+        colStartCount: s.startCount,
+        rowCenterCount: rowCount - rowTopCount - rowBottomCount,
+        rowTopCount: rowTopCount,
+    });
+    const current = cellSelectionAdditiveRects;
+    if (current && current.length === rects.length) {
+        if (current.every((c, i) => areRectsEqual(c, rects[i])))
+            return;
+    }
+    setSelectionAdditiveRects(rects);
+}

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

@@ -0,0 +1,6 @@
+export declare function useEdgeScroll(): {
+    cancelX: () => void;
+    edgeScrollX: (visualPositionX: number, isRtl: boolean) => void;
+    cancelY: () => void;
+    edgeScrollY: (visualPositionY: number, startY: number) => void;
+};

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

@@ -0,0 +1,71 @@
+import { useRoot } from "@1771technologies/lytenyte-core/internal";
+import { useCallback, useRef } from "react";
+export function useEdgeScroll() {
+    const { viewport, dimensions, totalHeaderHeight, yPositions, source } = useRoot();
+    const rowTopCount = source.useTopCount();
+    const rowBottomCount = source.useBottomCount();
+    const bottomHeight = yPositions.at(-1) - yPositions.at(-1 - rowBottomCount);
+    const topHeight = yPositions.at(rowTopCount);
+    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, startY) => {
+        if (!viewport)
+            return;
+        const viewportClientHeight = dimensions.innerHeight;
+        const topBound = totalHeaderHeight + topHeight;
+        const botBound = viewportClientHeight - bottomHeight;
+        const scrollTop = startY > topBound && visualPositionY <= totalHeaderHeight + 20;
+        const scrollBottom = startY < botBound && visualPositionY >= viewportClientHeight - 20;
+        const speed = 6;
+        if (scrollTop && !intervalIdY.current) {
+            intervalIdY.current = setInterval(() => {
+                viewport.scrollBy({ top: -speed });
+            }, 6);
+        }
+        else if (scrollBottom && !intervalIdY.current) {
+            intervalIdY.current = setInterval(() => {
+                viewport.scrollBy({ top: speed });
+            }, 6);
+        }
+        if (!scrollBottom && !scrollTop && intervalIdY.current) {
+            clearInterval(intervalIdY.current);
+            intervalIdY.current = null;
+        }
+    }, [bottomHeight, dimensions.innerHeight, topHeight, totalHeaderHeight, viewport]);
+    const edgeScrollX = useCallback((visualPositionX, isRtl) => {
+        if (!viewport)
+            return;
+        const viewportClientWidth = dimensions.innerWidth;
+        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, dimensions.innerWidth, viewport]);
+    return { cancelX, edgeScrollX, cancelY, edgeScrollY };
+}

package/dist/components/checkbox/checkbox.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "react";
+import { type SlotComponent } from "../../hooks/use-slot/index.js";
+export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<Checkbox.Props, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare namespace Checkbox {
+    type State = {
+        readonly indeterminate: boolean;
+        readonly checked: boolean;
+    };
+    type Props = JSX.IntrinsicElements["input"] & {
+        readonly indeterminate?: boolean;
+        readonly initialChecked?: boolean;
+        readonly renderMarker?: SlotComponent<State>;
+        readonly onCheckChange?: (b: boolean) => void;
+    };
+}