@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-freeze.js

@@ -0,0 +1,56 @@
+import { useCallback } from "react";
+import { freezeColumn, freezeRow } from "../interface/freeze";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnFreeze = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeEmbeds = _a.onChangeEmbeds, onChangeCharts = _a.onChangeCharts, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    var onFreezeRow = useCallback(function (sheetId, rowIndex) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        freezeRow({
+            createHistory: createHistory,
+            onChangeSheets: onChangeSheets,
+            onChangeEmbeds: onChangeEmbeds,
+            onChangeCharts: onChangeCharts,
+        })(sheetId, rowIndex);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "freeze-row",
+            sheetId: sheetId,
+            rowIndex: rowIndex,
+        });
+    }, [
+        canEditSheet,
+        createHistory,
+        onChangeSheets,
+        onChangeEmbeds,
+        onChangeCharts,
+        onCommand,
+    ]);
+    var onFreezeColumn = useCallback(function (sheetId, columnIndex) {
+        if (!(canEditSheet === null || canEditSheet === void 0 ? void 0 : canEditSheet(sheetId))) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        freezeColumn({
+            createHistory: createHistory,
+            onChangeSheets: onChangeSheets,
+            onChangeEmbeds: onChangeEmbeds,
+            onChangeCharts: onChangeCharts,
+        })(sheetId, columnIndex);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "freeze-column",
+            sheetId: sheetId,
+            columnIndex: columnIndex,
+        });
+    }, [
+        canEditSheet,
+        createHistory,
+        onChangeSheets,
+        onChangeEmbeds,
+        onChangeCharts,
+        onCommand,
+    ]);
+    return [onFreezeRow, onFreezeColumn];
+};

package/dist/cjs/hooks/use-on-group-columns.d.ts

@@ -0,0 +1,11 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnGroupColumnsProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+export declare const useOnGroupColumns: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnGroupColumnsProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+//# sourceMappingURL=use-on-group-columns.d.ts.map

package/dist/cjs/hooks/use-on-group-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-group-columns.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-group-columns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACxE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIpE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGjB,MAAM,iBAAiB,MAAM,EAAE,SAkC5C,CAAC"}

package/dist/cjs/hooks/use-on-group-columns.js

@@ -0,0 +1,49 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { clampOutlineLevel, contiguousSpans } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnGroupColumns = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, columnIndexes) {
+        if (!canEditSheet(sheetId) || columnIndexes.length === 0)
+            return;
+        var saveHistory = createHistory();
+        var sorted = __spreadArray([], __read(columnIndexes), false).sort(function (a, b) { return a - b; });
+        var spans = contiguousSpans(sorted);
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var _b;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!sheet)
+                    return;
+                if (!sheet.columnMetadata)
+                    sheet.columnMetadata = [];
+                try {
+                    for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                        var _c = spans_1_1.value, start = _c.start, end = _c.end;
+                        for (var c = start; c <= end; c++) {
+                            if (!sheet.columnMetadata[c]) {
+                                sheet.columnMetadata[c] = {};
+                            }
+                            var meta = sheet.columnMetadata[c];
+                            meta.outlineLevel = clampOutlineLevel(((_b = meta.outlineLevel) !== null && _b !== void 0 ? _b : 0) + 1);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_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 } });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "group-columns", sheetId: sheetId, columnIndexes: columnIndexes });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-group-rows.d.ts

@@ -0,0 +1,17 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnGroupRowsProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+/**
+ * Group a contiguous run of rows. The selection is split into
+ * contiguous spans first (so non-adjacent rows form independent
+ * groups). Each span has its `outlineLevel` incremented by one, capped
+ * at 7. Matches Excel's Data → Group → Rows command.
+ */
+export declare const useOnGroupRows: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnGroupRowsProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+//# sourceMappingURL=use-on-group-rows.d.ts.map

package/dist/cjs/hooks/use-on-group-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-group-rows.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-group-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EACN,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACrE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIjE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,eAGd,MAAM,cAAc,MAAM,EAAE,SAkCzC,CAAC"}

package/dist/cjs/hooks/use-on-group-rows.js

