@univerjs/engine-formula 0.13.0-insiders.20251216-1519cb7 → 0.13.0-insiders.20251218-2062647

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

@@ -217,5 +217,6 @@ export declare enum ConcatenateType {
 export interface IExprTreeNode {
     value: string;
     children: IExprTreeNode[];
+    startIndex: number;
     type?: sequenceNodeType;
 }

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,6 +10,7 @@ export declare class CalculateController extends Disposable {
     private _commandExecutedListener;
     private _calculate;
     private _queryFormulaDependencyJson;
+    private _queryFormulaDependencyAllJson;
     private _generateAllDependencyTreeJson;
     private _generateCellDependencyTreeJson;
     private _calculateFormulaString;

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

@@ -138,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>;

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';
@@ -20,6 +20,7 @@ export interface IFormulaDependencyGenerator {
     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 {
@@ -129,6 +130,9 @@ export declare class FormulaDependencyGenerator extends Disposable {
     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/facade/f-formula.d.ts

@@ -1,5 +1,5 @@
 import { IDisposable, IUnitRange, ICommandService, IConfigService, Injector } from '@univerjs/core';
-import { FormulaExecutedStateType, IExecutionInProgressParams, IExprTreeNode, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, ISetFormulaCalculationResultMutation, IDefinedNamesService, IFunctionService, ISuperTableService, 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.
@@ -515,4 +515,50 @@ export declare class FFormula extends FBase {
      * @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

@@ -28,12 +28,13 @@ 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';
@@ -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';
@@ -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 {
@@ -66,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/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;
+}

package/lib/types/services/register-other-formula.service.d.ts

@@ -0,0 +1,40 @@
+import { IRange, Nullable, Disposable, ICommandService, LifecycleService } from '@univerjs/core';
+import { IOtherFormulaResult } from './formula-common';
+import { BehaviorSubject } from 'rxjs';
+import { IActiveDirtyManagerService } from './active-dirty-manager.service';
+export declare enum OtherFormulaBizType {
+    DEFAULT = "default",
+    DATA_VALIDATION = "dv",
+    DATA_VALIDATION_CUSTOM = "dv-custom",
+    CONDITIONAL_FORMATTING = "cf",
+    DOC = "doc",
+    SLIDE = "slide"
+}
+export declare class RegisterOtherFormulaService extends Disposable {
+    private readonly _commandService;
+    private _activeDirtyManagerService;
+    private readonly _lifecycleService;
+    private _formulaCacheMap;
+    private _formulaChangeWithRange$;
+    formulaChangeWithRange$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+        formulaText: string;
+        formulaId: string;
+        ranges: IRange[];
+    }>;
+    private _formulaResult$;
+    formulaResult$: import('rxjs').Observable<Record<string, Record<string, IOtherFormulaResult[]>>>;
+    calculateStarted$: BehaviorSubject<boolean>;
+    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService, _lifecycleService: LifecycleService);
+    dispose(): void;
+    private _ensureCacheMap;
+    private _createFormulaId;
+    private _initFormulaRegister;
+    private _initFormulaCalculationResultChange;
+    registerFormulaWithRange(unitId: string, subUnitId: string, formulaText: string, ranges?: IRange[], extra?: Record<string, any>, bizType?: OtherFormulaBizType, bizId?: string): string;
+    deleteFormula(unitId: string, subUnitId: string, formulaIdList: string[]): void;
+    getFormulaValue(unitId: string, subUnitId: string, formulaId: string): Promise<Nullable<IOtherFormulaResult>>;
+    getFormulaValueSync(unitId: string, subUnitId: string, formulaId: string): Nullable<IOtherFormulaResult>;
+    markFormulaDirty(unitId: string, subUnitId: string, formulaId: string): void;
+}

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

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

package/lib/umd/facade.js

@@ -1 +1 @@
-(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"})}));
+(function(c,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):(c=typeof globalThis<"u"?globalThis:c||self,l(c.UniverEngineFormulaFacade={},c.UniverCoreFacade,c.UniverCore,c.UniverEngineFormula,c.rxjs))})(this,(function(c,l,m,n,f){"use strict";var v=Object.getOwnPropertyDescriptor,C=(p,e,i,t)=>{for(var r=t>1?void 0:t?v(e,i):e,o=p.length-1,s;o>=0;o--)(s=p[o])&&(r=s(r)||r);return r},d=(p,e)=>(i,t)=>e(i,t,p);c.FFormula=class extends l.FBase{constructor(e,i,t,r,o,s,a){super(),this._commandService=e,this._injector=i,this._lexerTreeBuilder=t,this._configService=r,this._functionService=o,this._definedNamesService=s,this._superTableService=a,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.SetTriggerFormulaCalculationStartMutation.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):f.firstValueFrom(f.race(i.computingStatus$.pipe(f.filter(t=>t)),f.timer(e!=null?e:3e4).pipe(f.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(()=>{S(),i(new Error("Calculation end timeout"))},3e4),s=setTimeout(()=>{t||(S(),e())},500),a=this.calculationProcessing(()=>{t||(t=!0,clearTimeout(s))}),u=this.calculationResultApplied(()=>{r||(r=!0,S(),e())});function S(){clearTimeout(o),clearTimeout(s),a.dispose(),u.dispose()}})}executeFormulas(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(a=>{if(a.id!==n.SetFormulaStringBatchCalculationResultMutation.id)return;const u=a.params;clearTimeout(s),o.dispose(),u.result!=null?t(u.result):r(new Error("Formula batch calculation returned no result"))}),s=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(s=>{if(s.id!==n.SetFormulaDependencyCalculationResultMutation.id)return;const a=s.params;clearTimeout(o),r.dispose(),a.result!=null?i(a.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(a=>{if(a.id!==n.SetCellFormulaDependencyCalculationResultMutation.id)return;const u=a.params;clearTimeout(s),o.dispose(),t(u.result)}),s=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(a=>{if(a.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const u=a.params;clearTimeout(s),o.dispose(),u.result!=null?t(u.result):t([])}),s=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(a=>{if(a.id!==n.SetQueryFormulaDependencyResultMutation.id)return;const u=a.params;clearTimeout(s),o.dispose(),u.result!=null?t(u.result):t([])}),s=setTimeout(()=>{o.dispose(),r(new Error("In-range formulas calculation timeout"))},i);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,i){return this._lexerTreeBuilder.getFormulaExprTree(e,i,this._functionService.hasExecutor.bind(this._functionService),this._definedNamesService.getValueByName.bind(this._definedNamesService),this._superTableService.getTable.bind(this._superTableService))}getRangeDependentsAndInRangeFormulas(e,i=3e4){return new Promise((t,r)=>{const o=this._commandService.onCommandExecuted(a=>{if(a.id!==n.SetQueryFormulaDependencyAllResultMutation.id)return;const u=a.params;clearTimeout(s),o.dispose(),u.result!=null?t(u.result):t({dependents:[],inRanges:[]})}),s=setTimeout(()=>{o.dispose(),r(new Error("Range dependents calculation timeout"))},i);this._commandService.executeCommand(n.SetQueryFormulaDependencyAllMutation.id,{unitRanges:e},{onlyLocal:!0})})}},c.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)],c.FFormula);class h extends l.FUniver{getFormula(){return this._injector.createInstance(c.FFormula)}}l.FUniver.extend(h),Object.defineProperty(c,Symbol.toStringTag,{value:"Module"})}));