@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-insert-table-row.js

@@ -0,0 +1,60 @@
+import { useCallback } from "react";
+import { insertTableRow } from "../interface/insert-table-row";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnInsertTableRow = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getActiveCell = _a.getActiveCell, getDependents = _a.getDependents, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, getSheetName = _a.getSheetName, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (tableView, relativeRowIndex, rowData) {
+        var sheetId = tableView.sheetId;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        // Insert table row
+        insertTableRow({
+            rowCount: rowCount,
+            columnCount: columnCount,
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            getActiveCell: getActiveCell,
+            getDependents: getDependents,
+            createHistory: createHistory,
+            enqueueGraphOperation: enqueueGraphOperation,
+            enqueueCalculation: enqueueCalculation,
+            enqueueStructureChange: enqueueStructureChange,
+            onChangeSheetData: onChangeSheetData,
+            onChangeSheets: onChangeSheets,
+            onChangeTables: onChangeTables,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+            onChangeDataValidations: onChangeDataValidations,
+            getSheetName: getSheetName,
+        })(tableView, relativeRowIndex, rowData);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "insert-table-row",
+            tableView: tableView,
+            relativeRowIndex: relativeRowIndex,
+            rowData: rowData,
+        });
+    }, [
+        columnCount,
+        rowCount,
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getActiveCell,
+        getDependents,
+        createHistory,
+        onChangeSheets,
+        onChangeTables,
+        onChangeSheetData,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        enqueueGraphOperation,
+        enqueueCalculation,
+        enqueueStructureChange,
+        canEditSheet,
+        getSheetName,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-insert-time.d.ts

@@ -0,0 +1,4 @@
+export declare const useOnInsertTime: ({ locale }?: {
+    locale?: string;
+}) => (sheetId: number, activeCell: import("@rowsncolumns/grid").CellInterface, selections: import("@rowsncolumns/grid").SelectionArea<import("@rowsncolumns/spreadsheet").SelectionAttributes>[]) => void;
+//# sourceMappingURL=use-on-insert-time.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-insert-time.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-insert-time.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,GAAI,aAAY;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,yMAUnE,CAAC"}

package/dist/cjs/hooks/use-on-insert-time.js

@@ -0,0 +1,12 @@
+import { useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import { getDefaultTimeFormat, ssfFormat } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+export var useOnInsertTime = function (_a) {
+    var _b = _a === void 0 ? {} : _a, locale = _b.locale;
+    var makeEditable = useSpreadsheet().makeEditable;
+    return useCallback(function (sheetId, activeCell) {
+        var now = new Date();
+        var time = ssfFormat(getDefaultTimeFormat(locale, "minute"), now, locale);
+        makeEditable === null || makeEditable === void 0 ? void 0 : makeEditable(sheetId, activeCell, time);
+    }, [locale, makeEditable]);
+};

package/dist/cjs/hooks/use-on-locale-change.d.ts

@@ -0,0 +1,35 @@
+import type { CellData, ConditionalFormatRule, DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { useUndoRedo } from "./use-undo-redo";
+export type UseOnLocaleChangeProps<T extends CellData> = {
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: ReturnType<typeof useUndoRedo>["createHistoryWithoutPointer"];
+    /**
+     * Data validations to normalize when locale changes
+     */
+    dataValidations?: DataValidationRuleRecord[];
+    /**
+     * Callback to update data validations
+     */
+    onChangeDataValidations?: (updater: (prev: DataValidationRuleRecord[]) => DataValidationRuleRecord[]) => void;
+    /**
+     * Conditional formats to normalize when locale changes
+     */
+    conditionalFormats?: ConditionalFormatRule[];
+    /**
+     * Callback to update conditional formats
+     */
+    onChangeConditionalFormats?: (updater: (prev: ConditionalFormatRule[]) => ConditionalFormatRule[]) => void;
+};
+/**
+ * Hook to handle locale changes.
+ * When locale changes, all cells with numeric values need their
+ * formatted values (fv) regenerated using the new locale's formatting rules.
+ * Also normalizes numeric values in data validations and conditional formats.
+ */
+export declare const useOnLocaleChange: <T extends CellData = CellData>({ cellXfsRegistry, sharedStringRegistry, onChangeSheetData, createHistory, dataValidations, onChangeDataValidations, conditionalFormats, onChangeConditionalFormats, }: UseOnLocaleChangeProps<T>) => (newLocale: string, oldLocale?: string) => void;
+//# sourceMappingURL=use-on-locale-change.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-locale-change.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-locale-change.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AAcnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAa,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA+LnD,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACvD,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,6BAA6B,CAAC,CAAC;IAC7E;;OAEG;IACH,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAC;IAC7C;;OAEG;IACH,uBAAuB,CAAC,EAAE,CACxB,OAAO,EAAE,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,wBAAwB,EAAE,KACtE,IAAI,CAAC;IACV;;OAEG;IACH,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC7C;;OAEG;IACH,0BAA0B,CAAC,EAAE,CAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,EAAE,KAAK,qBAAqB,EAAE,KAChE,IAAI,CAAC;CACX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,wKAS9D,sBAAsB,CAAC,CAAC,CAAC,iBAEZ,MAAM,cAAc,MAAM,SAoNzC,CAAC"}

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

@@ -0,0 +1,314 @@
+import { __assign, __read, __values } from "tslib";
+import { getCellEffectiveValue, getDefaultDateFormat, getDefaultDateTimeFormat, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { convertToNumber } from "../api/datatype";
+import { createSheetDraft } from "../api/immer-utils";
+import { getLocaleSeparators } from "../api/intl";
+import { SheetCell } from "../sheet-cell";
+var normalizePattern = function (pattern) {
+    return pattern === null || pattern === void 0 ? void 0 : pattern.trim().toLowerCase();
+};
+var replacePatternLocaleTags = function (pattern, locale) {
+    if (!pattern) {
+        return pattern !== null && pattern !== void 0 ? pattern : undefined;
+    }
+    var normalizedLocale = locale.trim().replace(/_/g, "-");
+    return pattern.replace(/\[\$-[^\]]+\]/gi, "[$-".concat(normalizedLocale, "]"));
+};
+/**
+ * Fold a date/date-time pattern to a canonical shape for locale-default
+ * detection. Locale defaults vary in separators (`/`, `.`, `-`, spaces),
+ * carry quoted literal text (bg-BG `" г."`, CJK `"年"`), and may include
+ * an `AM/PM` token — fold all separators and quoted literals to `/` and
+ * protect `am/pm` (as `@`) so field order is what's left to compare.
+ */
+var normalizeDatePatternForLocaleCheck = function (pattern) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return (_h = (_g = (_f = (_e = (_d = (_c = (_b = (_a = normalizePattern(pattern)) === null || _a === void 0 ? void 0 : _a.split(";")[0]) === null || _b === void 0 ? void 0 : _b.replace(/\[\$-[^\]]+\]/g, "")) === null || _c === void 0 ? void 0 : _c.replace(/\\(.)/g, "$1")) === null || _d === void 0 ? void 0 : _d.replace(/"[^"]*"/g, "/")) === null || _e === void 0 ? void 0 : _e.replace(/am\/pm/g, "@")) === null || _f === void 0 ? void 0 : _f.replace(/[.\s-]+/g, "/")) === null || _g === void 0 ? void 0 : _g.replace(/\/+/g, "/")) === null || _h === void 0 ? void 0 : _h.replace(/^\/|\/$/g, "");
+};
+// Numeric short dates in any of the three locale field orders
+// (month-first, day-first, year-first).
+var LOCALE_DEFAULT_DATE_CORE = "(?:m{1,2}/d{1,2}/y{2,4}|d{1,2}/m{1,2}/y{2,4}|y{2,4}/m{1,2}/d{1,2})";
+var LOCALE_DEFAULT_DATE_REGEX = new RegExp("^".concat(LOCALE_DEFAULT_DATE_CORE, "$"));
+// Date core plus a time tail: optional leading/trailing day-period token
+// (`@` placeholder), `:`-separated fields — or `/` where a locale's time
+// separator (fi-FI `.`) was folded — and optional seconds.
+var LOCALE_DEFAULT_DATE_TIME_REGEX = new RegExp("^".concat(LOCALE_DEFAULT_DATE_CORE, "/(?:@/)?h{1,2}[:/]m{1,2}(?:[:/]s{1,2})?(?:/?@)?$"));
+var isLocaleDefaultDatePattern = function (pattern) {
+    var normalizedPattern = normalizeDatePatternForLocaleCheck(pattern);
+    if (!normalizedPattern) {
+        return false;
+    }
+    return LOCALE_DEFAULT_DATE_REGEX.test(normalizedPattern);
+};
+var isLocaleDefaultDateTimePattern = function (pattern) {
+    var normalizedPattern = normalizeDatePatternForLocaleCheck(pattern);
+    if (!normalizedPattern) {
+        return false;
+    }
+    return LOCALE_DEFAULT_DATE_TIME_REGEX.test(normalizedPattern);
+};
+/**
+ * Format a number for display in a specific locale.
+ * Only handles decimal separator - no thousands grouping.
+ */
+var formatNumberForLocale = function (value, locale) {
+    var str = String(value);
+    if (!locale)
+        return str;
+    var decimal = getLocaleSeparators(locale).decimal;
+    if (decimal && decimal !== ".") {
+        return str.replace(".", decimal);
+    }
+    return str;
+};
+/**
+ * Normalize a locale-formatted number string to the new locale format.
+ * E.g., "6,5" (de-DE) → "6.5" (en-US) or "6.5" (en-US) → "6,5" (de-DE)
+ */
+var normalizeNumberValue = function (value, oldLocale, newLocale) {
+    if (typeof value === "number")
+        return formatNumberForLocale(value, newLocale);
+    if (!value || typeof value !== "string")
+        return value;
+    var trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    // If it starts with = it's a formula, don't normalize
+    if (trimmed.startsWith("="))
+        return value;
+    var parsed = convertToNumber(trimmed, oldLocale);
+    // If parsing succeeded, format for the new locale
+    if (!isNaN(parsed)) {
+        return formatNumberForLocale(parsed, newLocale);
+    }
+    // If parsing failed, return original value
+    return value;
+};
+/**
+ * Normalize numeric values in a data validation rule
+ */
+var normalizeDataValidationRule = function (rule, oldLocale, newLocale) {
+    var _a;
+    if (!((_a = rule.condition) === null || _a === void 0 ? void 0 : _a.values))
+        return rule;
+    var conditionType = rule.condition.type;
+    var isNumericCondition = conditionType === null || conditionType === void 0 ? void 0 : conditionType.startsWith("NUMBER_");
+    if (!isNumericCondition)
+        return rule;
+    return __assign(__assign({}, rule), { condition: __assign(__assign({}, rule.condition), { values: rule.condition.values.map(function (v) {
+                var _a;
+                return __assign(__assign({}, v), { userEnteredValue: (_a = normalizeNumberValue(v.userEnteredValue, oldLocale, newLocale)) !== null && _a !== void 0 ? _a : v.userEnteredValue });
+            }) }) });
+};
+/**
+ * Normalize numeric values in a conditional format rule
+ */
+var normalizeConditionalFormatRule = function (rule, oldLocale, newLocale) {
+    var _a, _b;
+    var normalized = __assign({}, rule);
+    // Normalize booleanRule values
+    if ((_b = (_a = normalized.booleanRule) === null || _a === void 0 ? void 0 : _a.condition) === null || _b === void 0 ? void 0 : _b.values) {
+        var conditionType = normalized.booleanRule.condition.type;
+        var isNumericCondition = conditionType === null || conditionType === void 0 ? void 0 : conditionType.startsWith("NUMBER_");
+        if (isNumericCondition) {
+            normalized.booleanRule = __assign(__assign({}, normalized.booleanRule), { condition: __assign(__assign({}, normalized.booleanRule.condition), { values: normalized.booleanRule.condition.values.map(function (v) {
+                        var _a;
+                        return (__assign(__assign({}, v), { userEnteredValue: (_a = normalizeNumberValue(v.userEnteredValue, oldLocale, newLocale)) !== null && _a !== void 0 ? _a : v.userEnteredValue }));
+                    }) }) });
+        }
+    }
+    // Normalize gradientRule interpolation points
+    if (normalized.gradientRule) {
+        var normalizePoint = function (point) {
+            var _a;
+            if (!(point === null || point === void 0 ? void 0 : point.value))
+                return point;
+            return __assign(__assign({}, point), { value: (_a = normalizeNumberValue(point.value, oldLocale, newLocale)) !== null && _a !== void 0 ? _a : point.value });
+        };
+        normalized.gradientRule = __assign(__assign({}, normalized.gradientRule), { minpoint: normalizePoint(normalized.gradientRule.minpoint), midpoint: normalizePoint(normalized.gradientRule.midpoint), maxpoint: normalizePoint(normalized.gradientRule.maxpoint) });
+    }
+    return normalized;
+};
+/**
+ * Hook to handle locale changes.
+ * When locale changes, all cells with numeric values need their
+ * formatted values (fv) regenerated using the new locale's formatting rules.
+ * Also normalizes numeric values in data validations and conditional formats.
+ */
+export var useOnLocaleChange = function (_a) {
+    var cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, dataValidations = _a.dataValidations, onChangeDataValidations = _a.onChangeDataValidations, conditionalFormats = _a.conditionalFormats, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return useCallback(function (newLocale, oldLocale) {
+        var saveHistory = createHistory();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a, e_2, _b, e_3, _c;
+                var _d, _e;
+                var sheetCell = new SheetCell();
+                try {
+                    // Iterate over all sheets
+                    for (var _f = __values(Object.keys(draft)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var sheetIdStr = _g.value;
+                        var sheetId = Number(sheetIdStr);
+                        var sheet = draft[sheetId];
+                        if (!sheet)
+                            continue;
+                        try {
+                            // Iterate over all rows
+                            for (var _h = (e_2 = void 0, __values(Object.keys(sheet))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                var rowIndexStr = _j.value;
+                                var rowIndex = Number(rowIndexStr);
+                                if (isNaN(rowIndex))
+                                    continue;
+                                var row = sheet[rowIndex];
+                                if (!(row === null || row === void 0 ? void 0 : row.values))
+                                    continue;
+                                try {
+                                    // Iterate over all cells in the row
+                                    for (var _k = (e_3 = void 0, __values(Object.keys(row.values))), _l = _k.next(); !_l.done; _l = _k.next()) {
+                                        var columnIndexStr = _l.value;
+                                        var columnIndex = Number(columnIndexStr);
+                                        if (isNaN(columnIndex))
+                                            continue;
+                                        var cellData = row.values[columnIndex];
+                                        if (!cellData)
+                                            continue;
+                                        // Get the effective value
+                                        var effectiveValue = getCellEffectiveValue(cellData);
+                                        // Only process cells with numeric values that need reformatting
+                                        // Skip cells that use shared strings (text cells)
+                                        // Skip cells without effective values
+                                        if ((effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.nv) === undefined &&
+                                            (effectiveValue === null || effectiveValue === void 0 ? void 0 : effectiveValue.bv) === undefined) {
+                                            continue;
+                                        }
+                                        // Assign cell data to SheetCell for processing
+                                        sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                                            locale: newLocale,
+                                            cellXfsRegistry: cellXfsRegistry,
+                                            sharedStringRegistry: sharedStringRegistry,
+                                        });
+                                        var numberFormat = (_d = sheetCell.getEffectiveCellFormat()) === null || _d === void 0 ? void 0 : _d.numberFormat;
+                                        var normalizedPattern = normalizePattern(numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern);
+                                        var didReformatUsingUserPattern = false;
+                                        if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE" &&
+                                            (normalizedPattern === undefined ||
+                                                isLocaleDefaultDatePattern(normalizedPattern))) {
+                                            sheetCell.setUserEnteredFormat("numberFormat", __assign(__assign({}, numberFormat), { pattern: getDefaultDateFormat(newLocale) }));
+                                            didReformatUsingUserPattern = true;
+                                        }
+                                        else if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE_TIME" &&
+                                            (normalizedPattern === undefined ||
+                                                isLocaleDefaultDateTimePattern(normalizedPattern))) {
+                                            sheetCell.setUserEnteredFormat("numberFormat", __assign(__assign({}, numberFormat), { pattern: getDefaultDateTimeFormat(newLocale) }));
+                                            didReformatUsingUserPattern = true;
+                                        }
+                                        else if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE" ||
+                                            (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE_TIME") {
+                                            // Re-apply existing date/date-time format to normalize user-entered date string
+                                            // for the new locale without overriding custom patterns.
+                                            sheetCell.setUserEnteredFormat("numberFormat", __assign(__assign({}, numberFormat), { pattern: replacePatternLocaleTags(numberFormat.pattern, newLocale) }));
+                                            didReformatUsingUserPattern = true;
+                                        }
+                                        else if (numberFormat &&
+                                            !((_e = sheetCell.userEnteredFormat) === null || _e === void 0 ? void 0 : _e.numberFormat)) {
+                                            // Legacy cells stored their number format on `ef` only.
+                                            // After the refactor `ef` is no longer persisted, so move
+                                            // the format to `uf` the first time we touch the cell —
+                                            // otherwise refreshFormattedValue below would lose the
+                                            // pattern after re-serialization.
+                                            sheetCell.setUserEnteredFormat("numberFormat", numberFormat);
+                                            didReformatUsingUserPattern = true;
+                                        }
+                                        // For date/date-time cells, setUserEnteredFormat already refreshes values using locale.
+                                        // Calling refreshFormattedValue here can overwrite fv with stale effective format.
+                                        if (!didReformatUsingUserPattern) {
+                                            sheetCell.refreshFormattedValue();
+                                        }
+                                        // Update the draft
+                                        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                        currentSheet[rowIndex].values[columnIndex] =
+                                            sheetCell.getCellData();
+                                        // Register updated formats for cellXfs history/registry updates
+                                        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                                    }
+                                }
+                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                finally {
+                                    try {
+                                        if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
+                                    }
+                                    finally { if (e_3) throw e_3.error; }
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history (allow undo of locale change formatting)
+            saveHistory({
+                sheetData: {
+                    patches: patches,
+                    inversePatches: inversePatches,
+                },
+                disableRecalc: true, // No recalc needed - just reformatting
+            });
+            // Persist cellXfs changes after the updater has actually run.
+            cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+            return nextState;
+        });
+        // Normalize data validation rules
+        // Convert locale-specific number formats (e.g., "6,5") to canonical format ("6.5")
+        if ((dataValidations === null || dataValidations === void 0 ? void 0 : dataValidations.length) && onChangeDataValidations) {
+            onChangeDataValidations(function (prev) {
+                var _a = __read(produceWithPatches(prev, function (draft) {
+                    for (var i = 0; i < draft.length; i++) {
+                        draft[i] = normalizeDataValidationRule(draft[i], oldLocale, newLocale);
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({
+                    dataValidations: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+        // Normalize conditional format rules
+        if ((conditionalFormats === null || conditionalFormats === void 0 ? void 0 : conditionalFormats.length) && onChangeConditionalFormats) {
+            onChangeConditionalFormats(function (prev) {
+                var _a = __read(produceWithPatches(prev, function (draft) {
+                    for (var i = 0; i < draft.length; i++) {
+                        draft[i] = normalizeConditionalFormatRule(draft[i], oldLocale, newLocale);
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({
+                    conditionalFormats: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+    }, [
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeSheetData,
+        createHistory,
+        dataValidations,
+        onChangeDataValidations,
+        conditionalFormats,
+        onChangeConditionalFormats,
+    ]);
+};

package/dist/cjs/hooks/use-on-merge-unmerge-cells.d.ts

@@ -0,0 +1,28 @@
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/grid";
+import { Direction } from "@rowsncolumns/grid";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { CalculationOperation } from "./use-calculation";
+import type { useSheetState } from "./use-sheet-state";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import { CellXfsRegistry } from "./use-cellxfs-registry";
+import { SharedStringRegistry } from "./use-ss-registry";
+type UseOnMergeUnMergeCellsProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    merges?: GridRange[] | null;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeSelections: ReturnType<typeof useSheetState>["onChangeSelections"];
+    enqueueCalculation: (operation: CalculationOperation) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnMergeUnMergeCells: <T extends CellData, S extends Sheet>({ locale, merges, cellXfsRegistry, sharedStringRegistry, createHistory, onChangeSheetData, onChangeSheets, onChangeSelections, enqueueCalculation, onCommand, }: UseOnMergeUnMergeCellsProps<T, S>) => {
+    onMergeCells: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], direction?: Direction) => void;
+    onUnMergeCells: (sheetId: number, activeCell: CellInterface, currentSelections: SelectionArea<SelectionAttributes>[]) => void;
+};
+export {};
+//# sourceMappingURL=use-on-merge-unmerge-cells.d.ts.map

package/dist/cjs/hooks/use-on-merge-unmerge-cells.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-merge-unmerge-cells.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-merge-unmerge-cells.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGL,SAAS,EAGV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAO9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,KAAK,2BAA2B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAC5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC3E,kBAAkB,EAAE,CAAC,SAAS,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,iKAWzE,2BAA2B,CAAC,CAAC,EAAE,CAAC,CAAC;4BASrB,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,cACpC,SAAS;8BAiSZ,MAAM,cACH,aAAa,qBACN,aAAa,CAAC,mBAAmB,CAAC,EAAE;CA4I5D,CAAC"}