@univerjs/engine-formula 0.4.2 → 0.5.0-alpha.0

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

@@ -49,7 +49,7 @@ export interface IRuntimeUnitDataPrimitiveType {
 export interface IRuntimeOtherUnitDataType {
     [unitId: string]: Nullable<{
         [sheetId: string]: Nullable<{
-            [formulaId: string]: Nullable<ICellData>[][];
+            [formulaId: string]: IObjectMatrixPrimitiveType<Nullable<ICellData>[][]>;
         }>;
     }>;
 }
@@ -107,7 +107,7 @@ export interface IFormulaData {
 export interface IOtherFormulaData {
     [unitId: string]: Nullable<{
         [subUnitId: string]: Nullable<{
-            [formulaId: string]: IFormulaDataItem;
+            [formulaId: string]: IOtherFormulaDataItem;
         }>;
     }>;
 }
@@ -121,6 +121,10 @@ export interface IFormulaDataItem {
     y?: number;
     si?: string;
 }
+export interface IOtherFormulaDataItem {
+    f: string;
+    ranges: IRange[];
+}
 export interface ISuperTable {
     sheetId: string;
     hasCustomTitle: BooleanNumber;

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

@@ -1,18 +1,4 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+import { BaseValueObject } from '../engine/value-object/base-value-object';
 /**
  * covert number to preview string by pattern
  * @TODODushusir: Internationalization, reuse with numfmt
@@ -22,3 +8,4 @@
  * @returns
  */
 export declare const getFormatPreview: (pattern: string, value: number) => string;
+export declare const getTextValueOfNumberFormat: (text: BaseValueObject) => string;

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

@@ -19,6 +19,9 @@ export declare function calculateGcd(a: number, b: number): number;
 export declare function calculateLcm(a: number, b: number): number;
 export declare function calculateMdeterm(matrix: number[][]): number;
 export declare function calculateMinverse(matrix: number[][]): number[][] | null;
+export declare function calculateMmult(matrix1: number[][], matrix2: number[][]): number[][];
+export declare function matrixTranspose(matrix: number[][]): number[][];
+export declare function inverseMatrixByUSV(matrix: number[][]): number[][] | null;
 export declare const romanToArabicMap: Map<string, number>;
 export declare const arabicToRomanMap: Map<number, string>;
 /**

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

@@ -7,16 +7,32 @@ export declare function binomialPDF(x: number, trials: number, probability: numb
 export declare function chisquareCDF(x: number, degFreedom: number): number;
 export declare function chisquarePDF(x: number, degFreedom: number): number;
 export declare function chisquareINV(probability: number, degFreedom: number): number;
-export declare function studentTINV(probability: number, degFreedom: number): number;
-export declare function exponentialCDF(x: number, lambda: number): number;
-export declare function exponentialPDF(x: number, lambda: number): number;
 export declare function centralFCDF(x: number, degFreedom1: number, degFreedom2: number): number;
 export declare function centralFPDF(x: number, degFreedom1: number, degFreedom2: number): number;
 export declare function centralFINV(probability: number, degFreedom1: number, degFreedom2: number): number;
+export declare function exponentialCDF(x: number, lambda: number): number;
+export declare function exponentialPDF(x: number, lambda: number): number;
 export declare function forecastLinear(x: number, knownYs: number[], knownXs: number[]): number;
+export declare function gamma(x: number): number;
+export declare function gammaCDF(x: number, alpha: number, beta: number): number;
+export declare function gammaPDF(x: number, alpha: number, beta: number): number;
+export declare function gammaINV(probability: number, alpha: number, beta: number): number;
+export declare function gammaln(x: number): number;
+export declare function hypergeometricCDF(x: number, n: number, M: number, N: number): number;
+export declare function hypergeometricPDF(x: number, n: number, M: number, N: number): number;
+export declare function lognormalCDF(x: number, mean: number, standardDev: number): number;
+export declare function lognormalPDF(x: number, mean: number, standardDev: number): number;
+export declare function lognormalINV(probability: number, mean: number, standardDev: number): number;
+export declare function negbinomialCDF(numberF: number, numberS: number, probabilityS: number): number;
+export declare function negbinomialPDF(numberF: number, numberS: number, probabilityS: number): number;
 export declare function normalCDF(x: number, mean: number, standardDev: number): number;
 export declare function normalPDF(x: number, mean: number, standardDev: number): number;
 export declare function normalINV(probability: number, mean: number, standardDev: number): number;
+export declare function poissonCDF(x: number, mean: number): number;
+export declare function poissonPDF(x: number, mean: number): number;
+export declare function studentTCDF(x: number, degFreedom: number): number;
+export declare function studentTPDF(x: number, degFreedom: number): number;
+export declare function studentTINV(probability: number, degFreedom: number): number;
 export declare function getTwoArrayNumberValues(array1: BaseValueObject, array2: BaseValueObject, count: number, array1ColumnCount: number, array2ColumnCount: number): {
     isError: boolean;
     errorObject: ErrorValueObject;

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

@@ -1,9 +1,9 @@
 import { IMutation } from '@univerjs/core';
-import { IFormulaDataItem } from '../../basics/common';
+import { IOtherFormulaDataItem } from '../../basics/common';
 export interface ISetOtherFormulaMutationParams {
     unitId: string;
     subUnitId: string;
-    formulaMap: Record<string, IFormulaDataItem>;
+    formulaMap: Record<string, IOtherFormulaDataItem>;
 }
 export interface IRemoveOtherFormulaMutationParams {
     unitId: string;

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

@@ -1,11 +1,11 @@
 import { Disposable, ICommandService } from '@univerjs/core';
 import { FormulaDataModel } from '../models/formula-data.model';
-import { CalculateFormulaService } from '../services/calculate-formula.service';
+import { ICalculateFormulaService } from '../services/calculate-formula.service';
 export declare class CalculateController extends Disposable {
     private readonly _commandService;
     private readonly _calculateFormulaService;
     private readonly _formulaDataModel;
-    constructor(_commandService: ICommandService, _calculateFormulaService: CalculateFormulaService, _formulaDataModel: FormulaDataModel);
+    constructor(_commandService: ICommandService, _calculateFormulaService: ICalculateFormulaService, _formulaDataModel: FormulaDataModel);
     private _initialize;
     private _commandExecutedListener;
     private _calculate;

package/lib/types/engine/analysis/parser.d.ts

@@ -25,8 +25,6 @@ export declare class AstTreeBuilder extends Disposable {
     private readonly _unionNodeFactory;
     private readonly _valueNodeFactory;
     private _astNodeFactoryList;
-    private _refOffsetX;
-    private _refOffsetY;
     constructor(_runtimeService: IFormulaRuntimeService, _astRootNodeFactory: AstRootNodeFactory, _functionNodeFactory: FunctionNodeFactory, _lambdaNodeFactory: LambdaNodeFactory, _lambdaParameterNodeFactory: LambdaParameterNodeFactory, _operatorNodeFactory: OperatorNodeFactory, _prefixNodeFactory: PrefixNodeFactory, _referenceNodeFactory: ReferenceNodeFactory, _suffixNodeFactory: SuffixNodeFactory, _unionNodeFactory: UnionNodeFactory, _valueNodeFactory: ValueNodeFactory);
     dispose(): void;
     parse(lexerNode: LexerNode): Nullable<BaseAstNode>;

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

@@ -44,6 +44,7 @@ export declare class BaseAstNode {
     serialize(): IAstNodeNodeJson;
     hasDefinedName(definedName: string): boolean;
     setDefinedNames(definedNames: Array<string>): void;
+    getDefinedNames(): Nullable<string[]>;
 }
 export declare class ErrorNode extends BaseAstNode {
     private _errorValueObject;

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

@@ -2,6 +2,7 @@ import { BaseFunction } from '../../functions/base-function';
 import { LexerNode } from '../analysis/lexer-node';
 import { Injector } from '@univerjs/core';
 import { AstNodePromiseType } from '../../basics/common';
+import { FormulaDataModel } from '../../models/formula-data.model';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDefinedNamesService } from '../../services/defined-names.service';
 import { IFunctionService } from '../../services/function.service';
@@ -14,7 +15,8 @@ export declare class FunctionNode extends BaseAstNode {
     private _currentConfigService;
     private _runtimeService;
     private _definedNamesService;
-    constructor(token: string, _functionExecutor: BaseFunction, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService);
+    private _formulaDataModel;
+    constructor(token: string, _functionExecutor: BaseFunction, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService, _formulaDataModel: FormulaDataModel);
     get nodeType(): NodeType;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
@@ -49,7 +51,8 @@ export declare class FunctionNodeFactory extends BaseAstNodeFactory {
     private readonly _runtimeService;
     private readonly _definedNamesService;
     private readonly _injector;
-    constructor(_functionService: IFunctionService, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService, _injector: Injector);
+    private readonly _formulaDataModel;
+    constructor(_functionService: IFunctionService, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService, _injector: Injector, _formulaDataModel: FormulaDataModel);
     get zIndex(): number;
     create(token: string): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

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

@@ -5,9 +5,8 @@ import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class OperatorNode extends BaseAstNode {
-    private _operatorString;
     private _functionExecutor;
-    constructor(_operatorString: string, _functionExecutor: BaseFunction);
+    constructor(operatorString: string, _functionExecutor: BaseFunction);
     get nodeType(): NodeType;
     execute(): void;
 }

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

@@ -1,23 +1,24 @@
-import { IAccessor, Nullable, Injector } from '@univerjs/core';
+import { Nullable } from '@univerjs/core';
 import { BaseFunction } from '../../functions/base-function';
 import { IFunctionService } from '../../services/function.service';
+import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode, ErrorNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class PrefixNode extends BaseAstNode {
-    private _accessor;
+    private _runtimeService;
     private _operatorString;
     private _functionExecutor?;
-    constructor(_accessor: IAccessor, _operatorString: string, _functionExecutor?: Nullable<BaseFunction>);
+    constructor(_runtimeService: IFormulaRuntimeService, _operatorString: string, _functionExecutor?: Nullable<BaseFunction>);
     get nodeType(): NodeType;
     execute(): void;
     private _handlerAT;
 }
 export declare class PrefixNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
-    private readonly _injector;
-    constructor(_functionService: IFunctionService, _injector: Injector);
+    private readonly _runtimeService;
+    constructor(_functionService: IFunctionService, _runtimeService: IFormulaRuntimeService);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ErrorNode | PrefixNode | undefined;
 }

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

@@ -1,20 +1,19 @@
-import { IAccessor, Injector } from '@univerjs/core';
-import { BaseReferenceObject } from '../reference-object/base-reference-object';
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
-import { ISuperTableService } from '../../services/super-table.service';
 import { LexerNode } from '../analysis/lexer-node';
+import { ReferenceObjectType } from '../utils/value-object';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class ReferenceNode extends BaseAstNode {
-    private _accessor;
-    private _operatorString;
-    private _referenceObject;
+    private _currentConfigService;
+    private _runtimeService;
+    private _referenceObjectType;
     private _isPrepareMerge;
     private _refOffsetX;
     private _refOffsetY;
-    constructor(_accessor: IAccessor, _operatorString: string, _referenceObject: BaseReferenceObject, _isPrepareMerge?: boolean);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, operatorString: string, _referenceObjectType: ReferenceObjectType, _isPrepareMerge?: boolean);
     get nodeType(): NodeType;
     execute(): void;
     setRefOffset(x?: number, y?: number): void;
@@ -24,11 +23,10 @@ export declare class ReferenceNode extends BaseAstNode {
     };
 }
 export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
-    private readonly _superTableService;
+    private readonly _currentConfigService;
     private readonly _formulaRuntimeService;
     private readonly _functionService;
-    private readonly _injector;
-    constructor(_superTableService: ISuperTableService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService, _injector: Injector);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ReferenceNode | undefined;
     private _checkParentIsUnionOperator;

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

@@ -1,23 +1,26 @@
-import { IAccessor, Injector } from '@univerjs/core';
 import { BaseFunction } from '../../functions/base-function';
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
+import { Lexer } from '../analysis/lexer';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode, ErrorNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class SuffixNode extends BaseAstNode {
-    private _accessor;
+    private _currentConfigService;
+    private _lexer;
     private _operatorString;
     private _functionExecutor?;
-    constructor(_accessor: IAccessor, _operatorString: string, _functionExecutor?: BaseFunction | undefined);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _lexer: Lexer, _operatorString: string, _functionExecutor?: BaseFunction | undefined);
     get nodeType(): NodeType;
     execute(): void;
     private _handlerPound;
 }
 export declare class SuffixNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
-    private readonly _injector;
-    constructor(_functionService: IFunctionService, _injector: Injector);
+    private readonly _lexer;
+    private readonly _currentConfigService;
+    constructor(_functionService: IFunctionService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ErrorNode | SuffixNode | undefined;
 }

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

@@ -4,8 +4,7 @@ import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class UnionNode extends BaseAstNode {
-    private _operatorString;
-    constructor(_operatorString: string);
+    constructor(operatorString: string);
     get nodeType(): NodeType;
     execute(): void;
     private _unionFunction;

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

@@ -3,8 +3,7 @@ import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class ValueNode extends BaseAstNode {
-    private _operatorString;
-    constructor(_operatorString: string);
+    constructor(operatorString: string);
     get nodeType(): NodeType;
     execute(): void;
 }

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

@@ -1,69 +1,116 @@
-import { IRange, IRTreeItem, IUnitRange, Nullable } from '@univerjs/core';
 import { IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IRuntimeUnitDataType, IUnitExcludedCell } from '../../basics/common';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { IAllRuntimeData } from '../../services/runtime.service';
-import { IExecuteAstNodeData } from '../utils/ast-node-tool';
+import { AstRootNode } from '../ast-node';
+import { IRange, IUnitRange, Nullable } from '@univerjs/core';
 export declare enum FDtreeStateType {
     DEFAULT = 0,
     ADDED = 1,
     SKIP = 2
 }
+export declare enum FormulaDependencyTreeType {
+    NORMAL_FORMULA = 0,
+    OTHER_FORMULA = 1,
+    FEATURE_FORMULA = 2
+}
+declare class FormulaDependencyTreeCalculator {
+    private _state;
+    resetState(): void;
+    setAdded(): void;
+    isAdded(): boolean;
+    setSkip(): void;
+    isSkip(): boolean;
+    treeId: number;
+    children: Set<number>;
+    parents: Set<number>;
+    pushChildren(tree: FormulaDependencyTreeCalculator): void;
+    hasChildren(treeId: number): boolean;
+    private _pushParent;
+}
+type GetDirtyDataType = Nullable<(dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
+    runtimeCellData: IRuntimeUnitDataType;
+    dirtyRanges: IFeatureDirtyRangeType;
+}>;
+export type IFormulaDependencyTree = FormulaDependencyTree | FormulaDependencyTreeVirtual;
+export declare class FormulaDependencyTreeVirtual extends FormulaDependencyTreeCalculator {
+    refTree: Nullable<FormulaDependencyTree>;
+    refOffsetX: number;
+    refOffsetY: number;
+    isCache: boolean;
+    isDirty: boolean;
+    get isVirtual(): boolean;
+    get row(): number;
+    get column(): number;
+    get rowCount(): number;
+    get columnCount(): number;
+    get unitId(): string;
+    get subUnitId(): string;
+    get formula(): string;
+    get nodeData(): {
+        node: Nullable<AstRootNode>;
+        refOffsetX: number;
+        refOffsetY: number;
+    };
+    get node(): Nullable<AstRootNode>;
+    dispose(): void;
+    get rangeList(): {
+        unitId: string;
+        sheetId: string;
+        range: IRange;
+    }[];
+    toRTreeItem(): IUnitRange[];
+    inRangeData(range: IRange): boolean;
+    dependencySheetName(dirtyUnitSheetNameMap?: IDirtyUnitSheetNameMap): boolean;
+    isExcludeRange(unitExcludedCell: Nullable<IUnitExcludedCell>): boolean;
+    getDirtyData: GetDirtyDataType;
+    featureId: Nullable<string>;
+    get formulaId(): Nullable<string>;
+}
 /**
  * A dependency tree, capable of calculating mutual dependencies,
  * is used to determine the order of formula calculations.
  */
-export declare class FormulaDependencyTree {
-    treeId: number;
-    nodeData: Nullable<IExecuteAstNodeData>;
-    children: Set<number>;
-    parents: Set<number>;
+export declare class FormulaDependencyTree extends FormulaDependencyTreeCalculator {
+    isCache: boolean;
+    featureId: Nullable<string>;
+    featureDirtyRanges: IUnitRange[];
+    refOffsetX: number;
+    refOffsetY: number;
+    type: FormulaDependencyTreeType;
+    formulaId: Nullable<string>;
+    subUnitId: string;
+    unitId: string;
+    rangeList: IUnitRange[];
     formula: string;
     row: number;
     column: number;
     rowCount: number;
     columnCount: number;
-    subUnitId: string;
-    unitId: string;
-    rangeList: IUnitRange[];
-    formulaId: Nullable<string>;
-    featureId: Nullable<string>;
-    isCache: boolean;
+    isDirty: boolean;
+    node: Nullable<AstRootNode>;
     constructor(treeId: number);
+    get isVirtual(): boolean;
+    get nodeData(): {
+        node: Nullable<AstRootNode>;
+        refOffsetX: number;
+        refOffsetY: number;
+    };
     toJson(): {
         formula: string;
-        row: number;
-        column: number;
-        subUnitId: string;
-        unitId: string;
-        formulaId: Nullable<string>;
-        featureId: Nullable<string>;
+        refOffsetX: number;
+        refOffsetY: number;
     };
-    getDirtyData: Nullable<(dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
-        runtimeCellData: IRuntimeUnitDataType;
-        dirtyRanges: IFeatureDirtyRangeType;
-    }>;
-    private _state;
+    getDirtyData: GetDirtyDataType;
     dispose(): void;
-    resetState(): void;
-    setAdded(): void;
-    isAdded(): boolean;
-    setSkip(): void;
-    isSkip(): boolean;
     inRangeData(range: IRange): boolean;
     dependencySheetName(dirtyUnitSheetNameMap?: IDirtyUnitSheetNameMap): boolean;
     isExcludeRange(unitExcludedCell: Nullable<IUnitExcludedCell>): boolean;
-    pushChildren(tree: FormulaDependencyTree): void;
     /**
      * Add the range corresponding to the current ast node.
      * @param range
      */
     pushRangeList(ranges: IUnitRange[]): void;
-    hasChildren(treeId: number): boolean;
-    toRTreeItem(): IRTreeItem;
-    /**
-     * Determine whether it is dependent on other trees.
-     * @param dependenceTree
-     */
-    dependency(dependenceTree: FormulaDependencyTree): boolean;
-    private _pushParent;
+    shouldBePushRangeList(): boolean;
+    toRTreeItem(): IUnitRange[];
 }
+export {};

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

@@ -1,44 +1,65 @@
-import { Disposable } from '@univerjs/core';
+import { IRange, IUnitRange, Nullable, Disposable } from '@univerjs/core';
+import { IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IOtherFormulaData, IUnitData } from '../../basics/common';
+import { IFeatureCalculationManagerParam, IFeatureCalculationManagerService } from '../../services/feature-calculation-manager.service';
+import { BaseAstNode } from '../ast-node/base-ast-node';
+import { IExecuteAstNodeData } from '../utils/ast-node-tool';
+import { IFormulaDependencyTree, FormulaDependencyTree, FormulaDependencyTreeVirtual } from './dependency-tree';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDependencyManagerService } from '../../services/dependency-manager.service';
-import { IFeatureCalculationManagerService } from '../../services/feature-calculation-manager.service';
 import { IOtherFormulaManagerService } from '../../services/other-formula-manager.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { Lexer } from '../analysis/lexer';
 import { AstTreeBuilder } from '../analysis/parser';
 import { Interpreter } from '../interpreter/interpreter';
-import { FormulaDependencyTree } from './dependency-tree';
+export declare function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): number;
+export interface IFormulaDependencyGenerator {
+    generate(): Promise<IFormulaDependencyTree[]>;
+}
+export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
-    private readonly _currentConfigService;
-    private readonly _runtimeService;
-    private readonly _otherFormulaManagerService;
+    protected readonly _currentConfigService: IFormulaCurrentConfigService;
+    protected readonly _runtimeService: IFormulaRuntimeService;
+    protected readonly _otherFormulaManagerService: IOtherFormulaManagerService;
     private readonly _featureCalculationManagerService;
     private readonly _interpreter;
-    private readonly _astTreeBuilder;
-    private readonly _lexer;
-    private readonly _dependencyManagerService;
-    private _formulaASTCache;
+    protected readonly _astTreeBuilder: AstTreeBuilder;
+    protected readonly _lexer: Lexer;
+    protected readonly _dependencyManagerService: IDependencyManagerService;
     private _updateRangeFlattenCache;
     constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService);
     dispose(): void;
-    generate(): Promise<FormulaDependencyTree[]>;
+    generate(): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
+    private _dependencyFeatureCalculation;
+    private _clearFeatureCalculationNode;
+    /**
+     * TODO @DR-Univer: The next step will be to try changing the incoming dirtyRanges to an array, thus avoiding conversion.
+     * @param dirtyRanges
+     * @returns
+     */
+    protected _convertDirtyRangesToUnitRange(dirtyRanges: IFeatureDirtyRangeType): IUnitRange[];
+    private _intersectFeatureCalculation;
+    private _getExistTreeList;
     private _isCyclicUtil;
-    private _checkIsCycleDependency;
+    protected _checkIsCycleDependency(treeList: IFormulaDependencyTree[]): boolean;
     /**
      * Generate nodes for the dependency tree, where each node contains all the reference data ranges included in each formula.
      * @param formulaData
      */
-    private _generateTreeList;
-    private _moveRangeList;
-    private _registerFeatureFormulas;
-    private _getFeatureFormulaTree;
-    private _registerOtherFormulas;
-    private _registerFormulas;
+    protected _generateTreeList(formulaData: IFormulaData, otherFormulaData: IOtherFormulaData, unitData: IUnitData): Promise<IFormulaDependencyTree[]>;
+    protected _registerFeatureFormulas(treeList: FormulaDependencyTree[]): void;
+    protected _getFeatureFormulaTree(featureId: string, treeId: Nullable<number>, params: IFeatureCalculationManagerParam): FormulaDependencyTree;
+    protected _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: IFormulaDependencyTree[]): void;
+    protected _getFirstCellOfRange(ranges: IRange[]): {
+        firstRow: number;
+        firstColumn: number;
+    };
+    protected _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: IFormulaDependencyTree[]): void;
+    protected _createFDtree(unitId: string, sheetId: string, row: number, column: number, unitData: IUnitData, formulaDataItem: IFormulaDataItem): FormulaDependencyTree;
+    protected _createVirtualFDtree(tree: FormulaDependencyTree, formulaDataItem: IFormulaDataItem): FormulaDependencyTreeVirtual;
     /**
      * Break down the dirty areas into ranges for subsequent matching.
      */
