@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/calculation/compiler/Types.d.ts

@@ -0,0 +1,274 @@
+import { IFunction, IRange, IRuntime } from '@sheetxl/primitives';
+import { ISymbolRegistry } from '../symbol';
+import { ICalculation } from '../ICalculation';
+import { ASTNode, ASTVisitor } from './ASTTypes';
+/**
+ * Parses a string into a CompiledFormula.
+ *
+ * @remarks
+ * Whether the expression is normalized or preserved-as-typed, and how hard a parse failure is
+ * recovered, are properties of the compiler INSTANCE (its profile — see `FormulaCompilerProfile`),
+ * not of an individual compile call.
+ */
+export interface IFormulaCompiler {
+    /**
+     * Parse an formula and returns a CompiledFormula.
+     *
+     * @param runtime The runtime to use for parsing. This is used to pass in locale details and other runtime details that may impact parsing.
+     * @param row The row of the cell the formula is in. Used for relative reference resolution.
+     * @param column The column of the cell the formula is in. Used for relative reference resolution.
+     * @param expression The formula expression to parse.
+     * @param symbolRegistry The symbol registry to use for name resolution.
+     * @param getFunction Resolves a function's stableId to its declaration. Optional: the only use is
+     * a function's DECLARED return type, which lets the compiler reject an implicit intersection over
+     * a scalar-returning call (`=SEQUENCE (RANDBETWEEN(1,2))`). Omitted (or unresolvable), functions
+     * are left alone and that check simply does not fire.
+     *
+     * @returns CompiledFormula
+     */
+    compile(runtime: IRuntime, row: number, column: number, expression: string, symbolRegistry?: ISymbolRegistry, getFunction?: ((name: string) => IFunction | null) | null, 
+    /**
+     * The sheet this formula is written on. Decides which definition a sheet-scoped name binds to;
+     * see `linkSymbols`.
+     */
+    scope?: string | null, 
+    /**
+     * A structural transform applied to the parsed tree before compilation (pre-link) — the READ
+     * half of the dialect hook. A format reader (io-xlsx) supplies its legacy unwrap here; typed
+     * text compiles without one.
+     */
+    formulaTransform?: ICalculation.FormulaTransform): CompiledFormula;
+    /**
+     * Excel-parity **Formula AutoCorrect** at the TEXT level: repair `expression` by appending the
+     * trailing closers (`)` / `}`) its unmatched openers imply. Purely lexical — brackets inside
+     * string literals / structured references never count (they lex as single tokens), and the repair
+     * is NOT validated here: the caller re-compiles and accepts it only when it parses clean (see
+     * `ICalculation.IFormula.autoCorrect`).
+     *
+     * @param expression The formula expression (no leading `=`), in this compiler's locale/grammar.
+     * @returns The repaired expression, or `null` when there is nothing to repair (already balanced),
+     * the input doesn't fully lex (e.g. an unterminated string), or the brackets are over-closed /
+     * interleaved (`SUM(A1))`, `SUM({1)`) — shapes this rule cannot safely fix.
+     */
+    autoCorrect(expression: string): string | null;
+}
+/**
+ * The compiled precedent.
+ */
+export interface CompiledPrecedent {
+    /**
+     * The ast for the precedent.
+     */
+    node: ASTNode;
+    /**
+     * The index of the results.
+     */
+    index: number;
+    /**
+     * The index of the value if it doesn't have inputs.
+     *
+     * @remarks
+     * For example a cell
+     */
+    value: number;
+    /**
+     * The index values of the inputs if this is an operator.
+     *
+     * @remarks
+     * For example the ':' range operator.
+     */
+    inputs: number[];
+    /**
+     * A string representing the operation to perform.
+     */
+    op: string;
+    /**
+     * Quick indicator that the precedent has absolutes references.
+     *
+     * @remarks
+     * We currently used this tell the calc engine to skip resolution and just evaluate all calcs in a formula block.
+     */
+    hasVerticalAbs?: boolean;
+    /** @inheritdoc CompiledPrecedent.hasVerticalAbs */
+    hasHorizontalAbs?: boolean;
+}
+/**
+ * The compiled formula.
+ */
+export interface CompiledFormula {
+    /**
+     * Runtime details used during parse.
+     *
+     * @remarks
+     * Provides locale details during parsing and rendering of tokens.
+     *
+     */
+    runtime: IRuntime;
+    /**
+     * The symbol registry used during parse.
+     *
+     * @remarks
+     * Provides a mapping from stable symbols to display values during parsing and rendering of tokens.
+     */
+    symbols: ISymbolRegistry;
+    /**
+     * Resolves a function by name, or `null` when the compile had no registry to consult
+     * (detached parses, tests).
+     *
+     * @remarks
+     * Retained from {@link IFormulaCompiler.compile} so consumers of a compiled formula can ask
+     * whether a NAME is a function without the resolver being threaded through unrelated public
+     * interfaces — notably `toJSON`, where it would leak an evaluation concern into serialization.
+     *
+     * Two things need it, and both are about a name used WITHOUT parentheses:
+     * - `toLegacy` — Excel writes a bare reference to a BUILT-IN as an eta-reduced lambda,
+     *   `_xleta.SUM`; a user-defined function (a name bound to `LAMBDA`) stays bare. So the test is
+     *   `isBuiltIn()`, not mere presence in the registry.
+     * - evaluation — a bare built-in is `#CALC!` (a legal lambda reference that cannot render in a
+     *   cell), while a genuinely unknown name is `#NAME?`. Without this the two collapse.
+     */
+    getFunction: ((name: string) => IFunction | null) | null;
+    /**
+     * The formula expressed as a tree of node with indices for each node.
+     *
+     * @remarks
+     * * The primary data structure for the formula.
+     * * All other items are derived from this.
+     */
+    ast: ASTNode;
+    /**
+     * Hold all incremental evaluations.
+     *
+     * @remarks
+     * A cache
+     */
+    evaluations: any[];
+    /**
+     * This is a sorted list of execution functions.
+     *
+     * @remarks
+     * A cache
+     */
+    executions: any[];
+    /**
+     * The `LET`/`LAMBDA` binding table: slot -> the `evalIndex` of the expression that slot is bound
+     * to, or `-1` when nothing binds it here (a `LAMBDA` parameter, bound by apply).
+     *
+     * @remarks
+     * Lexical resolution is done at COMPILE time — the binder pass gives every declaration a slot and
+     * every use its slot number, so evaluation is an array read rather than a name lookup up a scope
+     * chain. Empty for the overwhelming majority of formulas; its length is also the cheap test for
+     * "does this formula declare anything" (see `FormulaBlock.evaluateAt`).
+     */
+    bindings: number[];
+    /**
+     * Represents all references as absolute ranges.
+     *
+     * @remarks
+     * A cache
+     */
+    referencesAbsolute: IRange.Coords[];
+    /**
+     * List of all executions required to calculate the references.
+     */
+    referencesExecute: CompiledPrecedent[];
+    /**
+     * Represents all cell relative references.
+     */
+    referencesRelative: IRange.FixableCoords[];
+    /**
+     * The high level precedents indices that will be returned to the caller.
+     *
+     * @remarks
+     * We track these separately because getResolvedPrecedents should not have any
+     * intermediary precedents but these are needed for eval stack
+     */
+    referencesRoot: number[];
+    /**
+     * References to support getReferences() or setReferenceAt().
+     *
+     * @remarks
+     * Because we manage as cells but update as ranges we need to track the start and end of the references.
+     */
+    referenceIndices: number[];
+    /**
+     * The formula's editor tokens (syntax highlighting, function/argument hints). Computed lazily and
+     * cached on first call — most compiles (grid cells) never need them. On a parse failure this returns
+     * a best-effort stream (the longest parseable prefix + an `unparsed` tail); see the compiler.
+     */
+    getTokens(): ICalculation.FormulaToken[];
+    /**
+     * The stable nameIds of all NamedNodes in the formula (deduped).
+     *
+     * @remarks
+     * A cache. Computed once at compile time from {@link ast}. Names are applied at eval,
+     * never inlined, so a named node is a leaf and this is the formula's DIRECT named
+     * references. Used by `recompileNamed`/`invalidateNamed` to know which formulas depend
+     * on a name.
+     */
+    namedIds: string[];
+    /**
+     * The stable fake ids of all direct indirect-symbol references — named formulas AND tables
+     * (deduped).
+     *
+     * @remarks
+     * A cache, computed once at compile time from {@link ast}. Superset of {@link namedIds}. Used to
+     * reverse-invalidate the formulas that reference a name/table whose resolution changed
+     * (add/heal/delete/rename), matched against `IndirectSymbolProvider.reconcile()`.
+     */
+    symbolIds: string[];
+    /**
+     * Whether the formula calls `SUBTOTAL` or `AGGREGATE` anywhere in its tree.
+     *
+     * @remarks
+     * A cache, computed once at compile time from {@link ast}. What `IFormulaContext.filterTotals`
+     * needs to answer per CELL, and computing it here is what keeps that answer free: the alternative
+     * is re-inspecting a neighbour's formula on every recalculation of every enclosing total.
+     *
+     * "Anywhere in its tree", not "is the outermost call" — measured, `=SUM(SUBTOTAL(9,A1:A3))` is
+     * excluded from an enclosing SUBTOTAL exactly as a bare `=SUBTOTAL(9,A1:A3)` is. Resolved through
+     * `getFunction` rather than matched on the typed name, so a localized spelling and an
+     * `_xlfn.`-prefixed one both answer correctly.
+     */
+    hasTotals: boolean;
+    /**
+     * Indicates if the formula is reference-only (i.e. it only returns a range and does not return a scalar value).
+     */
+    isReferenceOnly: boolean;
+    /**
+     * If there was a parse error, or `null` if the formula parsed cleanly.
+     *
+     * @remarks
+     * Will return the error details and original input.
+     */
+    error: ParseError | null;
+    /**
+     * Visit and transform the AST of the formula.
+     */
+    transform: (visitor: ASTVisitor) => CompiledFormula;
+}
+/**
+ * The error returned when a formula fails to parse.
+ */
+export interface ParseError {
+    /**
+     * The original input that failed to parse.
+     */
+    input: string;
+    /**
+     * The primary error — the value returned when this formula is evaluated.
+     *
+     * @remarks
+     * Equivalent to `causes[0]`.
+     */
+    cause: any;
+    /**
+     * All parse errors, in source order.
+     *
+     * @remarks
+     * Includes both lexer errors and AST-level errors (e.g. unmatched parentheses).
+     * Use this for diagnostics and IDE error reporting.
+     */
+    causes: any[];
+}
+//# sourceMappingURL=Types.d.ts.map

