@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-calculation-process-array.js

@@ -0,0 +1,279 @@
+import { tokenize as formulaTokenizer } from "@rowsncolumns/calculator";
+import { isEqualCells } from "@rowsncolumns/grid";
+import { useCallback } from "react";
+import { parseFilterSourceRange } from "../api/filter-range";
+import { collisionDetection, generateCollisionError, isCellWithinCellRange, isEqualCellRange, isEqualPosition, iterateCellsInCellRange, iterateCellsInCellRangeWithResults, } from "../api/range";
+import { SheetCell } from "../sheet-cell";
+export const useCalculationProcessArray = ({ locale, getCalculator, getUserEnteredValue, getCellData, getSheetId, getComputationCache, }) => {
+    const isCellBlocked = useCallback((cell, anchor) => {
+        const userValue = getUserEnteredValue(cell.sheetId, cell.rowIndex, cell.columnIndex);
+        if (userValue !== undefined) {
+            return true;
+        }
+        const parent = getCalculator().getClosestArrayParentCell(cell);
+        if (parent && isEqualPosition(parent, anchor)) {
+            return false;
+        }
+        return Boolean(parent);
+    }, [getCalculator, getUserEnteredValue]);
+    const detectArrayCollision = useCallback((anchor, range) => {
+        if (!range) {
+            return [false, undefined];
+        }
+        for (const [rowIndex, columnIndex] of iterateCellsInCellRange(range)) {
+            if (rowIndex === anchor.rowIndex &&
+                columnIndex === anchor.columnIndex) {
+                continue;
+            }
+            const cell = {
+                sheetId: anchor.sheetId,
+                rowIndex,
+                columnIndex,
+            };
+            if (isCellBlocked(cell, anchor)) {
+                return [true, cell];
+            }
+        }
+        return [false, undefined];
+    }, [isCellBlocked]);
+    const processArrayResults = useCallback((result, position, results, getDependents) => {
+        const arrayReference = getCalculator().getArrayRange(position);
+        const [collides, collidingCell] = detectArrayCollision(position, arrayReference);
+        const collidingCellRange = collidingCell && getCalculator().getArrayRangeOfCell(collidingCell);
+        const isCollidingCellInRangeOfCurrentCell = collidingCell &&
+            isEqualCellRange(getCalculator().getArrayRangeOfCell(collidingCell), getCalculator().getArrayRangeOfCell(position));
+        const recomputeOperations = [];
+        // Create a sheet cell
+        const sheetCell = new SheetCell();
+        const sourceSheetCell = new SheetCell();
+        const anchorFormula = getUserEnteredValue(position.sheetId, position.rowIndex, position.columnIndex);
+        const filterSourceRange = parseFilterSourceRange(anchorFormula, position.sheetId, getSheetId, formulaTokenizer);
+        const getFilterFormatting = (columnIndex) => {
+            if (!filterSourceRange) {
+                return undefined;
+            }
+            const sourceColumnIndex = filterSourceRange.startColumnIndex +
+                (columnIndex - position.columnIndex);
+            if (sourceColumnIndex < filterSourceRange.startColumnIndex ||
+                sourceColumnIndex > filterSourceRange.endColumnIndex) {
+                return undefined;
+            }
+            const sourceCellData = getCellData(filterSourceRange.sheetId, filterSourceRange.startRowIndex, sourceColumnIndex);
+            const sourceNumberFormat = sourceSheetCell
+                .assign(filterSourceRange.sheetId, {
+                rowIndex: filterSourceRange.startRowIndex,
+                columnIndex: sourceColumnIndex,
+            }, sourceCellData, { locale })
+                .getNumberFormat();
+            return sourceNumberFormat
+                ? { numberFormat: sourceNumberFormat }
+                : undefined;
+        };
+        if (arrayReference) {
+            for (const [rowIndex, columnIndex, value,] of iterateCellsInCellRangeWithResults(arrayReference, result)) {
+                const preserveStringLiteral = typeof value === "string";
+                const effectiveValue = sheetCell
+                    .assign(position.sheetId, {
+                    rowIndex,
+                    columnIndex,
+                }, undefined, { locale })
+                    .setEffectiveValue(value, false, preserveStringLiteral)
+                    .getEffectiveValue();
+                const newPosition = {
+                    rowIndex,
+                    columnIndex,
+                    sheetId: getSheetId(arrayReference.sheet),
+                };
+                const cellKey = getCalculator().makeKey(newPosition);
+                const isParentCell = isEqualPosition(position, newPosition);
+                /**
+                 * When array cells are being filled,
+                 * We have to skip cells that are spilling
+                 * over other bounds
+                 *
+                 * 1. Check if colliding cell and the current array cell share the same range
+                 *  Yes => Fill
+                 *  No => Skip
+                 * 2. Verify if the newly generated cell is inside the colliding cell's range
+                 *  Yes => Skip
+                 *  No => fill
+                 */
+                const shouldSkipFilling = collidingCell
+                    ? !isCollidingCellInRangeOfCurrentCell &&
+                        isCellWithinCellRange(newPosition, collidingCellRange)
+                    : false;
+                const isCollidingCell = isEqualCells(collidingCell, {
+                    rowIndex,
+                    columnIndex,
+                });
+                const hasDependents = getDependents(newPosition).length > 0;
+                if (collides && collidingCell) {
+                    if (isParentCell) {
+                        const errorValue = generateCollisionError(collidingCell);
+                        // Add it to computation cache
+                        getComputationCache().set(cellKey, errorValue);
+                        results.set(cellKey, [newPosition, errorValue]);
+                    }
+                    else if (shouldSkipFilling ||
+                        isCollidingCell ||
+                        getUserEnteredValue(position.sheetId, rowIndex, columnIndex) !==
+                            undefined) {
+                        // Do not clear all
+                        continue;
+                    }
+                    else {
+                        if (hasDependents) {
+                            recomputeOperations.push({
+                                type: "add",
+                                position: newPosition,
+                                value: undefined,
+                            });
+                        }
+                        // // Add it to computation cache
+                        getComputationCache().set(cellKey, undefined);
+                        results.set(cellKey, [newPosition, undefined]);
+                    }
+                }
+                else {
+                    // Add it to computation cache
+                    getComputationCache().set(cellKey, effectiveValue);
+                    // Add to results
+                    const filterFormatting = getFilterFormatting(columnIndex);
+                    results.set(cellKey, [newPosition, value, filterFormatting]);
+                    // Do not add parent cell to recompute
+                    if (!isParentCell && hasDependents) {
+                        // Recompute
+                        recomputeOperations.push({
+                            type: "add",
+                            position: newPosition,
+                            value: String(value),
+                        });
+                    }
+                }
+            }
+        }
+        return [collides, recomputeOperations];
+    }, [
+        locale,
+        getCalculator,
+        getComputationCache,
+        getUserEnteredValue,
+        getCellData,
+        getSheetId,
+        detectArrayCollision,
+    ]);
+    /**
+     * Call when you want to reset an array formula
+     * @param position
+     * @returns
+     */
+    const createArraySideEffectsAndGetResults = useCallback(({ position, shouldRemoveArrayReference = true, getDependents, }) => {
+        const arrayResults = new Map();
+        const createSideEffects = (position) => {
+            const isArrayFormula = getCalculator().isArray(position);
+            // Remove array references
+            if (isArrayFormula) {
+                const arrayRange = getCalculator().getArrayRange(position);
+                const [collides, collidingCell] = collisionDetection(position, arrayRange, getUserEnteredValue);
+                const collidingCellRange = collidingCell && getCalculator().getArrayRangeOfCell(collidingCell);
+                const isCollidingCellInRangeOfCurrentCell = collidingCell &&
+                    isEqualCellRange(getCalculator().getArrayRangeOfCell(collidingCell), getCalculator().getArrayRangeOfCell(position));
+                if (arrayRange) {
+                    for (const [rowIndex, columnIndex] of iterateCellsInCellRange(arrayRange)) {
+                        const newPosition = {
+                            rowIndex,
+                            columnIndex,
+                            sheetId: position.sheetId,
+                        };
+                        const key = getCalculator().makeKey(newPosition);
+                        const isParentCell = isEqualPosition(position, newPosition);
+                        const isCollidingCell = isEqualCells(collidingCell, {
+                            rowIndex,
+                            columnIndex,
+                        });
+                        // Check if user has entered a value, if so skip
+                        const hasUserEnteredValue = () => !!getUserEnteredValue(newPosition.sheetId, newPosition.rowIndex, newPosition.columnIndex);
+                        const shouldSkipFilling = collidingCell
+                            ? (!isCollidingCellInRangeOfCurrentCell &&
+                                isCellWithinCellRange(newPosition, collidingCellRange)) ||
+                                hasUserEnteredValue()
+                            : hasUserEnteredValue();
+                        if (collides &&
+                            collidingCell &&
+                            (isParentCell || isCollidingCell)) {
+                            continue;
+                        }
+                        else if (isParentCell || shouldSkipFilling) {
+                            continue;
+                        }
+                        else {
+                            // Mark cell as dirty
+                            if (getDependents(newPosition).length) {
+                                getCalculator().markAsDirty(newPosition);
+                            }
+                            // Cache
+                            getComputationCache().set(key, undefined);
+                            // Add to results
+                            arrayResults.set(key, [newPosition, undefined]);
+                        }
+                    }
+                    // Removes array reference from graph
+                    if (shouldRemoveArrayReference) {
+                        getCalculator().removeArrayReferences(position);
+                    }
+                }
+            }
+        };
+        createSideEffects(position);
+        // If its part of a array range, make it dirty
+        const arrayParentCell = getCalculator().getClosestArrayParentCell(position);
+        // Pipeline function that returns array needs to be
+        // cleared immediately if parent cells becomes dirty
+        // THis is because pipeline functions could be async
+        // So user do not have to wait for the next async response
+        // to check if array is in conflict
+        if (arrayParentCell) {
+            if (getCalculator().isPipelineFunction(arrayParentCell)) {
+                createSideEffects(arrayParentCell);
+            }
+            getCalculator().markAsDirty(arrayParentCell);
+        }
+        return arrayResults;
+    }, [getCalculator, getComputationCache, getUserEnteredValue]);
+    // Mark all array cells as dirty
+    const getErrorResultsFromArrayPosition = useCallback((position) => {
+        const isArrayFormula = getCalculator().isArray(position);
+        const arrayResults = new Map();
+        const recomputeOperations = [];
+        if (isArrayFormula) {
+            const arrayRange = getCalculator().getArrayRange(position);
+            if (arrayRange) {
+                for (const [rowIndex, columnIndex] of iterateCellsInCellRange(arrayRange)) {
+                    const newPosition = {
+                        rowIndex,
+                        columnIndex,
+                        sheetId: position.sheetId,
+                    };
+                    const isParentCell = isEqualPosition(position, newPosition);
+                    const key = getCalculator().makeKey(newPosition);
+                    if (!isParentCell) {
+                        // Cache
+                        getComputationCache().set(key, undefined);
+                        arrayResults.set(key, [newPosition, undefined]);
+                        // Mark cell as dirty
+                        recomputeOperations.push({
+                            type: "add",
+                            position: newPosition,
+                        });
+                    }
+                }
+            }
+        }
+        return [arrayResults, recomputeOperations];
+    }, [getCalculator, getComputationCache]);
+    return [
+        processArrayResults,
+        createArraySideEffectsAndGetResults,
+        getErrorResultsFromArrayPosition,
+    ];
+};

