@ricsam/formula-engine 0.0.1

package/dist/types/core/sheet-renamer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sheet renamer utility for updating cross-sheet references in formulas
+ */
+/**
+ * Renames sheet references in a formula string
+ * @param formula The formula string (without the leading =)
+ * @param oldSheetName The old sheet name to replace
+ * @param newSheetName The new sheet name to use
+ * @returns The updated formula string
+ */
+export declare function renameSheetInFormula(options: {
+    formula: string;
+    oldSheetName: string;
+    newSheetName: string;
+}): string;
+/**
+ * Checks if a formula references a specific sheet
+ * @param formula The formula string (without the leading =)
+ * @param sheetName The sheet name to check for
+ * @returns True if the formula references the sheet
+ */
+export declare function formulaReferencesSheet(formula: string, sheetName: string): boolean;
+/**
+ * Gets all sheet names referenced in a formula
+ * @param formula The formula string (without the leading =)
+ * @returns Array of unique sheet names referenced in the formula
+ */
+export declare function getReferencedSheetNames(formula: string): string[];

package/dist/types/core/sheet-utils.d.ts

@@ -0,0 +1,2 @@
+export declare class SheetUtils {
+}

package/dist/types/core/table-renamer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Renames table references in a formula string
+ * @param formula - The formula string (without the leading =)
+ * @param oldTableName - The current table name to replace
+ * @param newTableName - The new table name
+ * @returns The updated formula string, or the original if no changes were made
+ */
+export declare function renameTableInFormula(formula: string, oldTableName: string, newTableName: string): string;
+/**
+ * Checks if a formula contains references to a specific table
+ * @param formula - The formula string (without the leading =)
+ * @param tableName - The table name to search for
+ * @returns True if the formula contains references to the table
+ */
+export declare function formulaReferencesTable(formula: string, tableName: string): boolean;
+/**
+ * Gets all table names referenced in a formula
+ * @param formula - The formula string (without the leading =)
+ * @returns Array of unique table names referenced in the formula
+ */
+export declare function getReferencedTableNames(formula: string): string[];

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

