@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,278 @@
+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 const deleteTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }) => {
+    return (tableView, rowIndexes) => {
+        const { sheetId } = tableView;
+        rowIndexes = rowIndexes.sort((a, b) => a - b);
+        const saveHistory = createHistory();
+        const { 0: minRowIndex, [rowIndexes.length - 1]: maxRowIndex } = rowIndexes;
+        const count = rowIndexes.length;
+        enqueueStructureChange?.({
+            kind: "delete-table-row",
+            sheetId,
+            index: minRowIndex,
+            count,
+            rowCount,
+            startColumnIndex: tableView.range.startColumnIndex,
+            endColumnIndex: tableView.range.endColumnIndex,
+        });
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Update table position
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    const startRowIndex = table.range.startRowIndex;
+                    const endRowIndex = table.range.endRowIndex;
+                    if (minRowIndex < startRowIndex) {
+                        moveFilterView(table, count, Direction.Up);
+                    }
+                    if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
+                        table.range.endRowIndex -= count;
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const rule = draft[idx];
+                    const ranges = rule.ranges
+                        ?.map((range) => updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId))
+                        .filter((range) => !!range) ?? [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const rule = draft[idx];
+                    const ranges = rule.ranges
+                        ?.map((range) => updateSheetRangeOnDelete(range, "row", minRowIndex, count, sheetId))
+                        .filter((range) => !!range) ?? [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => 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, (area) => {
+                            return (area.startColumnIndex >= tableView.range.startColumnIndex &&
+                                area.endColumnIndex <= tableView.range.endColumnIndex);
+                        });
+                    }
+                    sheet.rowCount = Math.max(1, (sheet.rowCount ?? rowCount) - count);
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const movedKeys = new Set();
+                const totalRows = draft[sheetId]?.length ?? 0;
+                const sourceRange = {
+                    ...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
+                const deletionRange = {
+                    startRowIndex: minRowIndex,
+                    endRowIndex: minRowIndex + count - 1,
+                    startColumnIndex: tableView.range.startColumnIndex,
+                    endColumnIndex: tableView.range.endColumnIndex,
+                };
+                const formulasToContract = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange: deletionRange,
+                    getDependents,
+                });
+                const sheetCell = new SheetCell();
+                for (const pos of formulasToContract.values()) {
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    if (!cellData)
+                        continue;
+                    // Check if cell has a formula
+                    sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale });
+                    const formulaValue = sheetCell.formula;
+                    if (formulaValue) {
+                        const activeSheetName = getSheetName(pos.sheetId);
+                        const 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)
+                            const adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex > maxRowIndex
+                                ? pos.rowIndex - count
+                                : pos.rowIndex;
+                            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,
+                            });
+                        }
+                    }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                const dependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                for (const pos of dependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        activeSheetName: getSheetName(pos.sheetId),
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: -count,
+                        columnDelta: 0,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (let rowIndex = minRowIndex; rowIndex <= tableView.range.endRowIndex; rowIndex++) {
+                    const rowValues = draft[sheetId]?.[rowIndex]?.values;
+                    if (!rowValues) {
+                        continue;
+                    }
+                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        const cellData = rowValues?.[columnIndex];
+                        const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                        if (!hasFormula) {
+                            continue;
+                        }
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: -count,
+                            columnDelta: 0,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                }
+                // Shift values up inside the table range
+                for (let rowIndex = minRowIndex; rowIndex < totalRows; rowIndex++) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        currentSheet[rowIndex].values[columnIndex] =
+                            currentSheet[rowIndex + count]?.values?.[columnIndex];
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/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/esm/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/esm/interface/duplicate-sheet.js

@@ -0,0 +1,206 @@
+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 const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrategy, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeEmbeds, onChangeConditionalFormats, onChangeDataValidations, enqueueGraphOperation, createHistory, generatedNames, }) => {
+    return (sheetId, newSheetIdDefinedByUser) => {
+        const saveHistory = createHistory();
+        // Track the newSheetId that gets generated inside produceWithPatches
+        let finalNewSheetId;
+        // Add sheet
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (!sheet) {
+                    return;
+                }
+                // Generate unique sheetId using the CURRENT draft state
+                let newSheetId = newSheetIdDefinedByUser ?? idCreationStrategy?.("sheet") ?? uuid();
+                const existingIds = new Set(draft.map((s) => s.sheetId));
+                // If ID already exists, generate a new one
+                while (existingIds.has(newSheetId)) {
+                    newSheetId = idCreationStrategy?.("sheet") ?? uuid();
+                }
+                // Generate unique title using the CURRENT draft state
+                const existingTitles = draft.map((s) => s.title);
+                const newTitle = generateUniqueSheetName(existingTitles, sheet.title, generatedNames);
+                /* Update the sheet title */
+                const newSheet = {
+                    ...sheet,
+                    sheetId: newSheetId,
+                    title: newTitle,
+                };
+                draft.push(castDraft(newSheet));
+                finalNewSheetId = newSheetId;
+            });
+            // Save history only if a sheet was duplicated
+            if (finalNewSheetId !== undefined) {
+                saveHistory({
+                    sheets: { patches, inversePatches },
+                    sheetId: { undo: sheetId, redo: finalNewSheetId },
+                });
+            }
+            return nextState;
+        });
+        // Copy sheetdata - only if sheet was duplicated
+        if (finalNewSheetId === undefined) {
+            return undefined;
+        }
+        const newSheetId = finalNewSheetId;
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Clone the sheet
+                draft[newSheetId] = draft[sheetId]
+                    ? JSON.parse(JSON.stringify(draft[sheetId]))
+                    : undefined;
+                const sheetCell = new SheetCell();
+                for (const row in draft[sheetId]) {
+                    for (const col in draft[sheetId][row]?.values ?? []) {
+                        const rowIndex = Number(row);
+                        const columnIndex = Number(col);
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                        // Create a cell
+                        sheetCell.assign(newSheetId, { rowIndex, columnIndex }, cellData, { locale });
+                        if (sheetCell.isFormula()) {
+                            enqueueGraphOperation({
+                                type: "add",
+                                position: {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId: newSheetId,
+                                },
+                            });
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update tables
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const currentTables = draft.filter((table) => table.sheetId === sheetId);
+                draft.push(...currentTables.map((table, index) => ({
+                    ...table,
+                    title: `${table.title}${index + 1}`,
+                    id: idCreationStrategy?.("table") ?? uuid(),
+                    sheetId: newSheetId,
+                })));
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Check if there are charts
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                const current = draft.filter((chart) => chart.position.sheetId === sheetId);
+                draft.push(...current.map((chart) => ({
+                    ...chart,
+                    chartId: idCreationStrategy?.("chart") ?? uuid(),
+                    position: {
+                        ...chart.position,
+                        sheetId: newSheetId,
+                    },
+                })));
+            });
+            // Save history
+            saveHistory({
+                charts: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Check if there are embeds
+        onChangeEmbeds?.((prevEmbeds) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                const current = draft.filter((embed) => embed.position.sheetId === sheetId);
+                draft.push(...current.map((embed) => ({
+                    ...embed,
+                    embedId: idCreationStrategy?.("embed") ?? uuid(),
+                    position: {
+                        ...embed.position,
+                        sheetId: newSheetId,
+                    },
+                })));
+            });
+            // Save history
+            saveHistory({
+                embeds: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formatting
+        onChangeConditionalFormats?.((prevEmbeds) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                for (const rule of draft) {
+                    // Update ranges and append new sheet
+                    const newRanges = rule.ranges;
+                    for (const range of rule.ranges) {
+                        if (range.sheetId === sheetId) {
+                            newRanges.push({
+                                ...range,
+                                sheetId: newSheetId,
+                            });
+                        }
+                    }
+                    rule.ranges = newRanges;
+                }
+            });
+            // Save history
+            saveHistory({
+                conditionalFormats: { patches, 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?.((prevRules) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRules, (draft) => {
+                for (const rule of draft) {
+                    const newRanges = rule.ranges;
+                    for (const range of rule.ranges) {
+                        if (range.sheetId === sheetId) {
+                            newRanges.push({
+                                ...range,
+                                sheetId: newSheetId,
+                            });
+                        }
+                    }
+                    rule.ranges = newRanges;
+                }
+            });
+            // Save history
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update active sheet
+        return newSheetId;
+    };
+};
+/**
+ * Generate unique sheetname
+ * @param existingSheets
+ * @param originalName
+ * @returns
+ */
+function generateUniqueSheetName(existingSheets, originalName, generatedNames) {
+    const baseName = getGeneratedSheetCopyName(originalName, generatedNames);
+    let newName = baseName;
+    let counter = 0;
+    while (existingSheets.includes(newName)) {
+        counter++;
+        newName = counter === 1 ? baseName : `${baseName} ${counter - 1}`;
+    }
+    return newName;
+}

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

package/dist/esm/interface/embeds.js

@@ -0,0 +1,115 @@
+import { DEFAULT_ACTIVE_CELL } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+const DEFAULT_OVERLAY_POSITION = {
+    anchorCell: DEFAULT_ACTIVE_CELL,
+    heightPixels: 400,
+    widthPixels: 400,
+};
+export const deleteEmbed = ({ onChangeEmbeds, createHistory, }) => {
+    return (embedId) => {
+        const saveHistory = createHistory();
+        onChangeEmbeds?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                const embedIndex = draft.findIndex((chart) => chart.embedId === embedId);
+                if (embedIndex !== -1) {
+                    draft.splice(embedIndex, 1);
+                }
+            });
+            saveHistory({
+                embeds: { patches, inversePatches },
+                selectedEmbedOrChart: {
+                    redo: embedId,
+                    undo: undefined,
+                },
+            });
+            return nextState;
+        });
+    };
+};
+export const updateEmbed = ({ onChangeEmbeds, createHistory, }) => {
+    return (embed) => {
+        const saveHistory = createHistory();
+        onChangeEmbeds?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                const embedIndex = draft.findIndex((chart) => chart.embedId === embed.embedId);
+                if (embedIndex !== -1) {
+                    draft[embedIndex] = embed;
+                }
+            });
+            saveHistory({
+                embeds: { patches, inversePatches },
+                selectedEmbedOrChart: {
+                    redo: embed.embedId,
+                    undo: undefined,
+                },
+            });
+            return nextState;
+        });
+    };
+};
+export const moveEmbed = ({ onChangeEmbeds, createHistory, }) => {
+    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) => {
+        const saveHistory = createHistory();
+        onChangeEmbeds?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                const embed = draft.find((chart) => chart.embedId === embedId);
+                if (embed) {
+                    if (typeof embed.position !== "object") {
+                        embed.position = {
+                            overlayPosition: { ...DEFAULT_OVERLAY_POSITION },
+                            sheetId,
+                        };
+                    }
+                    embed.position.overlayPosition.anchorCell = anchorCell;
+                    embed.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    embed.position.overlayPosition.offsetYPixels = offsetYPixels;
+                }
+            });
+            saveHistory({
+                embeds: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const resizeEmbed = ({ onChangeEmbeds, createHistory, }) => {
+    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) => {
+        const saveHistory = createHistory();
+        onChangeEmbeds?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                const embed = draft.find((chart) => chart.embedId === embedId);
+                if (embed) {
+                    if (typeof embed.position !== "object") {
+                        embed.position = {
+                            overlayPosition: { ...DEFAULT_OVERLAY_POSITION },
+                            sheetId,
+                        };
+                    }
+                    embed.position.overlayPosition.anchorCell = anchorCell;
+                    embed.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    embed.position.overlayPosition.offsetYPixels = offsetYPixels;
+                    embed.position.overlayPosition.widthPixels = width;
+                    embed.position.overlayPosition.heightPixels = height;
+                }
+            });
+            saveHistory({
+                embeds: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const createEmbed = ({ onChangeEmbeds, createHistory, }) => {
+    return (spec) => {
+        const saveHistory = createHistory();
+        onChangeEmbeds?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                draft.push(spec);
+            });
+            saveHistory({
+                embeds: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/freeze.d.ts

@@ -0,0 +1,5 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnFreezeProps } from "../hooks/use-on-freeze";
+export declare const freezeRow: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onChangeEmbeds, onChangeCharts, }: UseOnFreezeProps<T, S>) => (sheetId: number, rowIndex: number) => void;
+export declare const freezeColumn: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onChangeEmbeds, onChangeCharts, }: UseOnFreezeProps<T, S>) => (sheetId: number, columnIndex: number) => void;
+//# sourceMappingURL=freeze.d.ts.map

package/dist/esm/interface/freeze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeze.d.ts","sourceRoot":"","sources":["../../../interface/freeze.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,KAAK,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAO,MAAM,SAAS,GACnB,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oEAKnC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,MACxB,SAAS,MAAM,EAAE,UAAU,MAAM,SAoEjC,CAAC;AAEJ,eAAO,MAAM,YAAY,GACtB,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oEAKnC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,MACxB,SAAS,MAAM,EAAE,aAAa,MAAM,SAsEpC,CAAC"}