@univerjs/engine-formula 0.12.3 → 0.12.4-experimental.20251210-8d33c6e

package/lib/types/basics/common.d.ts

@@ -126,6 +126,20 @@ export interface IFormulaIdMap {
     r: number;
     c: number;
 }
+export interface IFormulaStringMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<string[]>;
+    }>;
+}
+export interface IFormulaExecuteResultItem {
+    value: Nullable<number | string | boolean | Array<Array<number | string | boolean | null>>>;
+    formula: string;
+}
+export interface IFormulaExecuteResultMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<IFormulaExecuteResultItem[]>;
+    }>;
+}
 export interface IFormulaIdMapData {
     [unitId: string]: Nullable<{
         [subUnitId: string]: Nullable<{

package/lib/types/basics/date.d.ts

@@ -33,7 +33,6 @@ export declare function formatDateDefault(date: Date): string;
  */
 export declare function isValidDateStr(dateStr: string): boolean;
 export declare function parseFormattedDate(value: string): numfmt.ParseData | null;
-export declare function parseFormattedValue(value: string): numfmt.ParseData | null;
 export declare function parseFormattedTime(value: string): numfmt.ParseData | null;
 export declare function isDate(format: string): boolean;
 export declare function isValidWeekend(weekend: number | string): boolean;

package/lib/types/commands/mutations/set-formula-calculation.mutation.d.ts

@@ -1,15 +1,46 @@
-import { IExecutionOptions, IMutation, Nullable } from '@univerjs/core';
-import { IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+import { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
+import { IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson } from '../../engine/dependency/dependency-tree';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation extends IFormulaDirtyData {
     options: Nullable<IExecutionOptions>;
 }
+export interface ISetFormulaStringBatchCalculationMutation {
+    formulas: IFormulaStringMap;
+}
+export interface ISetFormulaStringBatchCalculationResultMutation {
+    result: IFormulaExecuteResultMap;
+}
+export interface ISetFormulaStringBatchCalculationResultMutation {
+    result: IFormulaExecuteResultMap;
+}
+export interface ISetFormulaDependencyCalculationMutation {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface ISetFormulaDependencyCalculationResultMutation {
+    result: IFormulaDependencyTreeJson[];
+}
+export interface ISetCellFormulaDependencyCalculationResultMutation {
+    result: IFormulaDependencyTreeFullJson | undefined;
+}
+export interface ISetQueryFormulaDependencyMutation {
+    unitRanges: IUnitRange[];
+    isInRange?: boolean;
+}
+export interface ISetQueryFormulaDependencyResultMutation {
+    result: IFormulaDependencyTreeJson[];
+}
 /**
  * TODO: @DR-Univer
  * Trigger the calculation of the formula and stop the formula
  */
 export declare const SetFormulaCalculationStartMutation: IMutation<ISetFormulaCalculationStartMutation>;
+export declare const SetFormulaStringBatchCalculationMutation: IMutation<ISetFormulaStringBatchCalculationMutation>;
+export declare const SetFormulaStringBatchCalculationResultMutation: IMutation<ISetFormulaStringBatchCalculationResultMutation>;
 export interface ISetFormulaCalculationStopMutation {
 }
 export declare const SetFormulaCalculationStopMutation: IMutation<ISetFormulaCalculationStopMutation>;
@@ -23,3 +54,9 @@ export interface ISetFormulaCalculationResultMutation {
     unitOtherData: IRuntimeOtherUnitDataType;
 }
 export declare const SetFormulaCalculationResultMutation: IMutation<ISetFormulaCalculationResultMutation>;
+export declare const SetFormulaDependencyCalculationMutation: IMutation<{}>;
+export declare const SetFormulaDependencyCalculationResultMutation: IMutation<ISetFormulaDependencyCalculationResultMutation>;
+export declare const SetCellFormulaDependencyCalculationMutation: IMutation<ISetFormulaDependencyCalculationMutation>;
+export declare const SetCellFormulaDependencyCalculationResultMutation: IMutation<ISetCellFormulaDependencyCalculationResultMutation>;
+export declare const SetQueryFormulaDependencyMutation: IMutation<ISetQueryFormulaDependencyMutation>;
+export declare const SetQueryFormulaDependencyResultMutation: IMutation<ISetQueryFormulaDependencyResultMutation>;

package/lib/types/controller/calculate.controller.d.ts

@@ -9,6 +9,10 @@ export declare class CalculateController extends Disposable {
     private _initialize;
     private _commandExecutedListener;
     private _calculate;
+    private _queryFormulaDependencyJson;
+    private _generateAllDependencyTreeJson;
+    private _generateCellDependencyTreeJson;
+    private _calculateFormulaString;
     private _initialExecuteFormulaListener;
     private _applyResult;
 }

package/lib/types/engine/dependency/dependency-tree.d.ts

@@ -115,4 +115,43 @@ export declare class FormulaDependencyTree extends FormulaDependencyTreeCalculat
     shouldBePushRangeList(): boolean;
     toRTreeItem(): IUnitRange[];
 }
+interface IFormulaDependencyTreeJsonBase {
+    treeId: number;
+    formula: string;
+    row: number;
+    column: number;
+    unitId: string;
+    subUnitId: string;
+    refOffsetX: number;
+    refOffsetY: number;
+    rangeList: IUnitRange[];
+    refTreeId: number | undefined;
+}
+export interface IFormulaDependencyTreeJson extends IFormulaDependencyTreeJsonBase {
+    children: number[];
+    parents: number[];
+}
+export interface IFormulaDependencyTreeFullJson extends IFormulaDependencyTreeJsonBase {
+    children: IFormulaDependencyTreeJson[];
+    parents: IFormulaDependencyTreeJson[];
+}
+export declare class FormulaDependencyTreeModel {
+    children: Set<FormulaDependencyTreeModel>;
+    parents: Set<FormulaDependencyTreeModel>;
+    treeId: number;
+    formula: string;
+    refOffsetX: number;
+    refOffsetY: number;
+    row: number;
+    column: number;
+    unitId: string;
+    subUnitId: string;
+    rangeList: IUnitRange[];
+    refTreeId: number | undefined;
+    constructor(tree: IFormulaDependencyTree);
+    toJson(): IFormulaDependencyTreeJson;
+    toFullJson(): IFormulaDependencyTreeFullJson;
+    addParent(parent: FormulaDependencyTreeModel): void;
+    addChild(child: FormulaDependencyTreeModel): void;
+}
 export {};

package/lib/types/engine/dependency/formula-dependency.d.ts

@@ -4,17 +4,22 @@ import { IFeatureCalculationManagerParam, IFeatureCalculationManagerService } fr
 import { FunctionNode } from '../ast-node';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { IExecuteAstNodeData } from '../utils/ast-node-tool';
-import { IFormulaDependencyTree, FormulaDependencyTree, FormulaDependencyTreeVirtual } from './dependency-tree';
+import { IFormulaDependencyTree, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, FormulaDependencyTree, FormulaDependencyTreeModel, FormulaDependencyTreeVirtual } from './dependency-tree';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDependencyManagerService } from '../../services/dependency-manager.service';
 import { IOtherFormulaManagerService } from '../../services/other-formula-manager.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { Lexer } from '../analysis/lexer';
+import { LexerTreeBuilder } from '../analysis/lexer-tree-builder';
 import { AstTreeBuilder } from '../analysis/parser';
 import { Interpreter } from '../interpreter/interpreter';
 export declare function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): number;
 export interface IFormulaDependencyGenerator {
     generate(): Promise<IFormulaDependencyTree[]>;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }
 export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
@@ -26,9 +31,10 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected readonly _astTreeBuilder: AstTreeBuilder;
     protected readonly _lexer: Lexer;
     protected readonly _dependencyManagerService: IDependencyManagerService;
+    protected readonly _lexerTreeBuilder: LexerTreeBuilder;
     private _updateRangeFlattenCache;
     protected _dependencyRTreeCacheForAddressFunction: RTree;
-    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService, _lexerTreeBuilder: LexerTreeBuilder);
     dispose(): void;
     generate(): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
     private _dependencyFeatureCalculation;
@@ -110,4 +116,17 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * @param treeList
      */
     protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
+    protected _initializeGenerateTreeList(): Promise<IFormulaDependencyTree[]>;
+    protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
+    protected _formulaDependencyTreeModel: Map<number, FormulaDependencyTreeModel>;
+    protected _getTreeModel(treeId: number): FormulaDependencyTreeModel;
+    protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _getFormulaDependencyTreeModel(tree: IFormulaDependencyTree): FormulaDependencyTreeModel;
+    protected _endFormulaDependencyTreeModel(): void;
+    protected _startFormulaDependencyTreeModel(): void;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }

package/lib/types/facade/f-formula.d.ts

@@ -1,5 +1,5 @@
-import { IDisposable, ICommandService, IConfigService, Injector } from '@univerjs/core';
-import { FormulaExecutedStateType, IExecutionInProgressParams, ISequenceNode, LexerTreeBuilder } from '@univerjs/engine-formula';
+import { IDisposable, IUnitRange, ICommandService, IConfigService, Injector } from '@univerjs/core';
+import { FormulaExecutedStateType, IExecutionInProgressParams, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, ISetFormulaCalculationResultMutation, LexerTreeBuilder } from '@univerjs/engine-formula';
 import { FBase } from '@univerjs/core/facade';
 /**
  * This interface class provides methods to modify the behavior of the operation formula.
@@ -146,4 +146,245 @@ export declare class FFormula extends FBase {
      * ```
      */
     setMaxIteration(maxIteration: number): void;
+    /**
+     * Listens for the moment when formula-calculation results are applied.
+     *
+     * This event fires after the engine completes a calculation cycle and
+     * dispatches a `SetFormulaCalculationResultMutation`.
+     * The callback is invoked during an idle frame to avoid blocking UI updates.
+     *
+     * @param {Function} callback - A function called with the calculation result payload
+     * once the result-application mutation is emitted.
+     * @returns {IDisposable} A disposable used to unsubscribe from the event.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * const dispose = formulaEngine.calculationResultApplied((result) => {
+     *   console.log('Calculation results applied:', result);
+     * });
+     *
+     * // Later…
+     * dispose.dispose();
+     * ```
+     */
+    calculationResultApplied(callback: (result: ISetFormulaCalculationResultMutation) => void): IDisposable;
+    /**
+     * Waits for formula-calculation results to be applied.
+     *
+     * This method resolves under three conditions:
+     * 1. A real calculation runs and the engine emits a "calculation started" signal,
+     *    followed by a "calculation result applied" signal.
+     * 2. No calculation actually starts within 500 ms — the method assumes there is
+     *    nothing to wait for and resolves automatically.
+     * 3. A global 30 s timeout triggers, in which case the promise rejects.
+     *
+     * The API internally listens to both “calculation in progress” events and
+     * “calculation result applied” events, ensuring it behaves correctly whether
+     * formulas are recalculated or skipped due to cache/state.
+     *
+     * @returns {Promise<void>} A promise that resolves when calculation results are applied
+     * or when no calculation occurs within the start-detection window.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Wait for formula updates to apply before reading values.
+     * await formulaEngine.onCalculationResultApplied();
+     *
+     * const value = sheet.getRange("C24").getValue();
+     * console.log("Updated value:", value);
+     * ```
+     */
+    onCalculationResultApplied(): Promise<void>;
+    /**
+     * Execute a batch of formulas asynchronously and receive computed results.
+     *
+     * Each formula cell is represented as a string array:
+     *   [fullFormula, ...subFormulas]
+     *
+     * Where:
+     *   - fullFormula (index 0) is the complete formula expression written in the cell.
+     *     Example: "=SUM(A1:A10) + SQRT(D7)".
+     *
+     *   - subFormulas (index 1+) are **optional decomposed expressions** extracted from
+     *     the full formula. Each of them can be independently computed by the formula engine.
+     *
+     *     These sub-expressions can include:
+     *       - Single-cell references:  "A2", "B2", "C5"
+     *       - Range references:        "A1:A10"
+     *       - Function calls:          "SQRT(D7)", "ABS(A2-B2)"
+     *       - Any sub-formula that was parsed out of the original formula and can be
+     *         evaluated on its own.
+     *
+     *     The batch execution engine may use these sub-formulas for dependency resolution,
+     *     incremental computation, or performance optimizations.
+     *
+     * @param {IFormulaStringMap} formulas
+     *        Nested structure (unit → sheet → row → column) describing formulas and
+     *        their decomposed sub-expressions.
+     *
+     * @param {(result: IFormulaExecuteResultMap) => void} callback
+     *        Receives the computed value map mirroring the input structure.
+     *
+     * @returns {IDisposable}
+     *          A disposer to stop listening for batch results.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     * const formulas = {
+     *   Book1: {
+     *     Sheet1: {
+     *       2: {
+     *         3: [
+     *           // Full formula:
+     *           "=SUM(A1:A10) + SQRT(D7)",
+     *
+     *           // Decomposed sub-formulas (each one can be evaluated independently):
+     *           "SUM(A1:A10)",   // sub-formula 1
+     *           "SQRT(D7)",      // sub-formula 2
+     *           "A1:A10",        // range reference
+     *           "D7",            // single-cell reference
+     *         ],
+     *       },
+     *       4: {
+     *         5: [
+     *           "=A2 + B2 + SQRT(C5)",
+     *           "A2",
+     *           "B2",
+     *           "SQRT(C5)",
+     *         ],
+     *       }
+     *     },
+     *   },
+     * };
+     *
+     * const disposer = formulaEngine.executeFormulas(formulas, (result) => {
+     *   console.log(result);
+     * });
+     *
+     * ```
+     */
+    executeFormulas(formulas: IFormulaStringMap, callback: (result: IFormulaExecuteResultMap) => void): void;
+    /**
+     * Retrieve all formula dependency trees that were produced during the latest
+     * dependency-analysis run. This triggers a local dependency-calculation command
+     * and returns the complete set of dependency trees once the calculation finishes.
+     *
+     * @param callback A function invoked with the resulting array of dependency trees.
+     *
+     * @returns {IDisposable} An object that disposes the internal event listener.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Fetch all dependency trees generated for the current workbook.
+     * const disposable = formulaEngine.getAllDependencyTrees((trees) => {
+     *     console.log('All dependency trees:', trees);
+     * });
+     *
+     * ```
+     */
+    getAllDependencyTrees(callback: (result: IFormulaDependencyTreeJson[]) => void): void;
+    /**
+     * Retrieve the dependency tree of a specific cell. This triggers a local
+     * dependency-calculation command for the given unit, sheet, and cell location,
+     * and returns the computed dependency tree when the calculation is completed.
+     *
+     * @param param The target cell location:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `row`     The zero-based row index.
+     *   - `column`  The zero-based column index.
+     *
+     * @param callback A function invoked with the resulting dependency tree or
+     * `undefined` if no dependency tree exists for that cell.
+     *
+     * @returns {IDisposable} An object that disposes the internal event listener.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Query the dependency tree for cell B2 in a specific sheet.
+     * const disposable = formulaEngine.getCellDependencyTree(
+     *     { unitId: 'workbook1', sheetId: 'sheet1', row: 1, column: 1 },
+     *     (tree) => {
+     *         console.log('Cell dependency tree:', tree);
+     *     }
+     * );
+     *
+     * ```
+     */
+    getCellDependencyTree(param: {
+        unitId: string;
+        sheetId: string;
+        row: number;
+        column: number;
+    }, callback: (result: IFormulaDependencyTreeFullJson | undefined) => void): void;
+    /**
+     * Retrieve the full dependency trees for all formulas that *depend on* the
+     * specified ranges. This triggers a local dependency-calculation command and
+     * invokes the callback once the calculation completes.
+     *
+     * @param unitRanges An array of workbook/sheet ranges to query. Each range
+     *   includes:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `range`   The row/column boundaries.
+     *
+     * @param callback A function invoked with an array of `IFormulaDependencyTreeJson`
+     * results. Each entry represents a formula node and its parent/child
+     * relationships within the dependency graph.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Query all formulas that depend on A1:B10 in Sheet1.
+     * formulaEngine.getRangeDependents(
+     *     [{ unitId: 'workbook1', sheetId: 'sheet1', range: { startRow: 0, endRow: 9, startColumn: 0, endColumn: 1 } }],
+     *     (result) => {
+     *         console.log('Dependent formulas:', result);
+     *     }
+     * );
+     * ```
+     */
+    getRangeDependents(unitRanges: IUnitRange[], callback: (result: IFormulaDependencyTreeJson[]) => void): void;
+    /**
+     * Retrieve the dependency trees of all formulas *inside* the specified ranges.
+     * Unlike `getRangeDependents`, this API only returns formulas whose definitions
+     * physically reside within the queried ranges.
+     *
+     * Internally this triggers the same dependency-calculation command but with
+     * `isInRange = true`, and the callback is invoked when the results are ready.
+     *
+     * @param unitRanges An array of workbook/sheet ranges defining the lookup
+     *   boundaries:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `range`   The zero-based grid range.
+     *
+     * @param callback Receives an array of `IFormulaDependencyTreeJson` describing
+     * every formula found in the provided ranges along with their parent/child
+     * relationships.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Query all formulas that lie within A1:D20 in Sheet1.
+     * formulaEngine.getInRangeFormulas(
+     *     [{ unitId: 'workbook1', sheetId: 'sheet1', range: { startRow: 0, endRow: 19, startColumn: 0, endColumn: 3 } }],
+     *     (result) => {
+     *         console.log('Formulas inside range:', result);
+     *     }
+     * );
+     * ```
+     */
+    getInRangeFormulas(unitRanges: IUnitRange[], callback: (result: IFormulaDependencyTreeJson[]) => void): void;
 }

