@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/embeds.js

@@ -0,0 +1,121 @@
+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 deleteEmbed = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory;
+    return function (embedId) {
+        var saveHistory = createHistory();
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var embedIndex = draft.findIndex(function (chart) { return chart.embedId === embedId; });
+                if (embedIndex !== -1) {
+                    draft.splice(embedIndex, 1);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+                selectedEmbedOrChart: {
+                    redo: embedId,
+                    undo: undefined,
+                },
+            });
+            return nextState;
+        });
+    };
+};
+export var updateEmbed = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory;
+    return function (embed) {
+        var saveHistory = createHistory();
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var embedIndex = draft.findIndex(function (chart) { return chart.embedId === embed.embedId; });
+                if (embedIndex !== -1) {
+                    draft[embedIndex] = embed;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+                selectedEmbedOrChart: {
+                    redo: embed.embedId,
+                    undo: undefined,
+                },
+            });
+            return nextState;
+        });
+    };
+};
+export var moveEmbed = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory;
+    return function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) {
+        var saveHistory = createHistory();
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var embed = draft.find(function (chart) { return chart.embedId === embedId; });
+                if (embed) {
+                    if (typeof embed.position !== "object") {
+                        embed.position = {
+                            overlayPosition: __assign({}, DEFAULT_OVERLAY_POSITION),
+                            sheetId: sheetId,
+                        };
+                    }
+                    embed.position.overlayPosition.anchorCell = anchorCell;
+                    embed.position.overlayPosition.offsetXPixels = offsetXPixels;
+                    embed.position.overlayPosition.offsetYPixels = offsetYPixels;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var resizeEmbed = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory;
+    return function (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) {
+        var saveHistory = createHistory();
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var embed = draft.find(function (chart) { return chart.embedId === embedId; });
+                if (embed) {
+                    if (typeof embed.position !== "object") {
+                        embed.position = {
+                            overlayPosition: __assign({}, DEFAULT_OVERLAY_POSITION),
+                            sheetId: 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;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export var createEmbed = function (_a) {
+    var onChangeEmbeds = _a.onChangeEmbeds, createHistory = _a.createHistory;
+    return function (spec) {
+        var saveHistory = createHistory();
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                draft.push(spec);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                embeds: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

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

package/dist/cjs/interface/freeze.js

@@ -0,0 +1,160 @@
+import { __read, __values } from "tslib";
+import { produceWithPatches } from "immer";
+export var freezeRow = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeEmbeds = _a.onChangeEmbeds, onChangeCharts = _a.onChangeCharts;
+    return function (sheetId, rowIndex) {
+        var saveHistory = createHistory();
+        // Move embeds out of frozen area
+        if (onChangeEmbeds) {
+            onChangeEmbeds(function (prevEmbeds) {
+                var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                    var e_1, _a;
+                    try {
+                        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                            var embed = draft_1_1.value;
+                            if (embed.position.sheetId === sheetId &&
+                                embed.position.overlayPosition.anchorCell.rowIndex <= rowIndex) {
+                                // Move embed below frozen rows
+                                embed.position.overlayPosition.anchorCell.rowIndex =
+                                    rowIndex + 1;
+                                embed.position.overlayPosition.offsetYPixels = 0;
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                if (patches.length > 0) {
+                    saveHistory({ embeds: { patches: patches, inversePatches: inversePatches } });
+                }
+                return nextState;
+            });
+        }
+        // Move charts out of frozen area
+        if (onChangeCharts) {
+            onChangeCharts(function (prevCharts) {
+                var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                    var e_2, _a;
+                    try {
+                        for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
+                            var chart = draft_2_1.value;
+                            if (chart.position.sheetId === sheetId &&
+                                chart.position.overlayPosition.anchorCell.rowIndex <= rowIndex) {
+                                // Move chart below frozen rows
+                                chart.position.overlayPosition.anchorCell.rowIndex =
+                                    rowIndex + 1;
+                                chart.position.overlayPosition.offsetYPixels = 0;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                if (patches.length > 0) {
+                    saveHistory({ charts: { patches: patches, inversePatches: inversePatches } });
+                }
+                return nextState;
+            });
+        }
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    sheet.frozenRowCount = rowIndex;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+    };
+};
+export var freezeColumn = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeEmbeds = _a.onChangeEmbeds, onChangeCharts = _a.onChangeCharts;
+    return function (sheetId, columnIndex) {
+        var saveHistory = createHistory();
+        // Move embeds out of frozen area
+        if (onChangeEmbeds) {
+            onChangeEmbeds(function (prevEmbeds) {
+                var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                    var e_3, _a;
+                    try {
+                        for (var draft_3 = __values(draft), draft_3_1 = draft_3.next(); !draft_3_1.done; draft_3_1 = draft_3.next()) {
+                            var embed = draft_3_1.value;
+                            if (embed.position.sheetId === sheetId &&
+                                embed.position.overlayPosition.anchorCell.columnIndex <
+                                    columnIndex) {
+                                // Move embed to the right of frozen columns
+                                embed.position.overlayPosition.anchorCell.columnIndex =
+                                    columnIndex + 1;
+                                embed.position.overlayPosition.offsetXPixels = 0;
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (draft_3_1 && !draft_3_1.done && (_a = draft_3.return)) _a.call(draft_3);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                if (patches.length > 0) {
+                    saveHistory({ embeds: { patches: patches, inversePatches: inversePatches } });
+                }
+                return nextState;
+            });
+        }
+        // Move charts out of frozen area
+        if (onChangeCharts) {
+            onChangeCharts(function (prevCharts) {
+                var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                    var e_4, _a;
+                    try {
+                        for (var draft_4 = __values(draft), draft_4_1 = draft_4.next(); !draft_4_1.done; draft_4_1 = draft_4.next()) {
+                            var chart = draft_4_1.value;
+                            if (chart.position.sheetId === sheetId &&
+                                chart.position.overlayPosition.anchorCell.columnIndex <
+                                    columnIndex + 1) {
+                                // Move chart to the right of frozen columns
+                                chart.position.overlayPosition.anchorCell.columnIndex =
+                                    columnIndex + 1;
+                                chart.position.overlayPosition.offsetXPixels = 0;
+                            }
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (draft_4_1 && !draft_4_1.done && (_a = draft_4.return)) _a.call(draft_4);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                if (patches.length > 0) {
+                    saveHistory({ charts: { patches: patches, inversePatches: inversePatches } });
+                }
+                return nextState;
+            });
+        }
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    sheet.frozenColumnCount = columnIndex;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+import type { RecalcCellCoordinate } from "../types";
+export declare const markTableAsDirty: <T extends CellData, S extends Sheet>(sheetId: number, range: GridRange | undefined, getDependents: UseOnTableProps<T, S>["getDependents"], enqueueCalculation: UseOnTableProps<T, S>["enqueueCalculation"]) => Map<string, RecalcCellCoordinate>;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../interface/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAGrD,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAClE,SAAS,MAAM,EACf,OAAO,SAAS,GAAG,SAAS,EAC5B,eAAe,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,EACrD,oBAAoB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,oBAAoB,CAAC,sCAkChE,CAAC"}

package/dist/cjs/interface/helpers.js

@@ -0,0 +1,44 @@
+import { __read, __values } from "tslib";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { createSheetCellIdentifier } from "../api/formula";
+// Mark table as dirty
+export var markTableAsDirty = function (sheetId, range, getDependents, enqueueCalculation) {
+    var e_1, _a;
+    // We need to track this for history. Precedent cells
+    var recalcCells = new Map();
+    // Make cells dirty
+    if (range) {
+        try {
+            for (var _b = __values(iterateCellsInRange(range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                var position = {
+                    rowIndex: rowIndex,
+                    columnIndex: columnIndex,
+                    sheetId: sheetId,
+                };
+                var dependents = getDependents(position);
+                // Check if dependents
+                if (dependents.length) {
+                    enqueueCalculation({
+                        type: "dirty",
+                        position: {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                            sheetId: sheetId,
+                        },
+                    });
+                    // Add to recalc cells
+                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), position);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return recalcCells;
+};

package/dist/cjs/interface/hide-column.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseonHideColumnProps } from "../hooks/use-on-hide-column";
+export declare const hideColumns: <T extends CellData, S extends Sheet>({ getActiveCell, getSelections, onChangeActiveCell, onChangeSelections, onChangeSheets, createHistory, rowCount, columnCount, getNextFocusableCell, }: UseonHideColumnProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+//# sourceMappingURL=hide-column.d.ts.map

package/dist/cjs/interface/hide-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide-column.d.ts","sourceRoot":"","sources":["../../../interface/hide-column.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EAGR,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uJAU9D,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,MACnB,SAAS,MAAM,EAAE,eAAe,MAAM,EAAE,SAyEjD,CAAC"}

package/dist/cjs/interface/hide-column.js

@@ -0,0 +1,68 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+export var hideColumns = function (_a) {
+    var getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, rowCount = _a.rowCount, columnCount = _a.columnCount, getNextFocusableCell = _a.getNextFocusableCell;
+    return function (sheetId, columnIndexes) {
+        var _a;
+        var saveHistory = createHistory();
+        var sortedColumnIndexes = __spreadArray([], __read(columnIndexes), false).sort(function (a, b) { return a - b; });
+        var firstColumnIndex = sortedColumnIndexes[0];
+        var lastColumnIndex = sortedColumnIndexes[sortedColumnIndexes.length - 1];
+        var moveDirection = lastColumnIndex >= columnCount ? Direction.Left : Direction.Right;
+        var nextActiveCellCandidate = (_a = getNextFocusableCell === null || getNextFocusableCell === void 0 ? void 0 : getNextFocusableCell(sheetId, __assign(__assign({}, getActiveCell()), { columnIndex: moveDirection === Direction.Left
+                ? firstColumnIndex
+                : lastColumnIndex }), moveDirection, false)) !== null && _a !== void 0 ? _a : (moveDirection === Direction.Left
+            ? __assign(__assign({}, getActiveCell()), { columnIndex: firstColumnIndex - 1 }) : __assign(__assign({}, getActiveCell()), { columnIndex: lastColumnIndex + 1 }));
+        var nextColumnIndex = Math.max(1, Math.min(columnCount, nextActiveCellCandidate.columnIndex));
+        var nextActiveCell = nextColumnIndex === nextActiveCellCandidate.columnIndex
+            ? nextActiveCellCandidate
+            : __assign(__assign({}, nextActiveCellCandidate), { columnIndex: nextColumnIndex });
+        var newSelections = [
+            {
+                range: {
+                    startRowIndex: 1,
+                    startColumnIndex: nextColumnIndex,
+                    endColumnIndex: nextColumnIndex,
+                    endRowIndex: rowCount,
+                },
+            },
+        ];
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    if (!sheet.columnMetadata)
+                        sheet.columnMetadata = [];
+                    try {
+                        for (var columnIndexes_1 = __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 (!sheet.columnMetadata[columnIndex]) {
+                                sheet.columnMetadata[columnIndex] =
+                                    {};
+                            }
+                            sheet.columnMetadata[columnIndex].hiddenByUser = true;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (columnIndexes_1_1 && !columnIndexes_1_1.done && (_a = columnIndexes_1.return)) _a.call(columnIndexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                selections: { undo: getSelections(), redo: newSelections },
+                activeCell: { undo: getActiveCell(), redo: nextActiveCell },
+            });
+            return nextState;
+        });
+        onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(sheetId, nextActiveCell);
+        onChangeSelections === null || onChangeSelections === void 0 ? void 0 : onChangeSelections(sheetId, newSelections);
+    };
+};

package/dist/cjs/interface/hide-row.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnHideRowProps } from "../hooks/use-on-hide-row";
+export declare const hideRows: <T extends CellData, S extends Sheet>(deps: UseOnHideRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+//# sourceMappingURL=hide-row.d.ts.map

package/dist/cjs/interface/hide-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide-row.d.ts","sourceRoot":"","sources":["../../../interface/hide-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAC1D,MAAM,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,MAcrB,SAAS,MAAM,EAAE,YAAY,MAAM,EAAE,SA8D9C,CAAC"}

package/dist/cjs/interface/hide-row.js

@@ -0,0 +1,65 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+export var hideRows = function (deps) {
+    var getActiveCell = deps.getActiveCell, getSelections = deps.getSelections, onChangeActiveCell = deps.onChangeActiveCell, onChangeSelections = deps.onChangeSelections, onChangeSheets = deps.onChangeSheets, createHistory = deps.createHistory, columnCount = deps.columnCount, rowCount = deps.rowCount, getNextFocusableCell = deps.getNextFocusableCell;
+    return function (sheetId, rowIndexes) {
+        var _a;
+        var saveHistory = createHistory();
+        var sortedRowIndexes = __spreadArray([], __read(rowIndexes), false).sort(function (a, b) { return a - b; });
+        var firstRowIndex = sortedRowIndexes[0];
+        var lastRowIndex = sortedRowIndexes[sortedRowIndexes.length - 1];
+        var moveDirection = lastRowIndex >= rowCount ? Direction.Up : Direction.Down;
+        var nextCandidate = (_a = getNextFocusableCell === null || getNextFocusableCell === void 0 ? void 0 : getNextFocusableCell(sheetId, __assign(__assign({}, getActiveCell()), { rowIndex: moveDirection === Direction.Up ? firstRowIndex : lastRowIndex }), moveDirection, false)) !== null && _a !== void 0 ? _a : (moveDirection === Direction.Up
+            ? __assign(__assign({}, getActiveCell()), { rowIndex: firstRowIndex - 1 }) : __assign(__assign({}, getActiveCell()), { rowIndex: lastRowIndex + 1 }));
+        var nextRowIndex = Math.max(1, Math.min(rowCount, nextCandidate.rowIndex));
+        var next = nextRowIndex === nextCandidate.rowIndex
+            ? nextCandidate
+            : __assign(__assign({}, nextCandidate), { rowIndex: nextRowIndex });
+        var newSelections = [
+            {
+                range: {
+                    startRowIndex: nextRowIndex,
+                    startColumnIndex: 1,
+                    endColumnIndex: columnCount,
+                    endRowIndex: nextRowIndex,
+                },
+            },
+        ];
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    if (!sheet.rowMetadata)
+                        sheet.rowMetadata = [];
+                    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;
+                            if (!sheet.rowMetadata[rowIndex]) {
+                                sheet.rowMetadata[rowIndex] = {};
+                            }
+                            sheet.rowMetadata[rowIndex].hiddenByUser = true;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (rowIndexes_1_1 && !rowIndexes_1_1.done && (_a = rowIndexes_1.return)) _a.call(rowIndexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+                selections: { undo: getSelections(), redo: newSelections },
+                activeCell: { undo: getActiveCell(), redo: next },
+            });
+            return nextState;
+        });
+        onChangeActiveCell(sheetId, next);
+        onChangeSelections(sheetId, newSelections);
+    };
+};

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

@@ -0,0 +1,7 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { UseIndentProps } from "../hooks/use-indent";
+export declare const changeIndent: <T extends CellData>({ locale, cellXfsRegistry, enqueueCalculation, onChangeSheetData, createHistory, getDataValidationById, }: UseIndentProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], shouldIncrease?: boolean) => void;
+export declare const increaseIndent: <T extends CellData>(props: UseIndentProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+export declare const decreaseIndent: <T extends CellData>(props: UseIndentProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=indent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indent.d.ts","sourceRoot":"","sources":["../../../interface/indent.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,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,2GAO9C,cAAc,CAAC,CAAC,CAAC,MAEhB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,iBAAiB,OAAO,SAuE3B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAC/C,OAAO,cAAc,CAAC,CAAC,CAAC,MAGtB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAInD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAC/C,OAAO,cAAc,CAAC,CAAC,CAAC,MAGtB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAInD,CAAC"}

package/dist/cjs/interface/indent.js

@@ -0,0 +1,97 @@
+import { __read, __values } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var changeIndent = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, enqueueCalculation = _a.enqueueCalculation, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, getDataValidationById = _a.getDataValidationById;
+    return function (sheetId, activeCell, selections, shouldIncrease) {
+        var saveHistory = createHistory();
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        // Create a cell
+        var sheetCell = new SheetCell();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a, e_2, _b;
+                var _c, _d;
+                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;
+                        try {
+                            for (var _e = (e_2 = void 0, __values(iterateCellsInRange(sel.range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                var cellData = (_d = (_c = currentSheet[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                                    locale: locale,
+                                    cellXfsRegistry: cellXfsRegistry,
+                                    getDataValidationById: getDataValidationById,
+                                });
+                                if (shouldIncrease) {
+                                    sheetCell.increaseIndent();
+                                }
+                                else {
+                                    sheetCell.decreaseIndent();
+                                }
+                                // Set cell data
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                // Register
+                                cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                                // Enqueue calculation
+                                enqueueCalculation({
+                                    type: "dirty",
+                                    position: {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    },
+                                });
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+                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; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches: inversePatches,
+                    patches: patches,
+                },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+            });
+            return nextState;
+        });
+        // Update history
+        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+    };
+};
+export var increaseIndent = function (props) {
+    return function (sheetId, activeCell, selections) {
+        changeIndent(props)(sheetId, activeCell, selections, true);
+    };
+};
+export var decreaseIndent = function (props) {
+    return function (sheetId, activeCell, selections) {
+        changeIndent(props)(sheetId, activeCell, selections, false);
+    };
+};

package/dist/cjs/interface/insert-cells-shift-down.d.ts

@@ -0,0 +1,5 @@
+import type { CellData, CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnInsertCellsShiftDown } from "../hooks/use-on-insert-cells-shift-down";
+export declare const insertCellsShiftDown: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeCitations, }: UseOnInsertCellsShiftDown<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=insert-cells-shift-down.d.ts.map

package/dist/cjs/interface/insert-cells-shift-down.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-cells-shift-down.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAM5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAGzF,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,gQAgBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE9B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAoMnD,CAAC"}