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

package/lib/types/functions/text/search/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/lib/types/functions/text/search/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Search extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(findText: BaseValueObject, withinText: BaseValueObject, startNum?: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

package/lib/types/functions/text/searchb/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/lib/types/functions/text/searchb/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Searchb extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(findText: BaseValueObject, withinText: BaseValueObject, startNum?: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

package/lib/types/functions/text/t/index.d.ts

@@ -1,5 +1,5 @@
-import { BaseFunction } from '../../base-function';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
 export declare class T extends BaseFunction {
     minParams: number;
     maxParams: number;

package/lib/types/functions/text/textjoin/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/lib/types/functions/text/textjoin/index.d.ts

@@ -0,0 +1,10 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Textjoin extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(delimiter: BaseValueObject, ignoreEmpty: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
+    private _handleSingleObject;
+    private _getDelimiterValues;
+    private _getTextValues;
+}

package/lib/types/functions/text/trim/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/lib/types/functions/text/trim/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Trim extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

package/lib/types/functions/text/upper/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

package/lib/types/functions/text/upper/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Upper extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

package/lib/types/index.d.ts

@@ -49,7 +49,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 { FormulaDependencyGenerator } from './engine/dependency/formula-dependency';
+export { FormulaDependencyGenerator, IFormulaDependencyGenerator } from './engine/dependency/formula-dependency';
 export { Interpreter } from './engine/interpreter/interpreter';
 export { BaseReferenceObject, type FunctionVariantType } from './engine/reference-object/base-reference-object';
 export { AsyncArrayObject, AsyncObject } from './engine/reference-object/base-reference-object';
@@ -103,7 +103,7 @@ export type { IRangeChange } from './models/formula-data.model';
 export { UniverFormulaEnginePlugin } from './plugin';
 export { IActiveDirtyManagerService } from './services/active-dirty-manager.service';
 export { ActiveDirtyManagerService } from './services/active-dirty-manager.service';
-export { CalculateFormulaService } from './services/calculate-formula.service';
+export { CalculateFormulaService, ICalculateFormulaService } from './services/calculate-formula.service';
 export { FormulaCurrentConfigService, IFormulaCurrentConfigService, type IFormulaDirtyData } from './services/current-data.service';
 export { DefinedNamesService, type IDefinedNameMapItem, IDefinedNamesService, type IDefinedNamesServiceParam } from './services/defined-names.service';
 export { IDependencyManagerService } from './services/dependency-manager.service';
@@ -116,3 +116,14 @@ export { FormulaExecutedStateType, FormulaExecuteStageType, FormulaRuntimeServic
 export { ISuperTableService } from './services/super-table.service';
 export { SuperTableService } from './services/super-table.service';
 export { deserializeRangeWithSheetWithCache } from './engine/utils/reference-cache';
+export { FFormula } from './facade/f-formula';
+export { FormulaDependencyTree, type IFormulaDependencyTree } from './engine/dependency/dependency-tree';
+export { type IOtherFormulaData } from './basics/common';
+export { FormulaDependencyTreeType } from './engine/dependency/dependency-tree';
+export { FormulaDependencyTreeVirtual } from './engine/dependency/dependency-tree';
+export { generateAstNode } from './engine/utils/generate-ast-node';
+export { type IFeatureCalculationManagerParam } from './services/feature-calculation-manager.service';
+export { DEFAULT_INTERVAL_COUNT } from './services/calculate-formula.service';
+export { type IUniverEngineFormulaConfig, PLUGIN_CONFIG_KEY } from './controller/config.schema';
+export { generateRandomDependencyTreeId } from './engine/dependency/formula-dependency';
+export { DependencyManagerBaseService } from './services/dependency-manager.service';

package/lib/types/models/formula-data.model.d.ts

@@ -1,4 +1,4 @@
-import { ICellData, IObjectMatrixPrimitiveType, IRange, Nullable, Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
+import { ICellData, IObjectMatrixPrimitiveType, IRange, IUnitRange, Nullable, Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
 import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../basics/common';
 import { IFormulaIdMap } from './utils/formula-data-util';
 import { LexerTreeBuilder } from '../engine/analysis/lexer-tree-builder';
@@ -41,5 +41,10 @@ export declare class FormulaDataModel extends Disposable {
     getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): Nullable<IFormulaDataItem>;
     getFormulaIdMap(unitId: string, sheetId: string): Map<string, IFormulaIdMap>;
     getFormulaStringByCell(row: number, column: number, sheetId: string, unitId: string): string | null;
+    /**
+     * Function to get all formula ranges
+     * @returns
+     */
+    getFormulaDirtyRanges(): IUnitRange[];
 }
 export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<Nullable<ICellData>>): IFormulaData;

package/lib/types/plugin.d.ts

@@ -1,13 +1,14 @@
 import { IUniverEngineFormulaConfig } from './controller/config.schema';
 import { IConfigService, Injector, Plugin } from '@univerjs/core';
 export declare class UniverFormulaEnginePlugin extends Plugin {
-    private readonly _config;
+    protected readonly _config: Partial<IUniverEngineFormulaConfig>;
     protected _injector: Injector;
-    private readonly _configService;
+    protected readonly _configService: IConfigService;
     static pluginName: string;
     constructor(_config: Partial<IUniverEngineFormulaConfig> | undefined, _injector: Injector, _configService: IConfigService);
     onStarting(): void;
     onReady(): void;
     onRendered(): void;
     private _initialize;
+    protected _initializeWithOverride(): void;
 }

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

@@ -1,29 +1,40 @@
+import { Observable, Subject } from 'rxjs';
 import { IFeatureDirtyRangeType, IFormulaDatasetConfig, IRuntimeUnitDataType } from '../basics/common';
 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 { ErrorNode } from '../engine/ast-node/base-ast-node';
-import { FormulaDependencyGenerator } from '../engine/dependency/formula-dependency';
+import { IFormulaDependencyGenerator } from '../engine/dependency/formula-dependency';
 import { Interpreter } from '../engine/interpreter/interpreter';
 import { IFormulaCurrentConfigService } from './current-data.service';
 export declare const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
 export declare const DEFAULT_INTERVAL_COUNT = 500;
 export declare const CYCLE_REFERENCE_COUNT = "cycleReferenceCount";
 export declare const EVERY_N_FUNCTION_EXECUTION_PAUSE = 100;
+export interface ICalculateFormulaService {
+    executionInProgressListener$: Observable<IExecutionInProgressParams>;
+    executionCompleteListener$: Observable<IAllRuntimeData>;
+    setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+    execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
+    stopFormulaExecution(): void;
+    calculate(formulaString: string, transformSuffix?: boolean): void;
+}
+export declare const ICalculateFormulaService: import('@wendellhu/redi').IdentifierDecorator<ICalculateFormulaService>;
 export declare class CalculateFormulaService extends Disposable {
-    private readonly _configService;
-    private readonly _lexer;
-    private readonly _currentConfigService;
-    private readonly _runtimeService;
-    private readonly _formulaDependencyGenerator;
-    private readonly _interpreter;
-    private readonly _astTreeBuilder;
-    private readonly _executionInProgressListener$;
-    readonly executionInProgressListener$: import('rxjs').Observable<IExecutionInProgressParams>;
-    private readonly _executionCompleteListener$;
-    readonly executionCompleteListener$: import('rxjs').Observable<IAllRuntimeData>;
-    constructor(_configService: IConfigService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: FormulaDependencyGenerator, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder);
+    protected readonly _configService: IConfigService;
+    protected readonly _lexer: Lexer;
+    protected readonly _currentConfigService: IFormulaCurrentConfigService;
+    protected readonly _runtimeService: IFormulaRuntimeService;
+    protected readonly _formulaDependencyGenerator: IFormulaDependencyGenerator;
+    protected readonly _interpreter: Interpreter;
+    protected readonly _astTreeBuilder: AstTreeBuilder;
+    protected readonly _executionInProgressListener$: Subject<IExecutionInProgressParams>;
+    readonly executionInProgressListener$: Observable<IExecutionInProgressParams>;
+    protected readonly _executionCompleteListener$: Subject<IAllRuntimeData>;
+    readonly executionCompleteListener$: Observable<IAllRuntimeData>;
+    constructor(_configService: IConfigService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: IFormulaDependencyGenerator, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder);
     /**
      * Stop the execution of the formula.
      */
@@ -40,6 +51,6 @@ export declare class CalculateFormulaService extends Disposable {
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
     private _execute;
     private _getArrayFormulaDirtyRangeAndExcludedRange;
-    private _apply;
+    protected _apply(isArrayFormulaState?: boolean): Promise<IAllRuntimeData | undefined>;
     calculate(formulaString: string, transformSuffix?: boolean): ErrorNode | undefined;
 }

package/lib/types/services/dependency-manager.service.d.ts

@@ -1,50 +1,67 @@
-import { IUnitRange, Nullable, Disposable, ObjectMatrix } from '@univerjs/core';
-import { FormulaDependencyTree } from '../engine/dependency/dependency-tree';
-export interface IOtherFormulaDependencyParam {
-    [unitId: string]: Nullable<{
-        [sheetId: string]: {
-            [formulaId: string]: Nullable<number>;
-        };
-    }>;
-}
-export interface IFeatureFormulaDependencyParam {
-    [unitId: string]: Nullable<{
-        [sheetId: string]: {
-            [featureId: string]: Nullable<number>;
-        };
-    }>;
-}
-export interface IFormulaDependencyParam {
-    [unitId: string]: Nullable<{
-        [sheetId: string]: ObjectMatrix<number>;
-    }>;
-}
+import { IUnitRange, Nullable, Disposable, ObjectMatrix, RTree } from '@univerjs/core';
+import { AstRootNode } from '../engine/ast-node';
+import { FormulaDependencyTree, IFormulaDependencyTree } from '../engine/dependency/dependency-tree';
 export interface IDependencyManagerService {
     dispose(): void;
-    getAllTree(): FormulaDependencyTree[];
-    buildDependencyTree(shouldBeBuildTrees: FormulaDependencyTree[], dependencyTrees?: FormulaDependencyTree[]): FormulaDependencyTree[];
-    clearDependencyForTree(shouldBeClearTree: Nullable<FormulaDependencyTree>): void;
     reset(): void;
-    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
+    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree): void;
+    addOtherFormulaDependencyMainData(formulaId: string): void;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string[]): void;
-    getOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): Nullable<FormulaDependencyTree>;
+    hasOtherFormulaDataMainData(formulaId: string): boolean;
+    clearOtherFormulaDependency(unitId: string, sheetId?: string): void;
+    getOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): Nullable<ObjectMatrix<number>>;
     addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
     removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
-    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): Nullable<FormulaDependencyTree>;
-    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
+    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): Nullable<number>;
+    clearFeatureFormulaDependency(unitId: string, sheetId?: string): void;
+    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: IFormulaDependencyTree): void;
     removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