@@ -0,0 +1,272 @@
+/**
+ * Core type definitions for FormulaEngine
+ * This file contains all fundamental types used throughout the engine
+ */
+import type { FunctionNode } from "src/parser/ast";
+import type { FormulaEvaluator } from "src/evaluator/formula-evaluator";
+import type { EvaluationContext } from "src/evaluator/evaluation-context";
+import type { DependencyNode } from "./managers/dependency-node";
+import type { LookupOrder } from "./managers/range-eval-order-builder";
+export interface CellAddress {
+    sheetName: string;
+    workbookName: string;
+    colIndex: number;
+    rowIndex: number;
+}
+export interface RangeAddress {
+    sheetName: string;
+    workbookName: string;
+    range: SpreadsheetRange;
+}
+export interface LocalCellAddress {
+    colIndex: number;
+    rowIndex: number;
+}
+export type ArethmeticEvaluator = (left: CellValue, right: CellValue, context: EvaluationContext) => CellValue | ErrorEvaluationResult;
+export type PositiveInfinity = {
+    type: "infinity";
+    sign: "positive";
+};
+export type CellInfinity = {
+    type: "infinity";
+    sign: "positive" | "negative";
+};
+export type CellNumber = {
+    type: "number";
+    value: number;
+};
+export type SpreadsheetRangeEnd = CellNumber | PositiveInfinity;
+export type SpreadsheetRange = {
+    start: {
+        col: number;
+        row: number;
+    };
+    end: {
+        col: SpreadsheetRangeEnd;
+        row: SpreadsheetRangeEnd;
+    };
+};
+export type RelativeRange = {
+    start: {
+        col: number;
+        row: number;
+    };
+    width: SpreadsheetRangeEnd;
+    height: SpreadsheetRangeEnd;
+};
+export type FiniteSpreadsheetRange = {
+    start: {
+        col: number;
+        row: number;
+    };
+    end: {
+        col: number;
+        row: number;
+    };
+};
+export type CellString = {
+    type: "string";
+    value: string;
+};
+export type CellBoolean = {
+    type: "boolean";
+    value: boolean;
+};
+export type CellValue = CellNumber | CellString | CellBoolean | CellInfinity;
+/**
+ * undefined and "" are considered empty values
+ * undefineds are converted to "" in the engine
+ *
+ * any empty values are deleted from the sheet content
+ */
+export type SerializedCellValue = string | number | boolean | undefined;
+export interface NamedExpression {
+    name: string;
+    expression: string;
+}
+export interface TableDefinition {
+    name: string;
+    start: {
+        rowIndex: number;
+        colIndex: number;
+    };
+    headers: Map<string, {
+        name: string;
+        index: number;
+    }>;
+    endRow: SpreadsheetRangeEnd;
+    sheetName: string;
+    workbookName: string;
+}
+export declare enum FormulaError {
+    DIV0 = "#DIV/0!",
+    NA = "#N/A",
+    NAME = "#NAME?",
+    NUM = "#NUM!",
+    REF = "#REF!",
+    VALUE = "#VALUE!",
+    CYCLE = "#CYCLE!",
+    ERROR = "#ERROR!",
+    SPILL = "#SPILL!"
+}
+export interface Sheet {
+    name: string;
+    index: number;
+    content: Map<string, SerializedCellValue>;
+}
+export interface Workbook {
+    name: string;
+    sheets: Map<string, Sheet>;
+}
+export type ValueEvaluationResult = {
+    type: "value";
+    result: CellValue;
+    /**
+     * If the terminating evaluation result is a reference (see evaluateReference)
+     * then we store information about the source cell for context dependent functions like CELL
+     */
+    sourceCell?: CellAddress;
+};
+export type AwaitingEvaluationResult = {
+    type: "awaiting-evaluation";
+    waitingFor: DependencyNode;
+    errAddress: DependencyNode;
+    /**
+     * If the terminating evaluation result is a reference (see evaluateReference)
+     * then we store information about the source cell for context dependent functions like CELL
+     */
+    sourceCell?: CellAddress;
+};
+export type DoesNotSpillResult = {
+    type: "does-not-spill";
+};
+export type ErrorEvaluationResult = {
+    type: "error";
+    err: FormulaError;
+    errAddress: DependencyNode;
+    message: string;
+    /**
+     * If the terminating evaluation result is a reference (see evaluateReference)
+     * then we store information about the source cell for context dependent functions like CELL
+     */
+    sourceCell?: CellAddress;
+} | AwaitingEvaluationResult;
+export type SingleEvaluationResult = ValueEvaluationResult | ErrorEvaluationResult;
+export type SpilledValuesEvaluator = (spillOffset: {
+    x: number;
+    y: number;
+}, context: EvaluationContext) => SingleEvaluationResult;
+export type SpilledValuesEvaluationResult = {
+    type: "spilled-values";
+    /**
+     * When a raw range is evaluated, we will add it to the sourceRange so it can be used e.g. for context dependent functions
+     */
+    sourceRange?: RangeAddress;
+    /**
+     * If the terminating evaluation result is a reference (see evaluateReference)
+     * then we store information about the source cell for context dependent functions like CELL
+     * sourceCell will only be defined on a spilledValue when a single value is looked up,
+     */
+    sourceCell?: CellAddress;
+    spillArea: (origin: CellAddress) => SpreadsheetRange;
+    /**
+     * for debugging we add a source string to denote where the spilled values were created
+     */
+    source: string;
+    evaluate: SpilledValuesEvaluator;
+    /**
+     * evaluateAllCells evaluates all non-empty cells in the spilled range.
+     * Because a spilled range can be open-ended, we need to have logic for which cells we should evaluate.
+     * e.g. when evaluating a range such as D:D only the cells in the current sheet residing in
+     * column D should be evaluated and cells producing spilled values that spill onto D:D.
+     *
+     * In order to evaluate spilled cells in D:D the range evaluateAllCells need to get all cells in the
+     * the intersection of the spilled range and D:D, for that reason evaluateAllCells gets an intersection parameter,
+     * where the intersection is relative to the origin.
+     *
+     * #### Producers:
+     * In e.g. SEQUENCE and evaluateRange we have logic for which cells in a spilled range we should evaluate,
+     *
+     * #### Nesting:
+     * e.g. evaluation of scalar operators where we want to nest e.g. `5 * right.evaluate()`
+     * can be implemented by calling
+     * ```ts
+     * const vals = child.evaluateAllCells.call(this, options);
+     * return vals.map(val => ({ ...val, result: 5 * val.result }));
+     * ```
+     *
+     * #### Consumers:
+     * Only functions that need access to all spilled values in a range end up calling evaluateAllCells, e.g.
+     * SUM, MIN, MAX, MATCH. Other types of functions like INDEX doesn't need to evaluate all cells in a range,
+     * but does a lookup into a spilled range using the evaluate method.
+     *
+     */
+    evaluateAllCells: (this: FormulaEvaluator, options: {
+        /**
+         * an intersection relative to the origin
+         */
+        intersection?: SpreadsheetRange;
+        evaluate: SpilledValuesEvaluator;
+        context: EvaluationContext;
+        /**
+         * origin is the cell address that the spilled range is spilled from
+         * e.g. in A3=B2:B4 the origin is A3
+         */
+        origin: CellAddress;
+        lookupOrder: LookupOrder;
+    }) => EvaluateAllCellsResult;
+};
+export type EvaluateAllCellsResult = ErrorEvaluationResult | {
+    type: "values";
+    values: CellInRangeResult[];
+};
+export type CellInRangeResult = {
+    result: SingleEvaluationResult;
+    relativePos: {
+        x: number;
+        y: number;
+    };
+};
+export type FunctionEvaluationResult = SingleEvaluationResult | SpilledValuesEvaluationResult;
+export type SpilledValue = {
+    /**
+     * spillOnto is the range that the spilled value is spilled onto
+     */
+    spillOnto: SpreadsheetRange;
+    /**
+     * origin is the cell address that the spilled value is spilled from
+     */
+    origin: CellAddress;
+};
+/**
+ * Function definition
+ */
+export interface FunctionDefinition {
+    name: string;
+    evaluate: (this: FormulaEvaluator, node: FunctionNode, context: EvaluationContext) => FunctionEvaluationResult;
+    aliases?: string[];
+}
+/**
+ * Evaluation result
+ */
+export type EvaluationResult = {
+    dependencies: Set<string>;
+} & FunctionEvaluationResult;
+export type SCC = {
+    id: number;
+    nodes: Set<DependencyNode>;
+    evaluationOrder: DependencyNode[];
+    resolved: boolean;
+    hardEdgeSCCs: Set<DependencyNode>[];
+};
+export type SCCDAG = {
+    sccList: SCC[];
+    sccGraph: Map<number, Set<number>>;
+};
+export type EvaluationOrder = {
+    evaluationOrder: Set<DependencyNode>;
+    hasCycle: boolean;
+    cycleNodes?: Set<DependencyNode>;
+    hash: string;
+    sccDAG?: SCCDAG;
+};

