@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/new-sheet.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnCreateSheetProps } from "../hooks/use-on-create-sheet";
+export declare const createNewSheet: <T extends CellData, S extends Sheet>({ sheetId, maxSheetCount, sheets, maxRowCount, maxColumnCount, idCreationStrategy, onChangeSheets, onChangeActiveSheet, createHistory, generatedNames, }: UseOnCreateSheetProps<T, S>) => (sheetSpec?: Partial<Sheet>) => S;
+//# sourceMappingURL=new-sheet.d.ts.map

package/dist/esm/interface/new-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-sheet.d.ts","sourceRoot":"","sources":["../../../interface/new-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAUjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,0JAWjE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,YAAY,OAAO,CAAC,KAAK,CAAC,KA6HT,CAE1B,CAAC"}

package/dist/esm/interface/new-sheet.js

@@ -0,0 +1,102 @@
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { getGeneratedSheetName } from "../generated-names";
+import { MAX_SHEET_TITLE_LENGTH, truncateSheetTitle, } from "../helpers/sheet-title";
+const createNewSheetHelper = (sheetId, title, rowCount = 1000, columnCount = 100, hidden = false) => ({
+    title,
+    sheetId,
+    rowCount,
+    columnCount,
+    hidden,
+    merges: [],
+    columnMetadata: [],
+    rowMetadata: [],
+});
+export const createNewSheet = ({ sheetId, maxSheetCount, sheets, maxRowCount, maxColumnCount, idCreationStrategy, onChangeSheets, onChangeActiveSheet, createHistory, generatedNames, }) => {
+    return (sheetSpec) => {
+        const saveHistory = createHistory();
+        let createdSheet;
+        // Move ALL uniqueness logic inside produceWithPatches to use the latest draft state
+        // This ensures concurrent calls see each other's changes
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                // Generate unique sheetId using the CURRENT draft state
+                let newSheetId = sheetSpec?.sheetId ?? 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();
+                }
+                // Check if this exact sheet already exists (by ID)
+                if (sheetSpec?.sheetId && existingIds.has(sheetSpec.sheetId)) {
+                    createdSheet = draft.find((s) => s.sheetId === sheetSpec.sheetId);
+                    return; // Don't add duplicate
+                }
+                // Generate unique title using the CURRENT draft state
+                const baseTitle = truncateSheetTitle(sheetSpec?.title ||
+                    getGeneratedSheetName(draft.length + 1, generatedNames));
+                let finalTitle = baseTitle;
+                let counter = 1;
+                const existingTitles = new Set(draft.map((s) => s.title));
+                while (existingTitles.has(finalTitle)) {
+                    const suffix = `${counter}`;
+                    const titlePrefix = baseTitle.slice(0, Math.max(0, MAX_SHEET_TITLE_LENGTH - suffix.length));
+                    finalTitle = `${titlePrefix}${suffix}`;
+                    counter++;
+                }
+                // Create the new sheet
+                const newSheet = createNewSheetHelper(newSheetId, finalTitle, sheetSpec?.rowCount ?? maxRowCount, sheetSpec?.columnCount ?? maxColumnCount, sheetSpec?.hidden ?? false);
+                // Determine visual insertion index (after current active sheet) without
+                // mutating existing array positions. This keeps ShareDB patches append-only.
+                const orderedSheets = draft
+                    .map((s, arrayIndex) => ({
+                    sheet: s,
+                    effectiveIndex: s.index ?? arrayIndex,
+                    arrayIndex,
+                }))
+                    .sort((a, b) => a.effectiveIndex - b.effectiveIndex ||
+                    a.arrayIndex - b.arrayIndex);
+                const activeOrderedIndex = orderedSheets.findIndex((entry) => entry.sheet.sheetId === sheetId);
+                const fallbackMaxIndex = orderedSheets.length > 0
+                    ? Math.max(...orderedSheets.map((entry) => entry.effectiveIndex))
+                    : -1;
+                const computedIndex = activeOrderedIndex === -1
+                    ? fallbackMaxIndex + 1
+                    : (() => {
+                        const currentIndex = orderedSheets[activeOrderedIndex]?.effectiveIndex ??
+                            fallbackMaxIndex;
+                        const nextIndex = orderedSheets[activeOrderedIndex + 1]?.effectiveIndex;
+                        return nextIndex === undefined
+                            ? currentIndex + 1
+                            : currentIndex + (nextIndex - currentIndex) / 2;
+                    })();
+                // Merge any additional spec properties
+                const sheet = {
+                    ...newSheet,
+                    ...sheetSpec,
+                    // Ensure computed values override spec
+                    sheetId: newSheetId,
+                    title: finalTitle,
+                    index: sheetSpec?.index ?? computedIndex,
+                };
+                // Always append physically to keep patches as add-only.
+                draft.push(sheet);
+                createdSheet = sheet;
+            });
+            // Save to history only if a sheet was created
+            if (createdSheet) {
+                saveHistory({
+                    sheets: { patches, inversePatches },
+                    sheetId: { undo: sheetId, redo: createdSheet.sheetId },
+                });
+            }
+            return nextState;
+        });
+        // Update active sheet id
+        if (createdSheet) {
+            onChangeActiveSheet(createdSheet.sheetId);
+        }
+        // Return the created/existing sheet
+        return createdSheet;
+    };
+};