-    getFormulaDependency(unitId: string, sheetId: string, row: number, column: number): Nullable<FormulaDependencyTree>;
-    removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
+    getFormulaDependency(unitId: string, sheetId: string, row: number, column: number): Nullable<number>;
     clearFormulaDependency(unitId: string, sheetId?: string): void;
-    addDependencyRTreeCache(tree: FormulaDependencyTree): void;
-    searchDependency(search: IUnitRange[]): Set<number>;
+    removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
+    addFormulaDependencyByDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>): void;
+    addDependencyRTreeCache(tree: IFormulaDependencyTree): void;
+    searchDependency(search: IUnitRange[], exceptTreeIds?: Set<number>): Set<number>;
     getLastTreeId(): number;
-    clearDependencyAll(): void;
+    getTreeById(treeId: number): Nullable<IFormulaDependencyTree>;
+    getAllTree(): IFormulaDependencyTree[];
+    buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
+}
+export declare class DependencyManagerBaseService extends Disposable implements IDependencyManagerService {
+    buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
+    getTreeById(treeId: number): Nullable<IFormulaDependencyTree>;
+    getAllTree(): IFormulaDependencyTree[];
+    protected _otherFormulaData: Map<string, Map<string, Map<string, ObjectMatrix<number>>>>;
+    protected _featureFormulaData: Map<string, Map<string, Map<string, Nullable<number>>>>;
+    protected _formulaData: Map<string, Map<string, ObjectMatrix<number>>>;
+    protected _definedNameMap: Map<string, Map<string, Set<number>>>;
+    protected _otherFormulaDataMainData: Set<string>;
+    protected _dependencyRTreeCache: RTree;
+    private _dependencyTreeIdLast;
+    reset(): void;
+    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree): void;
+    removeOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string[]): void;
     clearOtherFormulaDependency(unitId: string, sheetId?: string): void;
