@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/patches.d.ts

@@ -0,0 +1,11 @@
+import type { Patch } from "immer";
+/**
+ * A pure, efficient implementation of applyPatches that doesn't use proxies
+ * Optimized for spreadsheet data by avoiding unnecessary deep cloning
+ *
+ * @param state The original state
+ * @param patches Array of patches to apply
+ * @returns A new state with patches applied
+ */
+export declare function applyPatches<T>(state: T, patches: Patch[]): T;
+//# sourceMappingURL=patches.d.ts.map

package/dist/esm/api/patches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patches.d.ts","sourceRoot":"","sources":["../../../api/patches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AA8DnC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,CAqK7D"}

package/dist/esm/api/patches.js

@@ -0,0 +1,206 @@
+// ArchType enum similar to Immer's internal type
+var ArchType;
+(function (ArchType) {
+    ArchType[ArchType["Object"] = 0] = "Object";
+    ArchType[ArchType["Array"] = 1] = "Array";
+    ArchType[ArchType["Map"] = 2] = "Map";
+    ArchType[ArchType["Set"] = 3] = "Set";
+    ArchType[ArchType["PlainObject"] = 4] = "PlainObject";
+})(ArchType || (ArchType = {}));
+// Operations similar to Immer
+const REPLACE = "replace";
+const ADD = "add";
+const REMOVE = "remove";
+/**
+ * Gets the architectural type of a value
+ */
+function getArchtype(value) {
+    if (Array.isArray(value))
+        return ArchType.Array;
+    if (value instanceof Map)
+        return ArchType.Map;
+    if (value instanceof Set)
+        return ArchType.Set;
+    if (value !== null && typeof value === "object")
+        return ArchType.Object;
+    return ArchType.PlainObject;
+}
+/**
+ * Shallow clone an object/array/map/set
+ * Much more efficient than deep cloning for spreadsheet use cases
+ */
+function shallowClone(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+    if (value instanceof Date) {
+        return new Date(value);
+    }
+    if (value instanceof Map) {
+        return new Map(value);
+    }
+    if (value instanceof Set) {
+        return new Set(value);
+    }
+    return { ...value };
+}
+/**
+ * Throw an error similar to Immer's die function
+ */
+function die(errorCode, details) {
+    throw new Error(`[PurePatches] error ${errorCode}${details ? `: ${details}` : ""}`);
+}
+/**
+ * A pure, efficient implementation of applyPatches that doesn't use proxies
+ * Optimized for spreadsheet data by avoiding unnecessary deep cloning
+ *
+ * @param state The original state
+ * @param patches Array of patches to apply
+ * @returns A new state with patches applied
+ */
+export function applyPatches(state, patches) {
+    // If no patches, return original state
+    if (!patches.length)
+        return state;
+    // Clone the top level of the state to avoid direct mutations
+    let result = shallowClone(state);
+    // Apply each patch
+    for (const patch of patches) {
+        const { path, op, value } = patch;
+        // Handle empty path - replacing the entire state
+        if (path.length === 0) {
+            if (op === REPLACE) {
+                result = value; // No need to clone value here
+            }
+            continue;
+        }
+        // Find the parent object/array that contains the property to be modified
+        let current = result;
+        let parent = null;
+        let parentKey = null;
+        const pathLen = path.length;
+        const lastIndex = pathLen - 1;
+        // Create a copy of the path to the modified object
+        for (let i = 0; i < lastIndex; i++) {
+            let p = path[i];
+            // Convert path elements to strings if needed
+            if (typeof p !== "string" && typeof p !== "number") {
+                p = String(p);
+            }
+            // Protection against prototype pollution
+            const parentType = getArchtype(current);
+            if ((parentType === ArchType.Object || parentType === ArchType.Array) &&
+                (p === "__proto__" || p === "constructor")) {
+                die(1, "Prototype pollution attempt detected");
+            }
+            // Handle function prototype
+            if (typeof current === "function" && p === "prototype") {
+                die(2, "Function prototype mutation attempt detected");
+            }
+            // Get the next level
+            let next = current[p];
+            // If path doesn't exist or isn't an object, create it
+            if (next === undefined || next === null || typeof next !== "object") {
+                const nextKey = i < lastIndex - 1 ? path[i + 1] : null;
+                const isNextKeyNumber = nextKey !== null && !isNaN(Number(nextKey));
+                // Create new object or array based on next key
+                next = isNextKeyNumber ? [] : {};
+                // Clone current before modifying if not already cloned
+                if (parent !== null && current === parent[parentKey]) {
+                    current = parent[parentKey] = shallowClone(current);
+                }
+                // Set the new object/array
+                current[p] = next;
+            }
+            // Clone the next object if needed
+            else if (i < lastIndex - 1) {
+                const clonedNext = shallowClone(next);
+                if (next !== clonedNext) {
+                    current[p] = clonedNext;
+                    next = clonedNext;
+                }
+            }
+            // Update references for next iteration
+            parent = current;
+            parentKey = p;
+            current = next;
+        }
+        // Get the final key
+        let key = path[lastIndex];
+        if (typeof key !== "string" && typeof key !== "number") {
+            key = String(key);
+        }
+        // Clone the current object if it's the same reference as in parent
+        if (parent !== null && current === parent[parentKey]) {
+            current = parent[parentKey] = shallowClone(current);
+        }
+        // Apply operation based on the architecture type
+        const type = getArchtype(current);
+        switch (op) {
+            case REPLACE:
+                switch (type) {
+                    case ArchType.Map:
+                        current.set(key, value);
+                        break;
+                    case ArchType.Set:
+                        die(3, "Cannot replace in a Set");
+                        break;
+                    default:
+                        current[key] = value;
+                        break;
+                }
+                break;
+            case ADD:
+                switch (type) {
+                    case ArchType.Array:
+                        if (key === "-") {
+                            current.push(value);
+                        }
+                        else {
+                            const numericKey = Number(key);
+                            if (isNaN(numericKey)) {
+                                die(4, `Cannot add non-numeric index ${key} to array`);
+                            }
+                            current.splice(numericKey, 0, value);
+                        }
+                        break;
+                    case ArchType.Map:
+                        current.set(key, value);
+                        break;
+                    case ArchType.Set:
+                        current.add(value);
+                        break;
+                    default:
+                        current[key] = value;
+                        break;
+                }
+                break;
+            case REMOVE:
+                switch (type) {
+                    case ArchType.Array: {
+                        const numericKey = Number(key);
+                        if (isNaN(numericKey)) {
+                            die(5, `Cannot remove non-numeric index ${key} from array`);
+                        }
+                        current.splice(numericKey, 1);
+                        break;
+                    }
+                    case ArchType.Map:
+                        current.delete(key);
+                        break;
+                    case ArchType.Set:
+                        current.delete(value);
+                        break;
+                    default:
+                        delete current[key];
+                        break;
+                }
+                break;
+            default:
+                die(6, `Unknown operation: ${op}`);
+        }
+    }
+    return result;
+}