package/dist/esm/interface/pivot-extensions.d.ts

@@ -0,0 +1,27 @@
+import type { PivotTable } from "@rowsncolumns/common-types";
+type CreatePivotTableFunction = (props: any) => (pivotTable: PivotTable, shouldCreateNewChart?: boolean, database?: any) => void;
+type DeletePivotTableFunction = (props: any) => (pivotId: PivotTable["pivotId"], database?: any) => void;
+export type PivotModule = {
+    createPivotTable?: CreatePivotTableFunction;
+    deletePivotTable?: DeletePivotTableFunction;
+};
+/**
+ * Register the pivot module explicitly. Required in environments where the
+ * fallback dynamic `require("@rowsncolumns/pivot/server")` cannot resolve at
+ * runtime: bun --compile single-file binaries, pure Node ESM, edge runtimes.
+ *
+ * Call once at startup, before invoking pivot operations:
+ *
+ * ```ts
+ * import * as pivotServer from "@rowsncolumns/pivot/server";
+ * import { registerPivotModule } from "@rowsncolumns/spreadsheet-state/server";
+ *
+ * registerPivotModule(pivotServer);
+ * ```
+ */
+export declare const registerPivotModule: (module: PivotModule) => void;
+export declare const isPivotAvailable: () => boolean;
+export declare const safeCreatePivotTable: CreatePivotTableFunction;
+export declare const safeDeletePivotTable: DeletePivotTableFunction;
+export {};
+//# sourceMappingURL=pivot-extensions.d.ts.map

package/dist/esm/interface/pivot-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-extensions.d.ts","sourceRoot":"","sources":["../../../interface/pivot-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,KAAK,wBAAwB,GAAG,CAC9B,KAAK,EAAE,GAAG,KACP,CACH,UAAU,EAAE,UAAU,EACtB,oBAAoB,CAAC,EAAE,OAAO,EAC9B,QAAQ,CAAC,EAAE,GAAG,KACX,IAAI,CAAC;AACV,KAAK,wBAAwB,GAAG,CAC9B,KAAK,EAAE,GAAG,KACP,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG;IACxB,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAIF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,WAAW,KAAG,IAEzD,CAAC;AAuBF,eAAO,MAAM,gBAAgB,QAAO,OAKnC,CAAC;AAUF,eAAO,MAAM,oBAAoB,EAAE,wBAMlC,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,wBAMlC,CAAC"}

package/dist/esm/interface/pivot-extensions.js

