@univerjs/engine-formula 0.3.0 → 0.4.0-alpha.0

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

@@ -141,12 +141,14 @@ export interface IUnitExcludedCell {
 export interface IFormulaDatasetConfig {
     formulaData: IFormulaData;
     arrayFormulaCellData: IArrayFormulaUnitCellType;
+    arrayFormulaRange: IArrayFormulaRangeType;
     forceCalculate: boolean;
     dirtyRanges: IUnitRange[];
     dirtyNameMap: IDirtyUnitSheetNameMap;
     dirtyDefinedNameMap: IDirtyUnitSheetNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
+    clearDependencyTreeCache?: IUnitSheetIdToNameMap;
     excludedCell?: IUnitExcludedCell;
     allUnitData?: IUnitData;
     unitStylesData?: IUnitStylesData;

package/lib/types/basics/match-token.d.ts

@@ -8,3 +8,7 @@ export declare function normalizeSheetName(sheetName: string): string;
  * @param char
  */
 export declare function matchRefDrawToken(char: string): boolean;
+export declare const TOKEN_CANNOT_BE_AT_END_SET: Set<string>;
+export declare function isTokenCannotBeAtEnd(token: string): boolean;
+export declare const TOKEN_CANNOT_PRECEDE_SUFFIX_TOKEN_SET: Set<string>;
+export declare function isTokenCannotPrecedeSuffixToken(token: string): boolean;

package/lib/types/basics/token-type.d.ts

@@ -21,3 +21,4 @@ export declare const DEFAULT_TOKEN_TYPE_LAMBDA_OMIT_PARAMETER = "LO_1";
 export declare const DEFAULT_TOKEN_LET_FUNCTION_NAME = "LET";
 export declare const DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME = "LAMBDA";
 export declare const DEFAULT_TOKEN_CUBE_FUNCTION_NAME = "CUBE";
+export declare const FORCED_RECALCULATION_FUNCTION_NAME: Set<string>;

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

@@ -57,6 +57,7 @@ export declare enum suffixToken {
 export declare const SUFFIX_TOKEN_SET: Set<string>;
 export declare enum prefixToken {
     AT = "@",
-    MINUS = "-"
+    MINUS = "-",
+    PLUS = "+"
 }
 export declare const SPACE_TOKEN = " ";

package/lib/types/commands/mutations/set-defined-name.mutation.d.ts

@@ -1,4 +1,4 @@
-import { IMutation } from '@univerjs/core';
+import { IAccessor, IMutation } from '@univerjs/core';
 export interface ISetDefinedNameMutationSearchParam {
     unitId: string;
     id: string;
@@ -10,6 +10,13 @@ export interface ISetDefinedNameMutationParam extends ISetDefinedNameMutationSea
     localSheetId?: string;
     hidden?: boolean;
 }
+/**
+ * Generate undo mutation of a `SetDefinedNameMutation`
+ * @param accessor
+ * @param params
+ * @returns
+ */
+export declare const SetDefinedNameMutationFactory: (accessor: IAccessor, params: ISetDefinedNameMutationParam) => ISetDefinedNameMutationParam;
 /**
  * In the formula engine, the mutation is solely responsible for communication between the worker and the main thread.
  * It requires setting local to true during execution.

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

@@ -1,7 +1,7 @@
 import { IExecutionOptions, IMutation, Nullable } from '@univerjs/core';
 import { IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
-import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 import { IFormulaDirtyData } from '../../services/current-data.service';
+import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation extends IFormulaDirtyData {
     options: Nullable<IExecutionOptions>;
     forceCalculation: boolean;

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

@@ -4,6 +4,9 @@ export interface ISetFormulaDataMutationParams {
     formulaData: IFormulaData;
 }
 /**
- * There is no need to process data here, it is used as the main thread to send data to the worker. The main thread has already updated the data in advance, and there is no need to update it again here.
+ * There is no need to process data here, it is used as the main thread to send data to the worker.
+ * The main thread has already updated the data in advance, and there is no need to update it again here.
+ *
+ * @deprecated Do not use command system as rpc calling method.
  */
 export declare const SetFormulaDataMutation: IMutation<ISetFormulaDataMutationParams>;

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

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

package/lib/types/controller/set-dependency.controller.d.ts

@@ -9,4 +9,5 @@ export declare class SetDependencyController extends Disposable {
     private _initialize;
     private _featureCalculationManagerServiceListener;
     private _commandExecutedListener;
+    private _handleSetDefinedName;
 }

package/lib/types/controller/set-other-formula.controller.d.ts

@@ -1,6 +1,6 @@
 import { Disposable, ICommandService } from '@univerjs/core';
-import { IOtherFormulaManagerService } from '../services/other-formula-manager.service';
 import { IDependencyManagerService } from '../services/dependency-manager.service';
+import { IOtherFormulaManagerService } from '../services/other-formula-manager.service';
 export declare class SetOtherFormulaController extends Disposable {
     private readonly _commandService;
     private readonly _otherFormulaManagerService;

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

@@ -1,7 +1,7 @@
+import { ISequenceArray, ISequenceNode } from '../utils/sequence';
 import { AbsoluteRefType, Disposable } from '@univerjs/core';
 import { FormulaAstLRU } from '../../basics/cache-lru';
 import { ErrorType } from '../../basics/error-type';
-import { ISequenceArray, ISequenceNode } from '../utils/sequence';
 import { LexerNode } from './lexer-node';
 export declare const FormulaLexerNodeCache: FormulaAstLRU<LexerNode>;
 export declare const FormulaSequenceNodeCache: FormulaAstLRU<(string | ISequenceNode)[]>;
@@ -16,6 +16,7 @@ export declare class LexerTreeBuilder extends Disposable {
     private _doubleQuotationState;
     private _lambdaState;
     private _colonState;
+    private _formulaErrorCount;
     private _tableBracketState;
     dispose(): void;
     getUpLevel(): number;
@@ -55,8 +56,11 @@ export declare class LexerTreeBuilder extends Disposable {
      *
      */
     private _mergeSequenceNodeReference;
+    /**
+     * =-A1  Separate the negative sign from the ref string.
+     */
+    private _minusSplitSequenceNode;
     private _pushSequenceNode;
-    private _replacePrefixString;
     nodeMakerTest(formulaString: string): ErrorType.VALUE | (string | LexerNode)[] | undefined;
     treeBuilder(formulaString: string, transformSuffix?: boolean, injectDefinedName?: (sequenceArray: ISequenceArray[]) => {
         sequenceString: string;
@@ -91,6 +95,8 @@ export declare class LexerTreeBuilder extends Disposable {
     private _isTableBracket;
     private _openTableBracket;
     private _closeTableBracket;
+    private _formalErrorOccurred;
+    private _hasFormalError;
     private _getLastChildCurrentLexerNode;
     private _getLastChildCurrent;
     private _setParentCurrentLexerNode;
@@ -102,8 +108,19 @@ export declare class LexerTreeBuilder extends Disposable {
     private _newAndPushCurrentLexerNode;
     private _getTopNode;
     private _removeLastChild;
+    /**
+     * fix univer-pro/issues/2447
+     * =1/3+
+     * =+
+     * =sum(A1+)
+     */
+    private _formulaErrorLastTokenCheck;
     private _findPreviousToken;
-    private _negativeCondition;
+    private _findSecondLastNonSpaceToken;
+    private _findNextToken;
+    private _unexpectedEndingTokenExcludeOperator;
+    private _unexpectedEndingToken;
+    private _isOperatorToken;
     private _getSequenceArray;
     private _resetTemp;
     private _checkErrorState;

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

@@ -1,7 +1,7 @@
 import { Nullable, Disposable } from '@univerjs/core';
+import { BaseAstNode } from '../ast-node/base-ast-node';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { AstRootNodeFactory } from '../ast-node/ast-root-node';
-import { BaseAstNode } from '../ast-node/base-ast-node';
 import { FunctionNodeFactory } from '../ast-node/function-node';
 import { LambdaNodeFactory } from '../ast-node/lambda-node';
 import { LambdaParameterNodeFactory } from '../ast-node/lambda-parameter-node';
@@ -33,6 +33,7 @@ export declare class AstTreeBuilder extends Disposable {
     private _lambdaParameterHandler;
     private _changeLetToLambda;
     private _parse;
+    private _setPrefixRefOffset;
     private _checkAstNode;
     private _initializeAstNode;
 }

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

@@ -1,7 +1,7 @@
 import { Nullable, Disposable } from '@univerjs/core';
-import { AstNodePromiseType } from '../../basics/common';
 import { ErrorType } from '../../basics/error-type';
 import { FunctionVariantType } from '../reference-object/base-reference-object';
+import { AstNodePromiseType } from '../../basics/common';
 import { ErrorValueObject } from '../value-object/base-value-object';
 import { NodeType } from './node-type';
 interface IAstNodeNodeJson {
@@ -21,15 +21,18 @@ export declare class BaseAstNode extends Disposable {
     private _address;
     private _refOffsetX;
     private _refOffsetY;
+    private _isForcedCalculateFunction;
     constructor(_token: string);
     dispose(): void;
     get nodeType(): NodeType;
     isAsync(): boolean;
     isAddress(): boolean;
+    isForcedCalculateFunction(): boolean;
     setAsync(): void;
     setAddress(): void;
     getParent(): Nullable<BaseAstNode>;
     setParent(node: BaseAstNode): void;
+    setForcedCalculateFunction(): void;
     getChildren(): BaseAstNode[];
     addChildren(...astNode: BaseAstNode[]): void;
     getToken(): string;

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

@@ -1,11 +1,11 @@
+import { BaseFunction } from '../../functions/base-function';
+import { LexerNode } from '../analysis/lexer-node';
 import { Injector } from '@univerjs/core';
 import { AstNodePromiseType } from '../../basics/common';
-import { BaseFunction } from '../../functions/base-function';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
+import { IDefinedNamesService } from '../../services/defined-names.service';
 import { IFunctionService } from '../../services/function.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
-import { LexerNode } from '../analysis/lexer-node';
-import { IDefinedNamesService } from '../../services/defined-names.service';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
@@ -35,6 +35,12 @@ export declare class FunctionNode extends BaseAstNode {
     private _setRefInfo;
     private _setRefData;
 }
+export declare class ErrorFunctionNode extends BaseAstNode {
+    constructor(token?: string);
+    get nodeType(): NodeType;
+    executeAsync(): Promise<AstNodePromiseType>;
+    execute(): void;
+}
 export declare class FunctionNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
     private readonly _currentConfigService;

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

@@ -25,5 +25,4 @@ export declare class LambdaNodeFactory extends BaseAstNodeFactory {
     create(param: LexerNode): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;
     private _updateLambdaStatement;
-    private _updateTree;
 }

package/lib/types/engine/ast-node/lambda-parameter-node.d.ts

@@ -1,5 +1,5 @@
-import { LexerNode } from '../analysis/lexer-node';
 import { LambdaPrivacyVarType, BaseAstNode } from './base-ast-node';
+import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class LambdaParameterNode extends BaseAstNode {

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

@@ -1,4 +1,4 @@
-import { Disposable, IRange, IUnitRange, Nullable } from '@univerjs/core';
+import { IRange, IRTreeItem, IUnitRange, Nullable, Disposable } from '@univerjs/core';
 import { IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IRuntimeUnitDataType, IUnitExcludedCell } from '../../basics/common';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { IAllRuntimeData } from '../../services/runtime.service';
@@ -8,18 +8,15 @@ export declare enum FDtreeStateType {
     ADDED = 1,
     SKIP = 2
 }
-export interface IUnitRangeWithToken {
-    gridRange: IUnitRange;
-    token: string;
-}
 /**
  * A dependency tree, capable of calculating mutual dependencies,
  * is used to determine the order of formula calculations.
  */
 export declare class FormulaDependencyTree extends Disposable {
+    treeId: string;
     node: Nullable<BaseAstNode>;
-    children: FormulaDependencyTree[];
-    parents: FormulaDependencyTree[];
+    children: Set<FormulaDependencyTree>;
+    parents: Set<FormulaDependencyTree>;
     formula: string;
     row: number;
     column: number;
@@ -27,20 +24,16 @@ export declare class FormulaDependencyTree extends Disposable {
     columnCount: number;
     subUnitId: string;
     unitId: string;
-    rangeList: IUnitRangeWithToken[];
+    rangeList: IUnitRange[];
     formulaId: Nullable<string>;
     featureId: Nullable<string>;
-    isPassive: boolean;
-    _childIds: Set<string>;
-    anchorToken: string;
+    isCache: boolean;
+    constructor(treeId?: string);
     getDirtyData: Nullable<(dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
         runtimeCellData: IRuntimeUnitDataType;
         dirtyRanges: IFeatureDirtyRangeType;
     }>;
     private _state;
-    private _id;
-    constructor();
-    get id(): string;
     dispose(): void;
     disposeWithChildren(): void;
     resetState(): void;
@@ -49,19 +42,16 @@ export declare class FormulaDependencyTree extends Disposable {
     setSkip(): void;
     isSkip(): boolean;
     inRangeData(range: IRange): boolean;
-    /**
-     * "Determine whether all ranges of the current node exist within the dirty area.
-     *  If they are within the dirty area, return true, indicating that this node needs to be calculated.
-     * @param dependencyRangeList
-     */
-    dependencyRange(dependencyRangeList: Map<string, Map<string, IRange[]>>, dirtyUnitSheetNameMap: IDirtyUnitSheetNameMap, unitExcludedCell: Nullable<IUnitExcludedCell>): boolean;
+    dependencySheetName(dirtyUnitSheetNameMap?: IDirtyUnitSheetNameMap): boolean;
+    isExcludeRange(unitExcludedCell: Nullable<IUnitExcludedCell>): boolean;
     pushChildren(tree: FormulaDependencyTree): void;
-    hasChild(tree: FormulaDependencyTree): boolean;
     /**
      * Add the range corresponding to the current ast node.
      * @param range
      */
-    pushRangeList(range: IUnitRangeWithToken): void;
+    pushRangeList(ranges: IUnitRange[]): void;
+    hasChildren(tree: FormulaDependencyTree): boolean;
+    toRTreeItem(): IRTreeItem;
     /**
      * Determine whether it is dependent on other trees.
      * @param dependenceTree
@@ -69,32 +59,3 @@ export declare class FormulaDependencyTree extends Disposable {
     dependency(dependenceTree: FormulaDependencyTree): boolean;
     private _pushParent;
 }
-export declare class FormulaDependencyTreeCache extends Disposable {
-    private _cacheItems;
-    private _map;
-    private _dependencyMap;
-    private _parentIdMap;
-    private _rangeTokens;
-    dispose(): void;
-    size(): number;
-    getDependencyMap(): Map<string, FormulaDependencyTree>;
-    getDependencyTree(id: string): FormulaDependencyTree | undefined;
-    get length(): number;
-    add(unitRangeWithToken: IUnitRangeWithToken, tree: FormulaDependencyTree): void;
-    addDependencyMap(tree: FormulaDependencyTree): void;
-    updateParent(tree: FormulaDependencyTree): void;
-    clear(): void;
-    remove(token: string, tree: FormulaDependencyTree): void;
-    delete(token: string): void;
-    getDependencyId(dependenceTree: FormulaDependencyTree, ids: Set<string>): void;
-    /**
-     * Determine whether range is dependent on other trees.
-     * @param dependenceTree
-     */
-    dependencyUseParentId(dependenceTree: FormulaDependencyTree): void;
-    /**
-     * Determine whether range is dependent on other trees.
-     * @param dependenceTree
-     */
-    dependency(dependenceTree: FormulaDependencyTree): void;
-}

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

@@ -1,12 +1,12 @@
 import { Disposable } from '@univerjs/core';
 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 { IDependencyManagerService } from '../../services/dependency-manager.service';
 import { FormulaDependencyTree } from './dependency-tree';
 export declare class FormulaDependencyGenerator extends Disposable {
     private readonly _currentConfigService;
@@ -17,9 +17,8 @@ export declare class FormulaDependencyGenerator extends Disposable {
     private readonly _astTreeBuilder;
     private readonly _lexer;
     private readonly _dependencyManagerService;
-    private _updateRangeFlattenCache;
-    private _dirtyUnitSheetNameMap;
     private _formulaASTCache;
+    private _updateRangeFlattenCache;
     constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService);
     dispose(): void;
     generate(): Promise<FormulaDependencyTree[]>;
@@ -59,11 +58,18 @@ export declare class FormulaDependencyGenerator extends Disposable {
     private _dependencyFeatureCalculation;
     private _clearFeatureCalculationNode;
     private _getExistTreeList;
-    private _convertDirtyRangesToMap;
+    /**
+     * 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;
     private _includeTreeFeature;
     private _includeOtherFormula;
     private _includeDefinedName;
+    private _detectForcedRecalculationNode;
+    private _detectForcedRecalculationNodeRecursion;
     /**
      * Determine whether all ranges of the current node exist within the dirty area.
      * If they are within the dirty area, return true, indicating that this node needs to be calculated.

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

@@ -0,0 +1,2 @@
+import { IDependencyManagerService } from '../../services/dependency-manager.service';
+export declare function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): string;

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

@@ -1,8 +1,8 @@
-import { Disposable } from '@univerjs/core';
-import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { FunctionVariantType } from '../reference-object/base-reference-object';
 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);

package/lib/types/engine/reference-object/base-reference-object.d.ts

@@ -1,10 +1,10 @@
 import { ICellData, IRange, Nullable } from '@univerjs/core';
+import { IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap, IUnitStylesData } from '../../basics/common';
 import { FormulaAstLRU } from '../../basics/cache-lru';
 import { ObjectClassType } from '../../basics/object-class-type';
 import { ArrayValueObject } from '../value-object/array-value-object';
 import { BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
 import { NullValueObject, NumberValueObject, StringValueObject } from '../value-object/primitive-object';
-import { IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap, IUnitStylesData } from '../../basics/common';
 export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject | AsyncArrayObject;
 export type FunctionVariantType = BaseValueObject | BaseReferenceObject;
 export declare const FORMULA_REF_TO_ARRAY_CACHE: FormulaAstLRU<ArrayValueObject>;
@@ -98,7 +98,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     getCurrentRuntimeActiveArrayFormulaCellData(): import('@univerjs/core').ObjectMatrix<Nullable<ICellData>> | undefined;
     getCellData(row: number, column: number): Nullable<ICellData>;
     getRuntimeFeatureCellValue(row: number, column: number): ICellData | undefined;
-    getCellByPosition(row?: number, column?: number): ErrorValueObject | NullValueObject | NumberValueObject | import('../..').BooleanValueObject | StringValueObject | ArrayValueObject;
+    getCellByPosition(rowRaw?: number, columnRaw?: number): ErrorValueObject | NullValueObject | NumberValueObject | import('../..').BooleanValueObject | StringValueObject | ArrayValueObject;
     /**
      * Get the pattern of the cell
      * @param unitId

package/lib/types/engine/utils/check-variant-error.d.ts

@@ -1,5 +1,14 @@
 import { BaseValueObject } from '../value-object/base-value-object';
 export declare function checkVariantErrorIsArray(variant: BaseValueObject): BaseValueObject;
+export declare function checkVariantsErrorIsArray(...variants: BaseValueObject[]): {
+    isError: boolean;
+    errorObject: BaseValueObject;
+    variants?: undefined;
+} | {
+    isError: boolean;
+    variants: BaseValueObject[];
+    errorObject?: undefined;
+};
 export declare function checkVariantsErrorIsArrayOrBoolean(...variants: BaseValueObject[]): {
     isError: boolean;
     errorObject: BaseValueObject;

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

@@ -1,7 +1,7 @@
 import { Injector, Nullable } from '@univerjs/core';
 import { IFunctionService } from '../../services/function.service';
 import { PrefixNode } from '../ast-node/prefix-node';
-export declare function prefixHandler(tokenTrim: string, functionService: IFunctionService, injector: Injector): {
+export declare function prefixHandler(tokenTrimParam: string, functionService: IFunctionService, injector: Injector): {
     tokenTrim: string;
     minusPrefixNode: Nullable<PrefixNode>;
     atPrefixNode: Nullable<PrefixNode>;

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

@@ -44,6 +44,7 @@ export declare function handleRefStringInfo(refString: string): {
 };
 export declare function deserializeRangeWithSheet(refString: string): IUnitRangeName;
 export declare function isReferenceStringWithEffectiveColumn(refString: string): boolean;
+export declare function replaceRefPrefixString(token: string): string;
 /**
  * implement getSheetIdByName
  * function getSheetIdByName(name: string) {

package/lib/types/engine/utils/regexp-check.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 function handleRegExp(regExpString: string, isGlobal: boolean): {
+    isError: boolean;
+    regExp: null;
+} | {
+    isError: boolean;
+    regExp: RegExp;
+};

package/lib/types/engine/utils/update-lambda-statement.d.ts

@@ -0,0 +1,3 @@
+import { LambdaPrivacyVarType } from '../ast-node/base-ast-node';
+import { LexerNode } from '../analysis/lexer-node';
+export declare function updateLambdaStatement(functionStatementNode: LexerNode, lambdaId: string, currentLambdaPrivacyVar: LambdaPrivacyVarType): void;

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

@@ -1,7 +1,7 @@
 import { Nullable } from '@univerjs/core';
+import { callbackMapFnType, IArrayValueObject, BaseValueObject, ErrorValueObject } from './base-value-object';
 import { compareToken } from '../../basics/token';
 import { ArrayBinarySearchType, ArrayOrderSearchType } from '../utils/compare';
-import { BaseValueObject, ErrorValueObject, callbackMapFnType, IArrayValueObject } from './base-value-object';
 import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from './primitive-object';
 export declare function fromObjectToString(array: IArrayValueObject): string;
 export declare function transformToValueObject(array?: Array<Array<number | string | boolean | null>>): BaseValueObject[][];

package/lib/types/functions/text/function-names.d.ts

@@ -38,6 +38,9 @@ export declare enum FUNCTION_NAMES_TEXT {
     NUMBERVALUE = "NUMBERVALUE",
     PHONETIC = "PHONETIC",
     PROPER = "PROPER",
+    REGEXEXTRACT = "REGEXEXTRACT",
+    REGEXMATCH = "REGEXMATCH",
+    REGEXREPLACE = "REGEXREPLACE",
     REPLACE = "REPLACE",
     REPLACEB = "REPLACEB",
     REPT = "REPT",

package/lib/types/functions/text/regexextract/__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/regexextract/index.d.ts

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

package/lib/types/functions/text/regexmatch/__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/regexmatch/index.d.ts

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

package/lib/types/functions/text/regexreplace/__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/regexreplace/index.d.ts

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