package/dist/esm/hooks/use-calculation-queue.d.ts

@@ -0,0 +1,10 @@
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+type UseCalculationQueueProps = {
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+};
+export declare const useCalculationQueue: ({ enqueueCalculation, }: UseCalculationQueueProps) => {
+    enqueue: (op: CalculationOperation) => void;
+    processQueue: () => void;
+};
+export {};
+//# sourceMappingURL=use-calculation-queue.d.ts.map

package/dist/esm/hooks/use-calculation-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-queue.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-queue.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9E,KAAK,wBAAwB,GAAG;IAC9B,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;CAC7E,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,yBAEjC,wBAAwB;kBAEQ,oBAAoB;;CAStD,CAAC"}

package/dist/esm/hooks/use-calculation-queue.js

@@ -0,0 +1,13 @@
+import { DEFAULT_ARRAY } from "@rowsncolumns/spreadsheet";
+import { useCallback, useRef } from "react";
+export const useCalculationQueue = ({ enqueueCalculation, }) => {
+    const queueRef = useRef(DEFAULT_ARRAY);
+    const enqueue = useCallback((op) => {
+        queueRef.current?.push(op);
+    }, []);
+    const processQueue = useCallback(() => {
+        queueRef.current.forEach((op) => enqueueCalculation(op));
+        queueRef.current.length = 0;
+    }, [enqueueCalculation]);
+    return { enqueue, processQueue };
+};

