@univerjs/engine-formula 0.12.3-nightly.202512060617 → 0.12.4-experimental.20251208-c4b8a44

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,39 @@
 import { IExecutionOptions, IMutation, Nullable } from '@univerjs/core';
-import { IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+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;
+}
 /**
  * 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 +47,7 @@ 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>;

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

@@ -9,6 +9,9 @@ export declare class CalculateController extends Disposable {
     private _initialize;
     private _commandExecutedListener;
     private _calculate;
+    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,20 @@ 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>;
 }
 export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
@@ -26,9 +29,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 +114,15 @@ 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>;
 }

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 { FormulaExecutedStateType, IExecutionInProgressParams, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, 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,131 @@ export declare class FFormula extends FBase {
      * ```
      */
     setMaxIteration(maxIteration: number): 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;
 }

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, SetCellFormulaDependencyCalculationMutation, SetCellFormulaDependencyCalculationResultMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaDependencyCalculationMutation, SetFormulaDependencyCalculationResultMutation, SetFormulaStringBatchCalculationMutation, SetFormulaStringBatchCalculationResultMutation, } 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 { Observable, Subject } from 'rxjs';
-import { IFeatureDirtyRangeType, IFormulaDatasetConfig, IRuntimeUnitDataType } from '../basics/common';
+import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFeatureDirtyRangeType, IFormulaData, 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,9 @@ export interface ICalculateFormulaService {
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
     stopFormulaExecution(): void;
     calculate(formulaString: string, transformSuffix?: boolean): void;
+    executeFormulas(formulas: IFormulaStringMap, formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, rowData: IUnitRowData): Promise<IFormulaExecuteResultMap>;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
 }
 export declare const ICalculateFormulaService: import('@wendellhu/redi').IdentifierDecorator<ICalculateFormulaService>;
 export declare class CalculateFormulaService extends Disposable implements ICalculateFormulaService {
@@ -53,5 +57,8 @@ 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, formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, 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>;
 }

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

@@ -1,5 +1,5 @@
 import { IUnitRange, LocaleType, Nullable, Disposable, IUniverInstanceService, LocaleService } from '@univerjs/core';
-import { IArrayFormulaRangeType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetIdToNameMap, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
+import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetIdToNameMap, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 import { FormulaDataModel } from '../models/formula-data.model';
 import { ISheetRowFilteredService } from './sheet-row-filtered.service';
 export interface IFormulaDirtyData {
@@ -55,6 +55,7 @@ export interface IFormulaCurrentConfigService {
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
     setSheetNameMap(sheetIdToNameMap: IUnitSheetIdToNameMap): void;
+    loadDataLite(formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, 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(formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, 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(a,u){typeof exports=="object"&&typeof module<"u"?u(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"],u):(a=typeof globalThis<"u"?globalThis:a||self,u(a.UniverEngineFormulaFacade={},a.UniverCoreFacade,a.UniverCore,a.UniverEngineFormula,a.rxjs))})(this,(function(a,u,c,n,l){"use strict";var f=Object.getOwnPropertyDescriptor,p=(s,e,t,i)=>{for(var r=i>1?void 0:i?f(e,t):e,o=s.length-1,m;o>=0;o--)(m=s[o])&&(r=m(r)||r);return r},d=(s,e)=>(t,i)=>e(t,i,s);a.FFormula=class extends u.FBase{constructor(e,t,i,r){super(),this._commandService=e,this._injector=t,this._lexerTreeBuilder=i,this._configService=r,this._initialize()}_initialize(){}get lexerTreeBuilder(){return this._lexerTreeBuilder}moveFormulaRefOffset(e,t,i,r){return this._lexerTreeBuilder.moveFormulaRefOffset(e,t,i,r)}sequenceNodesBuilder(e){return this._lexerTreeBuilder.sequenceNodesBuilder(e)||[]}executeCalculation(){this._commandService.executeCommand(n.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(n.SetFormulaCalculationStopMutation.id,{})}calculationStart(e){return this._commandService.onCommandExecuted(t=>{if(t.id===n.SetFormulaCalculationStartMutation.id){const i=t.params;e(i.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==n.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.functionsExecutedState!==void 0&&e(i.functionsExecutedState)})}whenComputingCompleteAsync(e){const t=this._injector.get(n.GlobalComputingStatusService);return t.computingStatus?Promise.resolve(!0):l.firstValueFrom(l.race(t.computingStatus$.pipe(l.filter(i=>i)),l.timer(e!=null?e:3e4).pipe(l.map(()=>!1))))}onCalculationEnd(){return new Promise((e,t)=>{const i=setTimeout(()=>{t(new Error("Calculation end timeout"))},3e4),r=this.calculationEnd(()=>{clearTimeout(i),r.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==n.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.stageInfo!==void 0&&e(i.stageInfo)})}setMaxIteration(e){this._configService.setConfig(n.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}executeFormulas(e,t){this._commandService.executeCommand(n.SetFormulaStringBatchCalculationMutation.id,{formulas:e},{onlyLocal:!0});const i=this._commandService.onCommandExecuted(r=>{if(r.id!==n.SetFormulaStringBatchCalculationResultMutation.id)return;const o=r.params;o.result!=null&&t(o.result),i.dispose()})}getAllDependencyTrees(e){this._commandService.executeCommand(n.SetFormulaDependencyCalculationMutation.id,void 0,{onlyLocal:!0});const t=this._commandService.onCommandExecuted(i=>{if(i.id!==n.SetFormulaDependencyCalculationResultMutation.id)return;const r=i.params;r.result!=null&&e(r.result),t.dispose()})}getCellDependencyTree(e,t){this._commandService.executeCommand(n.SetCellFormulaDependencyCalculationMutation.id,e,{onlyLocal:!0});const i=this._commandService.onCommandExecuted(r=>{if(r.id!==n.SetCellFormulaDependencyCalculationResultMutation.id)return;const o=r.params;o.result!==void 0&&t(o.result),i.dispose()})}},a.FFormula=p([d(0,c.Inject(c.ICommandService)),d(1,c.Inject(c.Injector)),d(2,c.Inject(n.LexerTreeBuilder)),d(3,c.IConfigService)],a.FFormula);class v extends u.FUniver{getFormula(){return this._injector.createInstance(a.FFormula)}}u.FUniver.extend(v),Object.defineProperty(a,Symbol.toStringTag,{value:"Module"})}));