@univerjs/engine-formula 0.4.0 → 0.4.1

package/lib/types/basics/object-class-type.d.ts

@@ -1,6 +1,21 @@
-import { Disposable } from '@univerjs/core';
-export declare class ObjectClassType extends Disposable {
+/**
+ * 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 declare class ObjectClassType {
     pattern: string;
+    dispose(): void;
     getPattern(): string;
     /**
      * Only used in NumberValueObject

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

@@ -14,20 +14,37 @@
  * limitations under the License.
  */
 export declare const UNIT_NAME_REGEX = "\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]";
+export declare const UNIT_NAME_REGEX_PRECOMPILING: RegExp;
 export declare const SHEET_NAME_REGEX = "((?![\\[\\]\\/?*\\\\]).)*!";
 export declare const ABSOLUTE_SYMBOL = "$";
 export declare const RANGE_SYMBOL = "\\s*?:\\s*?";
 export declare const UNIT_NAME_SHEET_NAME_REGEX = "'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?";
 export declare const SIMPLE_SINGLE_RANGE_REGEX = "\\$?[A-Za-z]+\\$?[1-9][0-9]*";
 export declare const REFERENCE_MULTIPLE_RANGE_REGEX = "^(@)?'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\$?[A-Za-z]+\\$?[1-9][0-9]*\\s*?:\\s*?\\$?[A-Za-z]+\\$?[1-9][0-9]*$";
+export declare const REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_SINGLE_RANGE_REGEX = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[A-Za-z]+\\$?[1-9][0-9]*(#)?$";
+export declare const REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_ROW = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\$?[1-9][0-9]*\\s*?:\\s*?\\$?[1-9][0-9]*$";
+export declare const REFERENCE_REGEX_ROW_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_COLUMN = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\$?[A-Za-z]+\\s*?:\\s*?\\$?[A-Za-z]+$";
+export declare const REFERENCE_REGEX_COLUMN_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_SINGLE_ROW = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[1-9][0-9]*$";
+export declare const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[A-Za-z]+$";
+export declare const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+$";
 export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[((?<!#).)*\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#).)*\\]\\])+$";
 export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[((?<!#).)*\\]\\s*?:\\s*?\\[((?<!#).)*\\]\\])?$|^((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#).)*\\]\\s*?:\\s*?\\[((?<!#).)*\\]\\])?$";
-export declare const $SUPER_TABLE_COLUMN_REGEX = "[.*?]";
-export declare const $ARRAY_VALUE_REGEX = "{.*?}";
+export declare const SUPER_TABLE_COLUMN_REGEX = "[.*?]";
+export declare const SUPER_TABLE_COLUMN_REGEX_PRECOMPILING: RegExp;
+export declare const ARRAY_VALUE_REGEX = "{.*?}";
+export declare const ARRAY_VALUE_REGEX_PRECOMPILING: RegExp;
+export declare function regexTestSingeRange(token: string): boolean;
+export declare function regexTestMultipleRange(token: string): boolean;
+export declare function regexTestRow(token: string): boolean;
+export declare function regexTestColumn(token: string): boolean;
+export declare function regexTestSingleRow(token: string): boolean;
+export declare function regexTestSingleColumn(token: string): boolean;
+export declare function regexTestSuperTableColumn(token: string): boolean;
+export declare function regexTestArrayValue(token: string): boolean;
 export declare function isReferenceString(refString: string): boolean;

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

@@ -29,11 +29,10 @@ export declare class AstTreeBuilder extends Disposable {
     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, refOffsetX?: number, refOffsetY?: number): Nullable<BaseAstNode>;
+    parse(lexerNode: LexerNode): Nullable<BaseAstNode>;
     private _lambdaParameterHandler;
     private _changeLetToLambda;
     private _parse;
-    private _setPrefixRefOffset;
     private _checkAstNode;
     private _initializeAstNode;
 }

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

@@ -1,9 +1,10 @@
-import { Nullable, Disposable } from '@univerjs/core';
+import { Nullable } from '@univerjs/core';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode } from './base-ast-node';
 export declare const DEFAULT_AST_NODE_FACTORY_Z_INDEX = 100;
-export declare abstract class BaseAstNodeFactory extends Disposable {
+export declare abstract class BaseAstNodeFactory {
     get zIndex(): number;
+    dispose(): void;
     create(param: LexerNode | string, currentRow?: number, currentColumn?: number): BaseAstNode;
     abstract checkAndCreateNodeType(param: LexerNode | string): Nullable<BaseAstNode>;
 }

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

@@ -1,4 +1,4 @@
-import { Nullable, Disposable } from '@univerjs/core';
+import { Nullable } from '@univerjs/core';
 import { ErrorType } from '../../basics/error-type';
 import { FunctionVariantType } from '../reference-object/base-reference-object';
 import { AstNodePromiseType } from '../../basics/common';
@@ -10,7 +10,7 @@ interface IAstNodeNodeJson {
     nodeType: string;
 }
 export type LambdaPrivacyVarType = Map<string, Nullable<BaseAstNode>>;
-export declare class BaseAstNode extends Disposable {
+export declare class BaseAstNode {
     private _token;
     private _children;
     private _definedNames;
@@ -19,8 +19,6 @@ export declare class BaseAstNode extends Disposable {
     private _calculateState;
     private _async;
     private _address;
-    private _refOffsetX;
-    private _refOffsetY;
     private _isForcedCalculateFunction;
     constructor(_token: string);
     dispose(): void;
@@ -42,11 +40,6 @@ export declare class BaseAstNode extends Disposable {
     setCalculated(): void;
     execute(): void;
     setNotEmpty(state?: boolean): void;
-    setRefOffset(x?: number, y?: number): void;
-    getRefOffset(): {
-        x: number;
-        y: number;
-    };
     executeAsync(): Promise<AstNodePromiseType>;
     serialize(): IAstNodeNodeJson;
     hasDefinedName(definedName: string): boolean;

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

@@ -1,9 +1,9 @@
 import { IAccessor, Injector } from '@univerjs/core';
+import { BaseReferenceObject } from '../reference-object/base-reference-object';
+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 { BaseReferenceObject } from '../reference-object/base-reference-object';
-import { IFunctionService } from '../../services/function.service';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
@@ -12,9 +12,16 @@ export declare class ReferenceNode extends BaseAstNode {
     private _operatorString;
     private _referenceObject;
     private _isPrepareMerge;
+    private _refOffsetX;
+    private _refOffsetY;
     constructor(_accessor: IAccessor, _operatorString: string, _referenceObject: BaseReferenceObject, _isPrepareMerge?: boolean);
     get nodeType(): NodeType;
     execute(): void;
+    setRefOffset(x?: number, y?: number): void;
+    getRefOffset(): {
+        x: number;
+        y: number;
+    };
 }
 export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
     private readonly _superTableService;

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

@@ -1,8 +1,8 @@
-import { IRange, IRTreeItem, IUnitRange, Nullable, Disposable } from '@univerjs/core';
+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 { BaseAstNode } from '../ast-node/base-ast-node';
+import { IExecuteAstNodeData } from '../utils/ast-node-tool';
 export declare enum FDtreeStateType {
     DEFAULT = 0,
     ADDED = 1,
@@ -12,9 +12,9 @@ export declare enum FDtreeStateType {
  * A dependency tree, capable of calculating mutual dependencies,
  * is used to determine the order of formula calculations.
  */
-export declare class FormulaDependencyTree extends Disposable {
+export declare class FormulaDependencyTree {
     treeId: string;
-    node: Nullable<BaseAstNode>;
+    nodeData: Nullable<IExecuteAstNodeData>;
     children: Set<FormulaDependencyTree>;
     parents: Set<FormulaDependencyTree>;
     formula: string;

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

@@ -29,6 +29,7 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * @param formulaData
      */
     private _generateTreeList;
+    private _moveRangeList;
     private _registerFeatureFormulas;
     private _getFeatureFormulaTree;
     private _registerOtherFormulas;

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

@@ -1,13 +1,14 @@
 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(node: BaseAstNode): Promise<FunctionVariantType>;
-    execute(node: BaseAstNode): FunctionVariantType;
+    executeAsync(nodeData: IExecuteAstNodeData): Promise<FunctionVariantType>;
+    execute(nodeData: IExecuteAstNodeData): FunctionVariantType;
     executePreCalculateNode(node: PreCalculateNodeType): import('@univerjs/core').Nullable<FunctionVariantType>;
     checkAsyncNode(node: BaseAstNode): boolean;
     private _checkAsyncNode;

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

@@ -1,3 +1,13 @@
 import { Nullable } from '@univerjs/core';
 import { BaseAstNode } from '../ast-node/base-ast-node';
+export interface IExecuteAstNodeData {
+    node: BaseAstNode;
+    refOffsetX: number;
+    refOffsetY: number;
+}
 export declare function getAstNodeTopParent(node: BaseAstNode): Nullable<BaseAstNode>;
+export declare function generateExecuteAstNodeData(node: BaseAstNode, refOffsetX?: number, refOffsetY?: number): {
+    node: BaseAstNode;
+    refOffsetX: number;
+    refOffsetY: number;
+};

package/lib/types/engine/utils/numfmt-kit.d.ts

@@ -39,6 +39,7 @@ export declare function handleNumfmtInCell(oldCell: Nullable<ICellData>, cell: N
  * @returns
  */
 export declare function compareNumfmtPriority(oldPattern: string, pattern: string): string;
+export declare function clearNumberFormatTypeCache(): void;
 /**
  * The number format of the formula inherits the number format of the referenced cell, usually taking the format of the cell at the front position, but some formats have higher priority, there are some special cases.
  *

package/lib/types/engine/utils/reference.d.ts

@@ -43,6 +43,8 @@ export declare function handleRefStringInfo(refString: string): {
     unitId: string;
 };
 export declare function deserializeRangeWithSheet(refString: string): IUnitRangeName;
+export declare function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName;
+export declare function clearReferenceToRangeCache(): void;
 export declare function isReferenceStringWithEffectiveColumn(refString: string): boolean;
 export declare function replaceRefPrefixString(token: string): string;
 /**

package/lib/types/engine/value-object/lambda-value-object.d.ts

@@ -1,7 +1,7 @@
-import { AsyncObject, FunctionVariantType } from '../reference-object/base-reference-object';
-import { BaseValueObject } from './base-value-object';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { Interpreter } from '../interpreter/interpreter';
+import { FunctionVariantType, AsyncObject } from '../reference-object/base-reference-object';
+import { BaseValueObject } from './base-value-object';
 export declare class LambdaValueObjectObject extends BaseValueObject {
     private _lambdaNode;
     private _interpreter;

package/lib/types/functions/base-function.d.ts

@@ -1,12 +1,12 @@
-import { Disposable, IRange, Nullable } from '@univerjs/core';
-import { ArrayOrderSearchType, ArrayBinarySearchType } from '../engine/utils/compare';
-import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
-import { PrimitiveValueType } from '../engine/value-object/primitive-object';
+import { IRange, Nullable } from '@univerjs/core';
 import { IFunctionNames } from '../basics/function';
 import { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
+import { ArrayBinarySearchType, ArrayOrderSearchType } from '../engine/utils/compare';
 import { ArrayValueObject } from '../engine/value-object/array-value-object';
 import { IDefinedNameMapItem } from '../services/defined-names.service';
-export declare class BaseFunction extends Disposable {
+import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
+import { PrimitiveValueType } from '../engine/value-object/primitive-object';
+export declare class BaseFunction {
     private _name;
     private _unitId;
     private _subUnitId;
@@ -35,6 +35,7 @@ export declare class BaseFunction extends Disposable {
     get subUnitId(): Nullable<string>;
     get row(): number;
     get column(): number;
+    dispose(): void;
     /**
      * In Excel, to inject a defined name into a function that has positioning capabilities,
      * such as using the INDIRECT function to reference a named range,

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

@@ -38,7 +38,7 @@ export interface IDependencyManagerService {
     clearFormulaDependency(unitId: string, sheetId?: string): void;
     addDependencyRTreeCache(tree: FormulaDependencyTree): void;
     searchDependency(search: IUnitRange[]): Map<string, IRTreeItem>;
-    hasTreeIdInCache(treeId: string): boolean;
+    getLastTreeId(): number;
     clearDependencyAll(): void;
     clearOtherFormulaDependency(unitId: string, sheetId?: string): void;
     clearFeatureFormulaDependency(unitId: string, sheetId?: string): void;
@@ -54,7 +54,7 @@ export declare class DependencyManagerService extends Disposable implements IDep
     private _featureFormulaData;
     private _formulaData;
     private _dependencyRTreeCache;
-    private _dependencyTreeIdsCache;
+    private _dependencyTreeIdLast;
     dispose(): void;
     /**
      * Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
@@ -97,10 +97,8 @@ export declare class DependencyManagerService extends Disposable implements IDep
     clearDependencyAll(): void;
     getFormulaDependency(unitId: string, sheetId: string, row: number, column: number): Nullable<Nullable<FormulaDependencyTree>>;
     addDependencyRTreeCache(tree: FormulaDependencyTree): void;
-    private _addTreeIdToCache;
-    private _removeTreeIdFromCache;
-    private _clearTreeIdCache;
-    hasTreeIdInCache(treeId: string): boolean;
+    private _restDependencyTreeId;
+    getLastTreeId(): number;
     private _removeDependencyRTreeCacheById;
     private _removeDependencyRTreeCache;
     removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;

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

@@ -96,6 +96,7 @@ export interface IFormulaRuntimeService {
     };
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
     setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+    clearReferenceAndNumberformatCache(): void;
 }
 export declare class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {
     private readonly _currentConfigService;
@@ -152,6 +153,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     setFormulaExecuteStage(type: FormulaExecuteStageType): void;
     getFormulaExecuteStage(): FormulaExecuteStageType;
     reset(): void;
+    clearReferenceAndNumberformatCache(): void;
     setCurrent(row: number, column: number, rowCount: number, columnCount: number, sheetId: string, unitId: string): void;
     clearFunctionDefinitionPrivacyVar(): void;
     registerFunctionDefinitionPrivacyVar(lambdaId: string, lambdaVar: Map<string, Nullable<BaseAstNode>>): void;