+    addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
+    removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
     clearFeatureFormulaDependency(unitId: string, sheetId?: string): void;
-    openKdTree(): void;
-    closeKdTree(): void;
-    getTreeById(treeId: number): Nullable<FormulaDependencyTree>;
+    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: IFormulaDependencyTree): void;
+    removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
+    clearFormulaDependency(unitId: string, sheetId?: string): void;
+    removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
+    searchDependency(search: IUnitRange[], exceptTreeIds?: Set<number>): Set<number>;
+    protected _restDependencyTreeId(): void;
+    getOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): ObjectMatrix<number> | undefined;
+    addOtherFormulaDependencyMainData(formulaId: string): void;
+    hasOtherFormulaDataMainData(formulaId: string): boolean;
+    protected _removeDependencyRTreeCacheById(unitId: string, sheetId: string): void;
+    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): Nullable<number>;
+    getFormulaDependency(unitId: string, sheetId: string, row: number, column: number): Nullable<number>;
+    addDependencyRTreeCache(tree: IFormulaDependencyTree): void;
+    getLastTreeId(): number;
+    protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
+    protected _addDefinedName(unitId: string, definedName: string, treeId: number): void;
+    addFormulaDependencyByDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>): void;
 }
 /**
  * Passively marked as dirty, register the reference and execution actions of the feature plugin.
@@ -52,22 +69,10 @@ export interface IDependencyManagerService {
  * causing the formula to be marked dirty again,
  * thereby completing the calculation of the entire dependency tree.
  */