-    private _updateRangeFlatten;
-    private _generateAstNode;
+    protected _updateRangeFlatten(): void;
     private _addFlattenCache;
     private _isPreCalculateNode;
     private _nodeTraversalRef;
@@ -49,26 +70,14 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * including references and location functions (such as OFFSET, INDIRECT, INDEX, etc.).
      * @param node
      */
-    private _getRangeListByNode;
-    private _isDirtyDefinedForNode;
+    protected _getRangeListByNode(nodeData: IExecuteAstNodeData): Promise<IUnitRange[]>;
     /**
      * Build a formula dependency tree based on the dependency relationships.
      * @param treeList
      */
-    private _getUpdateTreeListAndMakeDependency;
-    private _dependencyFeatureCalculation;
-    private _clearFeatureCalculationNode;
-    private _getExistTreeList;
-    /**
-     * TODO @DR-Univer: The next step will be to try changing the incoming dirtyRanges to an array, thus avoiding conversion.
-     * @param dirtyRanges
-     * @returns
-     */
-    private _convertDirtyRangesToUnitRange;
-    private _intersectFeatureCalculation;
+    protected _getUpdateTreeListAndMakeDependency(treeList: IFormulaDependencyTree[]): IFormulaDependencyTree[];
     private _includeTreeFeature;
     private _includeOtherFormula;
