@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,60 @@
+import { __values } from "tslib";
+import { DEFAULT_ROW_HEIGHT, isNil } from "@rowsncolumns/utils";
+export var autoResizeRows = function (_a) {
+    var e_1, _b, e_2, _c;
+    var _d, _e, _f;
+    var sheet = _a.sheet, sheetId = _a.sheetId, columnIndexes = _a.columnIndexes, dimension = _a.dimension, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell;
+    var rowIndexes = Object.keys((_d = sheet.rowMetadata) !== null && _d !== void 0 ? _d : {}).map(Number);
+    try {
+        for (var rowIndexes_1 = __values(rowIndexes), rowIndexes_1_1 = rowIndexes_1.next(); !rowIndexes_1_1.done; rowIndexes_1_1 = rowIndexes_1.next()) {
+            var rowIndex = rowIndexes_1_1.value;
+            var isResizedByUser = !!((_f = (_e = sheet.rowMetadata) === null || _e === void 0 ? void 0 : _e[rowIndex]) === null || _f === void 0 ? void 0 : _f.resizedByUser);
+            if (isResizedByUser) {
+                continue;
+            }
+            var baselineRowHeight = getRowHeight === null || getRowHeight === void 0 ? void 0 : getRowHeight(sheetId, rowIndex, function (index) {
+                return columnIndexes.includes(index);
+            });
+            var maxRowHeight = baselineRowHeight !== null && baselineRowHeight !== void 0 ? baselineRowHeight : DEFAULT_ROW_HEIGHT;
+            var didUpdateRowHeight = false;
+            try {
+                for (var columnIndexes_1 = (e_2 = void 0, __values(columnIndexes)), columnIndexes_1_1 = columnIndexes_1.next(); !columnIndexes_1_1.done; columnIndexes_1_1 = columnIndexes_1.next()) {
+                    var columnIndex = columnIndexes_1_1.value;
+                    if (isMergedCell === null || isMergedCell === void 0 ? void 0 : isMergedCell(sheetId, rowIndex, columnIndex)) {
+                        continue;
+                    }
+                    var newCellDimension = getCellDimensions === null || getCellDimensions === void 0 ? void 0 : getCellDimensions(sheetId, rowIndex, columnIndex, "x", {
+                        boundedWidth: dimension,
+                    });
+                    if (!isNil(newCellDimension) && newCellDimension.height !== undefined) {
+                        maxRowHeight = Math.max(maxRowHeight, newCellDimension.height);
+                        didUpdateRowHeight = true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (columnIndexes_1_1 && !columnIndexes_1_1.done && (_c = columnIndexes_1.return)) _c.call(columnIndexes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            if (didUpdateRowHeight) {
+                if (!sheet.rowMetadata) {
+                    sheet.rowMetadata = [];
+                }
+                if (!sheet.rowMetadata[rowIndex]) {
+                    sheet.rowMetadata[rowIndex] = {};
+                }
+                sheet.rowMetadata[rowIndex].size = maxRowHeight;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (rowIndexes_1_1 && !rowIndexes_1_1.done && (_b = rowIndexes_1.return)) _b.call(rowIndexes_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};

package/dist/cjs/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/cjs/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/cjs/interface/resize.js

@@ -0,0 +1,56 @@
+import { __read, __values } from "tslib";
+import { produceWithPatches } from "immer";
+import { autoResizeRows } from "./resize-utils";
+export var resize = function (_a) {
+    var createHistory = _a.createHistory, getActiveCell = _a.getActiveCell, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell, onChangeSheets = _a.onChangeSheets;
+    return function (sheetId, indexes, dimension, axis, autoFit) {
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    var metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                    if (!sheet[metaData]) {
+                        sheet[metaData] = [];
+                    }
+                    try {
+                        for (var indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
+                            var index = indexes_1_1.value;
+                            sheet[metaData][index] = {
+                                size: dimension,
+                                resizedByUser: autoFit ? false : true,
+                            };
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (indexes_1_1 && !indexes_1_1.done && (_a = indexes_1.return)) _a.call(indexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    // Auto-resize rows if column width changes
+                    if (axis === "y") {
+                        autoResizeRows({
+                            sheet: sheet,
+                            sheetId: sheetId,
+                            columnIndexes: indexes,
+                            dimension: dimension,
+                            getCellDimensions: getCellDimensions,
+                            getRowHeight: getRowHeight,
+                            isMergedCell: isMergedCell,
+                        });
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/slicers.js

@@ -0,0 +1,113 @@
+import { __assign, __read } from "tslib";
+import { DEFAULT_ACTIVE_CELL } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+var DEFAULT_OVERLAY_POSITION = {
+    anchorCell: DEFAULT_ACTIVE_CELL,
+    heightPixels: 400,
+    widthPixels: 400,
+};
+export var deleteSlicer = function (_a) {
+    var onChangeSlicers = _a.onChangeSlicers, createHistory = _a.createHistory;
+    return function (slicerId) {
+        var saveHistory = createHistory();
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                var slicerIndex = draft.findIndex(function (slicer) { return slicer.slicerId === slicerId; });
+                if (slicerIndex !== -1) {
+                    draft.splice(slicerIndex, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                slicers: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var updateSlicer = function (_a) {
+    var onChangeSlicers = _a.onChangeSlicers, createHistory = _a.createHistory;
+    return function (slicer) {
+        var saveHistory = createHistory();
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                var slicerIndex = draft.findIndex(function (s) { return s.slicerId === slicer.slicerId; });
+                if (slicerIndex !== -1) {
+                    draft[slicerIndex] = slicer;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                slicers: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var moveSlicer = function (_a) {
+    var onChangeSlicers = _a.onChangeSlicers, createHistory = _a.createHistory;
+    return function (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        var saveHistory = createHistory();
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                var slicer = draft.find(function (s) { return s.slicerId === slicerId; });
+                if (slicer) {
+                    if (typeof slicer.position !== "object") {
+                        slicer.position = {
+                            overlayPosition: __assign({}, DEFAULT_OVERLAY_POSITION),
+                            sheetId: sheetId,
+                        };
+                    }
+                    slicer.position.overlayPosition.anchorCell = anchorCell;
+                    slicer.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    slicer.position.overlayPosition.offsetYPixels = offsetYPixels;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                slicers: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var resizeSlicer = function (_a) {
+    var onChangeSlicers = _a.onChangeSlicers, createHistory = _a.createHistory;
+    return function (slicerId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        var saveHistory = createHistory();
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                var slicer = draft.find(function (s) { return s.slicerId === slicerId; });
+                if (slicer) {
+                    if (typeof slicer.position !== "object") {
+                        slicer.position = {
+                            overlayPosition: __assign({}, DEFAULT_OVERLAY_POSITION),
+                            sheetId: 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;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                slicers: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var createSlicer = function (_a) {
+    var onChangeSlicers = _a.onChangeSlicers, createHistory = _a.createHistory;
+    return function (spec) {
+        var saveHistory = createHistory();
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                draft.push(spec);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                slicers: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

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

package/dist/cjs/interface/split-text.js

@@ -0,0 +1,120 @@
+import { __read, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { splitTextToColumns } from "../api/split-text";
+import { SheetCell } from "../sheet-cell";
+export var splitText = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, getFormattedValue = _a.getFormattedValue, enqueueCalculation = _a.enqueueCalculation, onChangeSelections = _a.onChangeSelections;
+    return function (sheetId, activeCell, selections, delimiter) {
+        var e_1, _a;
+        if (delimiter === void 0) { delimiter = ","; }
+        var finalSelections = (selections === null || selections === void 0 ? void 0 : selections.length)
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Get selections values
+        var values = [];
+        try {
+            for (var finalSelections_1 = __values(finalSelections), finalSelections_1_1 = finalSelections_1.next(); !finalSelections_1_1.done; finalSelections_1_1 = finalSelections_1.next()) {
+                var sel = finalSelections_1_1.value;
+                for (var rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                    var columnIndex = sel.range.startColumnIndex;
+                    // You can only split text on a single column
+                    values.push(getFormattedValue(sheetId, rowIndex, columnIndex));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (finalSelections_1_1 && !finalSelections_1_1.done && (_a = finalSelections_1.return)) _a.call(finalSelections_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var newValues = splitTextToColumns(values, delimiter);
+        var columnCount = newValues.reduce(function (max, row) { var _a; return Math.max(max, (_a = row === null || row === void 0 ? void 0 : row.length) !== null && _a !== void 0 ? _a : 0); }, 0);
+        // Skip only when none of the selected rows can be split into multiple columns.
+        if (columnCount <= 1) {
+            return;
+        }
+        // Update selections
+        var firstSelection = finalSelections[0];
+        var newSelections = [
+            {
+                range: {
+                    startRowIndex: firstSelection.range.startRowIndex,
+                    endRowIndex: firstSelection.range.endRowIndex,
+                    startColumnIndex: firstSelection.range.startColumnIndex,
+                    endColumnIndex: firstSelection.range.startColumnIndex + columnCount - 1,
+                },
+            },
+        ];
+        // Update selections
+        onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, newSelections);
+        // Add cells to recalc
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a;
+                var _b;
+                // Create a cell
+                var sheetCell = new SheetCell();
+                try {
+                    for (var finalSelections_2 = __values(finalSelections), finalSelections_2_1 = finalSelections_2.next(); !finalSelections_2_1.done; finalSelections_2_1 = finalSelections_2.next()) {
+                        var sel = finalSelections_2_1.value;
+                        var startRowIndex = 0;
+                        for (var rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            var columnValues = newValues[startRowIndex];
+                            var endColumnIndex = sel.range.startColumnIndex + columnCount;
+                            var startColumnIndex = 0;
+                            for (var columnIndex = sel.range.startColumnIndex; columnIndex < endColumnIndex; columnIndex++) {
+                                var value = (_b = columnValues === null || columnValues === void 0 ? void 0 : columnValues[startColumnIndex]) !== null && _b !== void 0 ? _b : "";
+                                sheetCell.setUserEnteredValue(value);
+                                // Set data
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                    rowIndex: rowIndex,
+                                    columnIndex: columnIndex,
+                                    sheetId: sheetId,
+                                });
+                                // Enqueu
+                                enqueueCalculation({
+                                    type: "dirty",
+                                    position: {
+                                        sheetId: sheetId,
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                    },
+                                });
+                                startColumnIndex++;
+                            }
+                            startRowIndex++;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (finalSelections_2_1 && !finalSelections_2_1.done && (_a = finalSelections_2.return)) _a.call(finalSelections_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                selections: {
+                    redo: newSelections,
+                    undo: selections,
+                },
+            });
+            return nextState;
+        });
+    };
+};