-export declare class DependencyManagerService extends Disposable implements IDependencyManagerService {
-    private _otherFormulaData;
-    private _featureFormulaData;
-    private _formulaData;
-    private _allTreeMap;
-    private _dependencyRTreeCache;
-    private _dependencyTreeIdLast;
+export declare class DependencyManagerService extends DependencyManagerBaseService implements IDependencyManagerService {
+    protected _allTreeMap: Map<number, IFormulaDependencyTree>;
     dispose(): void;
-    /**
-     * Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
-     * return FormulaDependencyTree[]
-     */
-    getAllTree(): FormulaDependencyTree[];
-    getTreeById(treeId: number): FormulaDependencyTree | undefined;
-    buildDependencyTree(shouldBeBuildTrees: FormulaDependencyTree[], dependencyTrees?: FormulaDependencyTree[]): FormulaDependencyTree[];
-    searchDependency(search: IUnitRange[]): Set<number>;
+    buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
     /**
      * Build the dependency relationship between the trees.
      * @param allTrees  all FormulaDependencyTree
@@ -81,34 +86,30 @@ export declare class DependencyManagerService extends Disposable implements IDep
      */
     private _buildReverseDependency;
     /**
-     * Clear the dependency relationship of the tree.
-     * establish the relationship between the parent and the child.
-     * @param shouldBeClearTree
+     * Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
+     * return FormulaDependencyTree[]
      */
-    clearDependencyForTree(shouldBeClearTree: Nullable<FormulaDependencyTree>): void;
+    getAllTree(): IFormulaDependencyTree[];
+    getTreeById(treeId: number): IFormulaDependencyTree | undefined;
     reset(): void;
-    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
+    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree): void;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]): void;
-    getOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): FormulaDependencyTree | undefined;
-    hasOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): boolean;
     clearOtherFormulaDependency(unitId: string, sheetId?: string): void;
     addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
     removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
     clearFeatureFormulaDependency(unitId: string, sheetId?: string): void;
