@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-change-formatting.js

@@ -0,0 +1,158 @@
+import { useCallback, useRef } from "react";
+import { changeBorder } from "../interface/change-border";
+import { changeFormatting } from "../interface/change-formatting";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditCellRange, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export const useOnChangeFormatting = ({ locale, cellXfsRegistry, getFormattedValue, onChangeSheetData, onChangeSheets, enqueueCalculation, createHistory, getCellDimensions, getRowHeight, isMergedCell, getDataValidationById, onCommand, }) => {
+    const canEditCellRange = useCanEditCellRange();
+    const canPerformSheetAction = useCanPerformSheetAction();
+    const showError = useShowError();
+    const lastFormattingRef = useRef(undefined);
+    // Change formatting
+    const onChangeFormatting = useCallback((...args) => {
+        let sheetId;
+        let activeCell;
+        let type;
+        let value;
+        let cellFormatOrCellFormatArray;
+        if (args.length === 5) {
+            [sheetId, activeCell, , type, value] = args;
+            // Cell format
+            cellFormatOrCellFormatArray = { [type]: value };
+        }
+        else {
+            [sheetId, activeCell, , cellFormatOrCellFormatArray] =
+                args;
+        }
+        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;
+        }
+        changeFormatting({
+            createHistory,
+            enqueueCalculation,
+            getCellDimensions,
+            getFormattedValue,
+            getRowHeight,
+            isMergedCell,
+            onChangeSheetData,
+            onChangeSheets,
+            locale,
+            cellXfsRegistry,
+            getDataValidationById,
+        })(...args);
+        // Keep reference of last formatting
+        if (cellFormatOrCellFormatArray &&
+            !Array.isArray(cellFormatOrCellFormatArray)) {
+            lastFormattingRef.current = [cellFormatOrCellFormatArray];
+        }
+        // Emit semantic command. Both call shapes normalize to a CellFormat.
+        if (onCommand) {
+            const selections = (args[2] ??
+                []);
+            const optionsArg = args.length === 5
+                ? args[5]
+                : args[4];
+            onCommand({
+                command: "change-formatting",
+                sheetId,
+                activeCell,
+                selections,
+                cellFormat: cellFormatOrCellFormatArray,
+                options: optionsArg,
+            });
+        }
+    }, [
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        isMergedCell,
+        onChangeSheetData,
+        enqueueCalculation,
+        onChangeSheets,
+        createHistory,
+        getFormattedValue,
+        getCellDimensions,
+        getRowHeight,
+        canEditCellRange,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+    ]);
+    // Change borders
+    const onChangeBorder = useCallback((sheetId, activeCell, selections, location, color, style = "solid") => {
+        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;
+        }
+        changeBorder({
+            createHistory,
+            enqueueCalculation,
+            getCellDimensions,
+            getFormattedValue,
+            getRowHeight,
+            isMergedCell,
+            onChangeSheetData,
+            onChangeSheets,
+            locale,
+            cellXfsRegistry,
+        })(sheetId, activeCell, selections, location, color, style);
+        // Keep reference of last formatting
+        lastFormattingRef.current = ["borders", location, color, style];
+        // Emit semantic command, mirroring the callback args verbatim.
+        onCommand?.({
+            command: "change-border",
+            sheetId,
+            activeCell,
+            selections,
+            location,
+            color,
+            style,
+        });
+    }, [
+        locale,
+        createHistory,
+        canEditCellRange,
+        canPerformSheetAction,
+        showError,
+        cellXfsRegistry,
+        getCellDimensions,
+        getFormattedValue,
+        getRowHeight,
+        isMergedCell,
+        onChangeSheets,
+        onChangeSheetData,
+        enqueueCalculation,
+        onCommand,
+    ]);
+    // rRepeat formatting
+    const onRepeatFormatting = useCallback((sheetId, activeCell, selections) => {
+        const previousFormatting = lastFormattingRef.current;
+        if (previousFormatting) {
+            const [type] = previousFormatting;
+            // Borders
+            if (type === "borders" && previousFormatting.length === 4) {
+                const [_, location, color, style] = previousFormatting;
+                onChangeBorder?.(sheetId, activeCell, selections, location, color, style);
+            }
+            else {
+                onChangeFormatting?.(sheetId, activeCell, selections, previousFormatting);
+            }
+        }
+    }, [onChangeFormatting, onChangeBorder]);
+    return { onChangeFormatting, onChangeBorder, onRepeatFormatting };
+};

