@univerjs/engine-formula 0.12.4-insiders.20251213-692494c → 0.13.0-insiders.20251215-64041bb

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,15 @@ 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[];
+    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/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/formula-dependency.d.ts

@@ -15,7 +15,7 @@ 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[]>;
@@ -36,7 +36,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;
     /**
@@ -125,6 +125,7 @@ export declare class FormulaDependencyGenerator extends Disposable {
     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>;

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, 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,117 @@ 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;
 }

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';
@@ -40,7 +40,7 @@ export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationPa
 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';
@@ -71,7 +71,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';

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

@@ -40,6 +40,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;
     /**

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/runtime.service.d.ts

@@ -1,6 +1,7 @@
 import { Nullable, Disposable } from '@univerjs/core';
 import { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IFeatureDirtyRangeType, IRuntimeImageFormulaDataType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
 import { BaseAstNode } from '../engine/ast-node/base-ast-node';
+import { IFormulaDependencyTreeJson } from '../engine/dependency/dependency-tree';
 import { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IFormulaCurrentConfigService } from './current-data.service';
 import { IHyperlinkEngineFormulaService } from './hyperlink-engine-formula.service';
@@ -40,6 +41,7 @@ export interface IAllRuntimeData {
     runtimeFeatureCellData: {
         [featureId: string]: IRuntimeUnitDataType;
     };
+    dependencyTreeModelData: IFormulaDependencyTreeJson[];
 }
 export interface IExecutionInProgressParams {
     totalFormulasToCalculate: number;
@@ -100,6 +102,8 @@ export interface IFormulaRuntimeService {
     setUnitArrayFormulaEmbeddedMap(): void;
     clearArrayObjectCache(): void;
     getRuntimeImageFormulaData(): IRuntimeImageFormulaDataType[];
+    setDependencyTreeModelData(data: IFormulaDependencyTreeJson[]): void;
+    getDependencyTreeModelData(): IFormulaDependencyTreeJson[];
 }
 export declare class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {
     private readonly _currentConfigService;
@@ -129,6 +133,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _completedArrayFormulasCount;
     private _formulaCycleIndex;
     private _isCycleDependency;
+    private _dependencyTreeModelData;
     constructor(_currentConfigService: IFormulaCurrentConfigService, _hyperlinkEngineFormulaService: IHyperlinkEngineFormulaService);
     get currentRow(): number;
     get currentColumn(): number;
@@ -182,6 +187,8 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
         [featureId: string]: IRuntimeUnitDataType;
     };
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    setDependencyTreeModelData(data: IFormulaDependencyTreeJson[]): void;
+    getDependencyTreeModelData(): IFormulaDependencyTreeJson[];
     getRuntimeImageFormulaData(): IRuntimeImageFormulaDataType[];
     getAllRuntimeData(): IAllRuntimeData;
     getRuntimeState(): IExecutionInProgressParams;

package/lib/types/services/super-table.service.d.ts

@@ -12,6 +12,7 @@ export interface ISuperTableService {
     registerTableOptionMap(tableOption: string, tableOptionType: TableOptionType): void;
     remove(unitId: string, tableName: string): void;
     update$: Observable<unknown>;
+    getTable(unitId: string, tableName: string): Nullable<ISuperTable>;
 }
 export declare class SuperTableService extends Disposable implements ISuperTableService {
     private _tableMap;
@@ -25,6 +26,7 @@ export declare class SuperTableService extends Disposable implements ISuperTable
     getTableOptionMap(): Map<string, TableOptionType>;
     registerTable(unitId: string, tableName: string, reference: ISuperTable): void;
     registerTableOptionMap(tableOption: string, tableOptionType: TableOptionType): void;
+    getTable(unitId: string, tableName: string): Nullable<ISuperTable>;
     private _update;
 }
 export declare const ISuperTableService: import('@wendellhu/redi').IdentifierDecorator<ISuperTableService>;

package/lib/umd/facade.js

@@ -1 +1 @@
-(function(s,l){typeof exports=="object"&&typeof module<"u"?l(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"],l):(s=typeof globalThis<"u"?globalThis:s||self,l(s.UniverEngineFormulaFacade={},s.UniverCoreFacade,s.UniverCore,s.UniverEngineFormula,s.rxjs))})(this,(function(s,l,d,n,p){"use strict";var S=Object.getOwnPropertyDescriptor,v=(m,e,i,t)=>{for(var r=t>1?void 0:t?S(e,i):e,o=m.length-1,a;o>=0;o--)(a=m[o])&&(r=a(r)||r);return r},f=(m,e)=>(i,t)=>e(i,t,m);s.FFormula=class extends l.FBase{constructor(e,i,t,r){super(),this._commandService=e,this._injector=i,this._lexerTreeBuilder=t,this._configService=r,this._initialize()}_initialize(){}get lexerTreeBuilder(){return this._lexerTreeBuilder}moveFormulaRefOffset(e,i,t,r){return this._lexerTreeBuilder.moveFormulaRefOffset(e,i,t,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(i=>{if(i.id===n.SetFormulaCalculationStartMutation.id){const t=i.params;e(t.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==n.SetFormulaCalculationNotificationMutation.id)return;const t=i.params;t.functionsExecutedState!==void 0&&e(t.functionsExecutedState)})}whenComputingCompleteAsync(e){const i=this._injector.get(n.GlobalComputingStatusService);return i.computingStatus?Promise.resolve(!0):p.firstValueFrom(p.race(i.computingStatus$.pipe(p.filter(t=>t)),p.timer(e!=null?e:3e4).pipe(p.map(()=>!1))))}onCalculationEnd(){return new Promise((e,i)=>{const t=setTimeout(()=>{i(new Error("Calculation end timeout"))},3e4),r=this.calculationEnd(()=>{clearTimeout(t),r.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==n.SetFormulaCalculationNotificationMutation.id)return;const t=i.params;t.stageInfo!==void 0&&e(t.stageInfo)})}setMaxIteration(e){this._configService.setConfig(n.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}calculationResultApplied(e){return this._commandService.onCommandExecuted(i=>{if(i.id!==n.SetFormulaCalculationResultMutation.id)return;const t=i.params;t!==void 0&&requestIdleCallback(()=>{e(t)})})}onCalculationResultApplied(){return new Promise((e,i)=>{let t=!1,r=!1;const o=setTimeout(()=>{C(),i(new Error("Calculation end timeout"))},3e4),a=setTimeout(()=>{t||(C(),e())},500),u=this.calculationProcessing(()=>{t||(t=!0,clearTimeout(a))}),c=this.calculationResultApplied(()=>{r||(r=!0,C(),e())});function C(){clearTimeout(o),clearTimeout(a),u.dispose(),c.dispose()}})}executeFormulas(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(u=>{if(u.id!==n.SetFormulaStringBatchCalculationResultMutation.id)return;const c=u.params;clearTimeout(a),o.dispose(),c.result!=null?t(c.result):r(new Error("Formula batch calculation returned no result"))}),a=setTimeout(()=>{o.dispose(),r(new Error("Formula batch calculation timeout"))},i);this._commandService.executeCommand(n.SetFormulaStringBatchCalculationMutation.id,{formulas:e},{onlyLocal:!0})})}getAllDependencyTrees(e=3e4){return new Promise((i,t)=>{const r=this._commandService.onCommandExecuted(a=>{if(a.id!==n.SetFormulaDependencyCalculationResultMutation.id)return;const u=a.params;clearTimeout(o),r.dispose(),u.result!=null?i(u.result):i([])}),o=setTimeout(()=>{r.dispose(),t(new Error("Formula dependency calculation timeout"))},e);this._commandService.executeCommand(n.SetFormulaDependencyCalculationMutation.id,void 0,{onlyLocal:!0})})}getCellDependencyTree(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(u=>{if(u.id!==n.SetCellFormulaDependencyCalculationResultMutation.id)return;const c=u.params;clearTimeout(a),o.dispose(),t(c.result)}),a=setTimeout(()=>{o.dispose(),r(new Error("Cell dependency calculation timeout"))},i);this._commandService.executeCommand(n.SetCellFormulaDependencyCalculationMutation.id,e,{onlyLocal:!0})})}getRangeDependents(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(u=>{if(u.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const c=u.params;clearTimeout(a),o.dispose(),c.result!=null?t(c.result):t([])}),a=setTimeout(()=>{o.dispose(),r(new Error("Range dependents calculation timeout"))},i);this._commandService.executeCommand(n.SetQueryFormulaDependencyMutation.id,{unitRanges:e},{onlyLocal:!0})})}getInRangeFormulas(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(u=>{if(u.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const c=u.params;clearTimeout(a),o.dispose(),c.result!=null?t(c.result):t([])}),a=setTimeout(()=>{o.dispose(),r(new Error("In-range formulas calculation timeout"))},i);this._commandService.executeCommand(n.SetQueryFormulaDependencyMutation.id,{unitRanges:e,isInRange:!0},{onlyLocal:!0})})}},s.FFormula=v([f(0,d.Inject(d.ICommandService)),f(1,d.Inject(d.Injector)),f(2,d.Inject(n.LexerTreeBuilder)),f(3,d.IConfigService)],s.FFormula);class h extends l.FUniver{getFormula(){return this._injector.createInstance(s.FFormula)}}l.FUniver.extend(h),Object.defineProperty(s,Symbol.toStringTag,{value:"Module"})}));
+(function(u,l){typeof exports=="object"&&typeof module<"u"?l(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"],l):(u=typeof globalThis<"u"?globalThis:u||self,l(u.UniverEngineFormulaFacade={},u.UniverCoreFacade,u.UniverCore,u.UniverEngineFormula,u.rxjs))})(this,(function(u,l,m,n,f){"use strict";var v=Object.getOwnPropertyDescriptor,C=(p,e,t,i)=>{for(var r=i>1?void 0:i?v(e,t):e,o=p.length-1,a;o>=0;o--)(a=p[o])&&(r=a(r)||r);return r},d=(p,e)=>(t,i)=>e(t,i,p);u.FFormula=class extends l.FBase{constructor(e,t,i,r,o,a,s){super(),this._commandService=e,this._injector=t,this._lexerTreeBuilder=i,this._configService=r,this._functionService=o,this._definedNamesService=a,this._superTableService=s,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):f.firstValueFrom(f.race(t.computingStatus$.pipe(f.filter(i=>i)),f.timer(e!=null?e:3e4).pipe(f.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)}calculationResultApplied(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==n.SetFormulaCalculationResultMutation.id)return;const i=t.params;i!==void 0&&requestIdleCallback(()=>{e(i)})})}onCalculationResultApplied(){return new Promise((e,t)=>{let i=!1,r=!1;const o=setTimeout(()=>{S(),t(new Error("Calculation end timeout"))},3e4),a=setTimeout(()=>{i||(S(),e())},500),s=this.calculationProcessing(()=>{i||(i=!0,clearTimeout(a))}),c=this.calculationResultApplied(()=>{r||(r=!0,S(),e())});function S(){clearTimeout(o),clearTimeout(a),s.dispose(),c.dispose()}})}executeFormulas(e,t=3e4){return new Promise((i,r)=>{const o=this._commandService.onCommandExecuted(s=>{if(s.id!==n.SetFormulaStringBatchCalculationResultMutation.id)return;const c=s.params;clearTimeout(a),o.dispose(),c.result!=null?i(c.result):r(new Error("Formula batch calculation returned no result"))}),a=setTimeout(()=>{o.dispose(),r(new Error("Formula batch calculation timeout"))},t);this._commandService.executeCommand(n.SetFormulaStringBatchCalculationMutation.id,{formulas:e},{onlyLocal:!0})})}getAllDependencyTrees(e=3e4){return new Promise((t,i)=>{const r=this._commandService.onCommandExecuted(a=>{if(a.id!==n.SetFormulaDependencyCalculationResultMutation.id)return;const s=a.params;clearTimeout(o),r.dispose(),s.result!=null?t(s.result):t([])}),o=setTimeout(()=>{r.dispose(),i(new Error("Formula dependency calculation timeout"))},e);this._commandService.executeCommand(n.SetFormulaDependencyCalculationMutation.id,void 0,{onlyLocal:!0})})}getCellDependencyTree(e,t=3e4){return new Promise((i,r)=>{const o=this._commandService.onCommandExecuted(s=>{if(s.id!==n.SetCellFormulaDependencyCalculationResultMutation.id)return;const c=s.params;clearTimeout(a),o.dispose(),i(c.result)}),a=setTimeout(()=>{o.dispose(),r(new Error("Cell dependency calculation timeout"))},t);this._commandService.executeCommand(n.SetCellFormulaDependencyCalculationMutation.id,e,{onlyLocal:!0})})}getRangeDependents(e,t=3e4){return new Promise((i,r)=>{const o=this._commandService.onCommandExecuted(s=>{if(s.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const c=s.params;clearTimeout(a),o.dispose(),c.result!=null?i(c.result):i([])}),a=setTimeout(()=>{o.dispose(),r(new Error("Range dependents calculation timeout"))},t);this._commandService.executeCommand(n.SetQueryFormulaDependencyMutation.id,{unitRanges:e},{onlyLocal:!0})})}getInRangeFormulas(e,t=3e4){return new Promise((i,r)=>{const o=this._commandService.onCommandExecuted(s=>{if(s.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const c=s.params;clearTimeout(a),o.dispose(),c.result!=null?i(c.result):i([])}),a=setTimeout(()=>{o.dispose(),r(new Error("In-range formulas calculation timeout"))},t);this._commandService.executeCommand(n.SetQueryFormulaDependencyMutation.id,{unitRanges:e,isInRange:!0},{onlyLocal:!0})})}setFormulaReturnDependencyTree(e){this._configService.setConfig(n.ENGINE_FORMULA_RETURN_DEPENDENCY_TREE,e)}getFormulaExpressTree(e,t){return this._lexerTreeBuilder.getFormulaExprTree(e,t,this._functionService.hasExecutor.bind(this._functionService),this._definedNamesService.getValueByName.bind(this._definedNamesService),this._superTableService.getTable.bind(this._superTableService))}},u.FFormula=C([d(0,m.Inject(m.ICommandService)),d(1,m.Inject(m.Injector)),d(2,m.Inject(n.LexerTreeBuilder)),d(3,m.IConfigService),d(4,n.IFunctionService),d(5,n.IDefinedNamesService),d(6,n.ISuperTableService)],u.FFormula);class h extends l.FUniver{getFormula(){return this._injector.createInstance(u.FFormula)}}l.FUniver.extend(h),Object.defineProperty(u,Symbol.toStringTag,{value:"Module"})}));