@univerjs/engine-formula 0.1.0-beta.3 → 0.1.0-beta.4

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

@@ -60,7 +60,7 @@ export interface IUnitSheetNameMap {
 }
 export interface IDirtyUnitSheetNameMap {
     [unitId: string]: Nullable<{
-        [sheetId: string]: Nullable<string>;
+        [sheetId: string]: string;
     }>;
 }
 export interface IDirtyUnitFeatureMap {

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

@@ -17,7 +17,7 @@ export declare enum ErrorType {
     /** Division by zero. */
     DIV_BY_ZERO = "#DIV/0!",
     /** Function error. */
-    NAME = "#NAME!",
+    NAME = "#NAME?",
     VALUE = "#VALUE!",
     NUM = "#NUM!",
     NA = "#N/A",

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

@@ -28,7 +28,8 @@ export declare class ReferenceNode extends BaseAstNode {
     private _accessor;
     private _operatorString;
     private _referenceObject;
-    constructor(_accessor: IAccessor, _operatorString: string, _referenceObject: BaseReferenceObject);
+    private _isPrepareMerge;
+    constructor(_accessor: IAccessor, _operatorString: string, _referenceObject: BaseReferenceObject, _isPrepareMerge?: boolean);
     get nodeType(): NodeType;
     execute(): void;
 }

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

@@ -0,0 +1,19 @@
+/**
+ * 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 { ArrayValueObject } from '../value-object/array-value-object';
+import type { BaseValueObject } from '../value-object/base-value-object';
+export declare function expandArrayValueObject(rowCount: number, columnCount: number, valueObject: BaseValueObject, defaultValue?: BaseValueObject): ArrayValueObject;
+export declare function createNewArray(result: BaseValueObject[][], rowCount: number, columnCount: number): ArrayValueObject;

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

@@ -18,6 +18,11 @@ export declare enum ArrayBinarySearchType {
     MIN = 0,
     MAX = 1
 }
+export declare enum ArrayOrderSearchType {
+    NORMAL = 0,
+    MIN = 1,
+    MAX = 2
+}
 export declare function getCompare(): (x: string, y: string) => number;
 export declare function isWildcard(str: string): boolean;
 export declare function isMatchWildcard(currentValue: string, value: string): boolean;

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

@@ -23,3 +23,10 @@ export declare function findCompareToken(str: string): [compareToken, BaseValueO
  * 3. <apple*: normal value, <=apple: obtains the same effect as <apple*
  */
 export declare function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken): BaseValueObject;
+/**
+ * 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/value-object/array-value-object.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { type Nullable } from '@univerjs/core';
+import type { Nullable } from '@univerjs/core';
 import { compareToken } from '../../basics/token';
-import { ArrayBinarySearchType } from '../utils/compare';
+import { ArrayBinarySearchType, ArrayOrderSearchType } from '../utils/compare';
 import type { callbackMapFnType, callbackProductFnType, IArrayValueObject } from './base-value-object';
 import { BaseValueObject, ErrorValueObject } from './base-value-object';
 import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from './primitive-object';
@@ -32,8 +32,10 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _currentColumn;
     private _sliceCache;
     private _flattenCache;
+    private _flattenPosition;
     constructor(rawValue: string | IArrayValueObject);
     dispose(): void;
+    clone(): ArrayValueObject;
     getRowCount(): number;
     setRowCount(rowCount: number): void;
     getColumnCount(): number;
@@ -49,6 +51,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;
     get(row: number, column: number): BaseValueObject;
+    getRealValue(row: number, column: number): BaseValueObject | null;
     set(row: number, column: number, value: BaseValueObject): void;
     getRangePosition(): {
         startRow: number;
@@ -57,7 +60,17 @@ export declare class ArrayValueObject extends BaseValueObject {
         endColumn: number;
     };
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): void;
+    iteratorReverse(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): void;
+    getLastTruePosition(): Nullable<{
+        row: number;
+        column: number;
+    }>;
+    getFirstTruePosition(): Nullable<{
+        row: number;
+        column: number;
+    }>;
     getFirstCell(): BaseValueObject;
+    getLastCell(): BaseValueObject;
     /**
      * Referring to matrix calculations,
      * extract the matching values from a true/false matrix based on parameters and store them in a two-dimensional array.
@@ -71,6 +84,16 @@ export declare class ArrayValueObject extends BaseValueObject {
      * https://numpy.org/doc/stable/reference/generated/numpy.chararray.flatten.html#numpy.chararray.flatten
      */
     flatten(): ArrayValueObject;
+    /**
+     * Flatten a 2D array.
+     * In Excel, errors and blank cells are ignored, which results in a binary search that cannot strictly adhere to the number of cells.
+     */
+    flattenPosition(): {
+        stringArray: BaseValueObject[];
+        stringPosition: number[];
+        numberArray: BaseValueObject[];
+        numberPosition: number[];
+    };
     /**
      * I'm looking to perform slicing operations on 2D arrays, similar to the functionality provided by NumPy.
      * https://numpy.org/doc/stable/user/basics.indexing.html
@@ -82,7 +105,17 @@ export declare class ArrayValueObject extends BaseValueObject {
     sortByRow(index: number): void;
     sortByColumn(index: number): void;
     transpose(): ArrayValueObject;
-    binarySearch(valueObject: BaseValueObject, searchType?: ArrayBinarySearchType): number | null | undefined;
+    /**
+     * Due to the inability to effectively utilize the cache,
+     * the sequential matching approach is only used for special matches in XLOOKUP and XMATCH.
+     * For example, when match_mode is set to 1 and -1 for an exact match. If not found, it returns the next smaller item.
+     */
+    orderSearch(valueObject: BaseValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, isFuzzyMatching?: boolean): void | {
+        row: number;
+        column: number;
+    } | null;
+    binarySearch(valueObject: BaseValueObject, searchType?: ArrayBinarySearchType): number | undefined;
+    private _binarySearch;
     sum(): BaseValueObject;
     max(): BaseValueObject;
     min(): BaseValueObject;
@@ -100,6 +133,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     map(callbackFn: callbackMapFnType): BaseValueObject;
+    mapValue(callbackFn: callbackMapFnType): BaseValueObject;
     pow(valueObject: BaseValueObject): BaseValueObject;
     /**
      *

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

@@ -66,6 +66,7 @@ export declare class BaseValueObject extends ObjectClassType {
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
     map(callbackFn: callbackMapFnType): BaseValueObject;
+    mapValue(callbackFn: callbackMapFnType): BaseValueObject;
     product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     isEqual(valueObject: BaseValueObject): BaseValueObject;

package/lib/types/functions/__tests__/{create-command-test-bed.d.ts → create-function-test-bed.d.ts}

@@ -17,7 +17,7 @@ import type { IWorkbookData } from '@univerjs/core';
 import { Univer } from '@univerjs/core';
 import type { Dependency } from '@wendellhu/redi';
 import type { ISheetData } from '../../basics/common';
-export declare function createCommandTestBed(workbookConfig?: IWorkbookData, dependencies?: Dependency[]): {
+export declare function createFunctionTestBed(workbookConfig?: IWorkbookData, dependencies?: Dependency[]): {
     univer: Univer;
     get: {
         <T>(id: import("@wendellhu/redi").DependencyIdentifier<T>, lookUp?: import("@wendellhu/redi").LookUp | undefined): T;

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

@@ -17,6 +17,9 @@ import type { 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 { ArrayBinarySearchType } from '../engine/utils/compare';
+import { ArrayOrderSearchType } from '../engine/utils/compare';
+import type { ArrayValueObject } from '../engine/value-object/array-value-object';
 import { type BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
 import type { PrimitiveValueType } from '../engine/value-object/primitive-object';
 export declare class BaseFunction extends Disposable {
@@ -45,7 +48,7 @@ export declare class BaseFunction extends Disposable {
      * @param indexNum
      * @returns
      */
-    getIndexNumValue(indexNum: BaseValueObject): number | ErrorValueObject;
+    getIndexNumValue(indexNum: BaseValueObject, defaultValue?: number): number | ErrorValueObject;
     /**
      * A logical value that specifies 1/TRUE , 0/FALSE, default 1
      * For instance range_lookup, A logical value that specifies whether you want VLOOKUP to find an approximate or an exact match
@@ -60,4 +63,16 @@ export declare class BaseFunction extends Disposable {
      * @returns
      */
     getZeroOrOneByOneDefault(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;
 }

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

@@ -13,4 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const functionInformation: never[];
+import { FUNCTION_NAMES_INFORMATION } from './function-names';
+import { Isblank } from './isblank';
+export declare const functionInformation: (FUNCTION_NAMES_INFORMATION | typeof Isblank)[][];

package/lib/types/functions/information/isblank/__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/information/isblank/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 Isblank extends BaseFunction {
+    calculate(value: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/logical/and/__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/and/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 And extends BaseFunction {
+    calculate(...logicalValues: BaseValueObject[]): BaseValueObject;
+}

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { And } from './and';
 import { FUNCTION_NAMES_LOGICAL } from './function-names';
 import { Makearray } from './makearray';
-export declare const functionLogical: (FUNCTION_NAMES_LOGICAL | typeof Makearray)[][];
+export declare const functionLogical: ((FUNCTION_NAMES_LOGICAL | typeof And)[] | (FUNCTION_NAMES_LOGICAL | typeof Makearray)[])[];

package/lib/types/functions/logical/if/__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/if/index.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.
+ */
+import { type BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class If extends BaseFunction {
+    calculate(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse?: BaseValueObject): BaseValueObject;
+    private _getSingleValueObject;
+    private _calculateSingleCell;
+}

package/lib/types/functions/logical/iferror/__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/iferror/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 Iferror extends BaseFunction {
+    calculate(value: BaseValueObject, valueIfError: BaseValueObject): BaseValueObject;
+}

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

@@ -15,7 +15,10 @@
  */
 import { Address } from './address';
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
+import { Hlookup } from './hlookup';
 import { Indirect } from './indirect';
+import { Lookup } from './lookup';
 import { Offset } from './offset';
 import { Vlookup } from './vlookup';
-export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Address)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Vlookup)[])[];
+import { Xlookup } from './xlookup';
+export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Address)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Vlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Hlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Xlookup)[])[];

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

