@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/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/esm/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/esm/hooks/use-on-locale-change.js

@@ -0,0 +1,314 @@
+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";
+const normalizePattern = (pattern) => pattern?.trim().toLowerCase();
+const replacePatternLocaleTags = (pattern, locale) => {
+    if (!pattern) {
+        return pattern ?? undefined;
+    }
+    const normalizedLocale = locale.trim().replace(/_/g, "-");
+    return pattern.replace(/\[\$-[^\]]+\]/gi, `[$-${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.
+ */
+const normalizeDatePatternForLocaleCheck = (pattern) => normalizePattern(pattern)
+    ?.split(";")[0]
+    ?.replace(/\[\$-[^\]]+\]/g, "")
+    ?.replace(/\\(.)/g, "$1")
+    ?.replace(/"[^"]*"/g, "/")
+    ?.replace(/am\/pm/g, "@")
+    ?.replace(/[.\s-]+/g, "/")
+    ?.replace(/\/+/g, "/")
+    ?.replace(/^\/|\/$/g, "");
+// Numeric short dates in any of the three locale field orders
+// (month-first, day-first, year-first).
+const 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})";
+const LOCALE_DEFAULT_DATE_REGEX = new RegExp(`^${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.
+const LOCALE_DEFAULT_DATE_TIME_REGEX = new RegExp(`^${LOCALE_DEFAULT_DATE_CORE}/(?:@/)?h{1,2}[:/]m{1,2}(?:[:/]s{1,2})?(?:/?@)?$`);
+const isLocaleDefaultDatePattern = (pattern) => {
+    const normalizedPattern = normalizeDatePatternForLocaleCheck(pattern);
+    if (!normalizedPattern) {
+        return false;
+    }
+    return LOCALE_DEFAULT_DATE_REGEX.test(normalizedPattern);
+};
+const isLocaleDefaultDateTimePattern = (pattern) => {
+    const 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.
+ */
+const formatNumberForLocale = (value, locale) => {
+    const str = String(value);
+    if (!locale)
+        return str;
+    const { decimal } = getLocaleSeparators(locale);
+    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)
+ */
+const normalizeNumberValue = (value, oldLocale, newLocale) => {
+    if (typeof value === "number")
+        return formatNumberForLocale(value, newLocale);
+    if (!value || typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    // If it starts with = it's a formula, don't normalize
+    if (trimmed.startsWith("="))
+        return value;
+    const 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
+ */
+const normalizeDataValidationRule = (rule, oldLocale, newLocale) => {
+    if (!rule.condition?.values)
+        return rule;
+    const conditionType = rule.condition.type;
+    const isNumericCondition = conditionType?.startsWith("NUMBER_");
+    if (!isNumericCondition)
+        return rule;
+    return {
+        ...rule,
+        condition: {
+            ...rule.condition,
+            values: rule.condition.values.map((v) => {
+                return {
+                    ...v,
+                    userEnteredValue: normalizeNumberValue(v.userEnteredValue, oldLocale, newLocale) ??
+                        v.userEnteredValue,
+                };
+            }),
+        },
+    };
+};
+/**
+ * Normalize numeric values in a conditional format rule
+ */
+const normalizeConditionalFormatRule = (rule, oldLocale, newLocale) => {
+    const normalized = { ...rule };
+    // Normalize booleanRule values
+    if (normalized.booleanRule?.condition?.values) {
+        const conditionType = normalized.booleanRule.condition.type;
+        const isNumericCondition = conditionType?.startsWith("NUMBER_");
+        if (isNumericCondition) {
+            normalized.booleanRule = {
+                ...normalized.booleanRule,
+                condition: {
+                    ...normalized.booleanRule.condition,
+                    values: normalized.booleanRule.condition.values.map((v) => ({
+                        ...v,
+                        userEnteredValue: normalizeNumberValue(v.userEnteredValue, oldLocale, newLocale) ??
+                            v.userEnteredValue,
+                    })),
+                },
+            };
+        }
+    }
+    // Normalize gradientRule interpolation points
+    if (normalized.gradientRule) {
+        const normalizePoint = (point) => {
+            if (!point?.value)
+                return point;
+            return {
+                ...point,
+                value: normalizeNumberValue(point.value, oldLocale, newLocale) ??
+                    point.value,
+            };
+        };
+        normalized.gradientRule = {
+            ...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 const useOnLocaleChange = ({ cellXfsRegistry, sharedStringRegistry, onChangeSheetData, createHistory, dataValidations, onChangeDataValidations, conditionalFormats, onChangeConditionalFormats, }) => {
+    return useCallback((newLocale, oldLocale) => {
+        const saveHistory = createHistory();
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const sheetCell = new SheetCell();
+                // Iterate over all sheets
+                for (const sheetIdStr of Object.keys(draft)) {
+                    const sheetId = Number(sheetIdStr);
+                    const sheet = draft[sheetId];
+                    if (!sheet)
+                        continue;
+                    // Iterate over all rows
+                    for (const rowIndexStr of Object.keys(sheet)) {
+                        const rowIndex = Number(rowIndexStr);
+                        if (isNaN(rowIndex))
+                            continue;
+                        const row = sheet[rowIndex];
+                        if (!row?.values)
+                            continue;
+                        // Iterate over all cells in the row
+                        for (const columnIndexStr of Object.keys(row.values)) {
+                            const columnIndex = Number(columnIndexStr);
+                            if (isNaN(columnIndex))
+                                continue;
+                            const cellData = row.values[columnIndex];
+                            if (!cellData)
+                                continue;
+                            // Get the effective value
+                            const 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?.nv === undefined &&
+                                effectiveValue?.bv === undefined) {
+                                continue;
+                            }
+                            // Assign cell data to SheetCell for processing
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                                locale: newLocale,
+                                cellXfsRegistry,
+                                sharedStringRegistry,
+                            });
+                            const numberFormat = sheetCell.getEffectiveCellFormat()?.numberFormat;
+                            const normalizedPattern = normalizePattern(numberFormat?.pattern);
+                            let didReformatUsingUserPattern = false;
+                            if (numberFormat?.type === "DATE" &&
+                                (normalizedPattern === undefined ||
+                                    isLocaleDefaultDatePattern(normalizedPattern))) {
+                                sheetCell.setUserEnteredFormat("numberFormat", {
+                                    ...numberFormat,
+                                    pattern: getDefaultDateFormat(newLocale),
+                                });
+                                didReformatUsingUserPattern = true;
+                            }
+                            else if (numberFormat?.type === "DATE_TIME" &&
+                                (normalizedPattern === undefined ||
+                                    isLocaleDefaultDateTimePattern(normalizedPattern))) {
+                                sheetCell.setUserEnteredFormat("numberFormat", {
+                                    ...numberFormat,
+                                    pattern: getDefaultDateTimeFormat(newLocale),
+                                });
+                                didReformatUsingUserPattern = true;
+                            }
+                            else if (numberFormat?.type === "DATE" ||
+                                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", {
+                                    ...numberFormat,
+                                    pattern: replacePatternLocaleTags(numberFormat.pattern, newLocale),
+                                });
+                                didReformatUsingUserPattern = true;
+                            }
+                            else if (numberFormat &&
+                                !sheetCell.userEnteredFormat?.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
+                            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Register updated formats for cellXfs history/registry updates
+                            cellXfsRegistry?.registerCellXfs(sheetCell);
+                        }
+                    }
+                }
+            });
+            // Save history (allow undo of locale change formatting)
+            saveHistory({
+                sheetData: {
+                    patches,
+                    inversePatches,
+                },
+                disableRecalc: true, // No recalc needed - just reformatting
+            });
+            // Persist cellXfs changes after the updater has actually run.
+            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?.length && onChangeDataValidations) {
+            onChangeDataValidations((prev) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                    for (let i = 0; i < draft.length; i++) {
+                        draft[i] = normalizeDataValidationRule(draft[i], oldLocale, newLocale);
+                    }
+                });
+                saveHistory({
+                    dataValidations: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        // Normalize conditional format rules
+        if (conditionalFormats?.length && onChangeConditionalFormats) {
+            onChangeConditionalFormats((prev) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                    for (let i = 0; i < draft.length; i++) {
+                        draft[i] = normalizeConditionalFormatRule(draft[i], oldLocale, newLocale);
+                    }
+                });
+                saveHistory({
+                    conditionalFormats: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+    }, [
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeSheetData,
+        createHistory,
+        dataValidations,
+        onChangeDataValidations,
+        conditionalFormats,
+        onChangeConditionalFormats,
+    ]);
+};

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