@@ -0,0 +1,55 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { clampOutlineLevel, contiguousSpans } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+/**
+ * Group a contiguous run of rows. The selection is split into
+ * contiguous spans first (so non-adjacent rows form independent
+ * groups). Each span has its `outlineLevel` incremented by one, capped
+ * at 7. Matches Excel's Data → Group → Rows command.
+ */
+export var useOnGroupRows = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, rowIndexes) {
+        if (!canEditSheet(sheetId) || rowIndexes.length === 0)
+            return;
+        var saveHistory = createHistory();
+        var sorted = __spreadArray([], __read(rowIndexes), false).sort(function (a, b) { return a - b; });
+        var spans = contiguousSpans(sorted);
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var _b;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!sheet)
+                    return;
+                if (!sheet.rowMetadata)
+                    sheet.rowMetadata = [];
+                try {
+                    for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                        var _c = spans_1_1.value, start = _c.start, end = _c.end;
+                        for (var r = start; r <= end; r++) {
+                            if (!sheet.rowMetadata[r]) {
+                                sheet.rowMetadata[r] = {};
+                            }
+                            var meta = sheet.rowMetadata[r];
+                            meta.outlineLevel = clampOutlineLevel(((_b = meta.outlineLevel) !== null && _b !== void 0 ? _b : 0) + 1);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_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 } });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "group-rows", sheetId: sheetId, rowIndexes: rowIndexes });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-hide-column.d.ts

