fix: generateDependencyTrees

Author: Dushusir

packages/engine-formula/src/engine/dependency/formula-dependency.ts

@@ -58,6 +58,8 @@ export interface IFormulaDependencyGenerator {
     generate(): Promise<IFormulaDependencyTree[]>;
 }
 
+export type { IFormulaDependencyTree };
+
 export const IFormulaDependencyGenerator = createIdentifier<IFormulaDependencyGenerator>('engine-formula.dependency-generator');
 
 export class FormulaDependencyGenerator extends Disposable {

packages/engine-formula/src/services/calculate-formula.service.ts

@@ -23,9 +23,10 @@ import type {
     IRuntimeUnitDataType,
     IUnitExcludedCell,
 } from '../basics/common';
-
 import type { IUniverEngineFormulaConfig } from '../controller/config.schema';
+
 import type { LexerNode } from '../engine/analysis/lexer-node';
+import type { IFormulaDependencyTree } from '../engine/dependency/formula-dependency';
 import type { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import type { IAllRuntimeData, IExecutionInProgressParams } from './runtime.service';
 import {
@@ -64,6 +65,7 @@ export interface ICalculateFormulaService {
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
     setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
+    generateDependencyTrees(formulaDatasetConfig: IFormulaDatasetConfig): Promise<IFormulaDependencyTree[]>;
     stopFormulaExecution(): void;
     calculate(formulaString: string, transformSuffix?: boolean): void;
 }
@@ -363,6 +365,37 @@ export class CalculateFormulaService extends Disposable implements ICalculateFor
         return this._runtimeService.getAllRuntimeData();
     }
 
+    async generateDependencyTrees(formulaDatasetConfig: IFormulaDatasetConfig): Promise<IFormulaDependencyTree[]> {
+        this._currentConfigService.load(formulaDatasetConfig);
+
+        this._runtimeService.reset();
+
+        const normalTrees = await this._generateTrees(false);
+
+        const executeState = this._runtimeService.getAllRuntimeData();
+
+        const { dirtyRanges, excludedCell } = this._getArrayFormulaDirtyRangeAndExcludedRange(
+            executeState.arrayFormulaRange,
+            executeState.runtimeFeatureRange
+        );
+
+        let arrayTrees: IFormulaDependencyTree[] = [];
+
+        if (dirtyRanges && dirtyRanges.length > 0) {
+            this._currentConfigService.loadDirtyRangesAndExcludedCell(dirtyRanges, excludedCell);
+
+            arrayTrees = await this._generateTrees(true);
+        }
+
+        return [...normalTrees, ...arrayTrees];
+    }
+
+    private async _generateTrees(isArrayFormulaState: boolean): Promise<IFormulaDependencyTree[]> {
+        const treeList = (await this._formulaDependencyGenerator.generate()).reverse();
+
+        return treeList;
+    }
+
     calculate(formulaString: string, transformSuffix: boolean = true) {
         // TODO how to observe @alex
         // this.getObserver('onBeforeFormulaCalculateObservable')?.notifyObservers(formulaString);

packages/engine-formula/src/services/current-data.service.ts

@@ -65,8 +65,6 @@ export interface IFormulaCurrentConfigService {
 
     isForceCalculate(): boolean;
 
-    setForceCalculate(forceCalculate: boolean): void;
-
     getDirtyRanges(): IUnitRange[];
 
     getDirtyNameMap(): IDirtyUnitSheetNameMap;
@@ -224,10 +222,6 @@ export class FormulaCurrentConfigService extends Disposable implements IFormulaC
         return this._forceCalculate;
     }
 
-    setForceCalculate(forceCalculate: boolean) {
-        this._forceCalculate = forceCalculate;
-    }
-
     getDirtyRanges() {
         return this._dirtyRanges;
     }

packages/sheets-formula/src/services/remote/remote-formula-dependency-generator.service.ts

@@ -15,9 +15,8 @@
  */
 
 import type { IUnitRange } from '@univerjs/core';
-import type { FormulaCurrentConfigService } from '@univerjs/engine-formula';
-import { createIdentifier, isFormulaId, isFormulaString } from '@univerjs/core';
-import { IFormulaCurrentConfigService, IFormulaDependencyGenerator } from '@univerjs/engine-formula';
+import { createIdentifier, Inject, isFormulaId, isFormulaString } from '@univerjs/core';
+import { FormulaDataModel, ICalculateFormulaService, IFormulaCurrentConfigService } from '@univerjs/engine-formula';
 
 export interface IFormulaCellAndFeatureItem {
     unitId: string;
@@ -41,43 +40,46 @@ export const IRemoteFormulaDependencyGenerator = createIdentifier<IRemoteFormula
  */
 export class RemoteFormulaDependencyGeneratorService implements IRemoteFormulaDependencyGenerator {
     constructor(
-        @IFormulaDependencyGenerator private readonly _dependencyGenerator: IFormulaDependencyGenerator,
+        @ICalculateFormulaService private readonly _calculateFormulaService: ICalculateFormulaService,
+        @Inject(FormulaDataModel) private readonly _formulaDataModel: FormulaDataModel,
         @IFormulaCurrentConfigService private readonly _currentConfigService: IFormulaCurrentConfigService
     ) {}
 
     async generate(range?: IUnitRange): Promise<Array<IFormulaCellAndFeatureItem>> {
-        const configService = this._currentConfigService as FormulaCurrentConfigService;
-        const originalForceCalculate = configService.isForceCalculate();
-        configService.setForceCalculate(true);
-        const trees = await this._dependencyGenerator.generate();
-        configService.setForceCalculate(originalForceCalculate);
+        const formulaData = this._formulaDataModel.getFormulaData();
+        const arrayFormulaCellData = this._formulaDataModel.getArrayFormulaCellData();
+        const arrayFormulaRange = this._formulaDataModel.getArrayFormulaRange();
+
+        const formulaDatasetConfig = {
+            formulaData,
+            arrayFormulaCellData,
+            arrayFormulaRange,
+            forceCalculate: false,
+            dirtyRanges: range ? [range] : [],
+            dirtyNameMap: {},
+            dirtyDefinedNameMap: {},
+            dirtyUnitFeatureMap: {},
+            dirtyUnitOtherFormulaMap: {},
+            clearDependencyTreeCache: {},
+            maxIteration: 1,
+            rowData: undefined,
+        };
+
+        const trees = await this._calculateFormulaService.generateDependencyTrees(formulaDatasetConfig);
+
         const result: Array<IFormulaCellAndFeatureItem> = [];
         for (let i = 0; i < trees.length; i++) {
             const tree = trees[i];
             if ((isFormulaString(tree.formula) || isFormulaId(tree.formulaId)) || tree.featureId != null) {
-                let include = true;
-                if (range) {
-                    if (tree.unitId !== range.unitId || tree.subUnitId !== range.sheetId) {
-                        include = false;
-                    } else if (tree.row != null && tree.column != null) {
-                        const r = range.range;
-                        if (tree.row < r.startRow || tree.row > r.endRow || tree.column < r.startColumn || tree.column > r.endColumn) {
-                            include = false;
-                        }
-                    }
-                    // For features without row/column, include if unitId and subUnitId match
-                }
-                if (include) {
-                    result.push({
-                        unitId: tree.unitId,
-                        subUnitId: tree.subUnitId,
-                        row: tree.row,
-                        column: tree.column,
-                        featureId: tree.featureId || undefined,
-                        formula: tree.formula || undefined,
-                        formulaId: tree.formulaId || undefined,
-                    });
-                }
+                result.push({
+                    unitId: tree.unitId,
+                    subUnitId: tree.subUnitId,
+                    row: tree.row,
+                    column: tree.column,
+                    featureId: tree.featureId || undefined,
+                    formula: tree.formula || undefined,
+                    formulaId: tree.formulaId || undefined,
+                });
             }
         }
         return result;