@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,298 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { findActiveTableWithinCell, useGetEffectiveValuesFromRange, useTokenizer, } from "@rowsncolumns/spreadsheet";
+import { convertCellToRange, isAFormula, isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { findAdjacentTable, findTableColumnIndex, removeTableName, } from "../api/table";
+import { createSheetDraft } from "./../api/immer-utils";
+import { SheetCell } from "./../sheet-cell";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+import { useOnAdjustRowHeight } from "./use-on-adjust-row-height";
+import { useOnChangeCalculatedColumn } from "./use-on-change-calculated-column";
+import { useOnChangeTableColumn } from "./use-on-change-table-column";
+/**
+ * Deep equality for `TextFormatRun[]`. Lightweight — assumes both
+ * sides come from the same producer (PM extractor) so key order on
+ * the inner `format` object is stable, but we still iterate keys for
+ * safety because xlsx-imported runs may not match PM's key order.
+ *
+ * `undefined` and an empty array are treated as equal — the runs are
+ * "absent" either way.
+ */
+var areTextFormatRunsEqual = function (a, b) {
+    var e_1, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j;
+    var lenA = (_b = a === null || a === void 0 ? void 0 : a.length) !== null && _b !== void 0 ? _b : 0;
+    var lenB = (_c = b === null || b === void 0 ? void 0 : b.length) !== null && _c !== void 0 ? _c : 0;
+    if (lenA === 0 && lenB === 0)
+        return true;
+    if (lenA !== lenB)
+        return false;
+    // Both are non-empty arrays of the same length here.
+    for (var i = 0; i < lenA; i++) {
+        var ra = a[i];
+        var rb = b[i];
+        if (ra.startIndex !== rb.startIndex)
+            return false;
+        if (ra.endIndex !== rb.endIndex)
+            return false;
+        if (ra.nodeType !== rb.nodeType)
+            return false;
+        if (ra.nodeType === "mention") {
+            if (rb.nodeType !== "mention")
+                return false;
+            if (((_d = ra.mention) === null || _d === void 0 ? void 0 : _d.value) !== ((_e = rb.mention) === null || _e === void 0 ? void 0 : _e.value))
+                return false;
+            if (((_f = ra.mention) === null || _f === void 0 ? void 0 : _f.label) !== ((_g = rb.mention) === null || _g === void 0 ? void 0 : _g.label))
+                return false;
+            continue;
+        }
+        // Text runs — compare format keys.
+        var fa = (_h = ra.format) !== null && _h !== void 0 ? _h : {};
+        var fb = (_j = rb.format) !== null && _j !== void 0 ? _j : {};
+        var keys = new Set(__spreadArray(__spreadArray([], __read(Object.keys(fa)), false), __read(Object.keys(fb)), false));
+        try {
+            for (var keys_1 = (e_1 = void 0, __values(keys)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                var k = keys_1_1.value;
+                if (fa[k] !== fb[k])
+                    return false;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return true;
+};
+/**
+ * Change handler
+ * Undo history order
+ * 1. Cell change
+ * 2. If Table
+ *  1. Add column
+ *  2. If computed column - Fill all computed columns
+ *
+ * Refactor use-on-change and use-on-paste.
+ * @param param0
+ * @returns
+ */
+export var useOnChange = function (_a) {
+    var locale = _a.locale, tables = _a.tables, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getUserEnteredValue = _a.getUserEnteredValue, getTextFormatRuns = _a.getTextFormatRuns, onChangeSheetData = _a.onChangeSheetData, onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, getDataValidationById = _a.getDataValidationById, getSheetName = _a.getSheetName, onCommand = _a.onCommand, generatedNames = _a.generatedNames;
+    // Allowed values
+    var getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    var onChangeCalculatedColumn = useOnChangeCalculatedColumn({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        getUserEnteredValue: getUserEnteredValue,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        getSheetName: getSheetName,
+        onCommand: onCommand,
+    });
+    var onChangeTableColumn = useOnChangeTableColumn({
+        locale: locale,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueGraphOperation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        getDependents: getDependents,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    var adjustRowHeight = useOnAdjustRowHeight({
+        onChangeSheets: onChangeSheets,
+    });
+    var canEditCellRange = useCanEditCellRange();
+    var tokenizer = useTokenizer();
+    return useCallback(function (sheetId, coords, value, textFormatRuns, previousValue, isDirty, previousTextFormatRuns) {
+        if (!canEditCellRange(sheetId, coords)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // Trigger formula changes always
+        var isFormula = isAFormula(value);
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Resolve previous runs: prefer the caller's snapshot, then fall
+        // back to reading the store. Either path can be undefined, in
+        // which case the comparison below treats "no previous runs" and
+        // "no new runs" as identical.
+        var previousRuns = previousTextFormatRuns !== null && previousTextFormatRuns !== void 0 ? previousTextFormatRuns : getTextFormatRuns === null || getTextFormatRuns === void 0 ? void 0 : getTextFormatRuns(sheetId, coords.rowIndex, coords.columnIndex);
+        var runsChanged = !areTextFormatRunsEqual(textFormatRuns, previousRuns);
+        // Exit early when nothing actually changed — neither the text
+        // value nor the rich-text runs. Without the runs guard, a pure
+        // formatting edit (Cmd+B on existing text, or unformat-to-plain)
+        // would be silently dropped because the value compares equal.
+        if (!isFormula &&
+            !runsChanged &&
+            ((!value && !previousValue) || value === previousValue)) {
+            return;
+        }
+        // Check if the user is editing a table column
+        var tableHeaderColumnIndex = findTableColumnIndex(sheetId, coords, tables);
+        // When user enters a value in the last row of a
+        // table and if the entire row is empty
+        var _a = __read(findAdjacentTable(sheetId, coords, tables, getUserEnteredValue), 3), adjacentTable = _a[0], isRowExpansion = _a[1], isColumnExpansion = _a[2];
+        // Calculated columns
+        var currentTable = isColumnExpansion && adjacentTable
+            ? adjacentTable
+            : findActiveTableWithinCell(sheetId, coords, tables);
+        // Check if neighbouring column
+        // If so transform =TableName[@column] => =[@column]
+        var isAdjacentColumn = currentTable &&
+            coords.columnIndex === currentTable.range.endColumnIndex + 1;
+        var rowIndex = coords.rowIndex, columnIndex = coords.columnIndex;
+        var saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                var cellData = (_a = currentSheet[rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+                // Create a cell
+                var sheetCell = new SheetCell(sheetId, coords, cellData, {
+                    getRangeValues: getEffectiveValuesFromRange,
+                    locale: locale,
+                    cellXfsRegistry: cellXfsRegistry,
+                    getDataValidationById: getDataValidationById,
+                });
+                // TODO: User is changing table column
+                if (!isNil(tableHeaderColumnIndex)) {
+                    // Update all formulas and change table column name
+                }
+                // Set text value of the cell
+                sheetCell.setUserEnteredValue(value, textFormatRuns);
+                // Match Excel's Alt+Enter behavior: wrapText tracks the presence
+                // of a hard line break in the committed value. Inserting the
+                // first newline enables wrap; backspacing the last newline out
+                // disables it. Synced only on a transition so wrap toggled
+                // manually on plain-text cells is preserved.
+                var prevHasNewline = typeof previousValue === "string" && previousValue.includes("\n");
+                var valueHasNewline = typeof value === "string" && value.includes("\n");
+                if (valueHasNewline && !prevHasNewline) {
+                    sheetCell.setUserEnteredFormat("wrapStrategy", "wrap");
+                }
+                else if (!valueHasNewline && prevHasNewline) {
+                    sheetCell.setUserEnteredFormat("wrapStrategy", undefined);
+                }
+                sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                // Set cell data
+                currentSheet[rowIndex].values[columnIndex] =
+                    sheetCell.getCellData();
+                // Register cellXfs
+                cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                // Enqueue
+                enqueueCalculation({
+                    position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                    type: "add",
+                    force: true,
+                });
+                // Add to recalc cells
+                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                    rowIndex: rowIndex,
+                    columnIndex: columnIndex,
+                    sheetId: sheetId,
+                    force: true,
+                });
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches: inversePatches,
+                    patches: patches,
+                },
+                activeCell: { undo: coords, redo: coords },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+        // Save shared strings patches
+        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+        // Update table columns if necessary
+        // User is updating table column name
+        if (!isNil(tableHeaderColumnIndex) && currentTable) {
+            onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTableData) {
+                var _a = __read(produceWithPatches(prevTableData, function (draft) {
+                    var _a;
+                    var table = draft.find(function (table) {
+                        return table.range.startRowIndex === rowIndex &&
+                            table.sheetId === sheetId &&
+                            table.id === currentTable.id;
+                    });
+                    // Update table name
+                    if (table && ((_a = table.columns) === null || _a === void 0 ? void 0 : _a.length)) {
+                        if (!table.columns[tableHeaderColumnIndex]) {
+                            table.columns[tableHeaderColumnIndex] = {
+                                name: String(value),
+                            };
+                        }
+                        else {
+                            // Update name
+                            table.columns[tableHeaderColumnIndex].name = String(value);
+                        }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({
+                    tables: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+        // Update sheets to maintain rowHeight
+        if (isDirty && !isFormula) {
+            adjustRowHeight(sheetId, rowIndex, columnIndex, value, undefined, undefined, saveHistory, 
+            // `null` (not undefined) when the commit has no runs, so the
+            // sizer measures uniformly instead of reading the stale
+            // pre-commit runs from the store.
+            textFormatRuns !== null && textFormatRuns !== void 0 ? textFormatRuns : null);
+        }
+        // Adds new column to table and cell to sheet
+        // User is adding a table column
+        // Add banded range too
+        onChangeTableColumn(sheetId, coords, value, adjacentTable, isRowExpansion, isColumnExpansion, convertCellToRange(coords));
+        // Add calculated column
+        // User is adding a computed column
+        onChangeCalculatedColumn(sheetId, coords, isAdjacentColumn
+            ? removeTableName(tokenizer(value), currentTable.title)
+            : value, currentTable);
+        // Emit semantic command for collaboration layer
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "set-value",
+            sheetId: sheetId,
+            coords: coords,
+            value: value,
+            textFormatRuns: textFormatRuns,
+            previousValue: previousValue,
+            isDirty: isDirty,
+        });
+    }, [
+        locale,
+        tables,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        tokenizer,
+        onChangeCalculatedColumn,
+        onChangeTableColumn,
+        onChangeSheetData,
+        onChangeTables,
+        enqueueCalculation,
+        createHistory,
+        adjustRowHeight,
+        getUserEnteredValue,
+        getTextFormatRuns,
+        getEffectiveValuesFromRange,
+        canEditCellRange,
+        getDataValidationById,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-clear-formatting.d.ts

@@ -0,0 +1,17 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, DataValidationRuleRecord, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnClearFormattingProps<T extends CellData> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    getDataValidationById?: (id: DataValidationRuleRecord["id"]) => DataValidationRuleRecord | undefined;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnClearFormatting: <T extends CellData>({ locale, cellXfsRegistry, getDataValidationById, onChangeSheetData, createHistory, onCommand, }: UseOnClearFormattingProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+//# sourceMappingURL=use-on-clear-formatting.d.ts.map

package/dist/cjs/hooks/use-on-clear-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-clear-formatting.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-clear-formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,qBAAqB,CAAC,EAAE,CACtB,EAAE,EAAE,wBAAwB,CAAC,IAAI,CAAC,KAC/B,wBAAwB,GAAG,SAAS,CAAC;IAC1C,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,kGAOtD,yBAAyB,CAAC,CAAC,CAAC,eAMhB,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,SA2CrD,CAAC"}

package/dist/cjs/hooks/use-on-clear-formatting.js

@@ -0,0 +1,46 @@
+import { useCallback } from "react";
+import { clearFormatting } from "../interface/clear-formatting";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditCellRange, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export var useOnClearFormatting = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, getDataValidationById = _a.getDataValidationById, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, onCommand = _a.onCommand;
+    var canEditCellRange = useCanEditCellRange();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, activeCell, selections) {
+        if (!canPerformSheetAction(sheetId, "formatCells")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't change formatting on a protected sheet.",
+            });
+            return;
+        }
+        if (!canEditCellRange(sheetId, activeCell)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        clearFormatting({
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+        })(sheetId, activeCell, selections);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "clear-formatting",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        onChangeSheetData,
+        createHistory,
+        canEditCellRange,
+        canPerformSheetAction,
+        showError,
+        getDataValidationById,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-collapse-column-group.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 UseOnCollapseColumnGroupProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+export declare const useOnCollapseColumnGroup: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnCollapseColumnGroupProps<T, S>) => (sheetId: number, summaryColumnIndex: number) => void;
+//# sourceMappingURL=use-on-collapse-column-group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-collapse-column-group.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-collapse-column-group.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,6BAA6B,CACvC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,IACb;IACF,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,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAI3E,6BAA6B,CAAC,CAAC,EAAE,CAAC,CAAC,eAGxB,MAAM,sBAAsB,MAAM,SAkD/C,CAAC"}

package/dist/cjs/hooks/use-on-collapse-column-group.js

@@ -0,0 +1,47 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { findGroupAtSummary, resolveSummaryRight } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnCollapseColumnGroup = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, summaryColumnIndex) {
+        if (!canEditSheet(sheetId))
+            return;
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    if (!sheet.columnMetadata)
+                        sheet.columnMetadata = [];
+                    var summaryRight = resolveSummaryRight((_a = sheet.outlinePr) !== null && _a !== void 0 ? _a : undefined);
+                    var group = findGroupAtSummary(sheet.columnMetadata, summaryColumnIndex, summaryRight);
+                    if (group) {
+                        for (var c = group.startIndex; c <= group.endIndex; c++) {
+                            if (!sheet.columnMetadata[c]) {
+                                sheet.columnMetadata[c] =
+                                    {};
+                            }
+                            sheet.columnMetadata[c].hiddenByGroup = true;
+                        }
+                        if (!sheet.columnMetadata[summaryColumnIndex]) {
+                            sheet.columnMetadata[summaryColumnIndex] =
+                                {};
+                        }
+                        sheet.columnMetadata[summaryColumnIndex].collapsed = true;
+                    }
+                }
+            }), 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: "collapse-column-group",
+            sheetId: sheetId,
+            summaryColumnIndex: summaryColumnIndex,
+        });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

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

@@ -0,0 +1,18 @@
+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 UseOnCollapseRowGroupProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onCommand?: OnCommand;
+};
+/**
+ * Collapse the outline group whose summary sits at `summaryRowIndex`.
+ * The summary itself is marked `collapsed=true` (that's where the `+`
+ * button paints); each child row gets `hiddenByGroup=true` so the
+ * render layer skips it. Manual `hiddenByUser` and filter
+ * `hiddenByFilter` stay untouched — they re-emerge on expand.
+ */
+export declare const useOnCollapseRowGroup: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onCommand, }: UseOnCollapseRowGroupProps<T, S>) => (sheetId: number, summaryRowIndex: number) => void;
+//# sourceMappingURL=use-on-collapse-row-group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-collapse-row-group.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-collapse-row-group.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,0BAA0B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC5E,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;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAIxE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,eAGrB,MAAM,mBAAmB,MAAM,SAoD5C,CAAC"}

package/dist/cjs/hooks/use-on-collapse-row-group.js

@@ -0,0 +1,57 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { findGroupAtSummary, resolveSummaryBelow } from "../api/outline";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+/**
+ * Collapse the outline group whose summary sits at `summaryRowIndex`.
+ * The summary itself is marked `collapsed=true` (that's where the `+`
+ * button paints); each child row gets `hiddenByGroup=true` so the
+ * render layer skips it. Manual `hiddenByUser` and filter
+ * `hiddenByFilter` stay untouched — they re-emerge on expand.
+ */
+export var useOnCollapseRowGroup = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, summaryRowIndex) {
+        if (!canEditSheet(sheetId))
+            return;
+        var saveHistory = createHistory();
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (!sheet) {
+                    return;
+                }
+                if (!sheet.rowMetadata) {
+                    sheet.rowMetadata = [];
+                }
+                var summaryBelow = resolveSummaryBelow((_a = sheet.outlinePr) !== null && _a !== void 0 ? _a : undefined);
+                var group = findGroupAtSummary(sheet.rowMetadata, summaryRowIndex, summaryBelow);
+                if (!group)
+                    return;
+                if (!sheet.rowMetadata)
+                    sheet.rowMetadata = [];
+                for (var r = group.startIndex; r <= group.endIndex; r++) {
+                    if (!sheet.rowMetadata[r]) {
+                        sheet.rowMetadata[r] = {};
+                    }
+                    sheet.rowMetadata[r].hiddenByGroup = true;
+                }
+                if (!sheet.rowMetadata[summaryRowIndex]) {
+                    sheet.rowMetadata[summaryRowIndex] =
+                        {};
+                }
+                sheet.rowMetadata[summaryRowIndex].collapsed = true;
+            }), 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: "collapse-row-group",
+            sheetId: sheetId,
+            summaryRowIndex: summaryRowIndex,
+        });
+    }, [canEditSheet, createHistory, onChangeSheets, onCommand]);
+};