-    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): FormulaDependencyTree | null | undefined;
-    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
+    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: IFormulaDependencyTree): void;
     removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
     clearFormulaDependency(unitId: string, sheetId?: string): void;
-    clearDependencyAll(): void;
-    getFormulaDependency(unitId: string, sheetId: string, row: number, column: number): FormulaDependencyTree | null | undefined;
-    addDependencyRTreeCache(tree: FormulaDependencyTree): void;
-    private _restDependencyTreeId;
-    getLastTreeId(): number;
-    private _removeDependencyRTreeCacheById;
+    /**
+     * Clear the dependency relationship of the tree.
+     * establish the relationship between the parent and the child.
+     * @param shouldBeClearTree
+     */
+    clearDependencyForTree(shouldBeClearTree: Nullable<IFormulaDependencyTree>): void;
     private _removeDependencyRTreeCache;
     removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
-    openKdTree(): void;
-    closeKdTree(): void;
-    private _removeAllTreeMap;
+    protected _removeAllTreeMap(treeId: Nullable<number>): void;
+    protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
 }
 export declare const IDependencyManagerService: import('@wendellhu/redi').IdentifierDecorator<DependencyManagerService>;

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

@@ -1,17 +1,17 @@
 import { Nullable, Disposable } from '@univerjs/core';
