@univerjs/engine-formula 0.12.4-experimental.20251208-c4b8a44 → 0.12.4-experimental.20251210-d708bff

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

@@ -1,4 +1,4 @@
-import { IExecutionOptions, IMutation, Nullable } from '@univerjs/core';
+import { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
 import { IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
 import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson } from '../../engine/dependency/dependency-tree';
 import { IFormulaDirtyData } from '../../services/current-data.service';
@@ -27,6 +27,13 @@ export interface ISetFormulaDependencyCalculationResultMutation {
 export interface ISetCellFormulaDependencyCalculationResultMutation {
     result: IFormulaDependencyTreeFullJson | undefined;
 }
+export interface ISetQueryFormulaDependencyMutation {
+    unitRanges: IUnitRange[];
+    isInRange?: boolean;
+}
+export interface ISetQueryFormulaDependencyResultMutation {
+    result: IFormulaDependencyTreeJson[];
+}
 /**
  * TODO: @DR-Univer
  * Trigger the calculation of the formula and stop the formula
@@ -51,3 +58,5 @@ export declare const SetFormulaDependencyCalculationMutation: IMutation<{}>;
 export declare const SetFormulaDependencyCalculationResultMutation: IMutation<ISetFormulaDependencyCalculationResultMutation>;
 export declare const SetCellFormulaDependencyCalculationMutation: IMutation<ISetFormulaDependencyCalculationMutation>;
 export declare const SetCellFormulaDependencyCalculationResultMutation: IMutation<ISetCellFormulaDependencyCalculationResultMutation>;
+export declare const SetQueryFormulaDependencyMutation: IMutation<ISetQueryFormulaDependencyMutation>;
+export declare const SetQueryFormulaDependencyResultMutation: IMutation<ISetQueryFormulaDependencyResultMutation>;

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

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

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

@@ -18,6 +18,8 @@ export interface IFormulaDependencyGenerator {
     generate(): Promise<IFormulaDependencyTree[]>;
     getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
     getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }
 export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
@@ -124,5 +126,8 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected _endFormulaDependencyTreeModel(): void;
     protected _startFormulaDependencyTreeModel(): void;
     getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    protected _setRealFormulaString(treeModel: FormulaDependencyTreeModel): void;
     getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }

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

@@ -1,5 +1,5 @@
-import { IDisposable, ICommandService, IConfigService, Injector } from '@univerjs/core';
-import { FormulaExecutedStateType, IExecutionInProgressParams, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, LexerTreeBuilder } from '@univerjs/engine-formula';
+import { IDisposable, IUnitRange, ICommandService, IConfigService, Injector } from '@univerjs/core';
+import { FormulaExecutedStateType, IExecutionInProgressParams, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaExecuteResultMap, IFormulaStringMap, ISequenceNode, ISetFormulaCalculationResultMutation, LexerTreeBuilder } from '@univerjs/engine-formula';
 import { FBase } from '@univerjs/core/facade';
 /**
  * This interface class provides methods to modify the behavior of the operation formula.
@@ -146,6 +146,59 @@ export declare class FFormula extends FBase {
      * ```
      */
     setMaxIteration(maxIteration: number): void;
+    /**
+     * Listens for the moment when formula-calculation results are applied.
+     *
+     * This event fires after the engine completes a calculation cycle and
+     * dispatches a `SetFormulaCalculationResultMutation`.
+     * The callback is invoked during an idle frame to avoid blocking UI updates.
+     *
+     * @param {Function} callback - A function called with the calculation result payload
+     * once the result-application mutation is emitted.
+     * @returns {IDisposable} A disposable used to unsubscribe from the event.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * const dispose = formulaEngine.calculationResultApplied((result) => {
+     *   console.log('Calculation results applied:', result);
+     * });
+     *
+     * // Later…
+     * dispose.dispose();
+     * ```
+     */
+    calculationResultApplied(callback: (result: ISetFormulaCalculationResultMutation) => void): IDisposable;
+    /**
+     * Waits for formula-calculation results to be applied.
+     *
+     * This method resolves under three conditions:
+     * 1. A real calculation runs and the engine emits a "calculation started" signal,
+     *    followed by a "calculation result applied" signal.
+     * 2. No calculation actually starts within 500 ms — the method assumes there is
+     *    nothing to wait for and resolves automatically.
+     * 3. A global 30 s timeout triggers, in which case the promise rejects.
+     *
+     * The API internally listens to both “calculation in progress” events and
+     * “calculation result applied” events, ensuring it behaves correctly whether
+     * formulas are recalculated or skipped due to cache/state.
+     *
+     * @returns {Promise<void>} A promise that resolves when calculation results are applied
+     * or when no calculation occurs within the start-detection window.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Wait for formula updates to apply before reading values.
+     * await formulaEngine.onCalculationResultApplied();
+     *
+     * const value = sheet.getRange("C24").getValue();
+     * console.log("Updated value:", value);
+     * ```
+     */
+    onCalculationResultApplied(): Promise<void>;
     /**
      * Execute a batch of formulas asynchronously and receive computed results.
      *
@@ -173,11 +226,13 @@ export declare class FFormula extends FBase {
      *        Nested structure (unit → sheet → row → column) describing formulas and
      *        their decomposed sub-expressions.
      *
-     * @param {(result: IFormulaExecuteResultMap) => void} callback
-     *        Receives the computed value map mirroring the input structure.
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If no result is received within this
+     *        period, the promise will be rejected.
      *
-     * @returns {IDisposable}
-     *          A disposer to stop listening for batch results.
+     * @returns {Promise<IFormulaExecuteResultMap>}
+     *          A promise that resolves with the computed value map mirroring
+     *          the input structure.
      *
      * @example
      * ```ts
@@ -209,34 +264,33 @@ export declare class FFormula extends FBase {
      *   },
      * };
      *
-     * const disposer = formulaEngine.executeFormulas(formulas, (result) => {
-     *   console.log(result);
-     * });
-     *
+     * const result = await formulaEngine.executeFormulas(formulas);
+     * console.log(result);
      * ```
      */
-    executeFormulas(formulas: IFormulaStringMap, callback: (result: IFormulaExecuteResultMap) => void): void;
+    executeFormulas(formulas: IFormulaStringMap, timeout?: number): Promise<IFormulaExecuteResultMap>;
     /**
      * Retrieve all formula dependency trees that were produced during the latest
      * dependency-analysis run. This triggers a local dependency-calculation command
      * and returns the complete set of dependency trees once the calculation finishes.
      *
-     * @param callback A function invoked with the resulting array of dependency trees.
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If no result is received within this
+     *        period, the promise will be rejected.
      *
-     * @returns {IDisposable} An object that disposes the internal event listener.
+     * @returns {Promise<IFormulaDependencyTreeJson[]>}
+     *          A promise that resolves with the array of dependency trees.
      *
      * @example
      * ```ts
      * const formulaEngine = univerAPI.getFormula();
      *
      * // Fetch all dependency trees generated for the current workbook.
-     * const disposable = formulaEngine.getAllDependencyTrees((trees) => {
-     *     console.log('All dependency trees:', trees);
-     * });
-     *
+     * const trees = await formulaEngine.getAllDependencyTrees();
+     * console.log('All dependency trees:', trees);
      * ```
      */
-    getAllDependencyTrees(callback: (result: IFormulaDependencyTreeJson[]) => void): void;
+    getAllDependencyTrees(timeout?: number): Promise<IFormulaDependencyTreeJson[]>;
     /**
      * Retrieve the dependency tree of a specific cell. This triggers a local
      * dependency-calculation command for the given unit, sheet, and cell location,
@@ -248,23 +302,27 @@ export declare class FFormula extends FBase {
      *   - `row`     The zero-based row index.
      *   - `column`  The zero-based column index.
      *
-     * @param callback A function invoked with the resulting dependency tree or
-     * `undefined` if no dependency tree exists for that cell.
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If no result is received within this
+     *        period, the promise will be rejected.
      *
-     * @returns {IDisposable} An object that disposes the internal event listener.
+     * @returns {Promise<IFormulaDependencyTreeFullJson | undefined>}
+     *          A promise that resolves with the dependency tree or `undefined`
+     *          if no tree exists for that cell.
      *
      * @example
      * ```ts
      * const formulaEngine = univerAPI.getFormula();
      *
      * // Query the dependency tree for cell B2 in a specific sheet.
-     * const disposable = formulaEngine.getCellDependencyTree(
-     *     { unitId: 'workbook1', sheetId: 'sheet1', row: 1, column: 1 },
-     *     (tree) => {
-     *         console.log('Cell dependency tree:', tree);
-     *     }
-     * );
+     * const tree = await formulaEngine.getCellDependencyTree({
+     *   unitId: 'workbook1',
+     *   sheetId: 'sheet1',
+     *   row: 1,
+     *   column: 1,
+     * });
      *
+     * console.log('Cell dependency tree:', tree);
      * ```
      */
     getCellDependencyTree(param: {
@@ -272,5 +330,73 @@ export declare class FFormula extends FBase {
         sheetId: string;
         row: number;
         column: number;
-    }, callback: (result: IFormulaDependencyTreeFullJson | undefined) => void): void;
+    }, timeout?: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    /**
+     * Retrieve the full dependency trees for all formulas that *depend on* the
+     * specified ranges. This triggers a local dependency-calculation command and
+     * resolves once the calculation completes.
+     *
+     * @param unitRanges An array of workbook/sheet ranges to query. Each range
+     *   includes:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `range`   The row/column boundaries.
+     *
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If no result is received within this
+     *        period, the promise will be rejected.
+     *
+     * @returns {Promise<IFormulaDependencyTreeJson[]>}
+     *          A promise that resolves with an array of `IFormulaDependencyTreeJson`
+     *          representing formulas and their relationships within the dependency graph.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Query all formulas that depend on A1:B10 in Sheet1.
+     * const dependents = await formulaEngine.getRangeDependents([
+     *   { unitId: 'workbook1', sheetId: 'sheet1', range: { startRow: 0, endRow: 9, startColumn: 0, endColumn: 1 } }
+     * ]);
+     *
+     * console.log('Dependent formulas:', dependents);
+     * ```
+     */
+    getRangeDependents(unitRanges: IUnitRange[], timeout?: number): Promise<IFormulaDependencyTreeJson[]>;
+    /**
+     * Retrieve the dependency trees of all formulas *inside* the specified ranges.
+     * Unlike `getRangeDependents`, this API only returns formulas whose definitions
+     * physically reside within the queried ranges.
+     *
+     * Internally this triggers the same dependency-calculation command but with
+     * `isInRange = true`, and the promise resolves when the results are ready.
+     *
+     * @param unitRanges An array of workbook/sheet ranges defining the lookup
+     *   boundaries:
+     *   - `unitId`  The workbook ID.
+     *   - `sheetId` The sheet ID.
+     *   - `range`   The zero-based grid range.
+     *
+     * @param {number} [timeout]
+     *        Optional timeout in milliseconds. If no result is received within this
+     *        period, the promise will be rejected.
+     *
+     * @returns {Promise<IFormulaDependencyTreeJson[]>}
+     *          A promise that resolves with an array of `IFormulaDependencyTreeJson`
+     *          describing every formula found in the provided ranges along with
+     *          their parent/child relationships.
+     *
+     * @example
+     * ```ts
+     * const formulaEngine = univerAPI.getFormula();
+     *
+     * // Query all formulas that lie within A1:D20 in Sheet1.
+     * const formulasInRange = await formulaEngine.getInRangeFormulas([
+     *   { unitId: 'workbook1', sheetId: 'sheet1', range: { startRow: 0, endRow: 19, startColumn: 0, endColumn: 3 } }
+     * ]);
+     *
+     * console.log('Formulas inside range:', formulasInRange);
+     * ```
+     */
+    getInRangeFormulas(unitRanges: IUnitRange[], timeout?: number): Promise<IFormulaDependencyTreeJson[]>;
 }

package/lib/types/index.d.ts

@@ -33,7 +33,7 @@ export { type ISetArrayFormulaDataMutationParams, SetArrayFormulaDataMutation }
 export { type ISetDefinedNameMutationParam, type ISetDefinedNameMutationSearchParam, RemoveDefinedNameMutation, SetDefinedNameMutation } from './commands/mutations/set-defined-name.mutation';
 export { SetDefinedNameMutationFactory } from './commands/mutations/set-defined-name.mutation';
 export { RemoveFeatureCalculationMutation, SetFeatureCalculationMutation } from './commands/mutations/set-feature-calculation.mutation';
-export { type ISetCellFormulaDependencyCalculationResultMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaDependencyCalculationMutation, type ISetFormulaDependencyCalculationResultMutation, type ISetFormulaStringBatchCalculationResultMutation, SetCellFormulaDependencyCalculationMutation, SetCellFormulaDependencyCalculationResultMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaDependencyCalculationMutation, SetFormulaDependencyCalculationResultMutation, SetFormulaStringBatchCalculationMutation, SetFormulaStringBatchCalculationResultMutation, } from './commands/mutations/set-formula-calculation.mutation';
+export { type ISetCellFormulaDependencyCalculationResultMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaDependencyCalculationMutation, type ISetFormulaDependencyCalculationResultMutation, type ISetFormulaStringBatchCalculationResultMutation, type ISetQueryFormulaDependencyResultMutation, SetCellFormulaDependencyCalculationMutation, SetCellFormulaDependencyCalculationResultMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaDependencyCalculationMutation, SetFormulaDependencyCalculationResultMutation, SetFormulaStringBatchCalculationMutation, SetFormulaStringBatchCalculationResultMutation, SetQueryFormulaDependencyMutation, SetQueryFormulaDependencyResultMutation, } from './commands/mutations/set-formula-calculation.mutation';
 export { type ISetFormulaDataMutationParams, SetFormulaDataMutation } from './commands/mutations/set-formula-data.mutation';
 export { type ISetImageFormulaDataMutationParams, SetImageFormulaDataMutation } from './commands/mutations/set-image-formula-data.mutation';
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';

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

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

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

@@ -1,5 +1,5 @@
 import { IUnitRange, LocaleType, Nullable, Disposable, IUniverInstanceService, LocaleService } from '@univerjs/core';
-import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetIdToNameMap, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
+import { IArrayFormulaRangeType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetIdToNameMap, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 import { FormulaDataModel } from '../models/formula-data.model';
 import { ISheetRowFilteredService } from './sheet-row-filtered.service';
 export interface IFormulaDirtyData {
@@ -55,7 +55,7 @@ export interface IFormulaCurrentConfigService {
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
     setSheetNameMap(sheetIdToNameMap: IUnitSheetIdToNameMap): void;
-    loadDataLite(formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, rowData?: IUnitRowData): void;
+    loadDataLite(rowData?: IUnitRowData): void;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _univerInstanceService;
@@ -114,7 +114,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
     load(config: IFormulaDatasetConfig): void;
-    loadDataLite(formulaData: IFormulaData, arrayFormulaCellData: IArrayFormulaUnitCellType, arrayFormulaRange: IArrayFormulaRangeType, rowData?: IUnitRowData): void;
+    loadDataLite(rowData?: IUnitRowData): void;
     getDirtyData(): IFormulaDirtyData;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;

package/lib/umd/facade.js

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