@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

package/dist/types/plugins/core/squisher.d.ts

@@ -0,0 +1,82 @@
+import { CompiledFormula } from "../../formulas/compiler";
+import { Cell } from "../../types/cells";
+import { UpdateCellCommand } from "../../types/commands";
+import { CoreGetters } from "../../types/core_getters";
+import { UID } from "../../types/misc";
+/**
+ * Example of squishing:
+ * "=concat(A1, "test", B1:C3, 5)" followed by
+ * "=concat(A2, "test", B1:C3, 7)"
+ *        __|      |_     |    |
+ *       |    _______|____|    |
+ *       v   v       v         v
+ * {R: "+R1|=", S: ["="], N: "+2"}
+ *
+ * N can be full numbers or relative change identified with a + sign before the number.
+ * R can be full references or relative change identified with a +Ck or +Rk (k being the number of columns or rows of the change).
+ * S can only be the full string if it changed, or "=" if it did not change.
+ * * */
+export interface SquishedFormula {
+    N?: string;
+    S?: string[];
+    R?: string | string[];
+}
+export type SquishedContent = string | SquishedFormula;
+export declare const SEPARATOR = "|";
+export declare const NO_CHANGE = "=";
+export declare class Squisher {
+    private readonly getters;
+    private baseFormula;
+    private alreadyAppliedNumberOffsets;
+    private previousStrings;
+    private baseFormulaWasTransformed;
+    private baseNumber;
+    constructor(getters: CoreGetters);
+    /** Build the result object based on a transformation. Joins the numbers into a single string, tries to do the same
+     * with references (unless they contain a sheet name that contains the separator). */
+    private buildResult;
+    /** Change the base formula to the given one, resetting all offsets and previous strings */
+    resetBaseTo(formula: CompiledFormula): void;
+    /** Reset the base formula to undefined, resetting all offsets */
+    resetBaseFormula(): void;
+    /**
+     * Takes a cell and squish their formulas against the previous one (in the previous call).
+     * We should call this method for each cell in the sheet, in order from top to bottom, then from left to right (all cells of a columns, for each columns left to right).
+     *
+     * The result of this method is:
+     * - if the cell is not a formula, returns the content as is and resets the base formula
+     * - if the cell is a formula:
+     *   - if there is no previous formula, or the normalized formula is different from the previous one, resets the base formula to this one and returns the full formula string
+     *   - else, compares the literal values and range dependencies to the previous formula, and for each parameter:
+     *     - for numbers: returns a relative change (+N or -N) if possible, else the full number or "=" if unchanged
+     *     - for strings: returns the full string if changed, else "="
+     *     - for references: returns a relative change (+Ck or +Rk) if possible, else the full reference or "=" if unchanged
+     * */
+    squish(cell: Cell, forSheetId: UID): SquishedContent;
+    squishCommand(command: UpdateCellCommand): string | SquishedFormula | undefined;
+    /**
+     * Read all the consecutive cells with either the same content or the same transformation and merge their key into one zone
+     * Do not join cells from different columns
+     * */
+    squishSheet(cells: {
+        [key: string]: SquishedContent;
+    }, sheetId: UID): {
+        [key: string]: SquishedContent;
+    };
+    /**
+     * Squish the references. Result for each reference should be compared the previous formula.
+     * The result can be:
+     * - a relative change, e.g. +C2 or +R5 as string
+     * - the full reference if the reference is too different
+     * */
+    private squishReferences;
+    private squishOneReference;
+    /**
+     * Squish the number parameters. Result for each parameter should be compared the previous formula.
+     * The result can be:
+     * - a relative change, e.g. +2 or -5 as string
+     * - "=" meaning no change as string
+     * */
+    private squishNumbers;
+    private squishStrings;
+}

package/dist/types/plugins/core/table_style.d.ts

