@univerjs/engine-formula 0.1.3 → 0.1.4

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

@@ -65,6 +65,11 @@ export interface IUnitSheetNameMap {
         [sheetName: string]: string;
     }>;
 }
+export interface IUnitSheetIdToNameMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: string;
+    }>;
+}
 export interface IDirtyUnitSheetNameMap {
     [unitId: string]: Nullable<{
         [sheetId: string]: string;

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const DEFFAULT_DATE_FORMAT = "yyyy-mm-dd;@";
+export declare const DEFAULT_DATE_FORMAT = "yyyy/mm/dd;@";
 /**
  * Excel stores dates as sequential serial numbers so they can be used in calculations. By default, January 1, 1900 is serial number 1, and January 1, 2008 is serial number 39448 because it is 39,447 days after January 1, 1900.
  *

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+/**
+ * covert number to preview string by pattern
+ * @TODODushusir: Internationalization, reuse with numfmt
+ *
+ * @param pattern
+ * @param value
+ * @returns
+ */
+export declare const getFormatPreview: (pattern: string, value: number) => any;

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

@@ -29,8 +29,8 @@ export declare class InvertedIndexCache {
     private _cache;
     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, number[]> | undefined;
-    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean): number[] | undefined;
+    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;
     setContinueBuildingCache(unitId: string, sheetId: string, column: number, startRow: number, endRow: number): void;
     shouldContinueBuildingCache(unitId: string, sheetId: string, column: number, row: number): boolean;

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

@@ -17,6 +17,10 @@ import { Disposable } from '@univerjs/core';
 export declare class ObjectClassType extends Disposable {
     pattern: string;
     getPattern(): string;
+    /**
+     * Only used in NumberValueObject
+     * @param pattern
+     */
     setPattern(pattern: string): void;
     isError(): boolean;
     isAsyncObject(): boolean;

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

@@ -22,6 +22,10 @@ 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.
@@ -37,7 +41,7 @@ export declare class FormulaDependencyTree extends Disposable {
     columnCount: number;
     subUnitId: string;
     unitId: string;
-    rangeList: IUnitRange[];
+    rangeList: IUnitRangeWithToken[];
     formulaId: Nullable<string>;
     featureId: Nullable<string>;
     getDirtyData: Nullable<(tree: FormulaDependencyTree) => {
@@ -55,7 +59,6 @@ export declare class FormulaDependencyTree extends Disposable {
      * "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
-     * @returns
      */
     dependencyRange(dependencyRangeList: Map<string, Map<string, IRange[]>>, dirtyUnitSheetNameMap: IDirtyUnitSheetNameMap, unitExcludedCell: Nullable<IUnitExcludedCell>): boolean;
     pushChildren(tree: FormulaDependencyTree): void;
@@ -63,12 +66,25 @@ export declare class FormulaDependencyTree extends Disposable {
      * Add the range corresponding to the current ast node.
      * @param range
      */
-    pushRangeList(range: IUnitRange): void;
+    pushRangeList(range: IUnitRangeWithToken): void;
     /**
      * Determine whether it is dependent on other trees.
      * @param dependenceTree
-     * @returns
      */
     dependency(dependenceTree: FormulaDependencyTree): boolean;
     private _pushParent;
 }
+export declare class FormulaDependencyTreeCache extends Disposable {
+    private _cacheItems;
+    dispose(): void;
+    size(): number;
+    add(unitRangeWithToken: IUnitRangeWithToken, tree: FormulaDependencyTree): void;
+    clear(): void;
+    remove(token: string, tree: FormulaDependencyTree): void;
+    delete(token: string): void;
+    /**
+     * Determine whether range is dependent on other trees.
+     * @param dependenceTree
+     */
+    dependency(dependenceTree: FormulaDependencyTree): void;
+}

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

@@ -43,12 +43,10 @@ export declare class FormulaDependencyGenerator extends Disposable {
     /**
      * Generate nodes for the dependency tree, where each node contains all the reference data ranges included in each formula.
      * @param formulaData
-     * @returns
      */
     private _generateTreeList;
     /**
      * Break down the dirty areas into ranges for subsequent matching.
-     * @returns
      */
     private _updateRangeFlatten;
     private _generateAstNode;
@@ -61,26 +59,22 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * Calculate the range required for collection in advance,
      * including references and location functions (such as OFFSET, INDIRECT, INDEX, etc.).
      * @param node
-     * @returns
      */
     private _getRangeListByNode;
     /**
      * Build a formula dependency tree based on the dependency relationships.
      * @param treeList
-     * @returns
      */
     private _getUpdateTreeListAndMakeDependency;
     /**
      * 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 tree
-     * @returns
      */
     private _includeTree;
     /**
      * Generate the final formula calculation order array by traversing the dependency tree established via depth-first search.
      * @param treeList
-     * @returns
      */
     private _calculateRunList;
 }

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

@@ -19,7 +19,7 @@ import type { INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap
 import { ObjectClassType } from '../../basics/object-class-type';
 import { ArrayValueObject } from '../value-object/array-value-object';
 import { type BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
-import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../value-object/primitive-object';
+import { NullValueObject, NumberValueObject } from '../value-object/primitive-object';
 export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject | AsyncArrayObject;
 export type FunctionVariantType = BaseValueObject | BaseReferenceObject;
 export declare const FORMULA_REF_TO_ARRAY_CACHE: FormulaAstLRU<ArrayValueObject>;
@@ -41,6 +41,8 @@ export declare class BaseReferenceObject extends ObjectClassType {
     private _refOffsetY;
     constructor(_token: string);
     dispose(): void;
+    getToken(): string;
+    setToken(token: string): void;
     isExceedRange(): boolean;
     setRefOffset(x?: number, y?: number): void;
     getRefOffset(): {
@@ -55,7 +57,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     };
     isReferenceObject(): boolean;
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
-    getFirstCell(): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
+    getFirstCell(): ErrorValueObject | NullValueObject | NumberValueObject | import("../value-object/primitive-object").BooleanValueObject | import("../value-object/primitive-object").StringValueObject | ArrayValueObject;
     getRangeData(): IRange;
     setRangeData(range: IRange): void;
     getUnitId(): string;
@@ -98,16 +100,16 @@ export declare class BaseReferenceObject extends ObjectClassType {
     isTable(): boolean;
     unionBy(referenceObject: BaseReferenceObject): NodeValueType;
     unionRange(rangeData1: IRange, rangeData2: IRange): IRange;
-    getCellValueObject(cell: ICellData): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
-    getCellByRow(row: number): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
-    getCellByColumn(column: number): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
+    getCellValueObject(cell: ICellData): ErrorValueObject | NullValueObject | NumberValueObject | import("../value-object/primitive-object").BooleanValueObject | import("../value-object/primitive-object").StringValueObject | ArrayValueObject;
+    getCellByRow(row: number): ErrorValueObject | NullValueObject | NumberValueObject | import("../value-object/primitive-object").BooleanValueObject | import("../value-object/primitive-object").StringValueObject | ArrayValueObject;
+    getCellByColumn(column: number): ErrorValueObject | NullValueObject | NumberValueObject | import("../value-object/primitive-object").BooleanValueObject | import("../value-object/primitive-object").StringValueObject | ArrayValueObject;
     getCurrentActiveSheetData(): import("../../basics/common").ISheetItem;
     getCurrentRuntimeSheetData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>> | undefined;
     getCurrentActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>> | undefined;
     getCurrentRuntimeActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>> | undefined;
     getCellData(row: number, column: number): ICellData;
     getRuntimeFeatureCellValue(row: number, column: number): ICellData | undefined;
-    getCellByPosition(row?: number, column?: number): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
+    getCellByPosition(row?: number, column?: number): ErrorValueObject | NullValueObject | NumberValueObject | import("../value-object/primitive-object").BooleanValueObject | import("../value-object/primitive-object").StringValueObject | ArrayValueObject;
     toArrayValueObject(useCache?: boolean): ArrayValueObject;
     toUnitRange(): {
         range: {

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

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+/**
+ * Korean in Excel does not count as two characters. Here we calculate all Chinese, Japanese and Korean characters as two characters.
+ *
+ * ā -> 1
+ * ー -> 2
+ *
+ * @param str
+ * @returns
+ */
+export declare function charLenByte(str: string): number;

package/lib/types/engine/utils/object-compare.d.ts

@@ -27,6 +27,5 @@ export declare function valueObjectCompare(range: BaseValueObject, criteria: Bas
  * Find the Boolean intersection of two ArrayValueObjects
  * @param valueObject1
  * @param valueObject2
- * @returns
  */
 export declare function booleanObjectIntersection(valueObject1: BaseValueObject, valueObject2: BaseValueObject): BaseValueObject;

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

@@ -58,7 +58,7 @@ export declare function deserializeRangeWithSheet(refString: string): IUnitRange
  * Determine whether the sheet name needs to be wrapped in quotes
  * Excel will quote the worksheet name if any of the following is true:
  *  - It contains any space or punctuation characters, such as  ()$,;-{}"'（）【】“”‘’%… and many more
- *  - It is a valid cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
+ *  - It is a valid cell reference in A1 notation, e.g. B1048576 is quoted
  *  - It is a valid cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
  *  - It starts with a non-letter, e.g. 99, 1.5, 12a, 💩a
  *  - Excel will not quote worksheet names if they only contain non-punctuation, non-letter characters in non-initial positions. For example, a💩 remains unquoted.*

package/lib/types/engine/value-object/__tests__/array-value-divided.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/value-object/__tests__/array-value-minus.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/value-object/__tests__/array-value-multiply.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/value-object/__tests__/array-value-plus.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/value-object/array-value-object.d.ts

@@ -16,13 +16,14 @@
 import type { Nullable } from '@univerjs/core';
 import { compareToken } from '../../basics/token';
 import { ArrayBinarySearchType, ArrayOrderSearchType } from '../utils/compare';
-import type { callbackMapFnType, callbackProductFnType, IArrayValueObject } from './base-value-object';
+import type { callbackMapFnType, IArrayValueObject } from './base-value-object';
 import { BaseValueObject, ErrorValueObject } 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[][];
-export declare function transformToValue(array?: BaseValueObject[][]): (string | number | boolean | null)[][];
+export declare function transformToValue(array?: Nullable<BaseValueObject>[][]): (string | number | boolean | null)[][];
 export declare class ArrayValueObject extends BaseValueObject {
+    static create(rawValue: string | IArrayValueObject): ArrayValueObject;
     private _values;
     private _rowCount;
     private _columnCount;
@@ -47,12 +48,12 @@ export declare class ArrayValueObject extends BaseValueObject {
     getSheetId(): string;
     getCurrentRow(): number;
     getCurrentColumn(): number;
-    getArrayValue(): BaseValueObject[][];
+    getArrayValue(): Nullable<BaseValueObject>[][];
     setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;
-    get(row: number, column: number): BaseValueObject;
+    get(row: number, column: number): BaseValueObject | null;
     getRealValue(row: number, column: number): BaseValueObject | null;
-    set(row: number, column: number, value: BaseValueObject): void;
+    set(row: number, column: number, value: Nullable<BaseValueObject>): void;
     getRangePosition(): {
         startRow: number;
         endRow: number;
@@ -133,7 +134,6 @@ export declare class ArrayValueObject extends BaseValueObject {
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
-    product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     map(callbackFn: callbackMapFnType): BaseValueObject;
     mapValue(callbackFn: callbackMapFnType): BaseValueObject;
     pow(valueObject: BaseValueObject): BaseValueObject;
@@ -210,5 +210,5 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _createNewArray;
 }
 export declare class ValueObjectFactory {
-    static create(rawValue: string | number | boolean | null): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
+    static create(rawValue: string | number | boolean | null): ErrorValueObject | NullValueObject | NumberValueObject | BooleanValueObject | StringValueObject | ArrayValueObject;
 }

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

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { Nullable } from '@univerjs/core';
+import { FormulaAstLRU } from '../../basics/cache-lru';
 import { ConcatenateType } from '../../basics/common';
 import { ErrorType } from '../../basics/error-type';
 import { ObjectClassType } from '../../basics/object-class-type';
 import { compareToken } from '../../basics/token';
 export type callbackMapFnType = (currentValue: BaseValueObject, row: number, column: number) => BaseValueObject;
-export type callbackProductFnType = (currentValue: BaseValueObject, operationValue: BaseValueObject) => BaseValueObject;
 export interface IArrayValueObject {
-    calculateValueList: BaseValueObject[][];
+    calculateValueList: Nullable<BaseValueObject>[][];
     rowCount: number;
     columnCount: number;
     unitId: string;
@@ -43,7 +44,7 @@ export declare class BaseValueObject extends ObjectClassType {
         unitId: string;
     };
     getValue(): string | number | boolean;
-    getArrayValue(): BaseValueObject[][];
+    getArrayValue(): Nullable<BaseValueObject>[][];
     setValue(value: string | number | boolean): void;
     setArrayValue(value: BaseValueObject[][]): void;
     isCube(): boolean;
@@ -79,7 +80,6 @@ export declare class BaseValueObject extends ObjectClassType {
      * @returns
      */
     mapValue(callbackFn: callbackMapFnType): BaseValueObject;
-    product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     isEqual(valueObject: BaseValueObject): BaseValueObject;
     isNotEqual(valueObject: BaseValueObject): BaseValueObject;
@@ -148,10 +148,14 @@ export declare class BaseValueObject extends ObjectClassType {
     floorInverse(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
     ceilInverse(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): BaseValueObject;
+    convertToBooleanObjectValue(): BaseValueObject;
 }
+export declare const ErrorValueObjectCache: FormulaAstLRU<ErrorValueObject>;
 export declare class ErrorValueObject extends BaseValueObject {
     private _errorType;
     private _errorContent;
+    static create(errorType: ErrorType, errorContent?: string): ErrorValueObject;
     constructor(_errorType: ErrorType, _errorContent?: string);
     getValue(): ErrorType;
     getErrorType(): ErrorType;

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

@@ -17,6 +17,7 @@ import type { ArrayValueObject } from './array-value-object';
 import { BaseValueObject } from './base-value-object';
 import { NumberValueObject } from './primitive-object';
 export declare class CubeValueObject extends BaseValueObject {
+    static create(values: ArrayValueObject[]): CubeValueObject;
     isCube(): boolean;
     private _values;
     constructor(values: ArrayValueObject[]);

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

@@ -21,6 +21,7 @@ export declare class LambdaValueObjectObject extends BaseValueObject {
     private _lambdaNode;
     private _interpreter;
     private _lambdaPrivacyVarKeys;
+    static create(lambdaNode: BaseAstNode, interpreter: Interpreter, lambdaPrivacyVarKeys: string[]): LambdaValueObjectObject;
     private _lambdaPrivacyValueMap;
     constructor(_lambdaNode: BaseAstNode, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[]);
     isLambda(): boolean;

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

@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 import { compareToken } from '../../basics/token';
-import { BaseValueObject } from './base-value-object';
+import { FormulaAstLRU } from '../../basics/cache-lru';
+import { BaseValueObject, ErrorValueObject } from './base-value-object';
 export type PrimitiveValueType = string | boolean | number | null;
 export declare class NullValueObject extends BaseValueObject {
+    private static _instance;
+    static create(): NullValueObject;
     isNull(): boolean;
     plus(valueObject: BaseValueObject): BaseValueObject;
     minus(valueObject: BaseValueObject): BaseValueObject;
@@ -52,10 +55,15 @@ export declare class NullValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): NumberValueObject;
+    convertToBooleanObjectValue(): BooleanValueObject;
 }
 export declare class BooleanValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    private static _instanceTrue;
+    private static _instanceFalse;
+    static create(value: boolean): BooleanValueObject;
+    constructor(rawValue: boolean);
     getValue(): boolean;
     isBoolean(): boolean;
     getNegative(): BaseValueObject;
@@ -90,10 +98,14 @@ export declare class BooleanValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): ErrorValueObject | NumberValueObject;
+    convertToBooleanObjectValue(): this;
 }
+export declare const NumberValueObjectCache: FormulaAstLRU<NumberValueObject>;
 export declare class NumberValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    static create(value: number, pattern?: string): NumberValueObject;
+    constructor(rawValue: number);
     getValue(): number;
     setValue(value: number): void;
     isNumber(): boolean;
@@ -134,16 +146,25 @@ export declare class NumberValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): this;
+    convertToBooleanObjectValue(): BooleanValueObject;
     private _compareInfinity;
 }
+export declare const StringValueObjectCache: FormulaAstLRU<StringValueObject>;
 export declare class StringValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    static create(value: string): StringValueObject;
+    constructor(rawValue: string);
     getValue(): string;
     isString(): boolean;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    convertToNumberObjectValue(): ErrorValueObject | NumberValueObject;
+    convertToBooleanObjectValue(): BooleanValueObject;
     private _checkWildcard;
 }
+export declare function createBooleanValueObjectByRawValue(rawValue: string | number | boolean): BooleanValueObject;
+export declare function createStringValueObjectByRawValue(rawValue: string | number | boolean): StringValueObject;
+export declare function createNumberValueObjectByRawValue(rawValue: string | number | boolean): ErrorValueObject | NumberValueObject;

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

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Nullable } from '@univerjs/core';
+import type { IRange, Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 import type { IFunctionNames } from '../basics/function';
-import type { FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
+import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 import type { ArrayBinarySearchType } from '../engine/utils/compare';
 import { ArrayOrderSearchType } from '../engine/utils/compare';
 import type { ArrayValueObject } from '../engine/value-object/array-value-object';
@@ -54,7 +54,6 @@ export declare class BaseFunction extends Disposable {
      * For instance, The column number (starting with 1 for the left-most column of table_array) that contains the return value.
      * https://support.microsoft.com/en-us/office/vlookup-function-0bbc8083-26fe-4963-8ab8-93a18ad188a1
      * @param indexNum
-     * @returns
      */
     getIndexNumValue(indexNum: BaseValueObject, defaultValue?: number): number | ErrorValueObject;
     /**
@@ -68,28 +67,24 @@ export declare class BaseFunction extends Disposable {
      * If a1 is FALSE, ref_text is interpreted as an R1C1-style reference.
      * https://support.microsoft.com/zh-cn/office/indirect-%E5%87%BD%E6%95%B0-474b3a3a-8a26-4f44-b491-92b6306fa261
      * @param logicValueObject
-     * @returns
      */
     getZeroOrOneByOneDefault(logicValueObject?: BaseValueObject): number | undefined;
     /**
      * A logical value that specifies 1/TRUE , 0/FALSE, -1, default 1.
      * The difference from getZeroOrOneByOneDefault is that we need to get -1
      * @param logicValueObject
-     * @returns
      */
     getMatchTypeValue(logicValueObject?: BaseValueObject): number | undefined;
     binarySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayBinarySearchType): BaseValueObject;
     equalSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
     fuzzySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
     orderSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean): BaseValueObject;
-    /**
-     * @param axis 0 row, 1 column
-     * @returns
-     */
     binarySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, axis?: number, searchType?: ArrayBinarySearchType): ErrorValueObject | ArrayValueObject | undefined;
     equalSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     fuzzySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     orderSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     flattenArray(variants: BaseValueObject[], ignoreLogicalValuesAndText?: boolean): ArrayValueObject | BaseValueObject;
     private _includingLogicalValuesAndText;
+    createReferenceObject(reference: BaseReferenceObject, range: IRange): ErrorValueObject | BaseReferenceObject;
+    private _setReferenceDefault;
 }

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

@@ -0,0 +1,20 @@
+/**
+ * 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 { type BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Or extends BaseFunction {
+    calculate(...logicalValues: BaseValueObject[]): BaseValueObject;
+}

package/lib/types/functions/lookup/function-map.d.ts

@@ -13,14 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Address } from './address';
 import { Column } from './column';
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
-import { Indirect } from './indirect';
 import { Lookup } from './lookup';
 import { Match } from './match';
 import { Offset } from './offset';
 import { Xlookup } from './xlookup';
 import { Xmatch } from './xmatch';
-import { Index } from './index';
-export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Address)[] | (FUNCTION_NAMES_LOOKUP | typeof Column)[] | (FUNCTION_NAMES_LOOKUP | typeof Index)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Xlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Xmatch)[])[];
+export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Column)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Xlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Xmatch)[])[];