package/dist/types/core/utils/cell-address-parsing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/utils/range-serializer.d.ts

@@ -0,0 +1,22 @@
+import type { SpreadsheetRange } from "../types";
+/**
+ * Serializes a SpreadsheetRange into a human-readable range string following canonical format.
+ *
+ * Examples:
+ * - Finite range: A2:B10
+ * - Column-infinite range: A2:B (row infinite, column bounded)
+ * - Row-infinite range: A2:10 (column infinite, row bounded)
+ * - Fully infinite range: A2:INFINITY (both infinite)
+ *
+ * @param range The SpreadsheetRange to serialize
+ * @returns A human-readable range string in canonical format
+ */
+export declare function serializeRange(range: SpreadsheetRange): string;
+/**
+ * Serializes a SpreadsheetRange with an optional sheet name prefix.
+ *
+ * @param range The SpreadsheetRange to serialize
+ * @param sheetName Optional sheet name to prefix the range
+ * @returns A human-readable range string, optionally prefixed with sheet name
+ */
+export declare function serializeRangeWithSheet(range: SpreadsheetRange, sheetName?: string): string;

package/dist/types/core/utils/range-serializer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/utils/spreadsheet-visualizer.d.ts

@@ -0,0 +1,30 @@
+import { FormulaEngine } from "../engine";
+export interface SpreadsheetVisualizerOptions {
+    workbookName: string;
+    /** Number of rows to display (1-based) */
+    numRows: number;
+    /** Number of columns to display (0-based, so 11 = A-K) */
+    numCols: number;
+    /** Starting row (1-based, default: 1) */
+    startRow?: number;
+    /** Starting column (0-based, default: 0 = A) */
+    startCol?: number;
+    /** Sheet name to visualize (default: uses engine's current sheet) */
+    sheetName?: string;
+    /** Character to use for empty cells (default: ".") */
+    emptyCellChar?: string;
+    /** Minimum column width (default: 3) */
+    minColWidth?: number;
+    /** Maximum column width (default: 20) */
+    maxColWidth?: number;
+    /** Whether to show column headers (A, B, C...) */
+    showColumnHeaders?: boolean;
+    /** Whether to show row numbers */
+    showRowNumbers?: boolean;
+    /** If output is used for snapshotting */
+    snapshot?: boolean;
+}
+/**
+ * Generates a visual ASCII representation of a spreadsheet region
+ */
+export declare function visualizeSpreadsheet(engine: FormulaEngine, options: SpreadsheetVisualizerOptions): string;