package/dist/esm/hooks/use-on-change-sheet-tabcolor.d.ts

@@ -0,0 +1,11 @@
+import { type CellData, type Color, type 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 UseOnChangeSheetTabcolorProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnChangeSheetTabcolor: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, onCommand, }: UseOnChangeSheetTabcolorProps<T, S>) => (sheetId: number, color: Color | undefined) => void;
+//# sourceMappingURL=use-on-change-sheet-tabcolor.d.ts.map

package/dist/esm/hooks/use-on-change-sheet-tabcolor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-sheet-tabcolor.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-sheet-tabcolor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,KAAK,KAAK,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,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,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AACF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAI3E,6BAA6B,CAAC,CAAC,EAAE,CAAC,CAAC,eAIxB,MAAM,SAAS,KAAK,GAAG,SAAS,SA2B7C,CAAC"}

package/dist/esm/hooks/use-on-change-sheet-tabcolor.js

@@ -0,0 +1,26 @@
+import { useCallback } from "react";
+import { changeSheetTabcolor } from "../interface/change-sheet-tabcolor";
+import { useCanEditSheet, useCanEditWorkbook } from "./use-can-edit-cellrange";
+export const useOnChangeSheetTabcolor = ({ onChangeSheets, createHistory, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    const canEditWorkbook = useCanEditWorkbook();
+    return useCallback((sheetId, color) => {
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot change sheet tab color.");
+            return;
+        }
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        changeSheetTabcolor({
+            onChangeSheets,
+            createHistory,
+        })(sheetId, color);
+        onCommand?.({
+            command: "change-sheet-tab-color",
+            sheetId,
+            color,
+        });
+    }, [createHistory, onChangeSheets, canEditSheet, canEditWorkbook, onCommand]);
+};

package/dist/esm/hooks/use-on-change-table-column.d.ts

@@ -0,0 +1,25 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnChangeTableColumnProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    enqueueGraphOperation(operation: CalculationOperation): void;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+export declare const useOnChangeTableColumn: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, onChangeTables, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, onCommand, generatedNames, }: UseOnChangeTableColumnProps<T, S>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined, isRowExpansion: boolean, isColumnExpansion: boolean, range: GridRange) => void;
+//# sourceMappingURL=use-on-change-table-column.d.ts.map

package/dist/esm/hooks/use-on-change-table-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-table-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-table-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,qBAAqB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAE7D,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2LAYzE,2BAA2B,CAAC,CAAC,EAAE,CAAC,CAAC,eAIrB,MAAM,UACP,aAAa,SACd,MAAM,GAAG,OAAO,GAAG,SAAS,gBACrB,SAAS,GAAG,SAAS,kBACnB,OAAO,qBACJ,OAAO,SACnB,SAAS,SA4DrB,CAAC"}

package/dist/esm/hooks/use-on-change-table-column.js

@@ -0,0 +1,52 @@
+import { useTokenizer } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { changeTableColumn } from "../interface/change-table-column";
+export const useOnChangeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, onChangeTables, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, onCommand, generatedNames, }) => {
+    const tokenizer = useTokenizer();
+    return useCallback((sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range) => {
+        changeTableColumn({
+            locale,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            onChangeSheetData,
+            onChangeTables,
+            getDependents,
+            enqueueCalculation,
+            enqueueGraphOperation,
+            createHistory,
+            tokenizer,
+            generatedNames,
+        })(sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range);
+        // A header-cell edit on an existing column is a rename — stream the intent so the engine
+        // updates its header list + redefines the table (structured refs resolve to the new name).
+        // Column expansion (adding a column) rides update-table; this is only the in-place rename.
+        if (currentTable &&
+            !isColumnExpansion &&
+            currentTable.range.startRowIndex === coords.rowIndex &&
+            coords.columnIndex >= currentTable.range.startColumnIndex &&
+            coords.columnIndex <= currentTable.range.endColumnIndex &&
+            typeof value === "string" &&
+            value) {
+            onCommand?.({
+                command: "change-table-column",
+                sheetId,
+                tableId: currentTable.id,
+                columnIndex: coords.columnIndex,
+                name: value,
+            });
+        }
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeSheetData,
+        onChangeTables,
+        getDependents,
+        enqueueCalculation,
+        enqueueGraphOperation,
+        createHistory,
+        tokenizer,
+        onCommand,
+        generatedNames,
+    ]);
+};

package/dist/esm/hooks/use-on-change-theme.d.ts