package/types/src/calculation/compiler/Types.d.ts.map

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

package/types/src/calculation/compiler/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './Types';
+export * from './FormulaCompiler';
+//# sourceMappingURL=index.d.ts.map

package/types/src/calculation/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,SAAS,CAAC;AAE7B,cAAc,mBAAmB,CAAC"}

package/types/src/calculation/executor/CalcExecutor.d.ts

@@ -0,0 +1,115 @@
+import { IRange, IFormulaContext } from '@sheetxl/primitives';
+import { FixedPackedArray } from '../../primitives/PrimitiveUtils';
+import { ISpatialMap, ISpatialMap3D } from '../../collections';
+import { FormulaSpatialValue, PrecedentSpatialValue, PrecedentKind } from '../spatial';
+import { ICalcGrid } from '../grid';
+import { IContextContainer, CalcNode } from '../state';
+/**
+ * Executes a calculation cycle: collect → mark-and-plan → evaluate.
+ *
+ * Owns cycle counters, the async-recalc pending queue, and all transient
+ * per-pass state. `Calculation` is the controller that owns persistent spatial
+ * state; CalcExecutor receives snapshots and returns results.
+ */
+export declare class CalcExecutor {
+    protected _container: IContextContainer;
+    protected _context: IFormulaContext;
+    private readonly _requestCalculate;
+    protected _pendingCalcs: Set<CalcNode>;
+    /**
+     * Nodes the topological sort could not order — a reference cycle and everything downstream of it.
+     * Rewritten by every `doMarkAndPlan` that detects one; meaningless otherwise.
+     */
+    protected _circularNodes: CalcNode[];
+    /**
+     * Identifies the cycle last reported, so an unchanged one is not re-announced. A circular
+     * reference persists until the user edits it away, and every pass re-detects it — including
+     * volatile ones, which would otherwise log forever. `null` once a pass completes cycle-free.
+     */
+    protected _circularReported: string | null;
+    _gridUpdates: Map<string, ICalcGrid.IncrementalUpdates> | null;
+    _addDynamicPrecedent: ((node: CalcNode, range: IRange.Coords | undefined, kind: PrecedentKind) => void) | null;
+    constructor(container: IContextContainer, context: IFormulaContext, requestCalculate: () => void);
+    /**
+     * Called when an async formula promise resolves. Adds the node to the pending
+     * queue and debounces a new calculation cycle via `requestCalculate`.
+     */
+    scheduleRecalculation: (cycleId: number, calcNode?: CalcNode) => void;
+    /**
+     * Runs a full calculation pass.
+     *
+     * @param options  Per-pass options (isFullCalc, calcCoords, gridId).
+     * @param state    Snapshot of Calculation's persistent state for this pass.
+     * @returns Updated spatial maps and committed grid-update batches, or null if
+     *          nothing was dirty.
+     */
+    execute(cycleId: number, options: CalcExecutor.ExecuteOptions, state: CalcExecutor.ExecuteState): CalcExecutor.ExecuteResult | null;
+    /**
+     * Reports the reference cycle found by the preceding {@link doMarkAndPlan}.
+     *
+     * @remarks
+     * One line per calculation pass, naming a representative cell the way Excel's status bar does
+     * (`Worksheet.CircularReference` likewise returns a single cell, not the whole set). The count
+     * covers everything downstream of the cycle too, so it is normally larger than the cycle itself.
+     */
+    protected reportCircular(): void;
+    /**
+     * Collects and marks all volatile CalcNodes.
+     *
+     * @returns the length of the collectingCalcs array.
+     *
+     * @remarks
+     * The registry is keyed by node identity, not by coordinates, so it is the one collector that can
+     * hand back a node the grid has already replaced — see `isLiveBlock`.
+     */
+    doCollectVolatileCalcs: (cycleId: number, markId: number, volatiles: Set<CalcNode>, collecting: FixedPackedArray<CalcNode>, formulaSpatial: ISpatialMap3D<FormulaSpatialValue>) => number;
+    /**
+     * Searches all dirtyRegions and collects immediate CalcNodes.
+     *
+     * @param forceFull
+     * @returns the length of the collectingCalcs array
+     *
+     * @remarks
+     * Does not walk the graph.
+     */
+    doCollectDirtyCalcs: (cycleId: number, markId: number, dirtyRegions: IRange.Coords[], collecting: FixedPackedArray<CalcNode>, formulaSpatial: ISpatialMap3D<FormulaSpatialValue>, precedentSpatial: ISpatialMap3D<PrecedentSpatialValue>, dynamicPrecedentEntries: ISpatialMap.Entry<PrecedentSpatialValue>[]) => number;
+    /**
+     * Returns an execution plan (sorted order of nodes to evaluate)
+     *
+     * @remarks
+     * Uses Kahn's algorithm.
+     */
+    doMarkAndPlan(cycleId: number, markId: number, initial: FixedPackedArray<CalcNode>, plan: FixedPackedArray<CalcNode>): boolean;
+    doEvaluate(cycleId: number, getUpdates: (scope: string) => ICalcGrid.IncrementalUpdates, scheduleRecalculation: (cycleId: number, calcNode?: CalcNode) => void, commit: (calcNodes: CalcNode[], calcNodesLength: number) => void, forceFull: boolean, plan: FixedPackedArray<CalcNode>): ISpatialMap | undefined;
+}
+export declare namespace CalcExecutor {
+    /** Per-pass options derived from ICalculation.CalculateOptions */
+    interface ExecuteOptions {
+        isFullCalc: boolean;
+        calcCoords?: IRange.Coords;
+        /**
+         * The grid the request came THROUGH (`calculateGrid`). Only used to resolve `calcCoords` that
+         * carry no scope of their own — it does not narrow the pass.
+         */
+        gridId?: string;
+        /**
+         * The grid to seed the pass FROM — `ICalculation.CalculateOptions.scope`, i.e. "Calculate Sheet".
+         */
+        scopeGridId?: string;
+    }
+    /** Snapshot of Calculation's persistent state for one pass */
+    interface ExecuteState {
+        gridsAll: Map<string, ICalcGrid>;
+        formulaSpatial: ISpatialMap3D<FormulaSpatialValue>;
+        dirtySpatial: ISpatialMap3D;
+        /** Volatiles accumulated before this cycle — drained and cleared by execute() */
+        oldVolatiles: Set<CalcNode>;
+    }
+    /** Updated spatial maps and committed grid batches returned to Calculation */
+    interface ExecuteResult {
+        precedentSpatial: ISpatialMap3D<PrecedentSpatialValue>;
+        dynamicByBlock: Map<FormulaSpatialValue, ISpatialMap.Entry<PrecedentSpatialValue>[]>;
+        lastUpdates: Map<string, ICalcGrid.IncrementalUpdates>;
+    }
+}
+//# sourceMappingURL=CalcExecutor.d.ts.map