package/dist/types/core/utils.d.ts

@@ -0,0 +1,48 @@
+import { type CellAddress, type ErrorEvaluationResult, type LocalCellAddress, type RangeAddress, type RelativeRange, type SpreadsheetRange } from "./types";
+import type { DependencyNode } from "./managers/dependency-node";
+export declare function isCellAddress(obj: RangeAddress | CellAddress): obj is CellAddress;
+export declare function isRangeAddress(obj: RangeAddress | CellAddress): obj is RangeAddress;
+export declare const columnToIndex: (col: string) => number;
+export declare const indexToColumn: (index: number) => string;
+export declare function getRowNumber(index: number): number;
+export declare function getCellReference({ rowIndex, colIndex, }: {
+    rowIndex: number;
+    colIndex: number;
+}): string;
+export declare function rowToLetter(row: number): string;
+export declare function letterToRow(letter: string): number;
+export declare const parseCellReference: (cellReference: string) => {
+    colIndex: number;
+    rowIndex: number;
+};
+/**
+ * Returns true if the range is a single cell, false otherwise
+ */
+export declare function isRangeOneCell(range: SpreadsheetRange): boolean;
+export declare function isCellInRange(cellAddress: LocalCellAddress, range: SpreadsheetRange): boolean;
+export declare function getRangeKey(range: SpreadsheetRange): string;
+export declare function getRelativeRangeKey(range: RelativeRange): string;
+export declare function getRelativeRange(range: SpreadsheetRange, relativeTo: LocalCellAddress): RelativeRange;
+export declare function getAbsoluteRange(range: RelativeRange, relativeTo: LocalCellAddress): SpreadsheetRange;
+export declare function keyToCellAddress(key: string): CellAddress;
+/**
+ * For cache lookups, use dependencyManager.getCellNode(cellAddressToKey(cellAddress)).key
+ * because it may be an empty cell node key
+ */
+export declare function cellAddressToKey(cellAddress: CellAddress): string;
+export declare function rangeAddressToKey(rangeAddress: RangeAddress): string;
+/**
+ *
+ * @param key - the range key to parse e.g. range:workbook:sheet:A3:A5
+ * @returns
+ */
+export declare function keyToRangeAddress(key: string): RangeAddress;
+/**
+ * Check if two ranges intersect
+ */
+export declare function checkRangeIntersection(range1: SpreadsheetRange, range2: SpreadsheetRange): boolean;
+/**
+ * Get the intersection of two ranges
+ */
+export declare function getRangeIntersection(range1: SpreadsheetRange, range2: SpreadsheetRange): SpreadsheetRange | null;
+export declare function captureEvaluationErrors<T>(errAddress: DependencyNode, fn: () => T): T | ErrorEvaluationResult;