package/lib/types/index.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export type { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeImageFormulaDataType, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitImageFormulaDataType, IUnitSheetNameMap, } from './basics/common';
+export type { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeImageFormulaDataType, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitImageFormulaDataType, IUnitSheetNameMap, } from './basics/common';
 export { BooleanValue } from './basics/common';
 export { type IOtherFormulaData } from './basics/common';
 export { type IUnitRowData } from './basics/common';
@@ -33,7 +33,7 @@ export { type ISetArrayFormulaDataMutationParams, SetArrayFormulaDataMutation }
 export { type ISetDefinedNameMutationParam, type ISetDefinedNameMutationSearchParam, RemoveDefinedNameMutation, SetDefinedNameMutation } from './commands/mutations/set-defined-name.mutation';
 export { SetDefinedNameMutationFactory } from './commands/mutations/set-defined-name.mutation';
 export { RemoveFeatureCalculationMutation, SetFeatureCalculationMutation } from './commands/mutations/set-feature-calculation.mutation';
-export { type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, } from './commands/mutations/set-formula-calculation.mutation';
+export { type ISetCellFormulaDependencyCalculationResultMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaDependencyCalculationMutation, type ISetFormulaDependencyCalculationResultMutation, type ISetFormulaStringBatchCalculationResultMutation, type ISetQueryFormulaDependencyResultMutation, SetCellFormulaDependencyCalculationMutation, SetCellFormulaDependencyCalculationResultMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaDependencyCalculationMutation, SetFormulaDependencyCalculationResultMutation, SetFormulaStringBatchCalculationMutation, SetFormulaStringBatchCalculationResultMutation, SetQueryFormulaDependencyMutation, SetQueryFormulaDependencyResultMutation, } from './commands/mutations/set-formula-calculation.mutation';
 export { type ISetFormulaDataMutationParams, SetFormulaDataMutation } from './commands/mutations/set-formula-data.mutation';
 export { type ISetImageFormulaDataMutationParams, SetImageFormulaDataMutation } from './commands/mutations/set-image-formula-data.mutation';
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';
@@ -56,7 +56,7 @@ export { ReferenceNodeFactory } from './engine/ast-node/reference-node';
 export { SuffixNodeFactory } from './engine/ast-node/suffix-node';
 export { UnionNodeFactory } from './engine/ast-node/union-node';
 export { ValueNodeFactory } from './engine/ast-node/value-node';
