@univerjs/engine-formula 0.13.0 → 0.14.0-insiders.20251227-b250a8d

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

@@ -1,4 +1,5 @@
 import { ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix, Styles } from '@univerjs/core';
+import { sequenceNodeType } from '../engine/utils/sequence';
 import { IImageFormulaInfo } from '../engine/value-object/primitive-object';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
 export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
@@ -206,9 +207,16 @@ export interface IFormulaDatasetConfig {
     unitStylesData?: IUnitStylesData;
     unitSheetNameMap?: IUnitSheetNameMap;
     maxIteration?: number;
+    isCalculateTreeModel?: boolean;
     rowData?: IUnitRowData;
 }
 export declare enum ConcatenateType {
     FRONT = 0,
     BACK = 1
 }
+export interface IExprTreeNode {
+    value: string;
+    children: IExprTreeNode[];
+    startIndex: number;
+    type?: sequenceNodeType;
+}

package/lib/types/basics/match-token.d.ts

@@ -1,5 +1,5 @@
 import { compareToken, matchToken, operatorToken, prefixToken, suffixToken } from './token';
-export declare const FORMULA_LEXER_TOKENS: (operatorToken | suffixToken | compareToken | matchToken | prefixToken)[];
+export declare const FORMULA_LEXER_TOKENS: (operatorToken | suffixToken | compareToken | prefixToken | matchToken)[];
 export declare function isFormulaLexerToken(str: string): boolean;
 export declare function includeFormulaLexerToken(str: string): boolean;
 export declare function normalizeSheetName(sheetName: string): string;

package/lib/types/commands/mutations/formula.mutation.d.ts

@@ -0,0 +1,9 @@
+import { IMutation } from '@univerjs/core';
+export interface IOtherFormulaMarkDirtyParams {
+    [unitId: string]: {
+        [sunUnitId: string]: {
+            [formulaId: string]: boolean;
+        };
+    };
+}
+export declare const OtherFormulaMarkDirty: IMutation<IOtherFormulaMarkDirtyParams>;

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

