@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/formula.js

@@ -0,0 +1,422 @@
+import { isRangeToken, lexify, stripPropertyFromCellRef, tokenVocabulary, } from "@rowsncolumns/calculator";
+import { addressToCell, alpha2number, cellToAddress, desanitizeSheetName, number2Alpha, sanitizeSheetName, } from "@rowsncolumns/utils";
+export { ERROR_CIRCULAR_DEPENDENCY, ERROR_REFERENCE, formulaToRelativeReference, } from "@rowsncolumns/calculator";
+/**
+ * Update sheet name in formula
+ * @param formulaValue
+ * @param oldName
+ * @param newName
+ */
+export const updateSheetName = (formulaValue, newName, oldName) => {
+    const tokens = cloneTokens(lexify(formulaValue).tokens);
+    const newTokens = [];
+    for (const token of tokens) {
+        if (token.tokenType.name === tokenVocabulary.Sheet.name) {
+            token.image =
+                sanitizeSheetName(token.image
+                    .slice(0, -1)
+                    .replace(new RegExp("^" + oldName + "$", "gi"), newName)) + "!";
+        }
+        if (token.tokenType.name === tokenVocabulary.SheetQuoted.name) {
+            const cleanSheetName = desanitizeSheetName(token.image);
+            if (cleanSheetName) {
+                token.image =
+                    sanitizeSheetName(cleanSheetName
+                        .slice(0, -1)
+                        .replace(new RegExp("^" + oldName + "$", "gi"), newName)) + "!";
+            }
+        }
+        newTokens.push(token);
+    }
+    return detokenize(newTokens);
+};
+/**
+ * Update sheet name in formula
+ * @param formulaValue
+ * @param oldName
+ * @param newName
+ */
+export const updateNamedRangeName = (formulaValue, newName, oldName) => {
+    const tokens = cloneTokens(lexify(formulaValue).tokens);
+    const newTokens = [];
+    for (const token of tokens) {
+        if (token.tokenType.name === tokenVocabulary.Name.name &&
+            token.image === oldName) {
+            token.image = newName;
+        }
+        newTokens.push(token);
+    }
+    return detokenize(newTokens);
+};
+/**
+ * Update sheet name in formula
+ * @param formulaValue
+ * @param oldName
+ * @param newName
+ */
+export const updateColumnName = (formulaValue, newName, oldName) => {
+    const tokens = cloneTokens(lexify(formulaValue).tokens);
+    const newTokens = [];
+    for (const token of tokens) {
+        if (token.tokenType.name === tokenVocabulary.TableColumnName.name) {
+            token.image = token.image.replace(new RegExp(oldName, "gi"), newName);
+        }
+        newTokens.push(token);
+    }
+    return detokenize(newTokens);
+};
+/**
+ * Converts tokens to string
+ * @param tokens
+ */
+export const detokenize = (tokens) => {
+    let prevOffset;
+    let str = "";
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        str +=
+            (prevOffset && prevOffset !== token.startOffset ? " " : "") + token.image;
+        prevOffset = token.endColumn;
+    }
+    return str;
+};
+const cloneTokens = (tokens) => tokens.map((token) => ({ ...token }));
+const getSheetNameFromToken = (token) => {
+    if (!token)
+        return undefined;
+    if (token.tokenType.name === tokenVocabulary.Sheet.name) {
+        return token.image.slice(0, -1);
+    }
+    if (token.tokenType.name === tokenVocabulary.SheetQuoted.name) {
+        const cleanSheetName = desanitizeSheetName(token.image);
+        return cleanSheetName ? cleanSheetName.slice(0, -1) : undefined;
+    }
+    return undefined;
+};
+/**
+ * Create cell identifier
+ * @param sheetId
+ * @param rowIndex
+ * @param columnIndex
+ */
+export const createSheetCellIdentifier = (sheetId, rowIndex, columnIndex) => {
+    return `${sheetId}!${cellToAddress({ rowIndex, columnIndex })}`;
+};
+/**
+ * Check if a formula contains absolute column references
+ * $A2 | $A$2
+ * @param formula
+ */
+export const isAbsoluteColumnReference = (formula) => {
+    if (!formula)
+        return false;
+    return /\$[A-Z]+/gi.test(formula);
+};
+/**
+ * Check if a formula contains absolute row references
+ * A$2 | $A$2
+ * @param formula
+ */
+export const isAbsoluteRowReference = (formula) => {
+    if (!formula)
+        return false;
+    return /\$\d+/gi.test(formula);
+};
+/**
+ * Expands ranges in a formula when rows or columns are inserted within the range
+ * @param formula The formula to process
+ * @param insertionIndex The row or column index where insertion happens
+ * @param count Number of rows or columns being inserted
+ * @param dimension Whether inserting 'row' or 'column'
+ * @param activeSheetName Active sheet name to scope range updates
+ * @returns The formula with expanded ranges, or undefined if no changes
+ */
+export const expandRangesInFormula = (formula, insertionIndex, count, dimension, activeSheetName) => {
+    if (!formula || count <= 0) {
+        return formula;
+    }
+    const normalizedActiveSheetName = activeSheetName.toLowerCase();
+    const tokens = cloneTokens(lexify(formula).tokens);
+    const newTokens = [];
+    let hasChanges = false;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const sheetName = getSheetNameFromToken(tokens[i - 1]);
+        const skipSheet = sheetName && sheetName.toLowerCase() !== normalizedActiveSheetName;
+        // Handle cell ranges (e.g., A1:A10)
+        if (token.tokenType.name === tokenVocabulary.Cell.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                newTokens.push(token);
+                if (isRange) {
+                    newTokens.push(tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                }
+                continue;
+            }
+            if (isRange && tokens[i + 2]) {
+                const startCell = addressToCell(stripPropertyFromCellRef(token.image));
+                const endCell = addressToCell(stripPropertyFromCellRef(tokens[i + 2].image));
+                if (startCell && endCell) {
+                    const isAbsoluteEndRow = isAbsoluteRowReference(tokens[i + 2].image);
+                    const isAbsoluteEndCol = isAbsoluteColumnReference(tokens[i + 2].image);
+                    if (dimension === "row") {
+                        // Check if insertion point is within the row range
+                        if (insertionIndex > startCell.rowIndex &&
+                            insertionIndex <= endCell.rowIndex) {
+                            // Expand the end row
+                            endCell.rowIndex += count;
+                            const newAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
+                            if (newAddress) {
+                                tokens[i + 2].image = newAddress;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                    else {
+                        // dimension === 'column'
+                        // Check if insertion point is within the column range
+                        if (insertionIndex > startCell.columnIndex &&
+                            insertionIndex <= endCell.columnIndex) {
+                            // Expand the end column
+                            endCell.columnIndex += count;
+                            const newAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
+                            if (newAddress) {
+                                tokens[i + 2].image = newAddress;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        // Handle column ranges (e.g., A:C)
+        if (dimension === "column" &&
+            token.tokenType.name === tokenVocabulary.Column.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                if (isRange) {
+                    newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                    continue;
+                }
+            }
+            if (isRange && tokens[i + 2]) {
+                const startColumnIndex = alpha2number(token.image);
+                const endColumnIndex = alpha2number(tokens[i + 2].image);
+                // Check if insertion point is within the column range
+                if (insertionIndex > startColumnIndex &&
+                    insertionIndex <= endColumnIndex) {
+                    // Expand the end column
+                    const newEndColumnIndex = endColumnIndex + count;
+                    tokens[i + 2].image = number2Alpha(newEndColumnIndex - 1);
+                    hasChanges = true;
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        // Handle row ranges (e.g., 1:10)
+        if (dimension === "row" &&
+            token.tokenType.name === tokenVocabulary.Number.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                if (isRange) {
+                    newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                    continue;
+                }
+            }
+            if (isRange &&
+                tokens[i + 2] &&
+                tokens[i + 2].tokenType.name === tokenVocabulary.Number.name) {
+                const startRowIndex = Number(token.image);
+                const endRowIndex = Number(tokens[i + 2].image);
+                // Check if insertion point is within the row range
+                if (insertionIndex > startRowIndex && insertionIndex <= endRowIndex) {
+                    // Expand the end row
+                    tokens[i + 2].image = String(endRowIndex + count);
+                    hasChanges = true;
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        newTokens.push(token);
+    }
+    return hasChanges ? detokenize(newTokens) : formula;
+};
+/**
+ * Contracts ranges in a formula when rows or columns are deleted within the range
+ * @param formula The formula to process
+ * @param deletionIndex The row or column index where deletion starts
+ * @param count Number of rows or columns being deleted
+ * @param dimension Whether deleting 'row' or 'column'
+ * @param activeSheetName Active sheet name to scope range updates
+ * @returns The formula with contracted ranges, or undefined if no changes
+ */
+export const contractRangesInFormula = (formula, deletionIndex, count, dimension, activeSheetName) => {
+    if (!formula || count <= 0) {
+        return formula;
+    }
+    const normalizedActiveSheetName = activeSheetName.toLowerCase();
+    const tokens = cloneTokens(lexify(formula).tokens);
+    const newTokens = [];
+    let hasChanges = false;
+    const deletionEnd = deletionIndex + count - 1;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const sheetName = getSheetNameFromToken(tokens[i - 1]);
+        const skipSheet = sheetName && sheetName.toLowerCase() !== normalizedActiveSheetName;
+        // Handle cell ranges (e.g., A1:A10)
+        if (token.tokenType.name === tokenVocabulary.Cell.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                newTokens.push(token);
+                if (isRange) {
+                    newTokens.push(tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                }
+                continue;
+            }
+            if (isRange && tokens[i + 2]) {
+                const startCell = addressToCell(stripPropertyFromCellRef(token.image));
+                const endCell = addressToCell(stripPropertyFromCellRef(tokens[i + 2].image));
+                if (startCell && endCell) {
+                    const isAbsoluteStartRow = isAbsoluteRowReference(token.image);
+                    const isAbsoluteEndRow = isAbsoluteRowReference(tokens[i + 2].image);
+                    const isAbsoluteStartCol = isAbsoluteColumnReference(token.image);
+                    const isAbsoluteEndCol = isAbsoluteColumnReference(tokens[i + 2].image);
+                    if (dimension === "row") {
+                        const rangeStart = startCell.rowIndex;
+                        const rangeEnd = endCell.rowIndex;
+                        // Check if deletion overlaps with range
+                        if (deletionIndex <= rangeEnd && deletionEnd >= rangeStart) {
+                            // Calculate how many deleted rows are within the range
+                            const overlapStart = Math.max(deletionIndex, rangeStart);
+                            const overlapEnd = Math.min(deletionEnd, rangeEnd);
+                            const rowsDeletedInRange = overlapEnd - overlapStart + 1;
+                            // Contract the end of the range
+                            endCell.rowIndex -= rowsDeletedInRange;
+                            // If entire range is deleted, result in #REF! (but we'll just contract to minimum)
+                            if (endCell.rowIndex < startCell.rowIndex) {
+                                endCell.rowIndex = startCell.rowIndex;
+                            }
+                            const newStartAddress = cellToAddress(startCell, isAbsoluteStartCol, isAbsoluteStartRow);
+                            const newEndAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
+                            if (newStartAddress && newEndAddress) {
+                                token.image = newStartAddress;
+                                tokens[i + 2].image = newEndAddress;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                    else {
+                        // dimension === 'column'
+                        const rangeStart = startCell.columnIndex;
+                        const rangeEnd = endCell.columnIndex;
+                        // Check if deletion overlaps with range
+                        if (deletionIndex <= rangeEnd && deletionEnd >= rangeStart) {
+                            // Calculate how many deleted columns are within the range
+                            const overlapStart = Math.max(deletionIndex, rangeStart);
+                            const overlapEnd = Math.min(deletionEnd, rangeEnd);
+                            const colsDeletedInRange = overlapEnd - overlapStart + 1;
+                            // Contract the end of the range
+                            endCell.columnIndex -= colsDeletedInRange;
+                            // If entire range is deleted, result in #REF! (but we'll just contract to minimum)
+                            if (endCell.columnIndex < startCell.columnIndex) {
+                                endCell.columnIndex = startCell.columnIndex;
+                            }
+                            const newStartAddress = cellToAddress(startCell, isAbsoluteStartCol, isAbsoluteStartRow);
+                            const newEndAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
+                            if (newStartAddress && newEndAddress) {
+                                token.image = newStartAddress;
+                                tokens[i + 2].image = newEndAddress;
+                                hasChanges = true;
+                            }
+                        }
+                    }
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        // Handle column ranges (e.g., A:C)
+        if (dimension === "column" &&
+            token.tokenType.name === tokenVocabulary.Column.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                if (isRange) {
+                    newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                    continue;
+                }
+            }
+            if (isRange && tokens[i + 2]) {
+                const startColumnIndex = alpha2number(token.image);
+                const endColumnIndex = alpha2number(tokens[i + 2].image);
+                // Check if deletion overlaps with range
+                if (deletionIndex <= endColumnIndex &&
+                    deletionEnd >= startColumnIndex) {
+                    // Calculate how many deleted columns are within the range
+                    const overlapStart = Math.max(deletionIndex, startColumnIndex);
+                    const overlapEnd = Math.min(deletionEnd, endColumnIndex);
+                    const colsDeletedInRange = overlapEnd - overlapStart + 1;
+                    // Contract the end column
+                    const newEndColumnIndex = endColumnIndex - colsDeletedInRange;
+                    // If entire range is deleted, keep at minimum
+                    if (newEndColumnIndex >= startColumnIndex) {
+                        tokens[i + 2].image = number2Alpha(newEndColumnIndex - 1);
+                        hasChanges = true;
+                    }
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        // Handle row ranges (e.g., 1:10)
+        if (dimension === "row" &&
+            token.tokenType.name === tokenVocabulary.Number.name) {
+            const isRange = isRangeToken(tokens[i + 1]);
+            if (skipSheet) {
+                if (isRange) {
+                    newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                    i += 2;
+                    continue;
+                }
+            }
+            if (isRange &&
+                tokens[i + 2] &&
+                tokens[i + 2].tokenType.name === tokenVocabulary.Number.name) {
+                const startRowIndex = Number(token.image);
+                const endRowIndex = Number(tokens[i + 2].image);
+                // Check if deletion overlaps with range
+                if (deletionIndex <= endRowIndex && deletionEnd >= startRowIndex) {
+                    // Calculate how many deleted rows are within the range
+                    const overlapStart = Math.max(deletionIndex, startRowIndex);
+                    const overlapEnd = Math.min(deletionEnd, endRowIndex);
+                    const rowsDeletedInRange = overlapEnd - overlapStart + 1;
+                    // Contract the end row
+                    const newEndRowIndex = endRowIndex - rowsDeletedInRange;
+                    // If entire range is deleted, keep at minimum
+                    if (newEndRowIndex >= startRowIndex) {
+                        tokens[i + 2].image = String(newEndRowIndex);
+                        hasChanges = true;
+                    }
+                }
+                newTokens.push(token, tokens[i + 1], tokens[i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        newTokens.push(token);
+    }
+    return hasChanges ? detokenize(newTokens) : formula;
+};

package/dist/esm/api/immer-utils.d.ts

@@ -0,0 +1,66 @@
+import type { RowDataWithValue as SpreadsheetRowDataWithValue, SheetData as SpreadsheetSheetData } from "@rowsncolumns/common-types";
+import type { CellNode, CellRangeNode, StaticNode } from "@rowsncolumns/dag";
+import type { CellData, NumberFormat, NumberFormatType, ParsedToken } from "@rowsncolumns/spreadsheet";
+import { type Draft } from "immer";
+import type { CellXfsRegistry } from "../hooks/use-cellxfs-registry";
+import type { useSheetProperties } from "../hooks/use-sheet-properties";
+type SheetData<T extends CellData> = SpreadsheetSheetData<T>;
+type RowDataWithValue<T extends CellData | null | undefined> = SpreadsheetRowDataWithValue<T>;
+export declare const createSheetDraft: <T extends CellData>(draft: Draft<SheetData<T>>, sheetId: number, rowIndex?: number) => Draft<RowDataWithValue<T | null | undefined>>[];
+export declare const cloneRowWithFormatting: <T extends CellData>(rowData: Draft<RowDataWithValue<T | null | undefined>> | undefined) => Draft<RowDataWithValue<T | null | undefined>>;
+export declare const cloneCellWithFormatting: <T extends CellData>(celLData: Draft<T> | undefined | null) => Draft<T> | null;
+export declare const getFunctionNamesFromFormula: (formula: string) => string[];
+export declare const deriveEffectiveNumberFormatFromPrecedents: <T extends CellData>(formula: string | undefined, precedents: (CellNode | CellRangeNode | StaticNode)[], draft: Draft<SheetData<T>> | SheetData<T>, tokenizer: (str: string) => ParsedToken[], sheetId: number, rowIndex: number, columnIndex: number, locale: string | undefined, getSheetId: (sheetName: string) => number, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"], calculatedValue?: number | string | null, 
+/**
+ * Optional resolver for a precedent's effective `numberFormat`. When a
+ * precedent is itself a formula cell with no `uf.numberFormat`, its
+ * format is derived (not persisted on cellData), so reading
+ * `sheetCell.getNumberFormat()` would miss it. The resolver lets the
+ * caller recurse through formula chains so `C1 = B1 = A1` inherits A1's
+ * format. When omitted, only the precedent's persisted
+ * `uf.numberFormat` is consulted.
+ */
+resolvePrecedentNumberFormat?: (sheetId: number, rowIndex: number, columnIndex: number) => NumberFormat | undefined | null) => NumberFormat | undefined | null;
+/**
+ * Like `deriveEffectiveNumberFormatFromPrecedents` but synthesizes the
+ * `precedents` array from the formula's direct cell/range references —
+ * used by the XLSX/ODS/CSV exporters which don't have a calc graph.
+ *
+ * Internally calls `deriveEffectiveNumberFormatFromPrecedents`, so all the
+ * function-specific rules (FILTER source range, ROUND decimals, IFERROR,
+ * function return types, etc.) are honored — render and export produce
+ * the same format for the same formula.
+ */
+export declare const deriveEffectiveNumberFormatFromFormula: <T extends CellData>(formula: string | undefined, sheetId: number, rowIndex: number, columnIndex: number, draft: Draft<SheetData<T>> | SheetData<T>, tokenizer: (str: string) => ParsedToken[], getSheetId: (sheetName: string) => number, locale?: string, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"], calculatedValue?: number | string | null) => NumberFormat | undefined | null;
+/**
+ * Two phase inference:
+ * 1) parse formula tokens into AST
+ * 2) derive number format type from the AST semantics
+ */
+export declare const getNumberFormatTypeFromFormula: <T extends CellData>(formula: string, derivedNumberFormat: NumberFormat, draft: Draft<SheetData<T>> | SheetData<T>, tokenizer: (str: string) => ParsedToken[], sheetId: number, getSheetId: (sheetName: string) => number, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"]) => NumberFormatType | undefined;
+/**
+ * AST-based format derivation from formula semantics.
+ * Uses the parser-backed type analysis and preserves source pattern when
+ * the resolved type is unchanged.
+ */
+export declare const getNumberFormatFromFormulaAst: <T extends CellData>(formula: string, derivedNumberFormat: NumberFormat, draft: Draft<SheetData<T>> | SheetData<T>, tokenizer: (str: string) => ParsedToken[], sheetId: number, getSheetId: (sheetName: string) => number, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"], locale?: string) => NumberFormat | undefined;
+export declare const isPercentageType: <T extends CellData>(token: ParsedToken | undefined, sheetId: number, draft: Draft<SheetData<T>> | SheetData<T>, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"]) => boolean;
+export declare const isDateType: <T extends CellData>(token: ParsedToken | undefined, sheetId: number, draft: Draft<SheetData<T>> | SheetData<T>, cellXfsRegistry?: CellXfsRegistry, getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"]) => boolean;
+/**
+ * Peek an iterable
+ * @param iterator
+ * @returns
+ */
+export declare const peekIterable: <T>(iterator: IterableIterator<T>) => {
+    peeked: {
+        done: false;
+        value: T;
+    } | {
+        done: true;
+        value: undefined;
+    };
+    rebuiltIterator: () => Generator<T, void, unknown>;
+};
+export declare const deriveCellFromPrecedents: <T extends CellData>(formula: string | undefined, precedents: (CellNode | CellRangeNode | StaticNode)[], draft: Draft<SheetData<T>> | SheetData<T>, sheetId: number, locale: string | undefined, cellXfsRegistry?: CellXfsRegistry) => Draft<T> | null | undefined;
+export {};
+//# sourceMappingURL=immer-utils.d.ts.map

package/dist/esm/api/immer-utils.d.ts.map

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