-    private _includeDefinedName;
     private _detectForcedRecalculationNode;
     private _detectForcedRecalculationNodeRecursion;
     /**
@@ -76,10 +85,10 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * If they are within the dirty area, return true, indicating that this node needs to be calculated.
      * @param tree
      */
-    private _includeTree;
+    protected _includeTree(tree: IFormulaDependencyTree, node: BaseAstNode): boolean;
     /**
      * Generate the final formula calculation order array by traversing the dependency tree established via depth-first search.
      * @param treeList
      */
-    private _calculateRunList;
+    protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
 }

package/lib/types/engine/interpreter/interpreter.d.ts

@@ -1,16 +1,16 @@
+import { Nullable, Disposable } from '@univerjs/core';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { FunctionVariantType } from '../reference-object/base-reference-object';
 import { IExecuteAstNodeData } from '../utils/ast-node-tool';
 import { PreCalculateNodeType } from '../utils/node-type';
-import { Disposable } from '@univerjs/core';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 export declare class Interpreter extends Disposable {
     private readonly _runtimeService;
     constructor(_runtimeService: IFormulaRuntimeService);
     executeAsync(nodeData: IExecuteAstNodeData): Promise<FunctionVariantType>;
     execute(nodeData: IExecuteAstNodeData): FunctionVariantType;
-    executePreCalculateNode(node: PreCalculateNodeType): import('@univerjs/core').Nullable<FunctionVariantType>;
-    checkAsyncNode(node: BaseAstNode): boolean;
+    executePreCalculateNode(node: PreCalculateNodeType): Nullable<FunctionVariantType>;
+    checkAsyncNode(node: Nullable<BaseAstNode>): boolean;
     private _checkAsyncNode;
     private _executeAsync;
     private _execute;

package/lib/types/engine/utils/array-object.d.ts

@@ -1,4 +1,4 @@
-import { ArrayValueObject } from '../value-object/array-value-object';
 import { BaseValueObject } from '../value-object/base-value-object';
+import { ArrayValueObject } from '../value-object/array-value-object';
 export declare function expandArrayValueObject(rowCount: number, columnCount: number, valueObject: BaseValueObject, defaultValue?: BaseValueObject): ArrayValueObject;
 export declare function createNewArray(result: BaseValueObject[][], rowCount: number, columnCount: number, unitId?: string, sheetId?: string): ArrayValueObject;

package/lib/types/engine/utils/ast-node-tool.d.ts

@@ -1,7 +1,7 @@
 import { Nullable } from '@univerjs/core';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 export interface IExecuteAstNodeData {
-    node: BaseAstNode;
+    node: Nullable<BaseAstNode>;
     refOffsetX: number;
     refOffsetY: number;
 }