package/dist/esm/api/pivot-range.d.ts

@@ -0,0 +1,8 @@
+import type { GridRange, PivotTable } from "@rowsncolumns/common-types";
+import type { Draft } from "immer";
+type RangeDimension = "row" | "column";
+export declare const shiftPivotsOnInsert: (draft: Draft<PivotTable>[], sheetId: number, dimension: RangeDimension, index: number, count: number) => void;
+export declare const shiftPivotsOnDelete: (draft: Draft<PivotTable>[], sheetId: number, dimension: RangeDimension, index: number, count: number) => void;
+export declare const shiftPivotsOnMove: (draft: Draft<PivotTable>[], sheetId: number, from: GridRange, to: GridRange) => void;
+export {};
+//# sourceMappingURL=pivot-range.d.ts.map

package/dist/esm/api/pivot-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-range.d.ts","sourceRoot":"","sources":["../../../api/pivot-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAc,MAAM,4BAA4B,CAAC;AAEpF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKnC,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AA0DvC,eAAO,MAAM,mBAAmB,GAC9B,OAAO,KAAK,CAAC,UAAU,CAAC,EAAE,EAC1B,SAAS,MAAM,EACf,WAAW,cAAc,EACzB,OAAO,MAAM,EACb,OAAO,MAAM,SAoBd,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,OAAO,KAAK,CAAC,UAAU,CAAC,EAAE,EAC1B,SAAS,MAAM,EACf,WAAW,cAAc,EACzB,OAAO,MAAM,EACb,OAAO,MAAM,SA+Bd,CAAC;AAaF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,KAAK,CAAC,UAAU,CAAC,EAAE,EAC1B,SAAS,MAAM,EACf,MAAM,SAAS,EACf,IAAI,SAAS,SAqBd,CAAC"}

package/dist/esm/api/pivot-range.js