package/dist/types/core/workbook-renamer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Workbook renamer utility for updating cross-workbook references in formulas
+ */
+/**
+ * Renames workbook references in a formula string
+ * @param formula The formula string (without the leading =)
+ * @param oldWorkbookName The old workbook name to replace
+ * @param newWorkbookName The new workbook name to use
+ * @returns The updated formula string
+ */
+export declare function renameWorkbookInFormula(options: {
+    formula: string;
+    oldWorkbookName: string;
+    newWorkbookName: string;
+}): string;
+/**
+ * Checks if a formula references a specific workbook
+ * @param formula The formula string (without the leading =)
+ * @param workbookName The workbook name to check for
+ * @returns True if the formula references the workbook
+ */
+export declare function formulaReferencesWorkbook(formula: string, workbookName: string): boolean;
+/**
+ * Gets all workbook names referenced in a formula
+ * @param formula The formula string (without the leading =)
+ * @returns Array of unique workbook names referenced in the formula
+ */
+export declare function getReferencedWorkbookNames(formula: string): string[];

package/dist/types/debug/flags.d.ts

@@ -0,0 +1,11 @@
+type DebugFlags = {
+    isProfiling: boolean;
+    stopEvaluation: boolean;
+    profilingNamespaces: Record<string, boolean>;
+    numEvaluationCalls: number;
+    profiledCall: number;
+    maxEvaluationCalls: number;
+    prevSize: number;
+};
+export declare const flags: DebugFlags;
+export {};

package/dist/types/evaluator/arithmetic/add/add.d.ts

@@ -0,0 +1,2 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+export declare const add: ArethmeticEvaluator;

package/dist/types/evaluator/arithmetic/add/add.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/arithmetic/divide/divide.d.ts

@@ -0,0 +1,2 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+export declare const divide: ArethmeticEvaluator;

package/dist/types/evaluator/arithmetic/divide/divide.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/arithmetic/multiply/multiply.d.ts

@@ -0,0 +1,2 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+export declare const multiply: ArethmeticEvaluator;

package/dist/types/evaluator/arithmetic/multiply/multiply.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/arithmetic/power/power.d.ts

@@ -0,0 +1,2 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+export declare const power: ArethmeticEvaluator;

package/dist/types/evaluator/arithmetic/power/power.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/arithmetic/subtract/subtract.d.ts

@@ -0,0 +1,2 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+export declare const subtract: ArethmeticEvaluator;

package/dist/types/evaluator/arithmetic/subtract/subtract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/comparison/comparison-operators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/comparison/equals.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Equals operator (=) - Returns TRUE if both values are exactly equal
+ * Strict type checking: both type and value must match
+ */
+export declare const equals: ArethmeticEvaluator;

package/dist/types/evaluator/comparison/greater-than-or-equal.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Greater than or equal operator (>=) - Returns TRUE if left >= right
+ * Implemented as NOT (left < right)
+ */
+export declare const greaterThanOrEqual: ArethmeticEvaluator;

package/dist/types/evaluator/comparison/greater-than.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Greater than operator (>) - Returns TRUE if left > right
+ * Implemented as NOT (left <= right)
+ */
+export declare const greaterThan: ArethmeticEvaluator;

package/dist/types/evaluator/comparison/less-than-or-equal.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Less than or equal operator (<=) - Returns TRUE if left <= right
+ * Uses lessThan OR equals logic
+ */
+export declare const lessThanOrEqual: ArethmeticEvaluator;

package/dist/types/evaluator/comparison/less-than.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Less than operator (<) - Returns TRUE if left < right
+ * Only works with numbers and infinity
+ */
+export declare const lessThan: ArethmeticEvaluator;

package/dist/types/evaluator/comparison/not-equals.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Not equals operator (<>) - Returns TRUE if values are not equal
+ * Uses the equals operator and negates the result
+ */
+export declare const notEquals: ArethmeticEvaluator;

package/dist/types/evaluator/concatenation/concatenate.d.ts

@@ -0,0 +1,6 @@
+import type { ArethmeticEvaluator } from "src/core/types";
+/**
+ * Concatenation operator (&) - Concatenates two values as strings
+ * Works with numbers and strings only
+ */
+export declare const concatenate: ArethmeticEvaluator;