@@ -0,0 +1,11 @@
+import type { CellData, SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnChangeThemeProps<T extends CellData> = {
+    onChangeTheme: UseSpreadsheetProps<T>["onChangeTheme"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnChangeTheme: <T extends CellData>({ createHistory, onChangeTheme, onCommand, }: UseOnChangeThemeProps<T>) => (theme: SpreadsheetTheme) => Promise<void>;
+//# sourceMappingURL=use-on-change-theme.d.ts.map

package/dist/esm/hooks/use-on-change-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-theme.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAG5E,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,qBAAqB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACtD,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IACvD,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,8CAIlD,qBAAqB,CAAC,CAAC,CAAC,aAET,gBAAgB,kBAUjC,CAAC"}

package/dist/esm/hooks/use-on-change-theme.js

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { changeTheme } from "../interface/change-theme";
+export const useOnChangeTheme = ({ createHistory, onChangeTheme, onCommand, }) => {
+    return useCallback(async (theme) => {
+        await changeTheme({
+            createHistory,
+            onChangeTheme,
+        })(theme);
+        onCommand?.({ command: "change-theme", theme });
+    }, [createHistory, onChangeTheme, onCommand]);
+};

package/dist/esm/hooks/use-on-change.d.ts

@@ -0,0 +1,61 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { TextFormatRun } from "@rowsncolumns/ui";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnChangeProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    tables?: TableView[];
+    getUserEnteredValue: ReturnType<typeof useSheetProperties>["getUserEnteredValue"];
+    /**
+     * Reads the previous textFormatRuns from the cell store. Used to
+     * detect pure-formatting edits (value unchanged, runs differ) when
+     * the caller doesn't supply `previousTextFormatRuns` explicitly.
+     */
+    getTextFormatRuns?: ReturnType<typeof useSheetProperties>["getTextFormatRuns"];
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    enqueueGraphOperation(operation: CalculationOperation): void;
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    getSheetName(sheetId: number): string;
+    /**
+     * Check if a cell is merged cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @returns
+     */
+    isMergedCell: (sheetId: number, rowIndex: number, columnIndex: number) => boolean | undefined;
+    /**
+     * Emit a high-level command alongside the immer-patch history.
+     */
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+/**
+ * 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 declare const useOnChange: <T extends CellData, S extends Sheet>({ locale, tables, cellXfsRegistry, sharedStringRegistry, getUserEnteredValue, getTextFormatRuns, onChangeSheetData, onChangeTables, onChangeSheets, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, getDataValidationById, getSheetName, onCommand, generatedNames, }: UseOnChangeProps<T, S>) => (sheetId: number, coords: CellInterface, value: string, textFormatRuns: TextFormatRun[] | undefined | null, previousValue?: string | boolean | undefined, isDirty?: boolean, previousTextFormatRuns?: TextFormatRun[] | undefined | null) => void;
+//# sourceMappingURL=use-on-change.d.ts.map

package/dist/esm/hooks/use-on-change.d.ts.map

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

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

@@ -0,0 +1,281 @@
+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.
+ */
+const areTextFormatRunsEqual = (a, b) => {
+    const lenA = a?.length ?? 0;
+    const lenB = b?.length ?? 0;
+    if (lenA === 0 && lenB === 0)
+        return true;
+    if (lenA !== lenB)
+        return false;
+    // Both are non-empty arrays of the same length here.
+    for (let i = 0; i < lenA; i++) {
+        const ra = a[i];
+        const 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 (ra.mention?.value !== rb.mention?.value)
+                return false;
+            if (ra.mention?.label !== rb.mention?.label)
+                return false;
+            continue;
+        }
+        // Text runs — compare format keys.
+        const fa = ra.format ?? {};
+        const fb = rb.format ?? {};
+        const keys = new Set([...Object.keys(fa), ...Object.keys(fb)]);
+        for (const k of keys) {
+            if (fa[k] !== fb[k])
+                return false;
+        }
+    }
+    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 const useOnChange = ({ locale, tables, cellXfsRegistry, sharedStringRegistry, getUserEnteredValue, getTextFormatRuns, onChangeSheetData, onChangeTables, onChangeSheets, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, getDataValidationById, getSheetName, onCommand, generatedNames, }) => {
+    // Allowed values
+    const getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    const onChangeCalculatedColumn = useOnChangeCalculatedColumn({
+        locale,
+        createHistory,
+        enqueueCalculation,
+        getUserEnteredValue,
+        onChangeSheetData,
+        onChangeTables,
+        getSheetName,
+        onCommand,
+    });
+    const onChangeTableColumn = useOnChangeTableColumn({
+        locale,
+        createHistory,
+        enqueueCalculation: enqueueGraphOperation,
+        enqueueGraphOperation,
+        onChangeSheetData,
+        onChangeTables,
+        getDependents,
+        onCommand,
+        generatedNames,
+    });
+    const adjustRowHeight = useOnAdjustRowHeight({
+        onChangeSheets,
+    });
+    const canEditCellRange = useCanEditCellRange();
+    const tokenizer = useTokenizer();
+    return useCallback((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
+        const isFormula = isAFormula(value);
+        // We need to track this for history. Precedent cells
+        const 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.
+        const previousRuns = previousTextFormatRuns ??
+            getTextFormatRuns?.(sheetId, coords.rowIndex, coords.columnIndex);
+        const 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
+        const tableHeaderColumnIndex = findTableColumnIndex(sheetId, coords, tables);
+        // When user enters a value in the last row of a
+        // table and if the entire row is empty
+        const [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(sheetId, coords, tables, getUserEnteredValue);
+        // Calculated columns
+        const currentTable = isColumnExpansion && adjacentTable
+            ? adjacentTable
+            : findActiveTableWithinCell(sheetId, coords, tables);
+        // Check if neighbouring column
+        // If so transform =TableName[@column] => =[@column]
+        const isAdjacentColumn = currentTable &&
+            coords.columnIndex === currentTable.range.endColumnIndex + 1;
+        const { rowIndex, columnIndex } = coords;
+        const saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                // Create a cell
+                const sheetCell = new SheetCell(sheetId, coords, cellData, {
+                    getRangeValues: getEffectiveValuesFromRange,
+                    locale,
+                    cellXfsRegistry,
+                    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.
+                const prevHasNewline = typeof previousValue === "string" && previousValue.includes("\n");
+                const valueHasNewline = typeof value === "string" && value.includes("\n");
+                if (valueHasNewline && !prevHasNewline) {
+                    sheetCell.setUserEnteredFormat("wrapStrategy", "wrap");
+                }
+                else if (!valueHasNewline && prevHasNewline) {
+                    sheetCell.setUserEnteredFormat("wrapStrategy", undefined);
+                }
+                sharedStringRegistry?.registerCell(sheetCell);
+                // Set cell data
+                currentSheet[rowIndex].values[columnIndex] =
+                    sheetCell.getCellData();
+                // Register cellXfs
+                cellXfsRegistry?.registerCellXfs(sheetCell);
+                // Enqueue
+                enqueueCalculation({
+                    position: { rowIndex, columnIndex, sheetId },
+                    type: "add",
+                    force: true,
+                });
+                // Add to recalc cells
+                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                    rowIndex,
+                    columnIndex,
+                    sheetId,
+                    force: true,
+                });
+            });
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches,
+                    patches,
+                },
+                activeCell: { undo: coords, redo: coords },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry?.getPatches(saveHistory);
+        // Save shared strings patches
+        sharedStringRegistry?.getPatches(saveHistory);
+        // Update table columns if necessary
+        // User is updating table column name
+        if (!isNil(tableHeaderColumnIndex) && currentTable) {
+            onChangeTables?.((prevTableData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
+                    const table = draft.find((table) => table.range.startRowIndex === rowIndex &&
+                        table.sheetId === sheetId &&
+                        table.id === currentTable.id);
+                    // Update table name
+                    if (table && table.columns?.length) {
+                        if (!table.columns[tableHeaderColumnIndex]) {
+                            table.columns[tableHeaderColumnIndex] = {
+                                name: String(value),
+                            };
+                        }
+                        else {
+                            // Update name
+                            table.columns[tableHeaderColumnIndex].name = String(value);
+                        }
+                    }
+                });
+                saveHistory({
+                    tables: { patches, 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);
+        }
+        // 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?.({
+            command: "set-value",
+            sheetId,
+            coords,
+            value,
+            textFormatRuns,
+            previousValue,
+            isDirty,
+        });
+    }, [
+        locale,
+        tables,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        tokenizer,
+        onChangeCalculatedColumn,
+        onChangeTableColumn,
+        onChangeSheetData,
+        onChangeTables,
+        enqueueCalculation,
+        createHistory,
+        adjustRowHeight,
+        getUserEnteredValue,
+        getTextFormatRuns,
+        getEffectiveValuesFromRange,
+        canEditCellRange,
+        getDataValidationById,
+        onCommand,
+    ]);
+};