@@ -0,0 +1,93 @@
+import { areaInsideArea } from "@rowsncolumns/grid";
+import { moveRange } from "./selection";
+import { updateSheetRangeOnDelete } from "./range";
+const getDimensionKeys = (dimension) => dimension === "row"
+    ? ["startRowIndex", "endRowIndex"]
+    : ["startColumnIndex", "endColumnIndex"];
+const shiftCoordinate = (coordinate, sheetId, dimension, delta, fromIndex) => {
+    if (!coordinate || coordinate.sheetId !== sheetId)
+        return;
+    const key = dimension === "row" ? "rowIndex" : "columnIndex";
+    if (coordinate[key] >= fromIndex) {
+        coordinate[key] += delta;
+    }
+};
+// Mirrors the table-shift convention in insert-row/insert-column: an insert
+// AT-or-before the start translates the whole range; an insert strictly
+// inside extends the end. The shared `updateSheetRangeOnInsert` uses
+// `index < start`, which would leave a hole at the leading edge.
+const shiftRangeOnInsert = (range, sheetId, dimension, index, count) => {
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    const [startKey, endKey] = getDimensionKeys(dimension);
+    const start = range[startKey];
+    const end = range[endKey];
+    if (index <= start) {
+        return { ...range, [startKey]: start + count, [endKey]: end + count };
+    }
+    if (index <= end) {
+        return { ...range, [endKey]: end + count };
+    }
+    return range;
+};
+const shiftRangeOnDelete = (range, sheetId, dimension, index, count) => {
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    const next = updateSheetRangeOnDelete(range, dimension, index, count, sheetId);
+    return next ?? undefined;
+};
+export const shiftPivotsOnInsert = (draft, sheetId, dimension, index, count) => {
+    if (count <= 0)
+        return;
+    for (const pivot of draft) {
+        pivot.source = shiftRangeOnInsert(pivot.source, sheetId, dimension, index, count);
+        pivot.pivotRange = shiftRangeOnInsert(pivot.pivotRange, sheetId, dimension, index, count);
+        shiftCoordinate(pivot.targetPosition, sheetId, dimension, count, index);
+    }
+};
+export const shiftPivotsOnDelete = (draft, sheetId, dimension, index, count) => {
+    if (count <= 0)
+        return;
+    const deleteEnd = index + count - 1;
+    const key = dimension === "row" ? "rowIndex" : "columnIndex";
+    for (const pivot of draft) {
+        pivot.source = shiftRangeOnDelete(pivot.source, sheetId, dimension, index, count);
+        pivot.pivotRange = shiftRangeOnDelete(pivot.pivotRange, sheetId, dimension, index, count);
+        const target = pivot.targetPosition;
+        if (target && target.sheetId === sheetId) {
+            if (target[key] > deleteEnd) {
+                target[key] -= count;
+            }
+            else if (target[key] >= index) {
+                // The deletion swallowed the target's row/column. Anchor it to the
+                // first surviving index before the deletion.
+                target[key] = Math.max(1, index - 1);
+            }
+        }
+    }
+};
+const moveRangeIfInside = (range, sheetId, from, to) => {
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    if (!areaInsideArea(range, from))
+        return range;
+    return moveRange(range, from, to);
+};
+export const shiftPivotsOnMove = (draft, sheetId, from, to) => {
+    const rowDelta = to.startRowIndex - from.startRowIndex;
+    const columnDelta = to.startColumnIndex - from.startColumnIndex;
+    for (const pivot of draft) {
+        pivot.source = moveRangeIfInside(pivot.source, sheetId, from, to);
+        pivot.pivotRange = moveRangeIfInside(pivot.pivotRange, sheetId, from, to);
+        const target = pivot.targetPosition;
+        if (target &&
+            target.sheetId === sheetId &&
+            target.rowIndex >= from.startRowIndex &&
+            target.rowIndex <= from.endRowIndex &&
+            target.columnIndex >= from.startColumnIndex &&
+            target.columnIndex <= from.endColumnIndex) {
+            target.rowIndex += rowDelta;
+            target.columnIndex += columnDelta;
+        }
+    }
+};

package/dist/esm/api/range-rule-helpers.d.ts