package/dist/types/evaluator/concatenation/concatenate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/dependency-nodes/ast-evaluation-node.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionEvaluationResult } from "src/core/types";
+import type { ASTNode } from "src/parser/ast";
+import type { ContextDependency } from "../evaluation-context";
+import { BaseEvalNode } from "./base-eval-node";
+export declare class AstEvaluationNode extends BaseEvalNode<FunctionEvaluationResult> {
+    ast: ASTNode;
+    private _contextDependency;
+    constructor(ast: ASTNode, contextDependency: ContextDependency);
+    toString(): string;
+    getContextDependency(): ContextDependency;
+    setContextDependency(contextDependency: ContextDependency): void;
+}

package/dist/types/evaluator/dependency-nodes/base-eval-node.d.ts

@@ -0,0 +1,31 @@
+import { type DependencyNode } from "src/core/managers/dependency-node";
+import type { SpillMetaNode } from "./spill-meta-node";
+export declare class BaseEvalNode<T> {
+    key: string;
+    private _dependencies;
+    private _lastDependencies;
+    _evaluationResult: T;
+    private _resolved;
+    constructor(key: string);
+    addDependency(dep: DependencyNode): void;
+    get directDepsUpdated(): boolean;
+    resolve(): void;
+    canResolve(): boolean;
+    get resolved(): boolean;
+    get evaluationResult(): T;
+    setEvaluationResult(result: T): void;
+    resetDirectDepsUpdated(): void;
+    /**
+     * Get the direct dependencies of the node, either RangeEvaluationNode or DependencyNode
+     */
+    getDependencies(): Set<DependencyNode>;
+    /**
+     * Just to mirror the method in RangeEvaluationNode
+     */
+    getAllDependencies(): Set<DependencyNode>;
+    /**
+     * Just to mirror the method in RangeEvaluationNode
+     */
+    getFrontierDependencies(): Set<SpillMetaNode>;
+    toJSON(visitor?: Set<string>): any;
+}

package/dist/types/evaluator/dependency-nodes/cell-value-node.d.ts

@@ -0,0 +1,10 @@
+import type { CellAddress, SingleEvaluationResult } from "src/core/types";
+import { BaseEvalNode } from "./base-eval-node";
+import type { SpillMetaNode } from "./spill-meta-node";
+export declare class CellValueNode extends BaseEvalNode<SingleEvaluationResult> {
+    readonly cellAddress: CellAddress;
+    constructor(key: string);
+    toString(): string;
+    spillMeta: SpillMetaNode | undefined;
+    setSpillMetaNode(node: SpillMetaNode): void;
+}

package/dist/types/evaluator/dependency-nodes/empty-cell-evaluation-node.d.ts

@@ -0,0 +1,17 @@
+import type { DependencyManager } from "src/core/managers/dependency-manager";
+import { FrontierDependencyManager } from "src/core/managers/frontier-dependency-manager";
+import type { WorkbookManager } from "src/core/managers/workbook-manager";
+import type { CellAddress, SingleEvaluationResult } from "src/core/types";
+export declare class EmptyCellEvaluationNode extends FrontierDependencyManager {
+    emptyCellKey: string;
+    key: string;
+    cellAddress: CellAddress;
+    private _evaluationResult;
+    constructor(emptyCellKey: string, evaluationManager: DependencyManager, workbookManager: WorkbookManager);
+    setEvaluationResult(result: SingleEvaluationResult): void;
+    get evaluationResult(): SingleEvaluationResult;
+    resolve(): void;
+    canResolve(): boolean;
+    toJSON(visitor?: Set<string>): any;
+    toString(): string;
+}

package/dist/types/evaluator/dependency-nodes/spill-meta-node.d.ts

@@ -0,0 +1,7 @@
+import type { CellAddress, DoesNotSpillResult, ErrorEvaluationResult, SpilledValuesEvaluationResult } from "src/core/types";
+import { BaseEvalNode } from "./base-eval-node";
+export declare class SpillMetaNode extends BaseEvalNode<SpilledValuesEvaluationResult | ErrorEvaluationResult | DoesNotSpillResult> {
+    readonly cellAddress: CellAddress;
+    constructor(key: string);
+    toString(): string;
+}