@@ -0,0 +1,23 @@
+import type { SelectionArea } from "@rowsncolumns/common-types";
+import type { CanvasGridProps, CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import { useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseonHideColumnProps<T extends CellData, S extends Sheet> = {
+    getActiveCell(): {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    getSelections(): SelectionArea<SelectionAttributes>[];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeActiveCell: CanvasGridProps<T>["onChangeActiveCell"];
+    onChangeSelections: CanvasGridProps<T>["onChangeSelections"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    rowCount: number;
+    columnCount: number;
+    getNextFocusableCell?: ReturnType<typeof useSpreadsheet>["getNextFocusableCell"];
+    onCommand?: OnCommand;
+};
+export declare const useOnHideColumn: <T extends CellData, S extends Sheet>({ createHistory, getActiveCell, getSelections, onChangeActiveCell, onChangeSelections, onChangeSheets, rowCount, columnCount, onCommand, }: UseonHideColumnProps<T, S>) => (sheetId: number, columnIndexes: number[]) => void;
+//# sourceMappingURL=use-on-hide-column.d.ts.map

package/dist/cjs/hooks/use-on-hide-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-hide-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-hide-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EACV,eAAe,EACf,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,cAAc,EACf,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACtE,aAAa,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,aAAa,IAAI,aAAa,CAAC,mBAAmB,CAAC,EAAE,CAAC;IACtD,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7D,kBAAkB,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,CAAC,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,sBAAsB,CAAC,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4IAUlE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,eAMf,MAAM,iBAAiB,MAAM,EAAE,SAgD5C,CAAC"}

package/dist/cjs/hooks/use-on-hide-column.js

@@ -0,0 +1,55 @@
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useSpreadsheet, } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { hideColumns } from "../interface/hide-column";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export var useOnHideColumn = function (_a) {
+    var createHistory = _a.createHistory, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeSheets = _a.onChangeSheets, _b = _a.rowCount, rowCount = _b === void 0 ? DEFAULT_ROW_COUNT : _b, _c = _a.columnCount, columnCount = _c === void 0 ? DEFAULT_COLUMN_COUNT : _c, onCommand = _a.onCommand;
+    var getNextFocusableCell = useSpreadsheet().getNextFocusableCell;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, columnIndexes) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "formatColumns")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't hide or show columns on a protected sheet.",
+            });
+            return;
+        }
+        hideColumns({
+            createHistory: createHistory,
+            getActiveCell: getActiveCell,
+            getSelections: getSelections,
+            onChangeActiveCell: onChangeActiveCell,
+            onChangeSelections: onChangeSelections,
+            onChangeSheets: onChangeSheets,
+            rowCount: rowCount !== null && rowCount !== void 0 ? rowCount : DEFAULT_ROW_COUNT,
+            columnCount: columnCount !== null && columnCount !== void 0 ? columnCount : DEFAULT_COLUMN_COUNT,
+            getNextFocusableCell: getNextFocusableCell,
+        })(sheetId, columnIndexes);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "hide-column",
+            sheetId: sheetId,
+            columnIndexes: columnIndexes,
+        });
+    }, [
+        createHistory,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        rowCount,
+        columnCount,
+        getActiveCell,
+        getSelections,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        getNextFocusableCell,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-hide-row.d.ts

@@ -0,0 +1,32 @@
+import type { SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import { useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnHideRowProps<T extends CellData, S extends Sheet> = {
+    getActiveCell(): {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    getSelections(): SelectionArea<any>[];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeActiveCell(sheetId: number, cell: {
+        rowIndex: number;
+        columnIndex: number;
+    }): void;
+    onChangeSelections(sheetId: number, sel: SelectionArea<any>[]): void;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    columnCount: number;
+    rowCount: number;
+    getNextFocusableCell?: ReturnType<typeof useSpreadsheet>["getNextFocusableCell"];
+    onCommand?: OnCommand;
+    /**
+     * Called after row visibility changed. Values are untouched so the
+     * calc graph sees nothing dirty, but visibility-aware formulas
+     * (SUBTOTAL) must recalculate.
+     */
+    onRowVisibilityChange?: () => void;
+};
+export declare const useOnHideRow: <T extends CellData, S extends Sheet>({ createHistory, getActiveCell, getSelections, onChangeActiveCell, onChangeSelections, onChangeSheets, columnCount, rowCount, onCommand, onRowVisibilityChange, }: UseOnHideRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+//# sourceMappingURL=use-on-hide-row.d.ts.map

package/dist/cjs/hooks/use-on-hide-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-hide-row.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-hide-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAGL,cAAc,EACf,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACnE,aAAa,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,aAAa,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;IACtC,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAC9C,IAAI,CAAC;IACR,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC;IACrE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,sBAAsB,CAAC,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,IAAI,CAAC;CACpC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,mKAW/D,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,eAMZ,MAAM,cAAc,MAAM,EAAE,SAoDzC,CAAC"}

package/dist/cjs/hooks/use-on-hide-row.js

@@ -0,0 +1,58 @@
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useSpreadsheet, } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { hideRows } from "../interface/hide-row";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export var useOnHideRow = function (_a) {
+    var createHistory = _a.createHistory, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeSheets = _a.onChangeSheets, _b = _a.columnCount, columnCount = _b === void 0 ? DEFAULT_COLUMN_COUNT : _b, _c = _a.rowCount, rowCount = _c === void 0 ? DEFAULT_ROW_COUNT : _c, onCommand = _a.onCommand, onRowVisibilityChange = _a.onRowVisibilityChange;
+    var getNextFocusableCell = useSpreadsheet().getNextFocusableCell;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, rowIndexes) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "formatRows")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't hide or show rows on a protected sheet.",
+            });
+            return;
+        }
+        hideRows({
+            createHistory: createHistory,
+            getActiveCell: getActiveCell,
+            getSelections: getSelections,
+            onChangeActiveCell: onChangeActiveCell,
+            onChangeSelections: onChangeSelections,
+            onChangeSheets: onChangeSheets,
+            columnCount: columnCount,
+            rowCount: rowCount,
+            getNextFocusableCell: getNextFocusableCell,
+        })(sheetId, rowIndexes);
+        // Hiding rows affects SUBTOTAL(101-111) results
+        onRowVisibilityChange === null || onRowVisibilityChange === void 0 ? void 0 : onRowVisibilityChange();
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "hide-row",
+            sheetId: sheetId,
+            rowIndexes: rowIndexes,
+        });
+    }, [
+        createHistory,
+        getSelections,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        getActiveCell,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        columnCount,
+        rowCount,
+        getNextFocusableCell,
+        onCommand,
+        onRowVisibilityChange,
+    ]);
+};

package/dist/cjs/hooks/use-on-hide-show-sheet.d.ts