package/dist/esm/hooks/use-calculation-worker.d.ts

@@ -0,0 +1,37 @@
+import type { CalculationWorkerClientOptions, WorkerSheetMetadata } from "@rowsncolumns/calculation-worker";
+import type { IterativeCalculationOptions } from "@rowsncolumns/common-types";
+import type { NamedRange, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseCalculationProps } from "./use-calculation";
+import type { useCalculation } from "./use-calculation";
+type UseCalculationHookReturn = ReturnType<typeof useCalculation>;
+export type CalculationStats = {
+    queuedCount: number;
+    inFlightCount: number;
+    completedCount: number;
+    deferredCount: number;
+};
+export type WorkerPerfEvent = {
+    type: "worker-batch";
+    phase: "start" | "plan-built" | "worker-dispatch" | "worker-complete" | "worker-runtime-complete" | "first-result" | "complete";
+    size: number;
+    batchId: string;
+    timestamp: number;
+    duration?: number;
+};
+export type UseCalculationWorkerProps = UseCalculationProps & {
+    sheets: WorkerSheetMetadata[];
+    worker?: Worker;
+    createWorker?: () => Worker;
+    workerLogger?: CalculationWorkerClientOptions["logger"];
+    activeSheetId?: number;
+    tables?: TableView[];
+    namedRanges?: NamedRange[];
+    onDemandFormulaPattern?: string;
+    coalesceDelayMs?: number;
+    iterativeCalculation?: IterativeCalculationOptions;
+    onPerformanceEvent?(event: WorkerPerfEvent): void;
+    enablePerformanceLogging?: boolean;
+};
+export declare const useCalculationWorker: (props: UseCalculationWorkerProps) => UseCalculationHookReturn;
+export {};
+//# sourceMappingURL=use-calculation-worker.d.ts.map

package/dist/esm/hooks/use-calculation-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-calculation-worker.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,8BAA8B,EAQ9B,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAU1C,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,4BAA4B,CAAC;AAkBpC,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAWnC,OAAO,KAAK,EAIV,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EACD,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,GACjB,yBAAyB,GACzB,cAAc,GACd,UAAU,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAC5D,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,2BAA2B,CAAC;IACnD,kBAAkB,CAAC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAClD,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AA8KF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,yBAAyB,KAC/B,wBAg7DF,CAAC"}