@@ -0,0 +1,60 @@
+let pivotModuleCache;
+/**
+ * Register the pivot module explicitly. Required in environments where the
+ * fallback dynamic `require("@rowsncolumns/pivot/server")` cannot resolve at
+ * runtime: bun --compile single-file binaries, pure Node ESM, edge runtimes.
+ *
+ * Call once at startup, before invoking pivot operations:
+ *
+ * ```ts
+ * import * as pivotServer from "@rowsncolumns/pivot/server";
+ * import { registerPivotModule } from "@rowsncolumns/spreadsheet-state/server";
+ *
+ * registerPivotModule(pivotServer);
+ * ```
+ */
+export const registerPivotModule = (module) => {
+    pivotModuleCache = module;
+};
+const loadPivotModule = () => {
+    if (pivotModuleCache !== undefined) {
+        return pivotModuleCache;
+    }
+    pivotModuleCache = null;
+    if (typeof require !== "function") {
+        return pivotModuleCache;
+    }
+    try {
+        const requireFunc = require;
+        pivotModuleCache = requireFunc("@rowsncolumns/pivot/server");
+    }
+    catch {
+        pivotModuleCache = null;
+    }
+    return pivotModuleCache;
+};
+// Helper function to check if pivot are available
+export const isPivotAvailable = () => {
+    const pivotModule = loadPivotModule();
+    return Boolean(pivotModule?.createPivotTable && pivotModule?.deletePivotTable);
+};
+// Helper function to throw error when pivot are not available
+const throwPivotNotAvailable = (operation) => {
+    throw new Error(`Pivot ${operation} operation requires the @rowsncolumns/pivot package. Install it (npm install @rowsncolumns/pivot) or register it explicitly via registerPivotModule(import("@rowsncolumns/pivot/server")) at startup — required in bun --compile binaries and pure Node ESM where dynamic require fails.`);
+};
+// Exported pivot functions with availability checks
+export const safeCreatePivotTable = (props) => {
+    const createPivotTable = loadPivotModule()?.createPivotTable;
+    if (!createPivotTable) {
+        throwPivotNotAvailable("create");
+    }
+    return createPivotTable(props);
+};
+// Exported pivot functions with availability checks
+export const safeDeletePivotTable = (props) => {
+    const deletePivotTable = loadPivotModule()?.deletePivotTable;
+    if (!deletePivotTable) {
+        throwPivotNotAvailable("delete");
+    }
+    return deletePivotTable(props);
+};

package/dist/esm/interface/remove-duplicates.d.ts

@@ -0,0 +1,11 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { UseOnRemoveDuplicatesProps } from "../hooks/use-on-remove-duplicates";
+export type RemoveDuplicatesResult = {
+    /** Number of duplicate rows found and removed */
+    duplicatesRemoved: number;
+    /** Number of unique rows that remain */
+    uniqueRemaining: number;
+};
+export declare const removeDuplicates: <T extends CellData>({ getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, }: UseOnRemoveDuplicatesProps<T>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => RemoveDuplicatesResult;
+//# sourceMappingURL=remove-duplicates.d.ts.map

package/dist/esm/interface/remove-duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-duplicates.d.ts","sourceRoot":"","sources":["../../../interface/remove-duplicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAK/E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAGpF,MAAM,MAAM,sBAAsB,GAAG;IACnC,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,8EAKlD,0BAA0B,CAAC,CAAC,CAAC,MAE5B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,aAAa,aAAa,CAAC,mBAAmB,CAAC,EAAE,KAChD,sBA0JJ,CAAC"}

package/dist/esm/interface/remove-duplicates.js

@@ -0,0 +1,107 @@
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+export const removeDuplicates = ({ getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, }) => {
+    return (sheetId, activeCell, selections) => {
+        const finalSelections = selections?.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        const seenRows = new Set();
+        const duplicateRows = new Set();
+        // First pass: collect all row data and identify duplicates
+        for (const sel of finalSelections) {
+            for (let rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                const rowValues = [];
+                for (let columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                    const value = getFormattedValue(sheetId, rowIndex, columnIndex);
+                    rowValues.push(value ?? "");
+                }
+                // Create a key for this row based on all its values
+                const rowKey = JSON.stringify(rowValues);
+                if (seenRows.has(rowKey)) {
+                    // This is a duplicate row
+                    duplicateRows.add(rowIndex);
+                }
+                else {
+                    // First occurrence of this row
+                    seenRows.add(rowKey);
+                }
+            }
+        }
+        const result = {
+            duplicatesRemoved: duplicateRows.size,
+            uniqueRemaining: seenRows.size,
+        };
+        // If no duplicates found, return early
+        if (duplicateRows.size === 0) {
+            return result;
+        }
+        const markDirty = (rowIndex, columnIndex) => {
+            // Track for recalculation
+            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                rowIndex,
+                columnIndex,
+                sheetId,
+            });
+            // Enqueue calculation
+            enqueueCalculation({
+                type: "dirty",
+                position: {
+                    sheetId,
+                    rowIndex,
+                    columnIndex,
+                },
+            });
+        };
+        // Second pass: delete the duplicate rows and shift the remaining rows up
+        // within the selection, like Excel's Remove Duplicates
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const sel of finalSelections) {
+                    const { startRowIndex, endRowIndex, startColumnIndex, endColumnIndex } = sel.range;
+                    // Compact surviving rows towards the top of the selection
+                    let writeRowIndex = startRowIndex;
+                    for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
+                        // Skip rows that are duplicates — they get overwritten by the
+                        // rows below shifting up
+                        if (duplicateRows.has(rowIndex)) {
+                            continue;
+                        }
+                        if (writeRowIndex !== rowIndex) {
+                            const currentSheet = createSheetDraft(draft, sheetId, writeRowIndex);
+                            for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                                // Move the cell (value and formatting) up
+                                currentSheet[writeRowIndex].values[columnIndex] =
+                                    draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                                markDirty(writeRowIndex, columnIndex);
+                            }
+                        }
+                        writeRowIndex++;
+                    }
+                    // Clear the rows vacated at the bottom of the selection —
+                    // the rows were deleted, so the cells become empty like in Excel
+                    for (; writeRowIndex <= endRowIndex; writeRowIndex++) {
+                        const currentSheet = createSheetDraft(draft, sheetId, writeRowIndex);
+                        for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                            currentSheet[writeRowIndex].values[columnIndex] = undefined;
+                            markDirty(writeRowIndex, columnIndex);
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: undefined },
+            });
+            return nextState;
+        });
+        return result;
+    };
+};

