@1771technologies/lytenyte-pro 2.0.2 → 2.0.4-dev.0

package/dist/cell-selection/data-rect-from-cell-position.js

@@ -1,17 +0,0 @@
-export function dataRectFromCellPosition(position) {
-    if (position.root) {
-        const r = position.root;
-        return {
-            rowStart: r.rowIndex,
-            rowEnd: r.rowIndex + r.rowSpan,
-            columnStart: r.colIndex,
-            columnEnd: r.colIndex + r.colSpan,
-        };
-    }
-    return {
-        rowStart: position.rowIndex,
-        rowEnd: position.rowIndex + 1,
-        columnStart: position.colIndex,
-        columnEnd: position.colIndex + 1,
-    };
-}

package/dist/cell-selection/deselect-rect-range.d.ts

@@ -1,2 +0,0 @@
-import type { DataRect } from "../types/api.js";
-export declare function deselectRectRange(rect: DataRect, deselectRect: DataRect): DataRect[];

package/dist/cell-selection/deselect-rect-range.js

@@ -1,43 +0,0 @@
-import { isOverlappingRect } from "./is-overlapping-rect.js";
-export function deselectRectRange(rect, deselectRect) {
-    if (!isOverlappingRect(rect, deselectRect))
-        return [rect];
-    const result = [];
-    // Check for top split
-    if (deselectRect.rowStart > rect.rowStart) {
-        result.push({
-            rowStart: rect.rowStart,
-            rowEnd: deselectRect.rowStart,
-            columnStart: rect.columnStart,
-            columnEnd: rect.columnEnd,
-        });
-    }
-    // Check for bottom split
-    if (deselectRect.rowEnd < rect.rowEnd) {
-        result.push({
-            rowStart: deselectRect.rowEnd,
-            rowEnd: rect.rowEnd,
-            columnStart: rect.columnStart,
-            columnEnd: rect.columnEnd,
-        });
-    }
-    // Check for left split
-    if (deselectRect.columnStart > rect.columnStart) {
-        result.push({
-            rowStart: Math.max(deselectRect.rowStart, rect.rowStart),
-            rowEnd: Math.min(deselectRect.rowEnd, rect.rowEnd),
-            columnStart: rect.columnStart,
-            columnEnd: deselectRect.columnStart,
-        });
-    }
-    // Check for right split
-    if (deselectRect.columnEnd < rect.columnEnd) {
-        result.push({
-            rowStart: Math.max(deselectRect.rowStart, rect.rowStart),
-            rowEnd: Math.min(deselectRect.rowEnd, rect.rowEnd),
-            columnStart: deselectRect.columnEnd,
-            columnEnd: rect.columnEnd,
-        });
-    }
-    return result.filter((rect) => !(rect.rowStart >= rect.rowEnd || rect.columnStart >= rect.columnEnd));
-}

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

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

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

@@ -1,78 +0,0 @@
-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 expandSelectionDown(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, rowEnd: rowCount, rowStart: pos.rowStart };
-        const nextSelections = [...selections];
-        nextSelections[nextSelections.length - 1] = next;
-        setSelections(nextSelections);
-        if (pos.rowStart !== 0)
-            api.scrollIntoView({ row: rowCount - 1 });
-        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;
-    // Reduce our rect by one level
-    if (rect.rowStart < pivotStart) {
-        let highestRowEnd = -Infinity;
-        let setCell = rect;
-        for (let i = rect.columnStart; i < rect.columnEnd; i++) {
-            const cell = dataRectFromCellPosition(api.cellRoot(rect.rowStart + 1, i));
-            if (cell.rowStart > highestRowEnd) {
-                setCell = cell;
-                highestRowEnd = cell.rowStart;
-            }
-        }
-        api.scrollIntoView({ row: highestRowEnd });
-        next = {
-            ...rect,
-            rowStart: highestRowEnd,
-            columnStart: Math.min(setCell.columnStart, rect.columnStart),
-            columnEnd: Math.max(setCell.columnEnd, rect.columnEnd),
-        };
-    }
-    else {
-        // Move the rect level down by one.
-        let highestRowEnd = -Infinity;
-        let setCell = rect;
-        if (rect.rowEnd >= rowCount) {
-            highestRowEnd = rowCount;
-        }
-        else {
-            for (let i = rect.columnStart; i < rect.columnEnd; i++) {
-                const cell = dataRectFromCellPosition(api.cellRoot(rect.rowEnd, i));
-                highestRowEnd = Math.max(cell.rowEnd, highestRowEnd);
-                if (cell.rowEnd > highestRowEnd) {
-                    setCell = cell;
-                    highestRowEnd = cell.rowEnd;
-                }
-            }
-        }
-        api.scrollIntoView({ row: highestRowEnd - 1 });
-        next = {
-            ...rect,
-            rowEnd: highestRowEnd,
-            columnStart: Math.min(setCell.columnStart, rect.columnStart),
-            columnEnd: Math.max(setCell.columnEnd, rect.columnEnd),
-        };
-    }
-    const nextSelections = [...selections];
-    nextSelections[nextSelections.length - 1] = next;
-    setSelections(nextSelections);
-    return;
-}

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

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

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

@@ -1,76 +0,0 @@
-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 expandSelectionEnd(api, selections, setSelections, meta, position, view) {
-    const pos = dataRectFromCellPosition(position);
-    const rect = selections.at(-1);
-    if (!rect || !isOverlappingRect(rect, pos) || isFullyWithinRect(pos, rect))
-        return;
-    if (meta) {
-        const next = {
-            ...rect,
-            columnStart: pos.columnStart,
-            columnEnd: view.visibleColumns.length,
-        };
-        const nextSelections = [...selections];
-        nextSelections[nextSelections.length - 1] = next;
-        setSelections(nextSelections);
-        if (pos.columnStart !== 0)
-            api.scrollIntoView({ column: view.visibleColumns.length - 1 });
-        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.columnStart < pivotStart) {
-        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 {
-        if (rect.columnEnd === view.visibleColumns.length)
-            return;
-        let highestColEnd = -Infinity;
-        let setCell = rect;
-        for (let i = rect.rowStart; i < rect.rowEnd; i++) {
-            const cell = dataRectFromCellPosition(api.cellRoot(i, rect.columnEnd));
-            if (cell.columnStart > highestColEnd) {
-                highestColEnd = cell.columnStart;
-                setCell = cell;
-            }
-        }
-        next = {
-            ...rect,
-            columnEnd: highestColEnd + 1,
-            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-start.d.ts

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

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

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

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

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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-export { isWithinSelectionRect } from "./is-within-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 { 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

@@ -1,11 +0,0 @@
-export { isWithinSelectionRect } from "./is-within-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 { 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,41 +0,0 @@
-import type { DataRect } from "../types/api.js";
-import type { DataRectSplit } from "../types/grid.js";
-interface SplitCellSelectionRectArgs {
-    readonly rect: DataRect;
-    readonly colStartCount: number;
-    readonly colCenterCount: number;
-    readonly rowTopCount: number;
-    readonly rowCenterCount: number;
-    readonly isDeselect?: 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 {};