@univerjs/engine-formula 0.22.1 → 0.23.0-insiders.20260522-e8f2a3b

package/lib/types/engine/analysis/lexer-tree-builder.d.ts

@@ -44,6 +44,12 @@ export declare class LexerTreeBuilder extends Disposable {
     private _colonState;
     private _formulaErrorCount;
     private _tableBracketState;
+    private _hasNewExcelFunction;
+    private _lambdaFunctionParameterSet;
+    private _xlpmPrefix;
+    private _xlfnPrefix;
+    private _resetPrefix;
+    private _clearPrefix;
     dispose(): void;
     getUpLevel(): number;
     isColonClose(): boolean;
@@ -164,6 +170,18 @@ export declare class LexerTreeBuilder extends Disposable {
     private _isScientificNotation;
     private _addSequenceArray;
     getNewFormulaWithPrefix(formulaString: string, hasFunction: (functionToken: IFunctionNames) => boolean): string | null;
+    private _generateNewFunctionString;
+    private _handleNewFunctionChild;
+    private _clearFunctionString;
+    private _checkAddBracketForMinus;
+    private _currentUnitId;
     getFormulaExprTree(formulaString: string, unitId: string, hasFunction: (functionToken: IFunctionNames) => boolean, getDefinedNameName: (unitId: string, name: string) => Nullable<IDefinedNamesServiceParam>, getTable: (unitId: string, tableName: string) => Nullable<ISuperTable>): IExprTreeNode | null;
+    private _generateExprTree;
+    private _handleChildrenForExprTree;
+    private _checkColonNodeForExprTree;
+    private _handleTextNodeForExprTree;
+    private _getTableNameFromStructuredRef;
+    private _handleLambdaForExprTree;
+    private _getCurNodeTypeForExprTree;
 }
 export {};

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

@@ -45,7 +45,7 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
     protected readonly _currentConfigService: IFormulaCurrentConfigService;
     protected readonly _runtimeService: IFormulaRuntimeService;
     protected readonly _otherFormulaManagerService: IOtherFormulaManagerService;
-    private readonly _featureCalculationManagerService;
+    protected readonly _featureCalculationManagerService: IFeatureCalculationManagerService;
     private readonly _univerInstanceService;
     private readonly _interpreter;
     protected readonly _astTreeBuilder: AstTreeBuilder;
@@ -54,37 +54,49 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
     protected readonly _lexerTreeBuilder: LexerTreeBuilder;
     private _updateRangeFlattenCache;
     protected _dependencyRTreeCacheForAddressFunction: RTree;
+    protected _dependencyTreeCache: Map<number, IFormulaDependencyTree>;
     constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _univerInstanceService: IUniverInstanceService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService, _lexerTreeBuilder: LexerTreeBuilder);
     dispose(): void;
     private _initUnitDispose;
     private _disposeByUnitId;
     generate(isCalculateTreeModel?: boolean): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
-    private _dependencyFeatureCalculation;
-    private _clearFeatureCalculationNode;
+    private _isCyclicUtilMap;
+    protected _checkIsCycleDependency(treeList: IFormulaDependencyTree[]): boolean;
+    protected _getFeatureFormulaTree(featureId: string, treeId: Nullable<number>, params: IFeatureCalculationManagerParam): FormulaDependencyTree;
+    protected _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: IFormulaDependencyTree[]): void;
+    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;
+    /**
+     * Build a formula dependency tree based on the dependency relationships.
+     * @param treeList
+     */
+    protected _getUpdateTreeListAndMakeDependency(): IFormulaDependencyTree[];
+    protected _getTreeById(treeId: number): IFormulaDependencyTree | undefined;
+    protected _getTreeNode(tree: IFormulaDependencyTree): import("../ast-node").AstRootNode;
+    private _traverse;
+    protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
+    protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
+    protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _startFormulaDependencyTreeModel(): void;
+    protected _endFormulaDependencyTreeModel(): void;
     /**
      * 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;
-    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
      */
     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.