package/dist/esm/interface/remove-table.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const removeTable: <T extends CellData, S extends Sheet>({ onChangeTables, onChangeSheets, createHistory, getDependents, enqueueCalculation, }: Pick<UseOnTableProps<T, S>, "onChangeTables" | "onChangeSheets" | "getDependents" | "enqueueCalculation" | "createHistory">) => (tableView: TableView) => void;
+//# sourceMappingURL=remove-table.d.ts.map

package/dist/esm/interface/remove-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-table.d.ts","sourceRoot":"","sources":["../../../interface/remove-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uFAM9D,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,oBAAoB,GACpB,eAAe,CAClB,MACS,WAAW,SAAS,SAmE7B,CAAC"}

package/dist/esm/interface/remove-table.js

@@ -0,0 +1,50 @@
+import { produceWithPatches } from "immer";
+export const removeTable = ({ onChangeTables, onChangeSheets, createHistory, getDependents, enqueueCalculation, }) => {
+    return (tableView) => {
+        const saveHistory = createHistory();
+        // Move tables if necessary
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const tableIndex = draft.findIndex((table) => table.id == tableView.id // Accept both string and number
+                );
+                if (tableIndex !== -1) {
+                    draft.splice(tableIndex, 1);
+                }
+            });
+            // Mark table cells as dirty
+            // const recalcCells = markTableAsDirty(
+            //   tableView.sheetId,
+            //   tableView.range,
+            //   getDependents,
+            //   enqueueCalculation
+            // );
+            saveHistory({
+                tables: { patches, inversePatches },
+                // recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Remove hidden columns if user is removing table
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === tableView.sheetId);
+                if (sheet && tableView) {
+                    if (!sheet.rowMetadata) {
+                        sheet.rowMetadata = [];
+                    }
+                    const { range } = tableView;
+                    for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        if (sheet.rowMetadata[rowIndex]?.hiddenByFilter) {
+                            sheet.rowMetadata[rowIndex].hiddenByFilter = false;
+                        }
+                    }
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/resize-utils.d.ts

@@ -0,0 +1,18 @@
+import type { AXIS, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+type AutoResizeRowsConfig<T extends CellData, S extends Sheet> = {
+    sheet: S;
+    sheetId: number;
+    columnIndexes: number[];
+    dimension: number;
+    getCellDimensions?: (sheetId: number, rowIndex: number, columnIndex: number, axis: AXIS, options?: {
+        boundedWidth?: number;
+    }) => {
+        width?: number;
+        height?: number;
+    } | undefined;
+    getRowHeight?: (sheetId: number, rowIndex: number, shouldSkipColumn?: (columnIndex: number) => boolean) => number | undefined;
+    isMergedCell?: (sheetId: number, rowIndex: number, columnIndex: number) => boolean | undefined;
+};
+export declare const autoResizeRows: <T extends CellData, S extends Sheet>({ sheet, sheetId, columnIndexes, dimension, getCellDimensions, getRowHeight, isMergedCell, }: AutoResizeRowsConfig<T, S>) => void;
+export type { AutoResizeRowsConfig, };
+//# sourceMappingURL=resize-utils.d.ts.map

package/dist/esm/interface/resize-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-utils.d.ts","sourceRoot":"","sources":["../../../interface/resize-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGvE,KAAK,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC/D,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,CAClB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,KAChC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACrD,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,KAChD,MAAM,GAAG,SAAS,CAAC;IACxB,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,OAAO,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8FAQjE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,SA8C5B,CAAC;AAEF,YAAY,EACV,oBAAoB,GACrB,CAAC"}

package/dist/esm/interface/resize-utils.js

@@ -0,0 +1,34 @@
+import { DEFAULT_ROW_HEIGHT, isNil } from "@rowsncolumns/utils";
+export const autoResizeRows = ({ sheet, sheetId, columnIndexes, dimension, getCellDimensions, getRowHeight, isMergedCell, }) => {
+    const rowIndexes = Object.keys(sheet.rowMetadata ?? {}).map(Number);
+    for (const rowIndex of rowIndexes) {
+        const isResizedByUser = !!sheet.rowMetadata?.[rowIndex]?.resizedByUser;
+        if (isResizedByUser) {
+            continue;
+        }
+        const baselineRowHeight = getRowHeight?.(sheetId, rowIndex, (index) => columnIndexes.includes(index));
+        let maxRowHeight = baselineRowHeight ?? DEFAULT_ROW_HEIGHT;
+        let didUpdateRowHeight = false;
+        for (const columnIndex of columnIndexes) {
+            if (isMergedCell?.(sheetId, rowIndex, columnIndex)) {
+                continue;
+            }
+            const newCellDimension = getCellDimensions?.(sheetId, rowIndex, columnIndex, "x", {
+                boundedWidth: dimension,
+            });
+            if (!isNil(newCellDimension) && newCellDimension.height !== undefined) {
+                maxRowHeight = Math.max(maxRowHeight, newCellDimension.height);
+                didUpdateRowHeight = true;
+            }
+        }
+        if (didUpdateRowHeight) {
+            if (!sheet.rowMetadata) {
+                sheet.rowMetadata = [];
+            }
+            if (!sheet.rowMetadata[rowIndex]) {
+                sheet.rowMetadata[rowIndex] = {};
+            }
+            sheet.rowMetadata[rowIndex].size = maxRowHeight;
+        }
+    }
+};

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

@@ -0,0 +1,5 @@
+import type { CellData } from "@rowsncolumns/common-types";
+import type { AXIS, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnResizeProps } from "../hooks/use-on-resize";
+export declare const resize: <T extends CellData, S extends Sheet>({ createHistory, getActiveCell, getCellDimensions, getRowHeight, isMergedCell, onChangeSheets, }: UseOnResizeProps<T, S>) => (sheetId: number, indexes: number[], dimension: number, axis: AXIS, autoFit?: boolean) => void;
+//# sourceMappingURL=resize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../interface/resize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAuB,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGlF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kGAOzD,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,MAErB,SAAS,MAAM,EACf,SAAS,MAAM,EAAE,EACjB,WAAW,MAAM,EACjB,MAAM,IAAI,EACV,UAAU,OAAO,SA+CpB,CAAC"}

package/dist/esm/interface/resize.js

@@ -0,0 +1,43 @@
+import { produceWithPatches } from "immer";
+import { autoResizeRows } from "./resize-utils";
+export const resize = ({ createHistory, getActiveCell, getCellDimensions, getRowHeight, isMergedCell, onChangeSheets, }) => {
+    return (sheetId, indexes, dimension, axis, autoFit) => {
+        const saveHistory = createHistory();
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    const metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                    if (!sheet[metaData]) {
+                        sheet[metaData] = [];
+                    }
+                    for (const index of indexes) {
+                        sheet[metaData][index] = {
+                            size: dimension,
+                            resizedByUser: autoFit ? false : true,
+                        };
+                    }
+                    // Auto-resize rows if column width changes
+                    if (axis === "y") {
+                        autoResizeRows({
+                            sheet: sheet,
+                            sheetId,
+                            columnIndexes: indexes,
+                            dimension,
+                            getCellDimensions,
+                            getRowHeight,
+                            isMergedCell,
+                        });
+                    }
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { Slicer } from "@rowsncolumns/spreadsheet";
+import { type CanvasGridProps, type CellData } from "@rowsncolumns/spreadsheet";
+import type { UseOnSlicersProps } from "../hooks/use-slicers";
+export declare const deleteSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: Omit<UseOnSlicersProps<T>, "sheetId">) => (slicerId: Slicer["slicerId"]) => void;
+export declare const updateSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: Omit<UseOnSlicersProps<T>, "sheetId">) => (slicer: Slicer) => void;
+export declare const moveSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: UseOnSlicersProps<T>) => NonNullable<CanvasGridProps["onMoveSlicer"]>;
+export declare const resizeSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: UseOnSlicersProps<T>) => NonNullable<CanvasGridProps["onResizeSlicer"]>;
+export declare const createSlicer: <T extends CellData>({ onChangeSlicers, createHistory, }: Omit<UseOnSlicersProps<T>, "sheetId">) => (spec: Slicer) => void;
+//# sourceMappingURL=slicers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slicers.d.ts","sourceRoot":"","sources":["../../../interface/slicers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAQ9D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,UAAU,MAAM,CAAC,UAAU,CAAC,SAsBrC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,QAAQ,MAAM,SAsBvB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG5C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,cAAc,CAAC,CA6BpE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,iBAAiB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAuCtE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,qCAG9C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC9B,MAAM,MAAM,SAiBrB,CAAC"}