@@ -0,0 +1,65 @@
+import type { GridRange, SheetRange } from "@rowsncolumns/common-types";
+import type { WritableDraft } from "immer";
+type RangedRuleAxis = "row" | "column";
+/**
+ * Apply an insert or delete range adjustment to a list of rules whose
+ * `ranges: SheetRange[]` field references cells. Used for tables, conditional
+ * formats, data validations, etc. Mutates the immer draft in place; rules
+ * whose ranges all collapse to nothing are spliced out.
+ *
+ * Walks `draft` from the end so splice indices don't shift mid-iteration.
+ */
+export declare const updateRangedRulesOnStructuralChange: <R extends {
+    ranges?: SheetRange[] | null;
+}>(draft: WritableDraft<R>[], op: "insert" | "delete", axis: RangedRuleAxis, index: number, count: number, sheetId: number) => void;
+/**
+ * Returns true when a sheet range has any cells in the given grid bounds.
+ * Cheap pre-check used by callers to skip patch generation for sheets that
+ * have no rules touching the affected region.
+ */
+export declare const rangeOverlapsGrid: (range: SheetRange, sheetId: number, bounds: GridRange) => boolean;
+/**
+ * Maps an old index to its new index under the splice semantics that
+ * `useOnMoveRows` / `useOnMoveColumns` use:
+ *
+ *   `splice(firstIndex, count); splice(referenceIndex, 0, ...moved)`
+ *
+ * which lands the moved block at `[referenceIndex, referenceIndex + count
+ * - 1]` regardless of direction. Indices outside the moved block but
+ * inside the shift zone are pushed by `±count` to make room.
+ *
+ * @internal exported for testing
+ */
+export declare const mapMovedIndex: (index: number, firstIndex: number, lastIndex: number, referenceIndex: number) => number;
+type ReorderAxis = "row" | "column";
+/**
+ * Apply a row/column reorder to a list of rules whose `ranges:
+ * SheetRange[]` field references cells. Used for conditional formats,
+ * data validations, etc. Mutates the immer draft in place.
+ *
+ * Strategy matches Excel's "cell tracking" semantics for single-range
+ * rules: each range's start/end corners are mapped to their new
+ * positions via `mapMovedIndex`, then the range is rebuilt as the
+ * bounding box (`min`/`max`). For ranges fully inside or fully outside
+ * the moved block this is exact; for straddling ranges it degrades to
+ * a bounding box — same as Excel for non-CF rules.
+ */
+export declare const updateRangedRulesOnReorder: <R extends {
+    ranges?: SheetRange[] | null;
+}>(draft: WritableDraft<R>[], axis: ReorderAxis, firstIndex: number, lastIndex: number, referenceIndex: number, sheetId: number, 
+/**
+ * Optional. When provided, only rule ranges whose orthogonal axis
+ * overlaps `[start, end]` are re-anchored. Used by table-column moves
+ * — the splice only affects cells inside the table's row band, so a
+ * CF/DV rule outside that band shouldn't have its columns shifted.
+ *
+ * For an `axis: "column"` move, this is the table's `[startRowIndex,
+ * endRowIndex]`; for an `axis: "row"` move, it would be column
+ * bounds (no current caller, but kept symmetric).
+ */
+orthogonalBoundary?: {
+    start: number;
+    end: number;
+}) => void;
+export {};
+//# sourceMappingURL=range-rule-helpers.d.ts.map

package/dist/esm/api/range-rule-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-rule-helpers.d.ts","sourceRoot":"","sources":["../../../api/range-rule-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,GAC9C,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,IAAI,QAAQ,GAAG,QAAQ,EACvB,MAAM,cAAc,EACpB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,SAkBhB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,UAAU,EACjB,SAAS,MAAM,EACf,QAAQ,SAAS,YASlB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,KACrB,MAiBF,CAAC;AAEF,KAAK,WAAW,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,GACrC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,MAAM,WAAW,EACjB,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,SAAS,MAAM;AACf;;;;;;;;;GASG;AACH,qBAAqB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,SAkEpD,CAAC"}

package/dist/esm/api/range-rule-helpers.js