-export { FormulaDependencyTree, type IFormulaDependencyTree } from './engine/dependency/dependency-tree';
+export { FormulaDependencyTree, FormulaDependencyTreeModel, type IFormulaDependencyTree, type IFormulaDependencyTreeFullJson, type IFormulaDependencyTreeJson } from './engine/dependency/dependency-tree';
 export { FormulaDependencyTreeType } from './engine/dependency/dependency-tree';
 export { FormulaDependencyTreeVirtual } from './engine/dependency/dependency-tree';
 export { FormulaDependencyGenerator, IFormulaDependencyGenerator } from './engine/dependency/formula-dependency';

package/lib/types/services/calculate-formula.service.d.ts

@@ -1,10 +1,11 @@
+import { IUnitRange, Disposable, IConfigService } from '@univerjs/core';
 import { Observable, Subject } from 'rxjs';
-import { IFeatureDirtyRangeType, IFormulaDatasetConfig, IRuntimeUnitDataType } from '../basics/common';
+import { IFeatureDirtyRangeType, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeUnitDataType, IUnitRowData } from '../basics/common';
+import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson } from '../engine/dependency/dependency-tree';
+import { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IAllRuntimeData, IExecutionInProgressParams, IFormulaRuntimeService } from './runtime.service';
-import { Disposable, IConfigService } from '@univerjs/core';
 import { Lexer } from '../engine/analysis/lexer';
 import { AstTreeBuilder } from '../engine/analysis/parser';