package/dist/esm/interface/slicers.js

@@ -0,0 +1,107 @@
+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 deleteSlicer = ({ onChangeSlicers, createHistory, }) => {
+    return (slicerId) => {
+        const saveHistory = createHistory();
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                const slicerIndex = draft.findIndex((slicer) => slicer.slicerId === slicerId);
+                if (slicerIndex !== -1) {
+                    draft.splice(slicerIndex, 1);
+                }
+            });
+            saveHistory({
+                slicers: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const updateSlicer = ({ onChangeSlicers, createHistory, }) => {
+    return (slicer) => {
+        const saveHistory = createHistory();
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                const slicerIndex = draft.findIndex((s) => s.slicerId === slicer.slicerId);
+                if (slicerIndex !== -1) {
+                    draft[slicerIndex] = slicer;
+                }
+            });
+            saveHistory({
+                slicers: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const moveSlicer = ({ onChangeSlicers, createHistory, }) => {
+    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels) => {
+        const saveHistory = createHistory();
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                const slicer = draft.find((s) => s.slicerId === slicerId);
+                if (slicer) {
+                    if (typeof slicer.position !== "object") {
+                        slicer.position = {
+                            overlayPosition: { ...DEFAULT_OVERLAY_POSITION },
+                            sheetId,
+                        };
+                    }
+                    slicer.position.overlayPosition.anchorCell = anchorCell;
+                    slicer.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    slicer.position.overlayPosition.offsetYPixels = offsetYPixels;
+                }
+            });
+            saveHistory({
+                slicers: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const resizeSlicer = ({ onChangeSlicers, createHistory, }) => {
+    return (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) => {
+        const saveHistory = createHistory();
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                const slicer = draft.find((s) => s.slicerId === slicerId);
+                if (slicer) {
+                    if (typeof slicer.position !== "object") {
+                        slicer.position = {
+                            overlayPosition: { ...DEFAULT_OVERLAY_POSITION },
+                            sheetId,
+                        };
+                    }
+                    slicer.position.overlayPosition.anchorCell = anchorCell;
+                    slicer.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    slicer.position.overlayPosition.offsetYPixels = offsetYPixels;
+                    slicer.position.overlayPosition.widthPixels = width;
+                    slicer.position.overlayPosition.heightPixels = height;
+                }
+            });
+            saveHistory({
+                slicers: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const createSlicer = ({ onChangeSlicers, createHistory, }) => {
+    return (spec) => {
+        const saveHistory = createHistory();
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                draft.push(spec);
+            });
+            saveHistory({
+                slicers: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/split-text.d.ts

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSplitTextToColumnsProps } from "../hooks/use-split-text-to-columns";
+export declare const splitText: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheetData, getFormattedValue, enqueueCalculation, onChangeSelections, }: UseSplitTextToColumnsProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea[], delimiter?: string) => void;
+//# sourceMappingURL=split-text.d.ts.map

package/dist/esm/interface/split-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-text.d.ts","sourceRoot":"","sources":["../../../interface/split-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAOjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAIrF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kGAM5D,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,aAAa,aAAa,EAAE,EAC5B,kBAAe,SA2HlB,CAAC"}