@@ -0,0 +1,138 @@
+import { updateSheetRangeOnDelete, updateSheetRangeOnInsert } from "./range";
+/**
+ * Apply an insert or delete range adjustment to a list of rules whose
+ * `ranges: SheetRange[]` field references cells. Used for tables, conditional
+ * formats, data validations, etc. Mutates the immer draft in place; rules
+ * whose ranges all collapse to nothing are spliced out.
+ *
+ * Walks `draft` from the end so splice indices don't shift mid-iteration.
+ */
+export const updateRangedRulesOnStructuralChange = (draft, op, axis, index, count, sheetId) => {
+    const updater = op === "insert" ? updateSheetRangeOnInsert : updateSheetRangeOnDelete;
+    for (let i = draft.length - 1; i >= 0; i--) {
+        const rule = draft[i];
+        const ranges = rule.ranges
+            ?.map((range) => updater(range, axis, index, count, sheetId))
+            .filter((range) => !!range) ?? [];
+        if (ranges.length) {
+            // immer's typing for nested-mutation assignment is flaky here; cast
+            // through `unknown` since the runtime shape matches the rule type.
+            rule.ranges = ranges;
+        }
+        else {
+            draft.splice(i, 1);
+        }
+    }
+};
+/**
+ * Returns true when a sheet range has any cells in the given grid bounds.
+ * Cheap pre-check used by callers to skip patch generation for sheets that
+ * have no rules touching the affected region.
+ */
+export const rangeOverlapsGrid = (range, sheetId, bounds) => {
+    if (range.sheetId !== sheetId)
+        return false;
+    return (range.startRowIndex <= bounds.endRowIndex &&
+        range.endRowIndex >= bounds.startRowIndex &&
+        range.startColumnIndex <= bounds.endColumnIndex &&
+        range.endColumnIndex >= bounds.startColumnIndex);
+};
+/**
+ * Maps an old index to its new index under the splice semantics that
+ * `useOnMoveRows` / `useOnMoveColumns` use:
+ *
+ *   `splice(firstIndex, count); splice(referenceIndex, 0, ...moved)`
+ *
+ * which lands the moved block at `[referenceIndex, referenceIndex + count
+ * - 1]` regardless of direction. Indices outside the moved block but
+ * inside the shift zone are pushed by `±count` to make room.
+ *
+ * @internal exported for testing
+ */
+export const mapMovedIndex = (index, firstIndex, lastIndex, referenceIndex) => {
+    const count = lastIndex - firstIndex + 1;
+    if (index >= firstIndex && index <= lastIndex) {
+        // Inside the moved block — translate to the destination.
+        return referenceIndex + (index - firstIndex);
+    }
+    if (referenceIndex <= firstIndex) {
+        // Moving up: rows in [refIndex, firstIndex - 1] get pushed down.
+        if (index >= referenceIndex && index < firstIndex)
+            return index + count;
+        return index;
+    }
+    // Moving down (referenceIndex > lastIndex): rows in [lastIndex + 1,
+    // referenceIndex + count - 1] get pushed up.
+    if (index > lastIndex && index < referenceIndex + count) {
+        return index - count;
+    }
+    return index;
+};
+/**
+ * Apply a row/column reorder to a list of rules whose `ranges:
+ * SheetRange[]` field references cells. Used for conditional formats,
+ * data validations, etc. Mutates the immer draft in place.
+ *
+ * Strategy matches Excel's "cell tracking" semantics for single-range
+ * rules: each range's start/end corners are mapped to their new
+ * positions via `mapMovedIndex`, then the range is rebuilt as the
+ * bounding box (`min`/`max`). For ranges fully inside or fully outside
+ * the moved block this is exact; for straddling ranges it degrades to
+ * a bounding box — same as Excel for non-CF rules.
+ */
+export const updateRangedRulesOnReorder = (draft, axis, firstIndex, lastIndex, referenceIndex, sheetId, 
+/**
+ * Optional. When provided, only rule ranges whose orthogonal axis
+ * overlaps `[start, end]` are re-anchored. Used by table-column moves
+ * — the splice only affects cells inside the table's row band, so a
+ * CF/DV rule outside that band shouldn't have its columns shifted.
+ *
+ * For an `axis: "column"` move, this is the table's `[startRowIndex,
+ * endRowIndex]`; for an `axis: "row"` move, it would be column
+ * bounds (no current caller, but kept symmetric).
+ */
+orthogonalBoundary) => {
+    if (firstIndex > lastIndex)
+        return;
+    if (referenceIndex >= firstIndex && referenceIndex <= lastIndex + 1) {
+        // No-op move (destination is inside or immediately after the block).
+        return;
+    }
+    for (const rule of draft) {
+        if (!rule.ranges?.length)
+            continue;
+        const nextRanges = rule.ranges.map((range) => {
+            if (range.sheetId !== sheetId)
+                return range;
+            if (orthogonalBoundary) {
+                // Rule's orthogonal extent has to overlap the band of cells the
+                // splice actually touched; otherwise its data is untouched.
+                const orthoStart = axis === "column" ? range.startRowIndex : range.startColumnIndex;
+                const orthoEnd = axis === "column" ? range.endRowIndex : range.endColumnIndex;
+                if (orthoEnd < orthogonalBoundary.start ||
+                    orthoStart > orthogonalBoundary.end) {
+                    return range;
+                }
+            }
+            if (axis === "row") {
+                const newStart = mapMovedIndex(range.startRowIndex, firstIndex, lastIndex, referenceIndex);
+                const newEnd = mapMovedIndex(range.endRowIndex, firstIndex, lastIndex, referenceIndex);
+                return {
+                    ...range,
+                    startRowIndex: Math.min(newStart, newEnd),
+                    endRowIndex: Math.max(newStart, newEnd),
+                };
+            }
+            const newStart = mapMovedIndex(range.startColumnIndex, firstIndex, lastIndex, referenceIndex);
+            const newEnd = mapMovedIndex(range.endColumnIndex, firstIndex, lastIndex, referenceIndex);
+            return {
+                ...range,
+                startColumnIndex: Math.min(newStart, newEnd),
+                endColumnIndex: Math.max(newStart, newEnd),
+            };
+        });
+        // immer's typing for nested-mutation assignment is flaky here; cast
+        // through the rule's `ranges` shape since the runtime types match.
+        rule.ranges = nextRanges;
+    }
+};