@@ -1,6 +1,6 @@
 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 { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaDependentsAndInRangeResults } from '../../engine/dependency/dependency-tree';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation extends IFormulaDirtyData {
@@ -34,11 +34,18 @@ export interface ISetQueryFormulaDependencyMutation {
 export interface ISetQueryFormulaDependencyResultMutation {
     result: IFormulaDependencyTreeJson[];
 }
+export interface ISetQueryFormulaDependencyAllMutation {
+    unitRanges: IUnitRange[];
+}
+export interface ISetQueryFormulaDependencyAllResultMutation {
+    result: IFormulaDependentsAndInRangeResults;
+}
 /**
  * TODO: @DR-Univer
  * Trigger the calculation of the formula and stop the formula
  */
 export declare const SetFormulaCalculationStartMutation: IMutation<ISetFormulaCalculationStartMutation>;
+export declare const SetTriggerFormulaCalculationStartMutation: IMutation<ISetFormulaCalculationStartMutation>;
 export declare const SetFormulaStringBatchCalculationMutation: IMutation<ISetFormulaStringBatchCalculationMutation>;
 export declare const SetFormulaStringBatchCalculationResultMutation: IMutation<ISetFormulaStringBatchCalculationResultMutation>;
 export interface ISetFormulaCalculationStopMutation {
@@ -60,3 +67,5 @@ export declare const SetCellFormulaDependencyCalculationMutation: IMutation<ISet
 export declare const SetCellFormulaDependencyCalculationResultMutation: IMutation<ISetCellFormulaDependencyCalculationResultMutation>;
 export declare const SetQueryFormulaDependencyMutation: IMutation<ISetQueryFormulaDependencyMutation>;
 export declare const SetQueryFormulaDependencyResultMutation: IMutation<ISetQueryFormulaDependencyResultMutation>;
+export declare const SetQueryFormulaDependencyAllMutation: IMutation<ISetQueryFormulaDependencyAllMutation>;
+export declare const SetQueryFormulaDependencyAllResultMutation: IMutation<ISetQueryFormulaDependencyAllResultMutation>;

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

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

package/lib/types/controller/config.schema.d.ts

@@ -4,6 +4,7 @@ import { BaseFunction } from '../functions/base-function';
 export declare const ENGINE_FORMULA_PLUGIN_CONFIG_KEY = "engine-formula.config";
 export declare const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
 export declare const ENGINE_FORMULA_CYCLE_REFERENCE_COUNT = "CYCLE_REFERENCE_COUNT";
+export declare const ENGINE_FORMULA_RETURN_DEPENDENCY_TREE = "RETURN_DEPENDENCY_TREE";
 export declare const configSymbol: unique symbol;
 export interface IUniverEngineFormulaConfig {
     notExecuteFormula?: boolean;

package/lib/types/engine/analysis/lexer-tree-builder.d.ts

@@ -1,5 +1,5 @@
 import { Nullable, AbsoluteRefType, Disposable } from '@univerjs/core';
-import { IDirtyUnitSheetDefinedNameMap } from '../../basics/common';
+import { IDirtyUnitSheetDefinedNameMap, IExprTreeNode, ISuperTable } from '../../basics/common';
 import { IFunctionNames } from '../../basics/function';
 import { IDefinedNamesServiceParam } from '../../services/defined-names.service';
 import { ISequenceArray, ISequenceNode } from '../utils/sequence';
@@ -145,5 +145,6 @@ export declare class LexerTreeBuilder extends Disposable {
     private _isScientificNotation;
     private _addSequenceArray;
     getNewFormulaWithPrefix(formulaString: string, hasFunction: (functionToken: IFunctionNames) => boolean): string | null;
+    getFormulaExprTree(formulaString: string, unitId: string, hasFunction: (functionToken: IFunctionNames) => boolean, getDefinedNameName: (unitId: string, name: string) => Nullable<IDefinedNamesServiceParam>, getTable: (unitId: string, tableName: string) => Nullable<ISuperTable>): IExprTreeNode | null;
 }
 export {};

package/lib/types/engine/ast-node/reference-node.d.ts

@@ -36,7 +36,6 @@ export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
     private _getTableMap;
     private _getNode;
     private _getTableReferenceNode;
-    private _splitTableStructuredRef;
     private _checkTokenIsTableReference;
     private _checkParentIsUnionOperator;
 }

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

@@ -15,6 +15,7 @@ export declare enum FormulaDependencyTreeType {
 }
 declare class FormulaDependencyTreeCalculator {
     private _state;
+    type: FormulaDependencyTreeType;
     resetState(): void;
     setAdded(): void;
     isAdded(): boolean;
@@ -77,7 +78,6 @@ export declare class FormulaDependencyTree extends FormulaDependencyTreeCalculat
     featureDirtyRanges: IUnitRange[];
     refOffsetX: number;
     refOffsetY: number;
-    type: FormulaDependencyTreeType;
     formulaId: Nullable<string>;
     subUnitId: string;
     unitId: string;
@@ -126,6 +126,9 @@ interface IFormulaDependencyTreeJsonBase {
     refOffsetY: number;
     rangeList: IUnitRange[];
     refTreeId: number | undefined;
+    formulaId: Nullable<string>;
+    featureId: Nullable<string>;
+    type: Nullable<FormulaDependencyTreeType>;
 }
 export interface IFormulaDependencyTreeJson extends IFormulaDependencyTreeJsonBase {
     children: number[];
@@ -135,6 +138,10 @@ export interface IFormulaDependencyTreeFullJson extends IFormulaDependencyTreeJs
     children: IFormulaDependencyTreeJson[];
     parents: IFormulaDependencyTreeJson[];
 }
+export interface IFormulaDependentsAndInRangeResults {
+    dependents: IFormulaDependencyTreeJson[];
+    inRanges: IFormulaDependencyTreeJson[];
+}
 export declare class FormulaDependencyTreeModel {
     children: Set<FormulaDependencyTreeModel>;
     parents: Set<FormulaDependencyTreeModel>;
@@ -148,6 +155,9 @@ export declare class FormulaDependencyTreeModel {
     subUnitId: string;
     rangeList: IUnitRange[];
     refTreeId: number | undefined;
+    formulaId: Nullable<string>;
+    featureId: Nullable<string>;
+    type: Nullable<FormulaDependencyTreeType>;
     constructor(tree: IFormulaDependencyTree);
     toJson(): IFormulaDependencyTreeJson;
     toFullJson(): IFormulaDependencyTreeFullJson;

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

@@ -4,7 +4,7 @@ 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, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, FormulaDependencyTree, FormulaDependencyTreeModel, FormulaDependencyTreeVirtual } from './dependency-tree';
+import { IFormulaDependencyTree, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaDependentsAndInRangeResults, 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';
@@ -15,11 +15,12 @@ import { AstTreeBuilder } from '../analysis/parser';
 import { Interpreter } from '../interpreter/interpreter';
 export declare function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): number;
 export interface IFormulaDependencyGenerator {
-    generate(): Promise<IFormulaDependencyTree[]>;
+    generate(isCalculateTreeModel?: boolean): 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[]>;
+    getRangeDependentsAndInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependentsAndInRangeResults>;
 }
 export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
@@ -36,7 +37,7 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected _dependencyRTreeCacheForAddressFunction: RTree;
     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)[]>;
+    generate(isCalculateTreeModel?: boolean): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
     private _dependencyFeatureCalculation;
     private _clearFeatureCalculationNode;
     /**
@@ -119,15 +120,19 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected _initializeGenerateTreeList(): Promise<IFormulaDependencyTree[]>;
     protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
     protected _formulaDependencyTreeModel: Map<number, FormulaDependencyTreeModel>;
-    protected _getTreeModel(treeId: number): FormulaDependencyTreeModel;
+    protected _getTreeModel(treeId: number): FormulaDependencyTreeModel | undefined;
     protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
     protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
     protected _getFormulaDependencyTreeModel(tree: IFormulaDependencyTree): FormulaDependencyTreeModel;
     protected _endFormulaDependencyTreeModel(): void;
     protected _startFormulaDependencyTreeModel(): void;
+    protected _getAllDependencyJson(treeList: IFormulaDependencyTree[]): IFormulaDependencyTreeJson[];
     getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
     protected _setRealFormulaString(treeModel: FormulaDependencyTreeModel): void;
     getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    protected _getRangeDependents(unitRanges: IUnitRange[]): IFormulaDependencyTreeJson[];
     getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    protected _getInRangeFormulas(unitRanges: IUnitRange[], treeList: IFormulaDependencyTree[]): IFormulaDependencyTreeJson[];
     getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getRangeDependentsAndInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependentsAndInRangeResults>;
 }

package/lib/types/engine/utils/reference.d.ts

@@ -85,3 +85,12 @@ export declare function quoteSheetName(name: string): string;
  * @returns Unquoted name
  */
 export declare function unquoteSheetName(name: string): string;
+export declare function splitTableStructuredRef(ref: string): {
+    tableName: string;
+    struct: string;
+    columnStruct?: undefined;
+} | {
+    tableName: string;
+    columnStruct: string;
+    struct?: undefined;
+};

package/lib/types/engine/utils/sequence.d.ts

@@ -6,7 +6,8 @@ export declare enum sequenceNodeType {
     FUNCTION = 3,
     REFERENCE = 4,
     ARRAY = 5,
-    DEFINED_NAME = 6
+    DEFINED_NAME = 6,
+    TABLE = 7
 }
 export interface ISequenceNode {
     nodeType: sequenceNodeType;

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

@@ -1,5 +1,5 @@
 import { IDisposable, IUnitRange, ICommandService, IConfigService, Injector } from '@univerjs/core';
-import { FormulaExecutedStateType, IExecutionInProgressParams, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, ISetFormulaCalculationResultMutation, LexerTreeBuilder } from '@univerjs/engine-formula';
+import { FormulaExecutedStateType, IExecutionInProgressParams, IExprTreeNode, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaDependentsAndInRangeResults, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, ISetFormulaCalculationResultMutation, IDefinedNamesService, IFunctionService, ISuperTableService, LexerTreeBuilder } from '@univerjs/engine-formula';
 import { FBase } from '@univerjs/core/facade';
 /**
  * This interface class provides methods to modify the behavior of the operation formula.
@@ -10,7 +10,10 @@ export declare class FFormula extends FBase {
     protected readonly _injector: Injector;
     private _lexerTreeBuilder;
     protected readonly _configService: IConfigService;
-    constructor(_commandService: ICommandService, _injector: Injector, _lexerTreeBuilder: LexerTreeBuilder, _configService: IConfigService);
+    private readonly _functionService;
+    private readonly _definedNamesService;
+    private readonly _superTableService;
+    constructor(_commandService: ICommandService, _injector: Injector, _lexerTreeBuilder: LexerTreeBuilder, _configService: IConfigService, _functionService: IFunctionService, _definedNamesService: IDefinedNamesService, _superTableService: ISuperTableService);
     /**
      * @ignore
      */
@@ -399,4 +402,163 @@ export declare class FFormula extends FBase {
      * ```
      */
     getInRangeFormulas(unitRanges: IUnitRange[], timeout?: number): Promise<IFormulaDependencyTreeJson[]>;
+    /**
+     * Enable or disable emitting formula dependency trees after each formula calculation.
+     *
+     * When enabled, the formula engine will emit the dependency trees produced by
+     * each completed formula calculation through the internal command system.
+     * Consumers can obtain the result by listening for the corresponding
+     * calculation-result command.
+     *
+     * When disabled, dependency trees will not be emitted.
+     *
+     * This option only controls whether dependency trees are exposed.
+     * It does not affect formula calculation behavior.
+     *
+     * @param {boolean} value
+     *        Whether to emit formula dependency trees after calculation.
+     *        - `true`: Emit dependency trees after each calculation.
+     *        - `false`: Do not emit dependency trees (default behavior).
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Enable dependency tree emission
+     * formulaEngine.setFormulaReturnDependencyTree(true);
+     *
+     * // Listen for dependency trees produced by formula calculation
+     * const trees = await new Promise<IFormulaDependencyTreeJson[]>((resolve, reject) => {
+     *   const timer = setTimeout(() => {
+     *     disposable.dispose();
+     *     reject(new Error('Timeout waiting for formula dependency trees'));
+     *   }, 30_000);
+     *
+     *   const disposable = commandService.onCommandExecuted((command) => {
+     *     if (command.id !== SetFormulaDependencyCalculationResultMutation.id) {
+     *       return;
+     *     }
+     *
+     *     clearTimeout(timer);
+     *     disposable.dispose();
+     *
+     *     const params = command.params as ISetFormulaDependencyCalculationResultMutation;
+     *     resolve(params.result ?? []);
+     *   });
+     * });
+     *
+     * console.log('Dependency trees:', trees);
+     * ```
+     */
+    setFormulaReturnDependencyTree(value: boolean): void;
+    /**
+     * Parse a formula string and return its **formula expression tree**.
+     *
+     * This API analyzes the syntactic structure of a formula and builds an
+     * expression tree that reflects how the formula is composed (functions,
+     * operators, ranges, and nested expressions), without performing calculation
+     * or dependency evaluation.
+     *
+     * The returned tree is suitable for:
+     * - Formula structure visualization
+     * - Explaining complex formulas (e.g. LET / LAMBDA)
+     * - Debugging or inspecting formula composition
+     * - Building advanced formula tooling
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * const formula = '=LET(x,SUM(A1,B1,A1:B10),y,OFFSET(A1:B10,0,1),SUM(x,y)+x)+1';
+     *
+     * const exprTree = formulaEngine.getFormulaExpressTree(formula);
+     *
+     * console.log(exprTree);
+     * ```
+     *
+     * Example output (simplified):
+     *
+     * ```json
+     * {
+     *   "value": "let(x,sum(A1,B1,A1:B10),y,offset(A1:B10,0,1),sum(x,y)+x)+1",
+     *   "children": [
+     *     {
+     *       "value": "let(x,sum(A1,B1,A1:B10),y,offset(A1:B10,0,1),sum(x,y)+x)",
+     *       "children": [
+     *         {
+     *           "value": "sum(A1,B1,A1:B10)",
+     *           "children": [
+     *             {
+     *               "value": "A1:B10",
+     *               "children": []
+     *             }
+     *           ]
+     *         },
+     *         {
+     *           "value": "offset(A1:B10,0,1)",
+     *           "children": [
+     *             {
+     *               "value": "A1:B10",
+     *               "children": []
+     *             }
+     *           ]
+     *         }
+     *       ]
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * @param formulaString The formula string to parse (with or without leading `=`)
+     * @returns A formula expression tree describing the hierarchical structure of the formula
+     */
+    getFormulaExpressTree(formulaString: string, unitId: string): IExprTreeNode | null;
+    /**
+     * Retrieve **both**:
+     * 1) the full dependency trees of all formulas that **depend on** the specified ranges, and
+     * 2) the dependency trees of all formulas that **physically reside inside** the specified ranges.
+     *
+     * This is a convenience API that combines the behaviors of
+     * `getRangeDependents` and `getInRangeFormulas` into a single call.
+     *
+     * Internally, it triggers a local dependency-calculation command once and
+     * resolves when both result sets are available, avoiding duplicate
+     * calculations and event listeners.
+     *
+     * @param unitRanges An array of workbook/sheet ranges to query. Each range
+     *   includes:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `range`   The zero-based row/column boundaries.
+     *
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If the dependency calculation does
+     *        not complete within this period, the promise will be rejected.
+     *
+     * @returns {Promise<IFormulaDependentsAndInRangeResults>}
+     *          A promise that resolves with an object containing:
+     *          - `dependents`: Dependency trees of all formulas that depend on the
+     *            specified ranges (upstream consumers).
+     *          - `inRanges`: Dependency trees of all formulas whose definitions
+     *            are located inside the specified ranges.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * const result = await formulaEngine.getRangeDependentsAndInRangeFormulas([
+     *   {
+     *     unitId: 'workbook1',
+     *     sheetId: 'sheet1',
+     *     range: { startRow: 0, endRow: 9, startColumn: 0, endColumn: 1 },
+     *   },
+     * ]);
+     *
+     * console.log('Dependent formulas:', result.dependents);
+     * console.log('Formulas inside range:', result.inRanges);
+     * ```
+     */
+    getRangeDependentsAndInRangeFormulas(unitRanges: IUnitRange[], timeout?: number): Promise<IFormulaDependentsAndInRangeResults>;
 }

package/lib/types/index.d.ts

@@ -16,7 +16,7 @@
 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';
+export type { IExprTreeNode, ISuperTable, IUnitRowData } from './basics/common';
 export { isInDirtyRange } from './basics/dirty';
 export { ERROR_TYPE_SET, ErrorType } from './basics/error-type';
 export { type ISheetFormulaError } from './basics/error-type';
@@ -28,19 +28,20 @@ export { isReferenceString } from './basics/regex';
 export { convertUnitDataToRuntime } from './basics/runtime';
 export { compareToken, matchToken, OPERATOR_TOKEN_SET, operatorToken, prefixToken, SUFFIX_TOKEN_SET } from './basics/token';
 export { DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME, DEFAULT_TOKEN_LET_FUNCTION_NAME, DEFAULT_TOKEN_TYPE_LAMBDA_PARAMETER, DEFAULT_TOKEN_TYPE_PARAMETER, DEFAULT_TOKEN_TYPE_ROOT } from './basics/token-type';
+export { OtherFormulaMarkDirty } from './commands/mutations/formula.mutation';
 export { RegisterFunctionMutation } from './commands/mutations/register-function.mutation';
 export { type ISetArrayFormulaDataMutationParams, SetArrayFormulaDataMutation } from './commands/mutations/set-array-formula-data.mutation';
 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 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 ISetCellFormulaDependencyCalculationResultMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaDependencyCalculationMutation, type ISetFormulaDependencyCalculationResultMutation, type ISetFormulaStringBatchCalculationResultMutation, type ISetQueryFormulaDependencyAllResultMutation, type ISetQueryFormulaDependencyResultMutation, SetCellFormulaDependencyCalculationMutation, SetCellFormulaDependencyCalculationResultMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaDependencyCalculationMutation, SetFormulaDependencyCalculationResultMutation, SetFormulaStringBatchCalculationMutation, SetFormulaStringBatchCalculationResultMutation, SetQueryFormulaDependencyAllMutation, SetQueryFormulaDependencyAllResultMutation, SetQueryFormulaDependencyMutation, SetQueryFormulaDependencyResultMutation, SetTriggerFormulaCalculationStartMutation, } 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';
 export { RemoveSuperTableMutation, SetSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';
 export type { ISetSuperTableMutationParam, ISetSuperTableMutationSearchParam } from './commands/mutations/set-super-table.mutation';
 export { CalculateController } from './controller/calculate.controller';
-export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, type IUniverEngineFormulaConfig } from './controller/config.schema';
+export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, ENGINE_FORMULA_RETURN_DEPENDENCY_TREE, type IUniverEngineFormulaConfig } from './controller/config.schema';
 export { Lexer } from './engine/analysis/lexer';
 export { LexerNode } from './engine/analysis/lexer-node';
 export { LexerTreeBuilder } from './engine/analysis/lexer-tree-builder';
@@ -56,7 +57,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, FormulaDependencyTreeModel, type IFormulaDependencyTree, type IFormulaDependencyTreeFullJson, type IFormulaDependencyTreeJson } from './engine/dependency/dependency-tree';
+export { FormulaDependencyTree, FormulaDependencyTreeModel, type IFormulaDependencyTree, type IFormulaDependencyTreeFullJson, type IFormulaDependencyTreeJson, type IFormulaDependentsAndInRangeResults } 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';
@@ -71,7 +72,7 @@ export { generateAstNode } from './engine/utils/generate-ast-node';
 export { strip, stripErrorMargin } from './engine/utils/math-kit';
 export { handleNumfmtInCell } from './engine/utils/numfmt-kit';
 export { deserializeRangeForR1C1 } from './engine/utils/r1c1-reference';
-export { deserializeRangeWithSheet, getAbsoluteRefTypeWithSingleString, getAbsoluteRefTypeWitString, getRangeWithRefsString, type IAbsoluteRefTypeForRange, isReferenceStrings, isReferenceStringWithEffectiveColumn, needsQuoting, quoteSheetName, serializeRange, serializeRangeToRefString, serializeRangeWithSheet, serializeRangeWithSpreadsheet, singleReferenceToGrid, unquoteSheetName, } from './engine/utils/reference';
+export { deserializeRangeWithSheet, getAbsoluteRefTypeWithSingleString, getAbsoluteRefTypeWitString, getRangeWithRefsString, type IAbsoluteRefTypeForRange, isReferenceStrings, isReferenceStringWithEffectiveColumn, needsQuoting, quoteSheetName, serializeRange, serializeRangeToRefString, serializeRangeWithSheet, serializeRangeWithSpreadsheet, singleReferenceToGrid, splitTableStructuredRef, unquoteSheetName, } from './engine/utils/reference';
 export { handleRefStringInfo } from './engine/utils/reference';
 export { deserializeRangeWithSheetWithCache } from './engine/utils/reference-cache';
 export { generateStringWithSequence, type ISequenceNode, sequenceNodeType } from './engine/utils/sequence';
@@ -129,11 +130,14 @@ export { DependencyManagerService } from './services/dependency-manager.service'
 export { DependencyManagerBaseService } from './services/dependency-manager.service';
 export { FeatureCalculationManagerService, IFeatureCalculationManagerService } from './services/feature-calculation-manager.service';
 export type { IFeatureCalculationManagerParam } from './services/feature-calculation-manager.service';
+export type { IFormulaInfo, IOtherFormulaResult } from './services/formula-common';
+export { FormulaResultStatus } from './services/formula-common';
 export { FunctionService } from './services/function.service';
 export { IFunctionService } from './services/function.service';
 export { GlobalComputingStatusService } from './services/global-computing-status.service';
 export { HyperlinkEngineFormulaService, IHyperlinkEngineFormulaService } from './services/hyperlink-engine-formula.service';
 export { IOtherFormulaManagerService, OtherFormulaManagerService } from './services/other-formula-manager.service';
+export { OtherFormulaBizType, RegisterOtherFormulaService } from './services/register-other-formula.service';
 export { FormulaExecutedStateType, FormulaExecuteStageType, FormulaRuntimeService, type IAllRuntimeData, type IExecutionInProgressParams, IFormulaRuntimeService } from './services/runtime.service';
 export { ISheetRowFilteredService, SheetRowFilteredService } from './services/sheet-row-filtered.service';
 export { ISuperTableService } from './services/super-table.service';

package/lib/types/services/active-dirty-manager.service.d.ts

@@ -3,6 +3,7 @@ import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefined
 export interface IDirtyConversionManagerParams {
     commandId: string;
     getDirtyData: (command: ICommandInfo) => {
+        forceCalculation?: boolean;
         dirtyRanges?: IUnitRange[];
         dirtyNameMap?: IDirtyUnitSheetNameMap;
         dirtyDefinedNameMap?: IDirtyUnitSheetDefinedNameMap;

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

@@ -1,7 +1,7 @@
 import { IUnitRange, Disposable, IConfigService } from '@univerjs/core';
 import { Observable, Subject } from 'rxjs';
 import { IFeatureDirtyRangeType, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeUnitDataType, IUnitRowData } from '../basics/common';
-import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson } from '../engine/dependency/dependency-tree';
+import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaDependentsAndInRangeResults } from '../engine/dependency/dependency-tree';
 import { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IAllRuntimeData, IExecutionInProgressParams, IFormulaRuntimeService } from './runtime.service';
 import { Lexer } from '../engine/analysis/lexer';
@@ -25,6 +25,7 @@ export interface ICalculateFormulaService {
     getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number, rowData?: IUnitRowData): Promise<IFormulaDependencyTreeFullJson | undefined>;
     getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
     getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getDependentsAndInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependentsAndInRangeResults>;
 }
 export declare const ICalculateFormulaService: import('@wendellhu/redi').IdentifierDecorator<ICalculateFormulaService>;
 export declare class CalculateFormulaService extends Disposable implements ICalculateFormulaService {
@@ -40,6 +41,7 @@ export declare class CalculateFormulaService extends Disposable implements ICalc
     protected readonly _executionCompleteListener$: Subject<IAllRuntimeData>;
     readonly executionCompleteListener$: Observable<IAllRuntimeData>;
     private _executeLock;
+    protected _isCalculateTreeModel: boolean;
     constructor(_configService: IConfigService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: IFormulaDependencyGenerator, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder);
     dispose(): void;
     /**
@@ -65,4 +67,5 @@ export declare class CalculateFormulaService extends Disposable implements ICalc
     getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
     getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
     getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getDependentsAndInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependentsAndInRangeResults>;
 }

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

@@ -11,6 +11,7 @@ export interface IFormulaDirtyData {
     dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
     clearDependencyTreeCache: IDirtyUnitSheetNameMap;
     maxIteration?: number;
+    isCalculateTreeModel?: boolean;
     rowData?: IUnitRowData;
 }
 export interface IFormulaCurrentConfigService {

package/lib/types/services/defined-names.service.d.ts

@@ -64,6 +64,7 @@ export declare class DefinedNamesService extends Disposable implements IDefinedN
     getValueById(unitId: string, id: string): IDefinedNamesServiceParam;
     hasDefinedName(unitId: string): boolean;
     getAllDefinedNames(): IDefinedNameMap;
+    getDefinedNameByRefString(unitId: string, formulaOrRefString: string): IDefinedNamesServiceParam | undefined;
     private _update;
     private _updateCache;
 }

package/lib/types/services/dependency-manager.service.d.ts

@@ -26,6 +26,7 @@ export interface IDependencyManagerService {
     getTreeById(treeId: number): Nullable<IFormulaDependencyTree>;
     getAllTree(): IFormulaDependencyTree[];
     buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
+    updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
 }
 export declare class DependencyManagerBaseService extends Disposable implements IDependencyManagerService {
     buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
@@ -62,6 +63,7 @@ export declare class DependencyManagerBaseService extends Disposable implements
     protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
     protected _addDefinedName(unitId: string, definedName: string, treeId: number): void;
     addFormulaDependencyByDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>): void;
+    updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
 }
 /**
  * Passively marked as dirty, register the reference and execution actions of the feature plugin.
@@ -111,5 +113,6 @@ export declare class DependencyManagerService extends DependencyManagerBaseServi
     removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
     protected _removeAllTreeMap(treeId: Nullable<number>): void;
     protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
+    updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
 }
 export declare const IDependencyManagerService: import('@wendellhu/redi').IdentifierDecorator<DependencyManagerService>;

package/lib/types/services/formula-common.d.ts

@@ -0,0 +1,18 @@
+import { ICellData, IObjectMatrixPrimitiveType, Nullable } from '@univerjs/core';
+export declare enum FormulaResultStatus {
+    NOT_REGISTER = 1,
+    SUCCESS = 2,
+    WAIT = 3,
+    ERROR = 4
+}
+export interface IOtherFormulaResult {
+    result?: IObjectMatrixPrimitiveType<Nullable<ICellData>[][]>;
+    status: FormulaResultStatus;
+    formulaId: string;
+    callbacks: Set<(value: IObjectMatrixPrimitiveType<Nullable<ICellData>[][]>) => void>;
+    extra?: Record<string, any>;
+}
+export interface IFormulaInfo {
+    id: string;
+    text: string;
+}