@@ -0,0 +1,21 @@
+/**
+ * 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 Hlookup extends BaseFunction {
+    calculate(lookupValue: BaseValueObject, tableArray: BaseValueObject, rowIndexNum: BaseValueObject, rangeLookup?: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * 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 { ArrayValueObject } from '../../..';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Lookup extends BaseFunction {
+    calculate(lookupValue: BaseValueObject, lookupVectorOrArray: ArrayValueObject, resultVector?: BaseValueObject): BaseValueObject;
+    private _handleVector;
+    private _handleArray;
+}

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

@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
-import { CellReferenceObject } from '../../../engine/reference-object/cell-reference-object';
+import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Offset extends BaseFunction {
-    calculate(reference: FunctionVariantType, rows: FunctionVariantType, columns: FunctionVariantType, height?: FunctionVariantType, width?: FunctionVariantType): CellReferenceObject;
+    calculate(reference: BaseValueObject, rows: BaseValueObject, columns: BaseValueObject, height?: BaseValueObject, width?: BaseValueObject): ErrorValueObject | BaseReferenceObject;
+    private _setDefault;
 }

package/lib/types/functions/lookup/xlookup/__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/lookup/xlookup/index.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.
+ */
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Xlookup extends BaseFunction {
+    calculate(lookupValue: BaseValueObject, lookupArray: ArrayValueObject, returnArray: ArrayValueObject, ifNotFound?: BaseValueObject, matchMode?: BaseValueObject, searchMode?: BaseValueObject): BaseValueObject;
+    private _handleExpandObject;
+    private _handleSingleObject;
+    private _getSearchModeValue;
+}

package/lib/types/functions/math/sumifs/index.d.ts

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sumifs extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): ErrorValueObject;
+    calculate(sumRange: BaseValueObject, ...variants: BaseValueObject[]): ErrorValueObject | ArrayValueObject;
 }

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

@@ -13,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Concatenate extends BaseFunction {
-    calculate(numberVar: FunctionVariantType, powerVar: FunctionVariantType): ErrorValueObject;
+    calculate(...textValues: BaseValueObject[]): BaseValueObject;
 }

package/lib/types/services/current-data.service.d.ts

@@ -60,6 +60,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     registerUnitData(unitData: IUnitData): void;
     registerFormulaData(formulaData: IFormulaData): void;
     registerSheetNameMap(sheetNameMap: IUnitSheetNameMap): void;
+    private _mergeNameMap;
     private _loadSheetData;
 }
 export declare const IFormulaCurrentConfigService: import("@wendellhu/redi").IdentifierDecorator<FormulaCurrentConfigService>;