package/types/src/calculation/executor/CalcExecutor.d.ts.map

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

package/types/src/calculation/executor/CalcExecutorUtils.d.ts

@@ -0,0 +1,11 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+import { Tuple, ISpatialMap } from '../../collections';
+import { CalcNode } from '../state';
+import { PrecedentSpatialValue, FormulaSpatialValue } from '../spatial';
+export declare function rangeToTuples(range: IRange, offsetMajor?: number, offsetMinor?: number): Tuple.BoundedTuples<Scalar>;
+/**
+ * TODO - document and/or rationalize with visitPrecedentBlock
+ */
+export declare function visitDependencyBlock(depEntry: ISpatialMap.Entry<PrecedentSpatialValue>, rowIndex: number, colIndex: number, callbackFn: (calc: CalcNode) => void): void;
+export declare function valueCompareValues(a: ISpatialMap.Entry<FormulaSpatialValue>, removing: ISpatialMap.Entry<FormulaSpatialValue>): boolean;
+//# sourceMappingURL=CalcExecutorUtils.d.ts.map

package/types/src/calculation/executor/CalcExecutorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CalcExecutorUtils.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/executor/CalcExecutorUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,KAAK,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGlF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,MAAQ,EACrB,WAAW,GAAE,MAAQ,GACpB,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,CAgB7B;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GACnC,IAAI,CAkCN;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,OAAO,CAEvI"}