-import { ErrorNode } from '../engine/ast-node/base-ast-node';
 import { IFormulaDependencyGenerator } from '../engine/dependency/formula-dependency';
 import { Interpreter } from '../engine/interpreter/interpreter';
 import { IFormulaCurrentConfigService } from './current-data.service';
@@ -19,6 +20,11 @@ export interface ICalculateFormulaService {
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
     stopFormulaExecution(): void;
     calculate(formulaString: string, transformSuffix?: boolean): void;
+    executeFormulas(formulas: IFormulaStringMap, rowData?: IUnitRowData): Promise<IFormulaExecuteResultMap>;
+    getAllDependencyJson(rowData?: IUnitRowData): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number, rowData?: IUnitRowData): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }
 export declare const ICalculateFormulaService: import('@wendellhu/redi').IdentifierDecorator<ICalculateFormulaService>;
 export declare class CalculateFormulaService extends Disposable implements ICalculateFormulaService {
@@ -53,5 +59,10 @@ export declare class CalculateFormulaService extends Disposable implements ICalc
     private _executeStep;
     private _getArrayFormulaDirtyRangeAndExcludedRange;
     protected _apply(isArrayFormulaState?: boolean): Promise<IAllRuntimeData | undefined>;
-    calculate(formulaString: string, transformSuffix?: boolean): ErrorNode | undefined;
+    executeFormulas(formulas: IFormulaStringMap, rowData?: IUnitRowData): Promise<IFormulaExecuteResultMap>;
+    calculate(formulaString: string): Promise<FunctionVariantType | undefined>;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }

package/lib/types/services/current-data.service.d.ts

@@ -55,6 +55,7 @@ export interface IFormulaCurrentConfigService {
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
     setSheetNameMap(sheetIdToNameMap: IUnitSheetIdToNameMap): void;
+    loadDataLite(rowData?: IUnitRowData): void;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _univerInstanceService;
@@ -113,6 +114,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
     load(config: IFormulaDatasetConfig): void;
+    loadDataLite(rowData?: IUnitRowData): void;
     getDirtyData(): IFormulaDirtyData;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;

package/lib/umd/facade.js

@@ -1 +1 @@
-(function(r,o){typeof exports=="object"&&typeof module<"u"?o(exports,require("@univerjs/core/facade"),require("@univerjs/core"),require("@univerjs/engine-formula"),require("rxjs")):typeof define=="function"&&define.amd?define(["exports","@univerjs/core/facade","@univerjs/core","@univerjs/engine-formula","rxjs"],o):(r=typeof globalThis<"u"?globalThis:r||self,o(r.UniverEngineFormulaFacade={},r.UniverCoreFacade,r.UniverCore,r.UniverEngineFormula,r.rxjs))})(this,(function(r,o,u,a,s){"use strict";var f=Object.getOwnPropertyDescriptor,v=(c,e,t,i)=>{for(var n=i>1?void 0:i?f(e,t):e,d=c.length-1,m;d>=0;d--)(m=c[d])&&(n=m(n)||n);return n},l=(c,e)=>(t,i)=>e(t,i,c);r.FFormula=class extends o.FBase{constructor(e,t,i,n){super(),this._commandService=e,this._injector=t,this._lexerTreeBuilder=i,this._configService=n,this._initialize()}_initialize(){}get lexerTreeBuilder(){return this._lexerTreeBuilder}moveFormulaRefOffset(e,t,i,n){return this._lexerTreeBuilder.moveFormulaRefOffset(e,t,i,n)}sequenceNodesBuilder(e){return this._lexerTreeBuilder.sequenceNodesBuilder(e)||[]}executeCalculation(){this._commandService.executeCommand(a.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(a.SetFormulaCalculationStopMutation.id,{})}calculationStart(e){return this._commandService.onCommandExecuted(t=>{if(t.id===a.SetFormulaCalculationStartMutation.id){const i=t.params;e(i.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==a.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.functionsExecutedState!==void 0&&e(i.functionsExecutedState)})}whenComputingCompleteAsync(e){const t=this._injector.get(a.GlobalComputingStatusService);return t.computingStatus?Promise.resolve(!0):s.firstValueFrom(s.race(t.computingStatus$.pipe(s.filter(i=>i)),s.timer(e!=null?e:3e4).pipe(s.map(()=>!1))))}onCalculationEnd(){return new Promise((e,t)=>{const i=setTimeout(()=>{t(new Error("Calculation end timeout"))},3e4),n=this.calculationEnd(()=>{clearTimeout(i),n.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==a.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.stageInfo!==void 0&&e(i.stageInfo)})}setMaxIteration(e){this._configService.setConfig(a.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}},r.FFormula=v([l(0,u.Inject(u.ICommandService)),l(1,u.Inject(u.Injector)),l(2,u.Inject(a.LexerTreeBuilder)),l(3,u.IConfigService)],r.FFormula);class C extends o.FUniver{getFormula(){return this._injector.createInstance(r.FFormula)}}o.FUniver.extend(C),Object.defineProperty(r,Symbol.toStringTag,{value:"Module"})}));
+(function(o,s){typeof exports=="object"&&typeof module<"u"?s(exports,require("@univerjs/core/facade"),require("@univerjs/core"),require("@univerjs/engine-formula"),require("rxjs")):typeof define=="function"&&define.amd?define(["exports","@univerjs/core/facade","@univerjs/core","@univerjs/engine-formula","rxjs"],s):(o=typeof globalThis<"u"?globalThis:o||self,s(o.UniverEngineFormulaFacade={},o.UniverCoreFacade,o.UniverCore,o.UniverEngineFormula,o.rxjs))})(this,(function(o,s,u,r,l){"use strict";var f=Object.getOwnPropertyDescriptor,C=(c,e,i,t)=>{for(var n=t>1?void 0:t?f(e,i):e,a=c.length-1,d;a>=0;a--)(d=c[a])&&(n=d(n)||n);return n},m=(c,e)=>(i,t)=>e(i,t,c);o.FFormula=class extends s.FBase{constructor(e,i,t,n){super(),this._commandService=e,this._injector=i,this._lexerTreeBuilder=t,this._configService=n,this._initialize()}_initialize(){}get lexerTreeBuilder(){return this._lexerTreeBuilder}moveFormulaRefOffset(e,i,t,n){return this._lexerTreeBuilder.moveFormulaRefOffset(e,i,t,n)}sequenceNodesBuilder(e){return this._lexerTreeBuilder.sequenceNodesBuilder(e)||[]}executeCalculation(){this._commandService.executeCommand(r.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(r.SetFormulaCalculationStopMutation.id,{})}calculationStart(e){return this._commandService.onCommandExecuted(i=>{if(i.id===r.SetFormulaCalculationStartMutation.id){const t=i.params;e(t.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==r.SetFormulaCalculationNotificationMutation.id)return;const t=i.params;t.functionsExecutedState!==void 0&&e(t.functionsExecutedState)})}whenComputingCompleteAsync(e){const i=this._injector.get(r.GlobalComputingStatusService);return i.computingStatus?Promise.resolve(!0):l.firstValueFrom(l.race(i.computingStatus$.pipe(l.filter(t=>t)),l.timer(e!=null?e:3e4).pipe(l.map(()=>!1))))}onCalculationEnd(){return new Promise((e,i)=>{const t=setTimeout(()=>{i(new Error("Calculation end timeout"))},3e4),n=this.calculationEnd(()=>{clearTimeout(t),n.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==r.SetFormulaCalculationNotificationMutation.id)return;const t=i.params;t.stageInfo!==void 0&&e(t.stageInfo)})}setMaxIteration(e){this._configService.setConfig(r.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}calculationResultApplied(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==r.SetFormulaCalculationResultMutation.id)return;const t=i.params;t!==void 0&&requestIdleCallback(()=>{e(t)})})}onCalculationResultApplied(){return new Promise((e,i)=>{let t=!1,n=!1;const a=setTimeout(()=>{p(),i(new Error("Calculation end timeout"))},3e4),d=setTimeout(()=>{t||(p(),e())},500),v=this.calculationProcessing(()=>{t||(t=!0,clearTimeout(d))}),h=this.calculationResultApplied(()=>{n||(n=!0,p(),e())});function p(){clearTimeout(a),clearTimeout(d),v.dispose(),h.dispose()}})}executeFormulas(e,i){this._commandService.executeCommand(r.SetFormulaStringBatchCalculationMutation.id,{formulas:e},{onlyLocal:!0});const t=this._commandService.onCommandExecuted(n=>{if(n.id!==r.SetFormulaStringBatchCalculationResultMutation.id)return;const a=n.params;a.result!=null&&i(a.result),t.dispose()})}getAllDependencyTrees(e){this._commandService.executeCommand(r.SetFormulaDependencyCalculationMutation.id,void 0,{onlyLocal:!0});const i=this._commandService.onCommandExecuted(t=>{if(t.id!==r.SetFormulaDependencyCalculationResultMutation.id)return;const n=t.params;n.result!=null&&e(n.result),i.dispose()})}getCellDependencyTree(e,i){this._commandService.executeCommand(r.SetCellFormulaDependencyCalculationMutation.id,e,{onlyLocal:!0});const t=this._commandService.onCommandExecuted(n=>{if(n.id!==r.SetCellFormulaDependencyCalculationResultMutation.id)return;const a=n.params;a.result!==void 0&&i(a.result),t.dispose()})}getRangeDependents(e,i){this._commandService.executeCommand(r.SetQueryFormulaDependencyMutation.id,{unitRanges:e},{onlyLocal:!0});const t=this._commandService.onCommandExecuted(n=>{if(n.id!==r.SetQueryFormulaDependencyResultMutation.id)return;const a=n.params;a.result!=null&&i(a.result),t.dispose()})}getInRangeFormulas(e,i){this._commandService.executeCommand(r.SetQueryFormulaDependencyMutation.id,{unitRanges:e,isInRange:!0},{onlyLocal:!0});const t=this._commandService.onCommandExecuted(n=>{if(n.id!==r.SetQueryFormulaDependencyResultMutation.id)return;const a=n.params;a.result!=null&&i(a.result),t.dispose()})}},o.FFormula=C([m(0,u.Inject(u.ICommandService)),m(1,u.Inject(u.Injector)),m(2,u.Inject(r.LexerTreeBuilder)),m(3,u.IConfigService)],o.FFormula);class S extends s.FUniver{getFormula(){return this._injector.createInstance(o.FFormula)}}s.FUniver.extend(S),Object.defineProperty(o,Symbol.toStringTag,{value:"Module"})}));