@@ -102,7 +114,6 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
      */
     protected _getRangeListByNode(nodeData: IExecuteAstNodeData): Promise<IUnitRange[]>;
     protected _getAddressFunctionNodeList(node: Nullable<BaseAstNode>): FunctionNode[];
-    protected _getTreeNode(tree: IFormulaDependencyTree): import("../ast-node").AstRootNode;
     protected _buildDirtyRangesByAddressFunction(treeDependencyCache: RTree, tree: IFormulaDependencyTree): Promise<void>;
     private _executedAddressFunctionNodeIds;
     protected _calculateListByFunctionRefNode(treeList: IFormulaDependencyTree[]): Promise<void>;
@@ -110,7 +121,6 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
     private _calculateAddressFunctionRuntimeData;
     private _buildTreeNodeById;
     private _searchDependencyByAddressFunction;
-    protected _getTreeById(treeId: number): Nullable<IFormulaDependencyTree>;
     private _addDependencyTreeByAddressFunction;
     /**
      * Calculate the range required for collection in advance,
@@ -118,11 +128,6 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
      * @param node
      */
     protected _getRangeListByFunctionRefNode(referenceFunctionList: FunctionNode[], refOffsetX: number, refOffsetY: number): Promise<IUnitRange[]>;
-    /**
-     * Build a formula dependency tree based on the dependency relationships.
-     * @param treeList
-     */
-    protected _getUpdateTreeListAndMakeDependency(treeList: IFormulaDependencyTree[]): IFormulaDependencyTree[];
     private _includeTreeFeature;
     private _includeOtherFormula;
     private _detectForcedRecalculationNode;
@@ -133,20 +138,10 @@ export declare class FormulaDependencyGenerator extends Disposable implements IF
      * @param tree
      */
     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
-     */
-    protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
     protected _initializeGenerateTreeList(): Promise<IFormulaDependencyTree[]>;
-    protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
     protected _formulaDependencyTreeModel: Map<number, FormulaDependencyTreeModel>;
     protected _getTreeModel(treeId: number): FormulaDependencyTreeModel | undefined;
-    protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
-    protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
     protected _getFormulaDependencyTreeModel(tree: IFormulaDependencyTree): FormulaDependencyTreeModel;
-    protected _endFormulaDependencyTreeModel(): void;
-    protected _startFormulaDependencyTreeModel(): void;
     protected _getAllDependencyJson(treeList: IFormulaDependencyTree[]): IFormulaDependencyTreeJson[];
     getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
     protected _setRealFormulaString(treeModel: FormulaDependencyTreeModel): void;

package/lib/types/index.d.ts

@@ -23,6 +23,7 @@ export { ERROR_TYPE_SET, ErrorType } from './basics/error-type';
 export { type ISheetFormulaError } from './basics/error-type';
 export { FunctionType, type IFunctionInfo, type IFunctionParam } from './basics/function';
 export { type IFunctionNames } from './basics/function';
+export { CELL_INVERTED_INDEX_CACHE } from './basics/inverted-index-cache';
 export { includeFormulaLexerToken, isFormulaLexerToken, normalizeSheetName } from './basics/match-token';
 export { matchRefDrawToken } from './basics/match-token';
 export { isReferenceString } from './basics/regex';
@@ -41,7 +42,7 @@ export { type ISetImageFormulaDataMutationParams, SetImageFormulaDataMutation }
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';
 export { RemoveSuperTableMutation, SetSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';
 export type { ISetSuperTableMutationParam, ISetSuperTableMutationSearchParam } from './commands/mutations/set-super-table.mutation';
-export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, ENGINE_FORMULA_RETURN_DEPENDENCY_TREE, type IUniverEngineFormulaConfig } from './config/config';
+export { DEFAULT_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, ENGINE_FORMULA_RETURN_DEPENDENCY_TREE, type IUniverEngineFormulaConfig } from './config/config';
 export { CalculateController } from './controllers/calculate.controller';
 export { Lexer } from './engine/analysis/lexer';
 export { LexerNode } from './engine/analysis/lexer-node';
@@ -65,7 +66,7 @@ export { FormulaDependencyGenerator, IFormulaDependencyGenerator } from './engin
 export { generateRandomDependencyTreeId } 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';