package/dist/esm/api/range.d.ts

@@ -0,0 +1,19 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { CellCoordinate } from "@rowsncolumns/dag";
+import type { CellRange } from "@rowsncolumns/fast-formula-parser";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import type { SheetRange } from "@rowsncolumns/spreadsheet";
+export declare const iterateCellsInCellRangeWithResults: (range: CellRange, results: (string | number | boolean | Date)[][]) => Generator<readonly [number, number, string | number | boolean | Date], void, unknown>;
+export declare const iterateCellsInCellRange: (range: CellRange) => Generator<readonly [number, number], void, unknown>;
+export declare const isEqualPosition: (source: CellCoordinate, cell: CellCoordinate) => boolean;
+export declare const isSelectionRange: (rangeOrCell: GridRange | CellInterface) => rangeOrCell is GridRange;
+export declare const collisionDetection: (position: CellCoordinate, range: CellRange | undefined, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => [boolean, CellCoordinate | undefined];
+export declare const generateCollisionError: ({ rowIndex, columnIndex, }: CellCoordinate) => FormulaError;
+export declare const isEqualCellRange: (a: CellRange | undefined, b: CellRange | undefined) => boolean;
+export declare const isCellWithinCellRange: ({ rowIndex, columnIndex }: CellCoordinate, a: CellRange | undefined) => boolean;
+export declare const isEqualCellCoordinates: (pos1: CellCoordinate, pos2: CellCoordinate) => boolean;
+type RangeDimension = "row" | "column";
+export declare const updateSheetRangeOnInsert: (range: SheetRange, dimension: RangeDimension, index: number, count: number, sheetId: number) => SheetRange | null;
+export declare const updateSheetRangeOnDelete: (range: SheetRange, dimension: RangeDimension, index: number, count: number, sheetId: number) => SheetRange | null;
+export {};
+//# sourceMappingURL=range.d.ts.map

package/dist/esm/api/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../../api/range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,eAAO,MAAM,kCAAkC,GAC7C,OAAO,SAAS,EAChB,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,EAAE,0FAYhD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAc,OAAO,SAAS,wDAOjE,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,QAAQ,cAAc,EACtB,MAAM,cAAc,YAKrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,aAAa,SAAS,GAAG,aAAa,KACrC,WAAW,IAAI,SAEjB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,UAAU,cAAc,EACxB,OAAO,SAAS,GAAG,SAAS,EAC5B,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,KACtB,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,CAkCtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,4BAGpC,cAAc,iBAMd,CAAC;AAGJ,eAAO,MAAM,gBAAgB,GAC3B,GAAG,SAAS,GAAG,SAAS,EACxB,GAAG,SAAS,GAAG,SAAS,YAYzB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,2BAA2B,cAAc,EACzC,GAAG,SAAS,GAAG,SAAS,YAWzB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,MAAM,cAAc,EACpB,MAAM,cAAc,YAOrB,CAAC;AAEF,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AASvC,eAAO,MAAM,wBAAwB,GACnC,OAAO,UAAU,EACjB,WAAW,cAAc,EACzB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,KACd,UAAU,GAAG,IAyBf,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,OAAO,UAAU,EACjB,WAAW,cAAc,EACzB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,KACd,UAAU,GAAG,IA0Cf,CAAC"}