@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/delete-table-row.js

@@ -0,0 +1,313 @@
+import { __assign, __read, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { contractRangesInFormula, createSheetCellIdentifier, } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+import { updateSheetRangeOnDelete } from "../api/range";
+import { moveFilterView } from "../api/selection";
+import { SheetCell } from "../sheet-cell";
+export var deleteTableRow = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getDependents = _a.getDependents, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeDataValidations = _a.onChangeDataValidations, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (tableView, rowIndexes) {
+        var sheetId = tableView.sheetId;
+        rowIndexes = rowIndexes.sort(function (a, b) { return a - b; });
+        var saveHistory = createHistory();
+        var _a = rowIndexes, minRowIndex = _a[0], _b = rowIndexes.length - 1, maxRowIndex = _a[_b];
+        var count = rowIndexes.length;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "delete-table-row",
+            sheetId: sheetId,
+            index: minRowIndex,
+            count: count,
+            rowCount: rowCount,
+            startColumnIndex: tableView.range.startColumnIndex,
+            endColumnIndex: tableView.range.endColumnIndex,
+        });
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Update table position
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_1, _a;
+                try {
+                    for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                        var table = draft_1_1.value;
+                        var startRowIndex = table.range.startRowIndex;
+                        var endRowIndex = table.range.endRowIndex;
+                        if (minRowIndex < startRowIndex) {
+                            moveFilterView(table, count, Direction.Up);
+                        }
+                        if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
+                            table.range.endRowIndex -= count;
+                        }
+                    }
+                }
+                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; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                var _a, _b;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var rule = draft[idx];
+                    var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) {
+                        return updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId);
+                    }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                var _a, _b;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var rule = draft[idx];
+                    var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) {
+                        return updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId);
+                    }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (sheet.rowMetadata) {
+                        sheet.rowMetadata.splice(minRowIndex, count);
+                    }
+                    if (sheet.basicFilter) {
+                        if (minRowIndex < sheet.basicFilter.range.startRowIndex) {
+                            moveFilterView(sheet.basicFilter, count, Direction.Up);
+                        }
+                        if (minRowIndex > sheet.basicFilter.range.startRowIndex &&
+                            minRowIndex <= sheet.basicFilter.range.endRowIndex) {
+                            sheet.basicFilter.range.endRowIndex -= count;
+                        }
+                    }
+                    if (sheet.merges) {
+                        sheet.merges = moveMergedCells(sheet.merges, "row-remove", minRowIndex, count, function (area) {
+                            return (area.startColumnIndex >= tableView.range.startColumnIndex &&
+                                area.endColumnIndex <= tableView.range.endColumnIndex);
+                        });
+                    }
+                    sheet.rowCount = Math.max(1, ((_a = sheet.rowCount) !== null && _a !== void 0 ? _a : rowCount) - count);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a, e_3, _b;
+                var _c, _d, _e, _f, _g, _h, _j, _k;
+                var movedKeys = new Set();
+                var totalRows = (_d = (_c = draft[sheetId]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+                var sourceRange = __assign(__assign({}, tableView.range), { startRowIndex: maxRowIndex + 1 });
+                /**
+                 * THREE-PASS FORMULA UPDATE STRATEGY FOR DELETION:
+                 *
+                 * PASS 1 (lines below): Contract ranges when deletion overlaps with them
+                 *   Example: Delete table row 5, =SUM(A1:A10) → =SUM(A1:A9)
+                 *   Uses dependency graph to find only formulas that reference the deletion range (efficient!)
+                 *
+                 * PASS 2 (after this loop): Shift references in formulas that DEPEND ON the moved cells
+                 *   Example: If A10 is moved to A9, formulas referencing A10 must update
+                 *   Uses dependency graph to find only affected formulas (efficient)
+                 *
+                 * PASS 3 (final loop): Shift references in formulas WITHIN the moved cells themselves
+                 *   Example: If A11 contains =A1+A2 and moves to A10, references stay the same
+                 *   But if it contains =A15, it needs adjustment based on sourceRange exclusion
+                 *
+                 * The 'movedKeys' Set ensures no formula is processed twice across passes 2 & 3.
+                 * Range contraction (Pass 1) doesn't interfere with reference shifting (Pass 2 & 3).
+                 */
+                // PASS 1: Contract ranges using dependency graph (OPTIMIZED!)
+                // Collect formulas that reference cells in the deletion range
+                var deletionRange = {
+                    startRowIndex: minRowIndex,
+                    endRowIndex: minRowIndex + count - 1,
+                    startColumnIndex: tableView.range.startColumnIndex,
+                    endColumnIndex: tableView.range.endColumnIndex,
+                };
+                var formulasToContract = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: deletionRange,
+                    getDependents: getDependents,
+                });
+                var sheetCell = new SheetCell();
+                try {
+                    for (var _l = __values(formulasToContract.values()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                        var pos = _m.value;
+                        var currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                        var cellData = (_f = (_e = currentSheet[pos.rowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[pos.columnIndex];
+                        if (!cellData)
+                            continue;
+                        // Check if cell has a formula
+                        sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale: locale });
+                        var formulaValue = sheetCell.formula;
+                        if (formulaValue) {
+                            var activeSheetName = getSheetName(pos.sheetId);
+                            var contractedFormula = contractRangesInFormula(formulaValue, minRowIndex, count, "row", activeSheetName);
+                            // Update the formula if it changed
+                            if (contractedFormula && contractedFormula !== formulaValue) {
+                                // Preserve stale effective value until recalculation completes
+                                sheetCell.setFormulaValue(contractedFormula, false);
+                                currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                                    sheetCell.getCellData();
+                                // Adjust row index for formulas below the deleted range
+                                // (they will shift up by `count` after the splice)
+                                var adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex > maxRowIndex
+                                    ? pos.rowIndex - count
+                                    : pos.rowIndex;
+                                enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : enqueueCalculation({
+                                    type: "add",
+                                    position: {
+                                        sheetId: pos.sheetId,
+                                        rowIndex: adjustedRowIndex,
+                                        columnIndex: pos.columnIndex,
+                                    },
+                                    force: true,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, pos.columnIndex), {
+                                    sheetId: pos.sheetId,
+                                    rowIndex: adjustedRowIndex,
+                                    columnIndex: pos.columnIndex,
+                                    force: true,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                var dependents = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: sourceRange,
+                    getDependents: getDependents,
+                });
+                try {
+                    for (var _o = __values(dependents.values()), _p = _o.next(); !_p.done; _p = _o.next()) {
+                        var pos = _p.value;
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: pos,
+                            activeSheetName: getSheetName(pos.sheetId),
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (var rowIndex = minRowIndex; rowIndex <= tableView.range.endRowIndex; rowIndex++) {
+                    var rowValues = (_h = (_g = draft[sheetId]) === null || _g === void 0 ? void 0 : _g[rowIndex]) === null || _h === void 0 ? void 0 : _h.values;
+                    if (!rowValues) {
+                        continue;
+                    }
+                    for (var columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        var cellData = rowValues === null || rowValues === void 0 ? void 0 : rowValues[columnIndex];
+                        var hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                        if (!hasFormula) {
+                            continue;
+                        }
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                // Shift values up inside the table range
+                for (var rowIndex = minRowIndex; rowIndex < totalRows; rowIndex++) {
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (var columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        currentSheet[rowIndex].values[columnIndex] =
+                            (_k = (_j = currentSheet[rowIndex + count]) === null || _j === void 0 ? void 0 : _j.values) === null || _k === void 0 ? void 0 : _k[columnIndex];
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/interface/duplicate-sheet.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnDuplicateSheetProps } from "../hooks/use-on-duplicate-sheet";
+export declare const duplicateSheet: <T extends CellData, S extends Sheet>({ locale, maxSheetCount, sheets, idCreationStrategy, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeEmbeds, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, createHistory, generatedNames, }: UseOnDuplicateSheetProps<T, S>) => (sheetId: number, newSheetIdDefinedByUser?: number) => number | undefined;
+//# sourceMappingURL=duplicate-sheet.d.ts.map

package/dist/cjs/interface/duplicate-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-sheet.d.ts","sourceRoot":"","sources":["../../../interface/duplicate-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAc,MAAM,2BAA2B,CAAC;AAO7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sPAejE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,SAAS,MAAM,EAAE,0BAA0B,MAAM,uBAmQ1D,CAAC"}

package/dist/cjs/interface/duplicate-sheet.js

@@ -0,0 +1,232 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { uuid } from "@rowsncolumns/utils";
+import { castDraft, produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { getGeneratedSheetCopyName } from "../generated-names";
+import { SheetCell } from "../sheet-cell";
+export var duplicateSheet = function (_a) {
+    var locale = _a.locale, maxSheetCount = _a.maxSheetCount, sheets = _a.sheets, idCreationStrategy = _a.idCreationStrategy, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeCharts = _a.onChangeCharts, onChangeEmbeds = _a.onChangeEmbeds, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, generatedNames = _a.generatedNames;
+    return function (sheetId, newSheetIdDefinedByUser) {
+        var saveHistory = createHistory();
+        // Track the newSheetId that gets generated inside produceWithPatches
+        var finalNewSheetId;
+        // Add sheet
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a, _b;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (!sheet) {
+                    return;
+                }
+                // Generate unique sheetId using the CURRENT draft state
+                var newSheetId = (_a = newSheetIdDefinedByUser !== null && newSheetIdDefinedByUser !== void 0 ? newSheetIdDefinedByUser : idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("sheet")) !== null && _a !== void 0 ? _a : uuid();
+                var existingIds = new Set(draft.map(function (s) { return s.sheetId; }));
+                // If ID already exists, generate a new one
+                while (existingIds.has(newSheetId)) {
+                    newSheetId = (_b = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("sheet")) !== null && _b !== void 0 ? _b : uuid();
+                }
+                // Generate unique title using the CURRENT draft state
+                var existingTitles = draft.map(function (s) { return s.title; });
+                var newTitle = generateUniqueSheetName(existingTitles, sheet.title, generatedNames);
+                /* Update the sheet title */
+                var newSheet = __assign(__assign({}, sheet), { sheetId: newSheetId, title: newTitle });
+                draft.push(castDraft(newSheet));
+                finalNewSheetId = newSheetId;
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history only if a sheet was duplicated
+            if (finalNewSheetId !== undefined) {
+                saveHistory({
+                    sheets: { patches: patches, inversePatches: inversePatches },
+                    sheetId: { undo: sheetId, redo: finalNewSheetId },
+                });
+            }
+            return nextState;
+        });
+        // Copy sheetdata - only if sheet was duplicated
+        if (finalNewSheetId === undefined) {
+            return undefined;
+        }
+        var newSheetId = finalNewSheetId;
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a, _b, _c;
+                // Clone the sheet
+                draft[newSheetId] = draft[sheetId]
+                    ? JSON.parse(JSON.stringify(draft[sheetId]))
+                    : undefined;
+                var sheetCell = new SheetCell();
+                for (var row in draft[sheetId]) {
+                    for (var col in (_b = (_a = draft[sheetId][row]) === null || _a === void 0 ? void 0 : _a.values) !== null && _b !== void 0 ? _b : []) {
+                        var rowIndex = Number(row);
+                        var columnIndex = Number(col);
+                        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        var cellData = (_c = currentSheet[rowIndex].values) === null || _c === void 0 ? void 0 : _c[columnIndex];
+                        // Create a cell
+                        sheetCell.assign(newSheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale });
+                        if (sheetCell.isFormula()) {
+                            enqueueGraphOperation({
+                                type: "add",
+                                position: {
+                                    rowIndex: rowIndex,
+                                    columnIndex: columnIndex,
+                                    sheetId: newSheetId,
+                                },
+                            });
+                        }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update tables
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var currentTables = draft.filter(function (table) { return table.sheetId === sheetId; });
+                draft.push.apply(draft, __spreadArray([], __read(currentTables.map(function (table, index) {
+                    var _a;
+                    return (__assign(__assign({}, table), { title: "".concat(table.title).concat(index + 1), id: (_a = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("table")) !== null && _a !== void 0 ? _a : uuid(), sheetId: newSheetId }));
+                })), false));
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Check if there are charts
+        onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var current = draft.filter(function (chart) { return chart.position.sheetId === sheetId; });
+                draft.push.apply(draft, __spreadArray([], __read(current.map(function (chart) {
+                    var _a;
+                    return (__assign(__assign({}, chart), { chartId: (_a = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("chart")) !== null && _a !== void 0 ? _a : uuid(), position: __assign(__assign({}, chart.position), { sheetId: newSheetId }) }));
+                })), false));
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                charts: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Check if there are embeds
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevEmbeds) {
+            var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                var current = draft.filter(function (embed) { return embed.position.sheetId === sheetId; });
+                draft.push.apply(draft, __spreadArray([], __read(current.map(function (embed) {
+                    var _a;
+                    return (__assign(__assign({}, embed), { embedId: (_a = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("embed")) !== null && _a !== void 0 ? _a : uuid(), position: __assign(__assign({}, embed.position), { sheetId: newSheetId }) }));
+                })), false));
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formatting
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevEmbeds) {
+            var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                var e_1, _a, e_2, _b;
+                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;
+                        // Update ranges and append new sheet
+                        var newRanges = rule.ranges;
+                        try {
+                            for (var _c = (e_2 = void 0, __values(rule.ranges)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                var range = _d.value;
+                                if (range.sheetId === sheetId) {
+                                    newRanges.push(__assign(__assign({}, range), { sheetId: newSheetId }));
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        rule.ranges = newRanges;
+                    }
+                }
+                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; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update data validations — copy the source sheet's rule ranges onto the
+        // new sheet (mirrors the conditional-format remap above). Without this,
+        // duplicating a sheet silently dropped all of its validations.
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevRules) {
+            var _a = __read(produceWithPatches(prevRules, function (draft) {
+                var e_3, _a, e_4, _b;
+                try {
+                    for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
+                        var rule = draft_2_1.value;
+                        var newRanges = rule.ranges;
+                        try {
+                            for (var _c = (e_4 = void 0, __values(rule.ranges)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                var range = _d.value;
+                                if (range.sheetId === sheetId) {
+                                    newRanges.push(__assign(__assign({}, range), { sheetId: newSheetId }));
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        rule.ranges = newRanges;
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update active sheet
+        return newSheetId;
+    };
+};
+/**
+ * Generate unique sheetname
+ * @param existingSheets
+ * @param originalName
+ * @returns
+ */
+function generateUniqueSheetName(existingSheets, originalName, generatedNames) {
+    var baseName = getGeneratedSheetCopyName(originalName, generatedNames);
+    var newName = baseName;
+    var counter = 0;
+    while (existingSheets.includes(newName)) {
+        counter++;
+        newName = counter === 1 ? baseName : "".concat(baseName, " ").concat(counter - 1);
+    }
+    return newName;
+}

package/dist/cjs/interface/embeds.d.ts

@@ -0,0 +1,9 @@
+import type { EmbeddedObject } from "@rowsncolumns/spreadsheet";
+import { type CanvasGridProps, type CellData } from "@rowsncolumns/spreadsheet";
+import type { UseOnEmbedsProps } from "../hooks/use-on-embeds";
+export declare const deleteEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId">) => (embedId: EmbeddedObject["embedId"]) => void;
+export declare const updateEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId">) => (embed: EmbeddedObject) => void;
+export declare const moveEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: UseOnEmbedsProps<T>) => NonNullable<CanvasGridProps["onMoveEmbed"]>;
+export declare const resizeEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: UseOnEmbedsProps<T>) => NonNullable<CanvasGridProps["onResizeEmbed"]>;
+export declare const createEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId">) => (spec: EmbeddedObject) => void;
+//# sourceMappingURL=embeds.d.ts.map

package/dist/cjs/interface/embeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeds.d.ts","sourceRoot":"","sources":["../../../interface/embeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAQ/D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,SAAS,cAAc,CAAC,SAAS,CAAC,SA0B3C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,OAAO,cAAc,SA0B9B,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG3C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,CA6BlE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,eAAe,CAAC,CAuCpE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,MAAM,cAAc,SAiB7B,CAAC"}