+export { AsyncArrayObject, AsyncObject, FORMULA_REF_TO_ARRAY_CACHE } from './engine/reference-object/base-reference-object';
 export { RangeReferenceObject } from './engine/reference-object/range-reference-object';
 export { generateExecuteAstNodeData } from './engine/utils/ast-node-tool';
 export { extractFormulaError } from './engine/utils/cell';

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

@@ -54,8 +54,8 @@ export declare class FormulaDataModel extends Disposable {
      */
     getHiddenRowsFiltered(): IUnitRowData;
     updateFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): IObjectMatrixPrimitiveType<IFormulaDataItem | null>;
-    updateArrayFormulaRange(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
-    updateArrayFormulaCellData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
+    updateArrayFormulaRange(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): boolean;
+    updateArrayFormulaCellData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): boolean;
     updateImageFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
     getFormulaStringByCell(row: number, column: number, sheetId: string, unitId: string): Nullable<string>;
     /**

package/lib/types/models/utils/formula-data-util.d.ts

@@ -18,4 +18,4 @@ import type { IFormulaDataItem, IFormulaIdMap } from '../../basics/common';
 export declare function updateFormulaDataByCellValue(sheetFormulaDataMatrix: ObjectMatrix<Nullable<IFormulaDataItem>>, newSheetFormulaDataMatrix: ObjectMatrix<IFormulaDataItem | null>, formulaIdMap: {
     [formulaId: string]: IFormulaIdMap;
 }, deleteFormulaIdMap: Map<string, string | IFormulaIdMap>, r: number, c: number, cell: Nullable<ICellData>): void;
-export declare function clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix: ObjectMatrix<IRange>, arrayFormulaCellDataMatrix: ObjectMatrix<Nullable<ICellData>>, r: number, c: number): true | undefined;
+export declare function clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix: ObjectMatrix<IRange>, arrayFormulaCellDataMatrix: ObjectMatrix<Nullable<ICellData>>, r: number, c: number): boolean;

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

@@ -15,11 +15,11 @@
  */
 import type { IUnitRange } from '@univerjs/core';
 import type { Observable } from 'rxjs';
-import type { IFeatureDirtyRangeType, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeUnitDataType, IUnitRowData } from '../basics/common';
+import type { IArrayFormulaRangeType, IFeatureDirtyRangeType, IFormulaDatasetConfig, IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeUnitDataType, IUnitExcludedCell, IUnitRowData } from '../basics/common';
 import type { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, IFormulaDependentsAndInRangeResults } from '../engine/dependency/dependency-tree';
 import type { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import type { IAllRuntimeData, IExecutionInProgressParams } from './runtime.service';
-import { Disposable, IConfigService } from '@univerjs/core';
+import { AsyncLock, Disposable, IConfigService } from '@univerjs/core';
 import { Subject } from 'rxjs';
 import { Lexer } from '../engine/analysis/lexer';
 import { AstTreeBuilder } from '../engine/analysis/parser';
@@ -58,7 +58,7 @@ export declare class CalculateFormulaService extends Disposable implements ICalc
     readonly executionInProgressListener$: Observable<IExecutionInProgressParams>;
     protected readonly _executionCompleteListener$: Subject<IAllRuntimeData>;
     readonly executionCompleteListener$: Observable<IAllRuntimeData>;
-    private _executeLock;
+    protected _executeLock: AsyncLock;
     protected _isCalculateTreeModel: boolean;
     constructor(_configService: IConfigService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: IFormulaDependencyGenerator, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder);
     dispose(): void;
@@ -76,8 +76,13 @@ export declare class CalculateFormulaService extends Disposable implements ICalc
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
     setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
     execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
-    private _executeStep;
-    private _getArrayFormulaDirtyRangeAndExcludedRange;
+    protected _executeStep(): Promise<true | undefined>;
+    protected _getArrayFormulaDirtyRangeAndExcludedRange(arrayFormulaRange: IArrayFormulaRangeType, runtimeFeatureRange: {
+        [featureId: string]: IFeatureDirtyRangeType;
+    }): {
+        dirtyRanges: IUnitRange[];
+        excludedCell: IUnitExcludedCell;
+    };
     protected _apply(isArrayFormulaState?: boolean): Promise<IAllRuntimeData | undefined>;
     executeFormulas(formulas: IFormulaStringMap, rowData?: IUnitRowData): Promise<IFormulaExecuteResultMap>;
     calculate(formulaString: string): Promise<FunctionVariantType | undefined>;

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IUnitRange, Nullable } from '@univerjs/core';
+import type { IRange, IUnitRange, Nullable } from '@univerjs/core';
 import type { AstRootNode } from '../engine/ast-node';
 import type { FormulaDependencyTree, IFormulaDependencyTree } from '../engine/dependency/dependency-tree';
 import { Disposable, ObjectMatrix, RTree } from '@univerjs/core';
