@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/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/cjs/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/cjs/api/patches.js

@@ -0,0 +1,218 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+// 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
+var REPLACE = "replace";
+var ADD = "add";
+var 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 __spreadArray([], __read(value), false);
+    }
+    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 __assign({}, value);
+}
+/**
+ * Throw an error similar to Immer's die function
+ */
+function die(errorCode, details) {
+    throw new Error("[PurePatches] error ".concat(errorCode).concat(details ? ": ".concat(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) {
+    var e_1, _a;
+    // If no patches, return original state
+    if (!patches.length)
+        return state;
+    // Clone the top level of the state to avoid direct mutations
+    var result = shallowClone(state);
+    try {
+        // Apply each patch
+        for (var patches_1 = __values(patches), patches_1_1 = patches_1.next(); !patches_1_1.done; patches_1_1 = patches_1.next()) {
+            var patch = patches_1_1.value;
+            var path = patch.path, op = patch.op, value = patch.value;
+            // 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
+            var current = result;
+            var parent_1 = null;
+            var parentKey = null;
+            var pathLen = path.length;
+            var lastIndex = pathLen - 1;
+            // Create a copy of the path to the modified object
+            for (var i = 0; i < lastIndex; i++) {
+                var p = path[i];
+                // Convert path elements to strings if needed
+                if (typeof p !== "string" && typeof p !== "number") {
+                    p = String(p);
+                }
+                // Protection against prototype pollution
+                var 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
+                var next = current[p];
+                // If path doesn't exist or isn't an object, create it
+                if (next === undefined || next === null || typeof next !== "object") {
+                    var nextKey = i < lastIndex - 1 ? path[i + 1] : null;
+                    var 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_1 !== null && current === parent_1[parentKey]) {
+                        current = parent_1[parentKey] = shallowClone(current);
+                    }
+                    // Set the new object/array
+                    current[p] = next;
+                }
+                // Clone the next object if needed
+                else if (i < lastIndex - 1) {
+                    var clonedNext = shallowClone(next);
+                    if (next !== clonedNext) {
+                        current[p] = clonedNext;
+                        next = clonedNext;
+                    }
+                }
+                // Update references for next iteration
+                parent_1 = current;
+                parentKey = p;
+                current = next;
+            }
+            // Get the final key
+            var 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_1 !== null && current === parent_1[parentKey]) {
+                current = parent_1[parentKey] = shallowClone(current);
+            }
+            // Apply operation based on the architecture type
+            var 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 {
+                                var numericKey = Number(key);
+                                if (isNaN(numericKey)) {
+                                    die(4, "Cannot add non-numeric index ".concat(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: {
+                            var numericKey = Number(key);
+                            if (isNaN(numericKey)) {
+                                die(5, "Cannot remove non-numeric index ".concat(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: ".concat(op));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (patches_1_1 && !patches_1_1.done && (_a = patches_1.return)) _a.call(patches_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}

package/dist/cjs/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/cjs/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/cjs/api/pivot-range.js

@@ -0,0 +1,130 @@
+import { __assign, __read, __values } from "tslib";
+import { areaInsideArea } from "@rowsncolumns/grid";
+import { moveRange } from "./selection";
+import { updateSheetRangeOnDelete } from "./range";
+var getDimensionKeys = function (dimension) {
+    return dimension === "row"
+        ? ["startRowIndex", "endRowIndex"]
+        : ["startColumnIndex", "endColumnIndex"];
+};
+var shiftCoordinate = function (coordinate, sheetId, dimension, delta, fromIndex) {
+    if (!coordinate || coordinate.sheetId !== sheetId)
+        return;
+    var 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.
+var shiftRangeOnInsert = function (range, sheetId, dimension, index, count) {
+    var _a, _b;
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    var _c = __read(getDimensionKeys(dimension), 2), startKey = _c[0], endKey = _c[1];
+    var start = range[startKey];
+    var end = range[endKey];
+    if (index <= start) {
+        return __assign(__assign({}, range), (_a = {}, _a[startKey] = start + count, _a[endKey] = end + count, _a));
+    }
+    if (index <= end) {
+        return __assign(__assign({}, range), (_b = {}, _b[endKey] = end + count, _b));
+    }
+    return range;
+};
+var shiftRangeOnDelete = function (range, sheetId, dimension, index, count) {
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    var next = updateSheetRangeOnDelete(range, dimension, index, count, sheetId);
+    return next !== null && next !== void 0 ? next : undefined;
+};
+export var shiftPivotsOnInsert = function (draft, sheetId, dimension, index, count) {
+    var e_1, _a;
+    if (count <= 0)
+        return;
+    try {
+        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+            var pivot = draft_1_1.value;
+            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);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};
+export var shiftPivotsOnDelete = function (draft, sheetId, dimension, index, count) {
+    var e_2, _a;
+    if (count <= 0)
+        return;
+    var deleteEnd = index + count - 1;
+    var key = dimension === "row" ? "rowIndex" : "columnIndex";
+    try {
+        for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
+            var pivot = draft_2_1.value;
+            pivot.source = shiftRangeOnDelete(pivot.source, sheetId, dimension, index, count);
+            pivot.pivotRange = shiftRangeOnDelete(pivot.pivotRange, sheetId, dimension, index, count);
+            var 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);
+                }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+};
+var moveRangeIfInside = function (range, sheetId, from, to) {
+    if (!range || range.sheetId !== sheetId)
+        return range;
+    if (!areaInsideArea(range, from))
+        return range;
+    return moveRange(range, from, to);
+};
+export var shiftPivotsOnMove = function (draft, sheetId, from, to) {
+    var e_3, _a;
+    var rowDelta = to.startRowIndex - from.startRowIndex;
+    var columnDelta = to.startColumnIndex - from.startColumnIndex;
+    try {
+        for (var draft_3 = __values(draft), draft_3_1 = draft_3.next(); !draft_3_1.done; draft_3_1 = draft_3.next()) {
+            var pivot = draft_3_1.value;
+            pivot.source = moveRangeIfInside(pivot.source, sheetId, from, to);
+            pivot.pivotRange = moveRangeIfInside(pivot.pivotRange, sheetId, from, to);
+            var 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;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (draft_3_1 && !draft_3_1.done && (_a = draft_3.return)) _a.call(draft_3);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+};

package/dist/cjs/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/cjs/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/cjs/api/range-rule-helpers.js

@@ -0,0 +1,142 @@
+import { __assign, __values } from "tslib";
+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 var updateRangedRulesOnStructuralChange = function (draft, op, axis, index, count, sheetId) {
+    var _a, _b;
+    var updater = op === "insert" ? updateSheetRangeOnInsert : updateSheetRangeOnDelete;
+    for (var i = draft.length - 1; i >= 0; i--) {
+        var rule = draft[i];
+        var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) { return updater(range, axis, index, count, sheetId); }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+        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 var rangeOverlapsGrid = function (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 var mapMovedIndex = function (index, firstIndex, lastIndex, referenceIndex) {
+    var 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 var updateRangedRulesOnReorder = function (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) {
+    var e_1, _a;
+    var _b;
+    if (firstIndex > lastIndex)
+        return;
+    if (referenceIndex >= firstIndex && referenceIndex <= lastIndex + 1) {
+        // No-op move (destination is inside or immediately after the block).
+        return;
+    }
+    try {
+        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+            var rule = draft_1_1.value;
+            if (!((_b = rule.ranges) === null || _b === void 0 ? void 0 : _b.length))
+                continue;
+            var nextRanges = rule.ranges.map(function (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.
+                    var orthoStart = axis === "column" ? range.startRowIndex : range.startColumnIndex;
+                    var orthoEnd = axis === "column" ? range.endRowIndex : range.endColumnIndex;
+                    if (orthoEnd < orthogonalBoundary.start ||
+                        orthoStart > orthogonalBoundary.end) {
+                        return range;
+                    }
+                }
+                if (axis === "row") {
+                    var newStart_1 = mapMovedIndex(range.startRowIndex, firstIndex, lastIndex, referenceIndex);
+                    var newEnd_1 = mapMovedIndex(range.endRowIndex, firstIndex, lastIndex, referenceIndex);
+                    return __assign(__assign({}, range), { startRowIndex: Math.min(newStart_1, newEnd_1), endRowIndex: Math.max(newStart_1, newEnd_1) });
+                }
+                var newStart = mapMovedIndex(range.startColumnIndex, firstIndex, lastIndex, referenceIndex);
+                var newEnd = mapMovedIndex(range.endColumnIndex, firstIndex, lastIndex, referenceIndex);
+                return __assign(__assign({}, 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;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};

package/dist/cjs/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/cjs/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"}