@univerjs/engine-formula 0.4.0 → 0.4.1-experimental.20241023-bbb123f

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

@@ -0,0 +1,31 @@
+import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
+type DatabaseValueType = string | number | null;
+export declare function checkDatabase(database: BaseValueObject): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    databaseValues: DatabaseValueType[][];
+} | {
+    isError: boolean;
+    errorObject: null;
+    databaseValues: DatabaseValueType[][];
+};
+export declare function checkField(field: BaseValueObject, database: DatabaseValueType[][]): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    fieldIndex: number;
+} | {
+    isError: boolean;
+    errorObject: null;
+    fieldIndex: number;
+};
+export declare function checkCriteria(criteria: BaseValueObject): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    criteriaValues: DatabaseValueType[][];
+} | {
+    isError: boolean;
+    errorObject: null;
+    criteriaValues: DatabaseValueType[][];
+};
+export declare function isCriteriaMatch(criteria: DatabaseValueType[][], database: DatabaseValueType[][], databaseRowIndex: number): boolean;
+export {};

package/lib/types/basics/inverted-index-cache.d.ts

@@ -1,18 +1,4 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+import { NumericTuple } from '@flatten-js/interval-tree';
 export declare class InvertedIndexCache {
     /**
      * {
@@ -30,11 +16,14 @@ export declare class InvertedIndexCache {
     private _continueBuildingCache;
     set(unitId: string, sheetId: string, column: number, value: string | number | boolean | null, row: number): void;
     getCellValuePositions(unitId: string, sheetId: string, column: number): Map<string | number | boolean | null, Set<number>> | undefined;
-    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean): Set<number> | undefined;
-    getCellPosition(unitId: string, sheetId: string, column: number, value: string | number | boolean, startRow: number, endRow: number): number | undefined;
+    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean, rowsInCache: NumericTuple[]): number[] | undefined;
     setContinueBuildingCache(unitId: string, sheetId: string, column: number, startRow: number, endRow: number): void;
     shouldContinueBuildingCache(unitId: string, sheetId: string, column: number, row: number): boolean;
-    canUseCache(unitId: string, sheetId: string, column: number, rangeStartRow: number, rangeEndRow: number): boolean;
+    canUseCache(unitId: string, sheetId: string, column: number, rangeStartRow: number, rangeEndRow: number): {
+        rowsInCache: NumericTuple[];
+        rowsNotInCache: NumericTuple[];
+    };
     clear(): void;
+    private _handleNewInterval;
 }
 export declare const CELL_INVERTED_INDEX_CACHE: InvertedIndexCache;

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

@@ -19,3 +19,15 @@ export declare function calculateGcd(a: number, b: number): number;
 export declare function calculateLcm(a: number, b: number): number;
 export declare function calculateMdeterm(matrix: number[][]): number;
 export declare function calculateMinverse(matrix: number[][]): number[][] | null;
+export declare const romanToArabicMap: Map<string, number>;
+export declare const arabicToRomanMap: Map<number, string>;
+/**
+ * form: A number specifying the type of roman numeral you want.
+ * The roman numeral style ranges from Classic to Simplified, becoming more concise as the value of form increases
+ * 0 Classic
+ * 1 More concise
+ * 2 More concise
+ * 3 More concise
+ * 4 Simplified
+ */
+export declare const romanFormArray: number[][];

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/__tests__/dependency.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/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/function-node.d.ts

@@ -34,6 +34,7 @@ export declare class FunctionNode extends BaseAstNode {
     private _setDefinedNamesForFunction;
     private _setRefInfo;
     private _setRefData;
+    private _setLocale;
 }
 export declare class ErrorFunctionNode extends BaseAstNode {
     constructor(token?: string);

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,11 +12,11 @@ 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>;
-    children: Set<FormulaDependencyTree>;
-    parents: Set<FormulaDependencyTree>;
+    nodeData: Nullable<IExecuteAstNodeData>;
+    children: Set<string>;
+    parents: Set<string>;
     formula: string;
     row: number;
     column: number;
@@ -29,13 +29,21 @@ export declare class FormulaDependencyTree extends Disposable {
     featureId: Nullable<string>;
     isCache: boolean;
     constructor(treeId?: string);
+    toJson(): {
+        formula: string;
+        row: number;
+        column: number;
+        subUnitId: string;
+        unitId: string;
+        formulaId: Nullable<string>;
+        featureId: Nullable<string>;
+    };
     getDirtyData: Nullable<(dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
         runtimeCellData: IRuntimeUnitDataType;
         dirtyRanges: IFeatureDirtyRangeType;
     }>;
     private _state;
     dispose(): void;
-    disposeWithChildren(): void;
     resetState(): void;
     setAdded(): void;
     isAdded(): boolean;
@@ -50,7 +58,7 @@ export declare class FormulaDependencyTree extends Disposable {
      * @param range
      */
     pushRangeList(ranges: IUnitRange[]): void;
-    hasChildren(tree: FormulaDependencyTree): boolean;
+    hasChildren(treeId: string): boolean;
     toRTreeItem(): IRTreeItem;
     /**
      * Determine whether it is dependent on other trees.

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/reference-object/base-reference-object.d.ts

@@ -39,6 +39,11 @@ export declare class BaseReferenceObject extends ObjectClassType {
         endRow: number;
         startColumn: number;
         endColumn: number;
+        rangeType?: import('@univerjs/core').RANGE_TYPE;
+        startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        unitId?: string;
+        sheetId?: string;
     };
     isReferenceObject(): boolean;
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
@@ -115,6 +120,11 @@ export declare class BaseReferenceObject extends ObjectClassType {
             endRow: number;
             startColumn: number;
             endColumn: number;
+            rangeType?: import('@univerjs/core').RANGE_TYPE;
+            startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            unitId?: string;
+            sheetId?: string;
         };
         sheetId: string;
         unitId: string;

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/char-kit.d.ts

@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 /**
- * Korean in Excel does not count as two characters. Here we calculate all Chinese, Japanese and Korean characters as two characters.
+ * excel logic is cofusing, so we use google sheet logic
  *
- * ā -> 1
- * ー -> 2
- *
- * @param str
- * @returns
+ * @param text
+ * @returns number
  */
-export declare function charLenByte(str: string): number;
+export declare function charLenByte(text: string): number;
+export declare function getCharLenByteInText(text: string, charIndex: number, direction?: 'ltr' | 'rtl'): number;

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

@@ -1,4 +1,4 @@
-import { ICellData, Nullable, Styles } from '@univerjs/core';
+import { ICellData, Nullable, Styles, LocaleType } from '@univerjs/core';
 import { operatorToken } from '../../basics/token';
 /**
  * Handling number formats in styles
@@ -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.
  *
@@ -60,3 +61,15 @@ export declare function compareNumfmtPriority(oldPattern: string, pattern: strin
  * @param nextPattern
  */
 export declare function comparePatternPriority(previousPattern: string, nextPattern: string, operator: operatorToken): string;
+export declare function getCurrencyFormat(locale: LocaleType, numberDigits?: number): string;
+export declare function applyCurrencyFormat(locale: LocaleType, number: number, numberDigits?: number): string;
+export declare function stringIsNumberPattern(input: string): {
+    isNumberPattern: boolean;
+    value: number;
+    pattern: string;
+} | {
+    isNumberPattern: boolean;
+    value?: undefined;
+    pattern?: undefined;
+};
+export declare function clearStringToNumberPatternCache(): void;

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

@@ -0,0 +1,3 @@
+import { IUnitRangeName } from '@univerjs/core';
+export declare function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName;
+export declare function clearReferenceToRangeCache(): void;

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

@@ -219,6 +219,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _transposeArray;
     private _batchOperator;
     private _batchOperatorValue;
+    private __batchOperatorRowValue;
     private _batchOperatorArray;
     private _checkArrayCalculateType;
     private _formatValue;

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,18 +1,19 @@
-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, LocaleType, 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;
     private _row;
     private _column;
     private _definedNames;
+    private _locale;
     /**
      * Whether the function needs to expand the parameters
      */
@@ -21,6 +22,10 @@ export declare class BaseFunction extends Disposable {
      * Whether the function needs to pass in reference object
      */
     needsReferenceObject: boolean;
+    /**
+     * Whether the function needs handle locale
+     */
+    needsLocale: boolean;
     /**
      * Minimum number of parameters
      */
@@ -35,6 +40,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,
@@ -43,6 +49,8 @@ export declare class BaseFunction extends Disposable {
      */
     getDefinedName(name: string): import('..').IDefinedNamesServiceParam | null;
     setDefinedNames(definedNames: IDefinedNameMapItem): void;
+    getLocale(): LocaleType;
+    setLocale(locale: LocaleType): void;
     isAsync(): boolean;
     isAddress(): boolean;
     isCustom(): boolean;

package/lib/types/functions/database/daverage/__tests__/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/database/daverage/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Daverage extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dcount/__tests__/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/database/dcount/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dcount extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dcounta/__tests__/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/database/dcounta/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dcounta extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dget/__tests__/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/database/dget/index.d.ts

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