@@ -43,6 +43,8 @@ export interface IDependencyManagerService {
     getAllTree(): IFormulaDependencyTree[];
     buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
     updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
+    openKdTree(): void;
+    closeKdTree(): void;
 }
 export declare class DependencyManagerBaseService extends Disposable implements IDependencyManagerService {
     buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
@@ -80,6 +82,8 @@ export declare class DependencyManagerBaseService extends Disposable implements
     protected _addDefinedName(unitId: string, definedName: string, treeId: number): void;
     addFormulaDependencyByDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>): void;
     updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
+    openKdTree(): void;
+    closeKdTree(): void;
 }
 /**
  * Passively marked as dirty, register the reference and execution actions of the feature plugin.
@@ -88,27 +92,8 @@ export declare class DependencyManagerBaseService extends Disposable implements
  * thereby completing the calculation of the entire dependency tree.
  */
 export declare class DependencyManagerService extends DependencyManagerBaseService implements IDependencyManagerService {
-    protected _allTreeMap: Map<number, IFormulaDependencyTree>;
-    dispose(): void;
-    buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
-    /**
-     * Build the dependency relationship between the trees.
-     * @param allTrees  all FormulaDependencyTree
-     * @param shouldBeBuildTrees  FormulaDependencyTree[] | FormulaDependencyTreeCache
-     */
-    private _buildDependencyTree;
-    /**
-     * Build the reverse dependency relationship between the trees.
-     * @param allTrees
-     * @param dependencyTrees
-     */
-    private _buildReverseDependency;
-    /**
-     * Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
-     * return FormulaDependencyTree[]
-     */
-    getAllTree(): IFormulaDependencyTree[];
-    getTreeById(treeId: number): IFormulaDependencyTree | undefined;
+    protected _allTreeMap: Map<number, Map<string, Map<string, IRange>>>;
+    protected _dependencyRTreeCache: RTree;
     reset(): void;
     addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree): void;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]): void;
@@ -119,16 +104,25 @@ export declare class DependencyManagerService extends DependencyManagerBaseServi
     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;
-    /**
-     * 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;
     protected _removeAllTreeMap(treeId: Nullable<number>): void;
     protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
-    updateDependencyTreeDirtyState(treeId: number, isDirty: boolean): void;
+    dispose(): void;
+    buildDependencyTree(shouldBeBuildTrees: IFormulaDependencyTree[], dependencyTrees?: IFormulaDependencyTree[]): IFormulaDependencyTree[];
+    /**
+     * Build the dependency relationship between the trees.
+     * @param allTrees  all FormulaDependencyTree
+     * @param shouldBeBuildTrees  FormulaDependencyTree[] | FormulaDependencyTreeCache
+     */
+    private _buildDependencyTree;
+    /**
+     * Build the reverse dependency relationship between the trees.
+     * @param allTrees
+     * @param dependencyTrees
+     */
+    private _buildReverseDependency;
 }
 export declare const IDependencyManagerService: import("@wendellhu/redi").IdentifierDecorator<IDependencyManagerService>;

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

@@ -224,6 +224,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
      */
     private _isInOtherArrayFormulaRange;
     private _isInArrayFormulaRange;
+    private _isSameCellValue;
     private _checkIfArrayFormulaExceeded;
     private _isInDirtyRange;
 }