@@ -0,0 +1,24 @@
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { TableStyle } from "../../types/table";
+import { WorkbookData } from "../../types/workbook_data";
+import { CorePlugin } from "../core_plugin";
+interface TableStylesState {
+    readonly styles: {
+        [styleId: string]: TableStyle;
+    };
+}
+export declare class TableStylePlugin extends CorePlugin<TableStylesState> implements TableStylesState {
+    static getters: readonly ["getNewCustomTableStyleName", "getTableStyle", "getTableStyles", "isTableStyleEditable"];
+    readonly styles: {
+        [styleId: string]: TableStyle;
+    };
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getTableStyle(styleId: string): TableStyle;
+    getTableStyles(): Record<string, TableStyle>;
+    getNewCustomTableStyleName(): string;
+    isTableStyleEditable(styleId: string): boolean;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+export {};

package/dist/types/plugins/core/tables.d.ts

@@ -0,0 +1,61 @@
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { CellPosition, RangeAdapterFunctions, TableId, UID, Zone } from "../../types/misc";
+import { CoreTable } from "../../types/table";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+import { CorePlugin } from "../core_plugin";
+interface TableState {
+    tables: Record<UID, Record<TableId, CoreTable | undefined>>;
+    nextTableId: number;
+}
+export declare class TablePlugin extends CorePlugin<TableState> implements TableState {
+    static getters: readonly ["getCoreTable", "getCoreTables", "getCoreTableMatchingTopLeft"];
+    readonly tables: Record<UID, Record<TableId, CoreTable | undefined>>;
+    readonly nextTableId: number;
+    adaptRanges({ applyChange }: RangeAdapterFunctions): void;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getCoreTables(sheetId: UID): CoreTable[];
+    getCoreTable({ sheetId, col, row }: CellPosition): CoreTable | undefined;
+    private getTablesOverlappingZones;
+    /** Extend a table down one row */
+    private extendTableDown;
+    /** Extend a table right one col */
+    private extendTableRight;
+    /**
+     * Check if an UpdateCell command should cause the given table to be extended by one row or col.
+     *
+     * The table should be extended if all of these conditions are true:
+     * 1) The updated cell is right below/right of the table
+     * 2) The command adds a content to the cell
+     * 3) No cell right below/right next to the table had any content before the command
+     * 4) Extending the table down/right would not overlap with another table
+     * 5) Extending the table down/right would not overlap with a merge
+     *
+     */
+    private canUpdateCellCmdExtendTable;
+    private isPivotFormula;
+    getCoreTableMatchingTopLeft(sheetId: UID, zone: Zone): CoreTable | undefined;
+    private checkUpdatedTableZoneIsValid;
+    private checkTableConfigUpdateIsValid;
+    private createStaticTable;
+    private createDynamicTable;
+    private updateTable;
+    private updateStaticTable;
+    private updateDynamicTable;
+    /**
+     * Update the old config of a table with the new partial config from an UpdateTable command.
+     *
+     * Make sure the new config make sense (e.g. if the table has no header, it should not have
+     * filters and number of headers should be 0)
+     */
+    private updateTableConfig;
+    private createFilterFromZone;
+    private copyStaticTableForSheet;
+    private copyDynamicTableForSheet;
+    private applyRangeChangeOnTable;
+    private consumeNextId;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

package/dist/types/plugins/core/unsquisher.d.ts

@@ -0,0 +1,60 @@
+import { SquishedCoreCommand } from "../../collaborative/command_squisher";
+import { CompiledFormula } from "../../formulas/compiler";
+import { CoreCommand } from "../../types/commands";
+import { CoreGetters } from "../../types/core_getters";
+import { Position, UID } from "../../types/misc";
+import { SquishedContent } from "./squisher";
+export declare class Unsquisher {
+    private previousFormula;
+    private alreadyAppliedNumberOffset;
+    private previousString;
+    private alreadyAppliedReferenceOffset;
+    private previousOffset;
+    private previousNumber;
+    private previousNumberFormat?;
+    rebase(): void;
+    /**
+     * Expands a list of commands that may contain SQUISHED_UPDATE_CELL commands back to a list of full commands.
+     */
+    unsquishCommands(commands: readonly (CoreCommand | SquishedCoreCommand)[], getters: CoreGetters): Generator<CoreCommand>;
+    /**
+     * Expands a squished sheet object back to a full cell map.
+     * For range keys like "B2:B73", fills all cells in the range with the value.
+     * For single cell keys like "A1", copies as is.
+     * Assumes input is an object: { [ref: string]: string | object }
+     *
+     * @param squished - The squished sheet object.
+     * Yields [cellRef, value] for each cell in the expanded squished object.
+     * @param sheetId
+     * @param getters
+     */
+    unsquishSheet(squished: {
+        [cellRefOrRange: string]: SquishedContent | undefined;
+    }, sheetId: UID, getters: CoreGetters): Generator<{
+        position: Position;
+        content?: string;
+        compiled?: CompiledFormula;
+    }>;
+    /**
+     * Determines the unsquishing strategy based on the current content and previous state. This logic is the same for both unsquishing commands and sheets.
+     */
+    private chooseStrategy;
+    /**
+     * Applies the given unsquishing strategy to the current cell content and yields the resulting commands or cell updates.
+     * This logic is the same for both unsquishing commands and sheets.
+     * @param strategy - the unsquishing strategy to apply, determined by the current content and previous state
+     * @param targetPositions - the positions that the current squished content applies to (can be multiples in case of range keys)
+     * @param squishedContent
+     * @param sheetId
+     * @param getters
+     * @private
+     */
+    private applyStrategy;
+    private parseSquishableLiteral;
+    /**
+     * Unsquishes the given squished formula by applying the offsets to the previous formula's literal values and range dependencies.
+     */
+    private unsquishFormula;
+    private adjustStrings;
+    private adjustNumbers;
+}

package/dist/types/plugins/core_plugin.d.ts

@@ -0,0 +1,47 @@
+import { StateObserver } from "../state_observer";
+import { CoreCommand, CoreCommandDispatcher } from "../types/commands";
+import { CoreGetters } from "../types/core_getters";
+import { RangeAdapterFunctions, RangeProvider } from "../types/misc";
+import { ModelConfig } from "../types/model";
+import { WorkbookData } from "../types/workbook_data";
+import { BasePlugin } from "./base_plugin";
+import { RangeAdapterPlugin } from "./core/range";
+export interface CorePluginConfig {
+    readonly getters: CoreGetters;
+    readonly stateObserver: StateObserver;
+    readonly range: RangeAdapterPlugin;
+    readonly dispatch: CoreCommandDispatcher["dispatch"];
+    readonly canDispatch: CoreCommandDispatcher["dispatch"];
+    readonly custom: ModelConfig["custom"];
+    readonly external: ModelConfig["external"];
+}
+export interface CorePluginConstructor {
+    new (config: CorePluginConfig): CorePlugin;
+    getters: readonly string[];
+}
+/**
+ * Core plugins handle spreadsheet data.
+ * They are responsible to import, export and maintain the spreadsheet
+ * persisted state.
+ * They should not be concerned about UI parts or transient state.
+ */
+export declare class CorePlugin<State = any> extends BasePlugin<State, CoreCommand> implements RangeProvider {
+    protected getters: CoreGetters;
+    protected dispatch: CoreCommandDispatcher["dispatch"];
+    protected canDispatch: CoreCommandDispatcher["dispatch"];
+    constructor({ getters, stateObserver, range, dispatch, canDispatch }: CorePluginConfig);
+    import(data: WorkbookData): void;
+    export(data: WorkbookData, shouldSquish: boolean): void;
+    /**
+     * This method can be implemented in any plugin, to loop over the plugin's data structure and adapt the plugin's ranges.
+     * To adapt them, the implementation of the function must have a perfect knowledge of the data structure, thus
+     * implementing the loops over it makes sense in the plugin itself.
+     * When calling the method applyChange, the range will be adapted if necessary, then a copy will be returned along with
+     * the type of change that occurred.
+     *
+     * @param rangeAdapterFunctions a function that, when called, will adapt the range according to the change on the grid
+     * @param sheetId an sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
+     * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
+     */
+    adaptRanges(rangeAdapterFunctions: RangeAdapterFunctions): void;
+}

package/dist/types/plugins/core_view_plugin.d.ts

@@ -0,0 +1,29 @@
+import { Session } from "../collaborative/session";
+import { StateObserver } from "../state_observer";
+import { Command } from "../types/commands";
+import { Currency } from "../types/currency";
+import { Getters } from "../types/getters";
+import { Color } from "../types/misc";
+import { ModelConfig } from "../types/model";
+import { BasePlugin } from "./base_plugin";
+export interface CoreViewPluginConfig {
+    readonly getters: Getters;
+    readonly stateObserver: StateObserver;
+    readonly custom: ModelConfig["custom"];
+    readonly session: Session;
+    readonly defaultCurrency?: Partial<Currency>;
+    readonly customColors: Color[];
+    readonly external: ModelConfig["external"];
+}
+export interface CoreViewPluginConstructor {
+    new (config: CoreViewPluginConfig): CoreViewPlugin;
+    getters: readonly string[];
+}
+/**
+ * Core view plugins handle any data derived from core date (i.e. evaluation).
+ * They cannot impact the model data (i.e. cannot dispatch commands).
+ */
+export declare class CoreViewPlugin<State = any> extends BasePlugin<State, Command> {
+    protected getters: Getters;
+    constructor({ getters, stateObserver }: CoreViewPluginConfig);
+}

package/dist/types/plugins/plugin_registries.d.ts

@@ -0,0 +1,8 @@
+import { Registry } from "../registry";
+import { CorePluginConstructor } from "./core_plugin";
+import { CoreViewPluginConstructor } from "./core_view_plugin";
+import { UIPluginConstructor } from "./ui_plugin";
+export declare const corePluginRegistry: Registry<CorePluginConstructor>;
+export declare const featurePluginRegistry: Registry<UIPluginConstructor>;
+export declare const statefulUIPluginRegistry: Registry<UIPluginConstructor>;
+export declare const coreViewsPluginRegistry: Registry<CoreViewPluginConstructor>;

package/dist/types/plugins/ui_core_views/cell_evaluation/binary_grid.d.ts

@@ -0,0 +1,36 @@
+import { CellPosition } from "../../../types/misc";
+type Bit = 0 | 1;
+/**
+ * Implements a fixed-sized grid or 2D matrix of bits.
+ * based on https://github.com/zandaqo/structurae
+ *
+ * The grid is implemented as a 1D array of 32-bit integers, where each bit represents a cell in the grid.
+ * It follows row-major order, with each row stored consecutively in 32-bit blocks.
+ * Pads the number of columns to the next power of 2 to allow quick lookups with bitwise operations.
+ *
+ * Key terminology:
+ * - bucket: Index of an item in the Uint32Array, a 32-bit integer.
+ * - bitPosition: The position of a bit within the bucket 32-bit integer.
+ */
+export declare class BinaryGrid extends Uint32Array {
+    private columnOffset;
+    cols: number;
+    rows: number;
+    /**
+     * Creates a binary grid of specified dimensions.
+     */
+    static create(rows: number, columns: number): BinaryGrid;
+    /**
+     * Returns the bit at given coordinates.
+     */
+    getValue(position: CellPosition): Bit;
+    /**
+     * Sets the bit at given coordinates.
+     */
+    setValue(position: CellPosition, value: Bit): boolean;
+    isEmpty(): boolean;
+    fillAllPositions(): void;
+    clear(): void;
+    private getCoordinates;
+}
+export {};

package/dist/types/plugins/ui_core_views/cell_evaluation/compilation_parameters.d.ts

@@ -0,0 +1,17 @@
+import { EvaluatedCell } from "../../../types/cells";
+import { EvalContext } from "../../../types/functions";
+import { Getters } from "../../../types/getters";
+import { CellPosition, EnsureRange, ReferenceDenormalizer } from "../../../types/misc";
+import { ModelConfig } from "../../../types/model";
+export type CompilationParameters = {
+    referenceDenormalizer: ReferenceDenormalizer;
+    ensureRange: EnsureRange;
+    evalContext: EvalContext;
+};
+/**
+ * Return all functions necessary to properly evaluate a formula:
+ * - a refFn function to read any reference, cell or range of a normalized formula
+ * - a range function to convert any reference to a proper value array
+ * - an evaluation context
+ */
+export declare function buildCompilationParameters(context: ModelConfig["custom"], getters: Getters, computeCell: (position: CellPosition) => EvaluatedCell): CompilationParameters;

package/dist/types/plugins/ui_core_views/cell_evaluation/evaluation_plugin.d.ts

@@ -0,0 +1,56 @@
+import { CompiledFormula } from "../../../formulas/compiler";
+import { CellValue, EvaluatedCell, FormulaCell } from "../../../types/cells";
+import { Command, CoreViewCommand } from "../../../types/commands";
+import { PerfProfile } from "../../../types/functions";
+import { CellPosition, FunctionResultObject, GetSymbolValue, Matrix, UID, Zone } from "../../../types/misc";
+import { Range } from "../../../types/range";
+import { ExcelWorkbookData } from "../../../types/workbook_data";
+import { CoreViewPlugin, CoreViewPluginConfig } from "../../core_view_plugin";
+export declare class EvaluationPlugin extends CoreViewPlugin {
+    static getters: readonly ["evaluateFormula", "evaluateFormulaResult", "evaluateCompiledFormula", "getCorrespondingFormulaCell", "getVisibleRangeValues", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getEvaluatedCellsPositions", "getSpreadZone", "getArrayFormulaSpreadingOn", "isArrayFormulaSpillBlocked", "isEmpty", "getPerfProfile"];
+    private shouldRebuildDependenciesGraph;
+    private evaluator;
+    private positionsToUpdate;
+    constructor(config: CoreViewPluginConfig);
+    beforeHandle(cmd: Command): void;
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    evaluateFormula(sheetId: UID, formulaString: string, cellPosition?: CellPosition): CellValue | Matrix<CellValue>;
+    evaluateFormulaResult(sheetId: UID, formulaString: string, cellPosition?: CellPosition): Matrix<FunctionResultObject> | FunctionResultObject;
+    evaluateCompiledFormula(sheetId: UID, compiledFormula: CompiledFormula, getSymbolValue?: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;
+    /**
+     * Return the value of each cell in the range.
+     */
+    getVisibleRangeValues(range: Range): EvaluatedCell[];
+    getEvaluatedCell(position: CellPosition): EvaluatedCell;
+    getEvaluatedCells(sheetId: UID): EvaluatedCell[];
+    getEvaluatedCellsPositions(sheetId: UID): CellPosition[];
+    getEvaluatedCellsInZone(sheetId: UID, zone: Zone): EvaluatedCell[];
+    /**
+     * Return the spread zone the position is part of, if any
+     */
+    getSpreadZone(position: CellPosition, options?: {
+        ignoreSpillError: boolean;
+    }): Zone | undefined;
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    isArrayFormulaSpillBlocked(position: CellPosition): boolean;
+    /**
+     * Check if a zone only contains empty cells
+     */
+    isEmpty(sheetId: UID, zone: Zone): boolean;
+    getPerfProfile(): PerfProfile | undefined;
+    /**
+     * Maps the visible positions of a range  according to a provided callback
+     * @param range - the range we filter out
+     * @param evaluationCallback - the callback applied to the filtered positions
+     * @returns the values filtered (ie we keep only the not hidden values)
+     */
+    private mapVisiblePositions;
+    exportForExcel(data: ExcelWorkbookData): void;
+    /**
+     * Returns the corresponding formula cell of a given cell
+     * It could be the formula present in the cell itself or the
+     * formula of the array formula that spreads to the cell
+     */
+    getCorrespondingFormulaCell(position: CellPosition): FormulaCell | undefined;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/evaluator.d.ts

@@ -0,0 +1,73 @@
+import { CompiledFormula } from "../../../formulas/compiler";
+import { EvaluatedCell } from "../../../types/cells";
+import { CompilationParameters } from "./compilation_parameters";
+import { PerfProfile } from "../../../types/functions";
+import { Getters } from "../../../types/getters";
+import { CellPosition, FunctionResultObject, GetSymbolValue, Matrix, UID, Zone } from "../../../types/misc";
+import { ModelConfig } from "../../../types/model";
+export declare class Evaluator {
+    private readonly context;
+    private readonly getters;
+    private compilationParams;
+    private evaluatedCells;
+    private formulaDependencies;
+    private blockedArrayFormulas;
+    private spreadingRelations;
+    private perfProfile;
+    constructor(context: ModelConfig["custom"], getters: Getters);
+    getPerfProfile(): PerfProfile | undefined;
+    getEvaluatedCell(position: CellPosition): EvaluatedCell;
+    getSpreadZone(position: CellPosition, options?: {
+        ignoreSpillError: boolean;
+    }): Zone | undefined;
+    getEvaluatedPositions(): CellPosition[];
+    getEvaluatedPositionsInSheet(sheetId: UID): CellPosition[];
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    isArrayFormulaSpillBlocked(position: CellPosition): boolean;
+    updateDependencies(position: CellPosition): void;
+    private addDependencies;
+    private computeDependencies;
+    private updateCompilationParametersForIsolatedFormula;
+    private updateCompilationParameters;
+    private createEmptyPositionSet;
+    evaluateCells(positions: CellPosition[]): void;
+    private getArrayFormulasImpactedByChangesOf;
+    buildDependencyGraph(): void;
+    evaluateAllCells(profiling?: boolean): void;
+    evaluateFormulaResult(sheetId: UID, formulaString: string, originCellPosition?: CellPosition): FunctionResultObject | Matrix<FunctionResultObject>;
+    evaluateCompiledFormula(sheetId: UID, compiledFormula: CompiledFormula, getContextualSymbolValue?: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;
+    /**
+     * Return the position of formulas blocked by the given positions
+     * as well as all their dependencies.
+     */
+    private getArrayFormulasBlockedBy;
+    private nextRangesToUpdate;
+    private cellsBeingComputed;
+    private symbolsBeingComputed;
+    private evaluate;
+    private clearEvaluatedRanges;
+    private computeCell;
+    private computeAndSave;
+    private computeFormulaCell;
+    private postProcessFormulaReturn;
+    private invalidatePositionsDependingOnSpread;
+    private assertSheetHasEnoughSpaceToSpreadFormulaResult;
+    private assertNoMergedCellsInSpreadZone;
+    private checkCollision;
+    private spreadValues;
+    private invalidateSpreading;
+    /**
+     * Wraps a GetSymbolValue function to add cycle detection
+     * and error handling.
+     */
+    private buildSafeGetSymbolValue;
+    private processPerfProfile;
+    /**
+     * Merge timing entries into RangeTimings by combining adjacent cell
+     * positions into contiguous ranges and summing their times.
+     */
+    private mergeIntoRangeTimings;
+    private getDirectDependencies;
+    private getCellsDependingOn;
+}
+export declare function updateEvalContextAndExecute(compiledFormula: CompiledFormula, compilationParams: CompilationParameters, sheetId: UID, getSymbolValue: GetSymbolValue, originCellPosition: CellPosition | undefined): FunctionResultObject | Matrix<FunctionResultObject>;

package/dist/types/plugins/ui_core_views/cell_evaluation/formula_dependency_graph.d.ts

@@ -0,0 +1,18 @@
+import { CellPosition } from "../../../types/misc";
+import { BoundedRange, Range } from "../../../types/range";
+import { RangeSet } from "./range_set";
+/**
+ * Implementation of a dependency Graph.
+ * The graph is used to evaluate the cells in the correct
+ * order, and should be updated each time a cell's content is modified
+ *
+ * It uses a collection of interval trees to efficiently find dependent cells.
+ * There is one interval tree per column.
+ */
+export declare class FormulaDependencyGraph {
+    private forest;
+    removeAllDependencies(formulaPosition: CellPosition): void;
+    addDependencies(formulaPosition: CellPosition, dependencies: Iterable<Range>): void;
+    getCellsDependingOn(ranges: Iterable<BoundedRange>, visited?: RangeSet): RangeSet;
+    private getOrCreateIntervalTree;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/interval_tree.d.ts

@@ -0,0 +1,47 @@
+import { BoundedRange } from "../../../types/range";
+/**
+ * Represents a numeric range [top, bottom].
+ * Optional 'dependents' link the interval to the range of cells that depend on
+ * the interval.
+ */
+export interface Interval {
+    top: number;
+    bottom: number;
+    dependents?: BoundedRange;
+}
+/**
+ * An Interval Tree is an (augmented) binary search tree where each node stores an
+ * interval [<low value>, <high value>]
+ *
+ * Augmented: each node stores the maximum 'high' value among all intervals in its subtree,
+ * enabling O(log n) retrieval of all intervals overlapping a given range.
+ *
+ * To avoid constant, expensive tree rebalancing, new intervals are pushed to a
+ * `buffer` (O(1) insert).
+ * The tree is only rebuilt and balanced when a `query` is performed or the buffer exceeds a threshold.
+ */
+export declare class IntervalTree {
+    private root;
+    private buffer;
+    /**
+     * Adds an interval to the uncommitted buffer.
+     * O(1) operation until the buffer needs to be merged into the main tree on the next query.
+     */
+    insert(interval: Required<Interval>): void;
+    /**
+     * Finds all intervals overlapping the target.
+     */
+    query(target: Interval): Required<Interval>[];
+    private rebuild;
+    /**
+     * Compacts consecutive intervals with consecutive dependents into a single
+     * interval.
+     */
+    private compactSortedIntervals;
+    private mergeSortedIntervals;
+    private bulkLoad;
+    private buildBalancedTree;
+    private searchTree;
+    private inOrderTraversal;
+    private isOverlapping;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/position_set.d.ts

@@ -0,0 +1,28 @@
+import { CellPosition, UID } from "../../../types/misc";
+export type SheetSizes = Record<UID, {
+    rows: number;
+    cols: number;
+}>;
+export declare class PositionSet {
+    private sheets;
+    /**
+     * List of positions in the order they were inserted.
+     */
+    private insertions;
+    private maxSize;
+    constructor(sheetSizes: SheetSizes);
+    add(position: CellPosition): void;
+    addMany(positions: Iterable<CellPosition>): void;
+    delete(position: CellPosition): void;
+    deleteMany(positions: Iterable<CellPosition>): void;
+    has(position: CellPosition): boolean;
+    clear(): CellPosition[];
+    isEmpty(): boolean;
+    fillAllPositions(): void;
+    /**
+     * Iterate over the positions in the order of insertion.
+     * Note that the same position may be yielded multiple times if the value was added
+     * to the set then removed and then added again.
+     */
+    [Symbol.iterator](): Generator<CellPosition>;
+}