package/types/src/calculation/executor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CalcExecutor';
+export * as CalcExecutorUtils from './CalcExecutorUtils';
+//# sourceMappingURL=index.d.ts.map

package/types/src/calculation/executor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/executor/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC"}

package/types/src/calculation/formula/Formula.d.ts

@@ -0,0 +1,168 @@
+import { Scalar, IRange } from '@sheetxl/primitives';
+import { ITransaction } from '../../transaction';
+import { ICellRanges, ICellRange } from '../../cellRange';
+import { ICalcGrid } from '../grid';
+import { ReferenceCoords } from '../Types';
+import { ICalculation } from '../ICalculation';
+import { IFormulaBlock } from './IFormulaBlock';
+/**
+ * A formula for a cell.
+ */
+export declare class Formula implements ICalculation.IFormula {
+    protected _coords: IRange.CellCoords | null;
+    private _blockOwn;
+    protected _options: Formula.ConstructorOptions;
+    /**
+     * The compiled body this formula reads through.
+     *
+     * @remarks
+     * A read-only accessor rather than a plain field, for two reasons. A formula never re-points its
+     * own body — every rewrite (`setReferenceAt`, `setReferenceModeAt`) mints a new `Formula` — so
+     * the field was writable only by accident. And it lets a subclass whose body is owned by the grid
+     * DERIVE it instead of holding an instance: see `NamedFormula`, where a structural shift or an
+     * undo replaces the block in the versioned store and any captured instance is a snapshot of the
+     * definition as it was. A cell formula is handed its block at construction and keeps it.
+     */
+    protected get _block(): IFormulaBlock;
+    constructor(coords: IRange.CellCoords | null, // temporary
+    block: IFormulaBlock, options: Formula.ConstructorOptions);
+    /** {@inheritDoc ICalculation.IFormula.getTokens} */
+    getTokens(evalIndex?: number): readonly ICalculation.FormulaToken[];
+    /** {@inheritDoc ICalculation.IFormula.isValid} */
+    isValid(): boolean;
+    /** {@inheritDoc ICalculation.IFormula.autoCorrect} */
+    autoCorrect(): ICalculation.IFormula | null;
+    /** {@inheritDoc ICalculation.IFormula.evaluate} */
+    evaluate(options?: number | ICalculation.EvaluateOptions): Promise<Scalar | IRange>;
+    /** {@inheritDoc ICalculation.IFormula.getCalculationStatus} */
+    getCalculationStatus(): ICalculation.ResultStatus;
+    /** {@inheritDoc ICalculation.IFormula.getReferences} */
+    getReferences(): ICellRanges | null;
+    /** {@inheritDoc ICalculation.IFormula.hasRefError} */
+    hasRefError(): boolean;
+    /**
+     * Resolve raw ABSOLUTE precedent refs (cell/range coords or named ids) into an {@link ICellRanges}, or
+     * `null` when there are none. Shared by the committed path ({@link getReferences}) and
+     * {@link TemporaryFormula}'s own-block path.
+     */
+    protected _resolveReferences(rawRefs: ReferenceCoords[] | undefined): ICellRanges | null;
+    /** {@inheritDoc ICalculation.IFormula.setReferenceAt} */
+    setReferenceAt(index: number, reference: ICellRange.Address, options?: string | ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICalculation.IFormula.setReferenceModeAt} */
+    setReferenceModeAt(index: number, side?: ICalculation.ReferenceSide, mode?: number, options?: string | ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICalculation.IFormula.isReferenceOnly} */
+    isReferenceOnly(): boolean;
+    /** {@inheritDoc ICalculation.IFormula.isVolatile} */
+    isVolatile(): boolean;
+    /** {@inheritDoc ICalculation.IFormula.getExpression} */
+    getExpression(options?: ICalculation.FormulaTextOptions): string;
+    /** {@inheritDoc ICalculation.IFormula.getAnchor} */
+    getAnchor(): IRange.CellCoords | null;
+    /** {@inheritDoc ICalculation.IFormula.shift} */
+    shift(target: IRange.CellCoords): ICalculation.IFormula | null;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Provides a string representation of the formula.
+     */
+    toString(): string;
+    /** {@inheritDoc ICalculation.IFormula.isIFormula} */
+    get isIFormula(): true;
+}
+export declare class TemporaryFormula extends Formula {
+    protected _doEval: (block: IFormulaBlock, options: number | ICalculation.EvaluateOptions) => Promise<Scalar | IRange>;
+    constructor(coords: IRange.CellCoords | null, block: IFormulaBlock, options: Formula.ConstructorOptions, doEval: (block: IFormulaBlock, options: number | ICalculation.EvaluateOptions) => Promise<Scalar | IRange>);
+    /** {@inheritDoc ICalculation.IFormula.evaluate} */
+    evaluate(options: number | ICalculation.EvaluateOptions): Promise<Scalar | IRange>;
+    /**
+     * {@inheritDoc ICalculation.IFormula.getReferences}
+     *
+     * @remarks
+     * Sources references from THIS block, not the grid — a temporary / in-flight formula (what the editor
+     * tokenizes while typing) was never written to the grid, so `getReferencesAt` at these coords would
+     * come back empty (blank cell) or stale (an existing formula being edited). The block yields RELATIVE
+     * refs; convert to absolute exactly as `ICalcGrid.getReferencesAt` does, then resolve as usual.
+     */
+    getReferences(): ICellRanges | null;
+    /**
+     * {@inheritDoc ICalculation.IFormula.hasRefError}
+     *
+     * @remarks
+     * Own-block sourced, like {@link getReferences} — a temporary formula (including a
+     * {@link shift} result) has no grid entry to ask. Error markers are position-independent,
+     * so an anchorless formula still answers.
+     */
+    hasRefError(): boolean;
+    /**
+     * {@inheritDoc ICalculation.IFormula.setReferenceAt}
+     *
+     * @remarks
+     * A PURE rewrite of THIS block — no grid write. The base persists through a transaction (correct for a
+     * committed cell); an in-flight edit (an editor range drag) must instead just produce the new text
+     * (via `getExpression`) without committing. Returns a new `TemporaryFormula` so it stays evaluable + chainable.
+     */
+    setReferenceAt(index: number, reference: ICellRange.Address): this;
+    /**
+     * {@inheritDoc ICalculation.IFormula.setReferenceModeAt}
+     *
+     * @remarks
+     * The PURE counterpart of the base — the SAME `$`-cycle ({@link cycleReferenceStyle}), but it reads THIS
+     * block's reference and writes through the (pure) {@link setReferenceAt} instead of a grid transaction.
+     * Returns `this` unchanged when there's no reference at `index` (e.g. the caret isn't on one).
+     */
+    setReferenceModeAt(index: number, side?: ICalculation.ReferenceSide, mode?: number, _options?: string | ITransaction.OperationOptions): this;
+}
+export declare namespace Formula {
+    interface ConstructorOptions {
+        getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
+        getRange(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
+        getCalcGrid?(): ICalcGrid;
+        doBatchCalcGrid?(callback: (calcGrid: ICalcGrid) => IRange.Coords, options?: string | ITransaction.OperationOptions): void;
+        /**
+         * Resolve a sheet's internal stableId (`Sheet1-<uuid>`, rename-safe) to its current display name,
+         * or `null` when it can't be resolved. Reference coords from the calc engine carry stableId scopes;
+         * {@link Formula._resolveReferences} resolves them to names before {@link getRanges} (a name-only
+         * lookup) so cross-sheet references resolve instead of throwing. See the reference-picker path.
+         */
+        resolveSheetScope?(stableId: string): string | null;
+        /**
+         * The display name of the sheet this formula is anchored to, or `null`. Supplied ONLY where
+         * {@link getRanges} is not already sheet-anchored — i.e. a temporary formula, whose resolvers are
+         * workbook-level. See {@link Formula._resolveReferences}; a committed formula deliberately omits it and
+         * keeps same-sheet references unscoped.
+         */
+        getOwnScope?(): string | null;
+        /**
+         * Attempt Formula AutoCorrect on `text` (this formula's as-typed expression, no leading `=`),
+         * returning a corrected DETACHED formula or `null` when no safe correction exists. Supplied by
+         * the calculation — it owns the locale-aware editing compiler and the validating re-compile
+         * (`Calculation.createFormula` / the sheet's cell options). When absent,
+         * {@link Formula.autoCorrect} reports no correction.
+         *
+         * @param text The formula expression to repair.
+         * @param coords The formula's anchor cell — suppliers that already close over more precise
+         * coords (the temporary path's `scope`-carrying originals) may ignore it.
+         */
+        autoCorrect?(text: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula | null;
+        /**
+         * Compile `text` as a DETACHED formula anchored at `coords`. Supplied by the calculation, which
+         * owns the editing compiler (`Calculation.createFormula`), for the same reason
+         * {@link autoCorrect} is. When absent, {@link Formula.shift} reports no copy.
+         *
+         * @param text The expression to compile, no leading `=`.
+         * @param coords The cell to anchor it at. Unlike {@link autoCorrect}'s — which re-anchors at the
+         * ORIGINAL coords — this one is the point: the supplier keeps its own sheet scope and takes the
+         * row/column from here.
+         */
+        createAt?(text: string, coords: IRange.CellCoords): ICalculation.IFormula | null;
+    }
+}
+/**
+ * Cycle a reference's absolute/relative `$` style at one corner (`end` picks start vs end) to the next
+ * Excel-F4 mode — or to an explicit `mode` (0 = absolute `$A$1`, 1 = row-absolute `A$1`, 2 =
+ * col-absolute `$A1`, 3 = relative `A1`). Pure: returns a NEW coords with updated `$` flags. Operates on
+ * the `$` flags only (position-independent), so it's shared by the committed ({@link Formula}) and
+ * in-flight ({@link TemporaryFormula}) `setReferenceModeAt`, which differ only in how they read/write the
+ * reference (grid transaction vs pure block).
+ */
+export declare const cycleReferenceStyle: (reference: IRange.FixableCoords, side?: ICalculation.ReferenceSide, mode?: number) => IRange.FixableCoords;
+//# sourceMappingURL=Formula.d.ts.map

package/types/src/calculation/formula/Formula.d.ts.map

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