-import { IDirtyUnitOtherFormulaMap, IFormulaDataItem, IOtherFormulaData } from '../basics/common';
+import { IDirtyUnitOtherFormulaMap, IOtherFormulaData, IOtherFormulaDataItem } from '../basics/common';
 export interface IOtherFormulaManagerSearchParam {
     unitId: string;
     subUnitId: string;
     formulaId: string;
 }
 export interface IOtherFormulaManagerInsertParam extends IOtherFormulaManagerSearchParam {
-    item: IFormulaDataItem;
+    item: IOtherFormulaDataItem;
 }
 export interface IOtherFormulaManagerService {
     dispose(): void;
     remove(searchParam: IOtherFormulaManagerSearchParam): void;
-    get(searchParam: IOtherFormulaManagerSearchParam): Nullable<IFormulaDataItem>;
+    get(searchParam: IOtherFormulaManagerSearchParam): Nullable<IOtherFormulaDataItem>;
     has(searchParam: IOtherFormulaManagerSearchParam): boolean;
     register(insertParam: IOtherFormulaManagerInsertParam): void;
     getOtherFormulaData(): IOtherFormulaData;
@@ -28,7 +28,7 @@ export declare class OtherFormulaManagerService extends Disposable implements IO
     private _otherFormulaData;
     dispose(): void;
     remove(searchParam: IOtherFormulaManagerSearchParam): void;
-    get(searchParam: IOtherFormulaManagerSearchParam): IFormulaDataItem | undefined;
+    get(searchParam: IOtherFormulaManagerSearchParam): IOtherFormulaDataItem | undefined;
     has(searchParam: IOtherFormulaManagerSearchParam): boolean;
     register(insertParam: IOtherFormulaManagerInsertParam): void;
     batchRegister(formulaData: IOtherFormulaData): void;

package/lib/types/services/runtime.service.d.ts

@@ -69,7 +69,7 @@ export interface IFormulaRuntimeService {
     setFormulaCycleIndex(index: number): void;
     isStopExecution(): boolean;
     getFormulaExecuteStage(): FormulaExecuteStageType;
-    setRuntimeOtherData(formulaId: string, functionVariant: FunctionVariantType): void;
+    setRuntimeOtherData(formulaId: string, x: number, y: number, functionVariant: FunctionVariantType): void;
     getRuntimeOtherData(): IRuntimeOtherUnitDataType;
     getAllRuntimeData(): IAllRuntimeData;
     markedAsSuccessfullyExecuted(): void;
@@ -159,7 +159,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     clearFunctionDefinitionPrivacyVar(): void;
     registerFunctionDefinitionPrivacyVar(lambdaId: string, lambdaVar: Map<string, Nullable<BaseAstNode>>): void;
     getFunctionDefinitionPrivacyVar(lambdaId: string): Nullable<Map<string, Nullable<BaseAstNode>>>;
-    setRuntimeOtherData(formulaId: string, functionVariant: FunctionVariantType): void;
+    setRuntimeOtherData(formulaId: string, x: number, y: number, functionVariant: FunctionVariantType): void;
     setRuntimeData(functionVariant: FunctionVariantType): void;
     getUnitData(): IRuntimeUnitDataType;
     getUnitArrayFormula(): IArrayFormulaRangeType;

package/lib/umd/facade.js

@@ -0,0 +1 @@
+(function(i,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("@univerjs/core"),require("@univerjs/engine-formula")):typeof define=="function"&&define.amd?define(["exports","@univerjs/core","@univerjs/engine-formula"],a):(i=typeof globalThis<"u"?globalThis:i||self,a(i.UniverEngineFormulaFacade={},i.UniverCore,i.UniverEngineFormula))})(this,function(i,a,u){"use strict";var m=Object.defineProperty,d=Object.getOwnPropertyDescriptor,f=(r,t,e,n)=>{for(var o=n>1?void 0:n?d(t,e):t,c=r.length-1,s;c>=0;c--)(s=r[c])&&(o=(n?s(t,e,o):s(o))||o);return n&&o&&m(t,e,o),o},l=(r,t)=>(e,n)=>t(e,n,r);i.FFormula=class extends a.FBase{constructor(t,e){super(),this._commandService=t,this._injector=e}executeCalculation(){this._commandService.executeCommand(u.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(u.SetFormulaCalculationStopMutation.id,{})}calculationStart(t){return this._commandService.onCommandExecuted(e=>{if(e.id===u.SetFormulaCalculationStartMutation.id){const n=e.params;t(n.forceCalculation)}})}calculationEnd(t){return this._commandService.onCommandExecuted(e=>{if(e.id!==u.SetFormulaCalculationNotificationMutation.id)return;const n=e.params;n.functionsExecutedState!==void 0&&t(n.functionsExecutedState)})}onCalculationEnd(){return new Promise((t,e)=>{const n=setTimeout(()=>{e(new Error("Calculation end timeout"))},3e4),o=this.calculationEnd(()=>{clearTimeout(n),o.dispose(),t()})})}calculationProcessing(t){return this._commandService.onCommandExecuted(e=>{if(e.id!==u.SetFormulaCalculationNotificationMutation.id)return;const n=e.params;n.stageInfo!==void 0&&t(n.stageInfo)})}},i.FFormula=f([l(0,a.Inject(a.ICommandService)),l(1,a.Inject(a.Injector))],i.FFormula);class v extends a.FUniver{getFormula(){return this._injector.createInstance(i.FFormula)}}a.FUniver.extend(v),Object.defineProperty(i,Symbol.toStringTag,{value:"Module"})});