@@ -0,0 +1,18 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnShowHideSheetsProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeActiveSheet(sheetId: number): void;
+    sheets: Sheet[];
+    sheetId: number;
+    onCommand?: OnCommand;
+};
+export declare const useOnShowHideSheet: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, onChangeActiveSheet, sheets, sheetId: previousSheetId, onCommand, }: UseOnShowHideSheetsProps<T, S>) => {
+    onHideSheet: (sheetId: number) => void;
+    onShowSheet: (sheetId: number) => void;
+};
+export {};
+//# sourceMappingURL=use-on-hide-show-sheet.d.ts.map

package/dist/cjs/hooks/use-on-hide-show-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-hide-show-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-hide-show-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,wBAAwB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACnE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sGAOrE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC;2BAKnB,MAAM;2BA+DN,MAAM;CAkDnB,CAAC"}

package/dist/cjs/hooks/use-on-hide-show-sheet.js

@@ -0,0 +1,90 @@
+import { __read } from "tslib";
+import { sortSheetsByIndex } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useCanEditSheet, useCanEditWorkbook } from "./use-can-edit-cellrange";
+export var useOnShowHideSheet = function (_a) {
+    var onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, onChangeActiveSheet = _a.onChangeActiveSheet, sheets = _a.sheets, previousSheetId = _a.sheetId, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    var canEditWorkbook = useCanEditWorkbook();
+    // Hide sheets
+    var onHideSheet = useCallback(function (sheetId) {
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot hide a sheet.");
+            return;
+        }
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        var saveHistory = createHistory();
+        var sortedSheets = sortSheetsByIndex(sheets).filter(function (sheet) { return !sheet.hidden; });
+        var index = sortedSheets.findIndex(function (sheet) { return sheet.sheetId === sheetId; });
+        var prevSheetId = index === 0
+            ? sortedSheets[index + 1].sheetId
+            : sortedSheets[Math.max(0, index - 1)].sheetId;
+        // Switch to new sheet
+        onChangeActiveSheet(prevSheetId);
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    sheet.hidden = true;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: prevSheetId },
+            });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "hide-sheet", sheetId: sheetId });
+    }, [
+        sheets,
+        onChangeSheets,
+        createHistory,
+        onChangeActiveSheet,
+        canEditSheet,
+        canEditWorkbook,
+        onCommand,
+    ]);
+    // Show sheets
+    var onShowSheet = useCallback(function (sheetId) {
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot show a sheet.");
+            return;
+        }
+        if (!(canEditSheet === null || canEditSheet === void 0 ? void 0 : canEditSheet(sheetId))) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        var saveHistory = createHistory();
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    sheet.hidden = false;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: previousSheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "show-sheet", sheetId: sheetId });
+    }, [
+        previousSheetId,
+        onChangeSheets,
+        createHistory,
+        canEditSheet,
+        canEditWorkbook,
+        onCommand,
+    ]);
+    return {
+        onHideSheet: onHideSheet,
+        onShowSheet: onShowSheet,
+    };
+};

package/dist/cjs/hooks/use-on-import-csv-legacy.d.ts

@@ -0,0 +1,8 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { InsertFileOptions } from "./use-on-drag-n-drop";
+import type { UseOnImportCSVProps } from "./use-on-import-csv";
+export declare const useOnImportCSVLegacy: <T extends CellData, S extends Sheet>({ locale, sheetId: activeSheetId, activeCell: currentActiveCell, createHistory, onChangeSheets, onChangeSheetData, sharedStringRegistry, enabledSharedStrings, enqueueCalculation, getDependents, }: UseOnImportCSVProps<T, S>) => {
+    importCSVFile: (file: File, sheetId?: number, activeCell?: CellInterface, options?: InsertFileOptions) => Promise<void>;
+};
+//# sourceMappingURL=use-on-import-csv-legacy.d.ts.map

package/dist/cjs/hooks/use-on-import-csv-legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-import-csv-legacy.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-import-csv-legacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAejE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAG/D,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qMAWvE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC;0BAQhB,IAAI,iCAEE,aAAa,YACf,iBAAiB;CAsLhC,CAAC"}