package/dist/cjs/hooks/use-on-copy.d.ts

@@ -0,0 +1,49 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import { type GridRange, type SelectionArea } from "@rowsncolumns/grid";
+import type { SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { BandedRange, TableView } from "@rowsncolumns/spreadsheet";
+import { type CellData, type CellFormat, type SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { CellXfs, SharedStringValue, SharedStrings } from "../types";
+import type { useSheetProperties } from "./use-sheet-properties";
+type UseOnCopyProps<T extends CellData> = {
+    theme?: SpreadsheetTheme;
+    merges?: GridRange[] | null;
+    tables?: TableView[];
+    bandedRanges?: BandedRange[] | null;
+    getFormattedValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined | null;
+    getCellData(sheetId: number, rowIndex: number, columnIndex: number): T | undefined | null;
+    getColumnWidth(sheetId: number, columnIndex: number): number;
+    getRowHeight(sheetId: number, rowIndex: number): number;
+    cellXfs?: CellXfs | null;
+    sharedStrings?: SharedStrings | null;
+    getEffectiveFormat?: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+    isHiddenRow?(sheetId: number, rowIndex: number): boolean;
+    isColumnHidden?(sheetId: number, columnIndex: number): boolean;
+};
+export type EnhancedCellData<T> = {
+    data: T;
+    sourceCell?: CellInterface;
+    rowspan?: number;
+    colspan?: number;
+};
+export type TableViewWithDelta = TableView & {
+    rowDelta?: number;
+    colDelta?: number;
+};
+export type CopySchema<T extends CellData> = {
+    tables?: TableViewWithDelta[];
+    sheetData: EnhancedCellData<T | undefined | null>[][];
+    sharedStrings?: Record<string, SharedStringValue>;
+    cellXfs?: Array<[string | number, CellFormat | undefined | null]>;
+};
+/**
+ * Called when user copies a selection from sheet
+ * 1. User can copy from any cell
+ * 2. User can also copy from a different browser tab
+ * @param param0
+ * @returns
+ */
+export declare const useOnCopy: <T extends CellData>({ theme, merges, tables: sheetTables, bandedRanges, getFormattedValue, getCellData, getColumnWidth, getRowHeight, cellXfs, sharedStrings, getEffectiveFormat, isHiddenRow, isColumnHidden, }: UseOnCopyProps<T>) => (e: ClipboardEvent | undefined, sheetId: number, copiedSelections: SelectionArea<SelectionAttributes>[]) => void;
+export declare const useMergedCellMap: (merges?: GridRange[] | null) => Map<string, [isMasterCell: boolean, readonly [rowspan: number, colspan: number]]>;
+export {};
+//# sourceMappingURL=use-on-copy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-copy.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-copy.ts"],"names":[],"mappings":"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"}