@univerjs/engine-formula 0.1.0-beta.1 → 0.1.0-beta.2

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

@@ -42,60 +42,60 @@ export interface IUnitData {
     [unitId: string]: ISheetData;
 }
 export interface IRuntimeUnitDataType {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: ObjectMatrix<Nullable<ICellData>>;
-    };
+    }>;
 }
 export interface IRuntimeOtherUnitDataType {
-    [unitId: string]: {
-        [sheetId: string]: {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: Nullable<{
             [formulaId: string]: ICellData;
-        };
-    };
+        }>;
+    }>;
 }
 export interface IUnitSheetNameMap {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetName: string]: string;
-    };
+    }>;
 }
 export interface IDirtyUnitSheetNameMap {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: Nullable<string>;
-    };
+    }>;
 }
 export interface IDirtyUnitFeatureMap {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: {
             [featureId: string]: boolean;
         };
-    };
+    }>;
 }
 export interface IArrayFormulaRangeType {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: IObjectMatrixPrimitiveType<IRange>;
-    };
+    }>;
 }
 export interface IFeatureDirtyRangeType {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: IRange[];
-    };
+    }>;
 }
 export interface IArrayFormulaUnitCellType {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: IObjectMatrixPrimitiveType<Nullable<ICellData>>;
-    };
+    }>;
 }
 export interface IFormulaData {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: IObjectMatrixPrimitiveType<IFormulaDataItem>;
-    };
+    }>;
 }
 export interface IOtherFormulaData {
-    [unitId: string]: {
-        [subComponentId: string]: {
+    [unitId: string]: Nullable<{
+        [subUnitId: string]: Nullable<{
             [formulaId: string]: IFormulaDataItem;
-        };
-    };
+        }>;
+    }>;
 }
 /**
  * @f  formulaString, the text string of the formula.
@@ -120,9 +120,9 @@ export declare enum TableOptionType {
     TOTALS = "#Totals"
 }
 export interface IUnitExcludedCell {
-    [unitId: string]: {
+    [unitId: string]: Nullable<{
         [sheetId: string]: ObjectMatrix<boolean>;
-    };
+    }>;
 }
 export interface IFormulaDatasetConfig {
     formulaData: IFormulaData;
@@ -132,6 +132,8 @@ export interface IFormulaDatasetConfig {
     dirtyNameMap: IDirtyUnitSheetNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     excludedCell?: IUnitExcludedCell;
+    allUnitData?: IUnitData;
+    unitSheetNameMap?: IUnitSheetNameMap;
 }
 export declare enum ConcatenateType {
     FRONT = 0,

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

@@ -36,4 +36,4 @@ export declare enum ErrorType {
     /** In the case of SUM(B1 C1), */
     NULL = "#NULL!"
 }
-export declare const ERROR_TYPE_SET: Set<string>;
+export declare const ERROR_TYPE_SET: Set<ErrorType>;

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

@@ -93,7 +93,11 @@ export declare enum FunctionType {
     /**
      * Univer-specific functions
      */
-    Univer = 14
+    Univer = 14,
+    /**
+     * User-defined functions
+     */
+    User = 15
 }
 export interface IFunctionParam {
     /**

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

@@ -28,8 +28,8 @@ export declare class InvertedIndexCache {
      */
     private _cache;
     private _continueBuildingCache;
-    set(unitId: string, sheetId: string, column: number, value: string | number | boolean, row: number): void;
-    getCellValuePositions(unitId: string, sheetId: string, column: number): Map<string | number | boolean, number[]> | undefined;
+    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;
     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;

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

@@ -13,20 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const UNIT_NAME_REGEX = "'?\\[((?![\\/?:\"<>|*\\\\]).)*\\]";
 export declare const SHEET_NAME_REGEX = "((?![\\[\\]\\/?*\\\\]).)*!";
 export declare const ABSOLUTE_SYMBOL = "$";
 export declare const RANGE_SYMBOL = "\\s*?:\\s*?";
 export declare const SIMPLE_SINGLE_RANGE_REGEX = "\\$?[A-Za-z]+\\$?[0-9]+";
-export declare const REFERENCE_MULTIPLE_RANGE_REGEX = "^(@)?('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[A-Za-z]+\\$?[0-9]+\\s*?:\\s*?\\$?[A-Za-z]+\\$?[0-9]+$";
-export declare const REFERENCE_SINGLE_RANGE_REGEX = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[A-Za-z]+\\$?[0-9]+(#)?$";
-export declare const REFERENCE_REGEX_ROW = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[0-9]+\\s*?:\\s*?\\$?[0-9]+$";
-export declare const REFERENCE_REGEX_COLUMN = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[A-Za-z]+\\s*?:\\s*?\\$?[A-Za-z]+$";
-export declare const REFERENCE_REGEX_SINGLE_ROW = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[0-9]+$";
-export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[A-Za-z]+$";
-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 REFERENCE_MULTIPLE_RANGE_REGEX = "^(@)?('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[A-Za-z]+\\$?[0-9]+\\s*?:\\s*?\\$?[A-Za-z]+\\$?[0-9]+$";
+export declare const REFERENCE_SINGLE_RANGE_REGEX = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[A-Za-z]+\\$?[0-9]+(#)?$";
+export declare const REFERENCE_REGEX_ROW = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[0-9]+\\s*?:\\s*?\\$?[0-9]+$";
+export declare const REFERENCE_REGEX_COLUMN = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\$?[A-Za-z]+\\s*?:\\s*?\\$?[A-Za-z]+$";
+export declare const REFERENCE_REGEX_SINGLE_ROW = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[0-9]+$";
+export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^('?\\[((?![\\/?:\"<>|*\\\\]).)*?\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?\\s*?\\$?[A-Za-z]+$";
+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 function isReferenceString(refString: string): boolean;

package/lib/types/commands/mutations/register-function.mutation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { IMutation } from '@univerjs/core';
+/**
+ *
+ * Register function in main thread, then send function to worker thread.
+ *
+ * In the formula engine, the mutation is solely responsible for communication between the worker and the main thread.
+ * It requires setting local to true during execution.
+ */
+export interface IRegisterFunctionMutationParam {
+    /**
+     * function string, function name
+     */
+    functions: [[string, string]];
+}
+export declare const RegisterFunctionMutation: IMutation<IRegisterFunctionMutationParam>;

package/lib/types/commands/mutations/unregister-function.mutation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { IMutation } from '@univerjs/core';
+/**
+ *
+ * Register function in main thread, then send function to worker thread.
+ *
+ * In the formula engine, the mutation is solely responsible for communication between the worker and the main thread.
+ * It requires setting local to true during execution.
+ */
+export interface IUnregisterFunctionMutationParam {
+    /**
+     * Function string
+     */
+    functions: string[];
+}
+export declare const UnregisterFunctionMutation: IMutation<IUnregisterFunctionMutationParam>;

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

@@ -14,13 +14,17 @@
  * limitations under the License.
  */
 import { Disposable, ICommandService } from '@univerjs/core';
+import type { Ctor } from '@wendellhu/redi';
 import { Injector } from '@wendellhu/redi';
+import type { IFunctionNames } from '../basics/function';
+import type { BaseFunction } from '../functions/base-function';
 import { IFunctionService } from '../services/function.service';
 export declare class FormulaController extends Disposable {
+    private _function;
     private readonly _commandService;
     private readonly _injector;
     private readonly _functionService;
-    constructor(_commandService: ICommandService, _injector: Injector, _functionService: IFunctionService);
+    constructor(_function: Array<[Ctor<BaseFunction>, IFunctionNames]>, _commandService: ICommandService, _injector: Injector, _functionService: IFunctionService);
     private _initialize;
     private _registerCommands;
     private _registerFunctions;

package/lib/types/controller/register-function.controller.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { Disposable, ICommandService } from '@univerjs/core';
+import { FormulaDataModel } from '../models/formula-data.model';
+import { IFunctionService } from '../services/function.service';
+export declare class RegisterFunctionController extends Disposable {
+    private readonly _commandService;
+    private readonly _formulaDataModel;
+    private readonly _functionService;
+    constructor(_commandService: ICommandService, _formulaDataModel: FormulaDataModel, _functionService: IFunctionService);
+    private _initialize;
+    private _commandExecutedListener;
+}

package/lib/types/engine/analysis/__tests__/create-command-test-bed.d.ts

@@ -16,6 +16,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[]): {
     univer: Univer;
     get: {
@@ -27,4 +28,7 @@ export declare function createCommandTestBed(workbookConfig?: IWorkbookData, dep
         <T_5>(id: import("@wendellhu/redi").DependencyIdentifier<T_5>, quantityOrLookup?: import("@wendellhu/redi").Quantity | import("@wendellhu/redi").LookUp | undefined, lookUp?: import("@wendellhu/redi").LookUp | undefined): T_5 | T_5[] | null;
     };
     sheet: import("@univerjs/core").Workbook;
+    unitId: string;
+    sheetId: string;
+    sheetData: ISheetData;
 };

package/lib/types/engine/analysis/__tests__/parser.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/lexer-tree-builder.d.ts

@@ -107,5 +107,6 @@ export declare class LexerTreeBuilder extends Disposable {
     private _negativeCondition;
     private _getSequenceArray;
     private _resetTemp;
+    private _checkSimilarErrorToken;
     private _nodeMaker;
 }

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

@@ -16,22 +16,31 @@
 import { Injector } from '@wendellhu/redi';
 import { AstNodePromiseType } from '../../basics/common';
 import type { BaseFunction } from '../../functions/base-function';
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
+import { IFormulaRuntimeService } from '../../services/runtime.service';
 import type { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class FunctionNode extends BaseAstNode {
     private _functionExecutor;
-    constructor(token: string, _functionExecutor: BaseFunction);
+    private _currentConfigService;
+    private _runtimeService;
+    constructor(token: string, _functionExecutor: BaseFunction, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService);
     get nodeType(): NodeType;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
+    private _calculate;
+    private _setRefInfo;
+    private _setRefData;
 }
 export declare class FunctionNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
+    private readonly _currentConfigService;
+    private readonly _runtimeService;
     private readonly _injector;
-    constructor(_functionService: IFunctionService, _injector: Injector);
+    constructor(_functionService: IFunctionService, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _injector: Injector);
     get zIndex(): number;
     create(token: string): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AstNodePromiseType } from '../../basics/common';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { LexerNode } from '../analysis/lexer-node';
 import { Interpreter } from '../interpreter/interpreter';
@@ -32,7 +31,6 @@ export declare class LambdaNode extends BaseAstNode {
     isFunctionParameter(): boolean;
     getLambdaId(): string;
     execute(): void;
-    executeAsync(): Promise<AstNodePromiseType>;
 }
 export declare class LambdaNodeFactory extends BaseAstNodeFactory {
     private readonly _runtimeService;

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

@@ -26,7 +26,6 @@ export declare class LambdaParameterNode extends BaseAstNode {
     getCurrentLambdaPrivacyVar(): LambdaPrivacyVarType;
     get nodeType(): NodeType;
     execute(): void;
-    private _getRootLexerNode;
 }
 export declare class LambdaParameterNodeFactory extends BaseAstNodeFactory {
     get zIndex(): number;

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

@@ -33,7 +33,9 @@ export declare class FormulaDependencyTree extends Disposable {
     formula: string;
     row: number;
     column: number;
-    subComponentId: string;
+    rowCount: number;
+    columnCount: number;
+    subUnitId: string;
     unitId: string;
     rangeList: IUnitRange[];
     formulaId: Nullable<string>;

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

@@ -19,7 +19,7 @@ import type { IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../../b
 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, NumberValueObject, StringValueObject } from '../value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } 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>;
@@ -30,8 +30,6 @@ export declare class BaseReferenceObject extends ObjectClassType {
     private _defaultSheetId;
     private _rangeData;
     private _unitData;
-    private _rowCount;
-    private _columnCount;
     private _defaultUnitId;
     private _forcedUnitId;
     private _runtimeData;
@@ -42,6 +40,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     private _refOffsetY;
     constructor(_token: string);
     dispose(): void;
+    isExceedRange(): boolean;
     setRefOffset(x?: number, y?: number): void;
     getRefOffset(): {
         x: number;
@@ -55,7 +54,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     };
     isReferenceObject(): boolean;
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
-    getFirstCell(): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getFirstCell(): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
     getRangeData(): IRange;
     setRangeData(range: IRange): void;
     getUnitId(): string;
@@ -64,7 +63,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     getForcedUnitId(): string;
     setForcedSheetId(sheetNameMap: IUnitSheetNameMap): void;
     setForcedSheetIdDirect(sheetId: string): void;
-    getForcedSheetId(): string;
+    getForcedSheetId(): Nullable<string>;
     setForcedSheetName(sheetName: string): void;
     getForcedSheetName(): string;
     setDefaultSheetId(sheetId: string): void;
@@ -94,23 +93,29 @@ export declare class BaseReferenceObject extends ObjectClassType {
     isTable(): boolean;
     unionBy(referenceObject: BaseReferenceObject): NodeValueType;
     unionRange(rangeData1: IRange, rangeData2: IRange): IRange;
-    getCellValueObject(cell: ICellData): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
-    getCellByRow(row: number): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
-    getCellByColumn(column: number): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getCellValueObject(cell: ICellData): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getCellByRow(row: number): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getCellByColumn(column: number): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
     getCurrentActiveSheetData(): import("../../basics/common").ISheetItem;
-    getCurrentRuntimeSheetData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
-    getCurrentActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
-    getCurrentRuntimeActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
+    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): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
-    toArrayValueObject(): ArrayValueObject;
+    getCellByPosition(row?: number, column?: number): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    toArrayValueObject(useCache?: boolean): ArrayValueObject;
     toUnitRange(): {
-        range: IRange;
+        range: {
+            startRow: number;
+            endRow: number;
+            startColumn: number;
+            endColumn: number;
+        };
         sheetId: string;
         unitId: string;
     };
     private _checkIfWorksheetMiss;
+    private _getBlankArrayValueObject;
 }
 export declare class AsyncObject extends ObjectClassType {
     private _promise;

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

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IRange } from '@univerjs/core';
+import type { IRange, Nullable } from '@univerjs/core';
 import { BaseReferenceObject } from './base-reference-object';
 export declare class RangeReferenceObject extends BaseReferenceObject {
-    constructor(range: IRange, forcedSheetId?: string, forcedUnitId?: string);
+    constructor(range: IRange, forcedSheetId?: Nullable<string>, forcedUnitId?: string);
     isRange(): boolean;
 }

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

@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 import { compareToken } from '../../basics/token';
+export declare enum ArrayBinarySearchType {
+    MIN = 0,
+    MAX = 1
+}
 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/value-object/array-value-object.d.ts

@@ -15,20 +15,23 @@
  */
 import { type Nullable } from '@univerjs/core';
 import { compareToken } from '../../basics/token';
+import { ArrayBinarySearchType } from '../utils/compare';
 import type { callbackMapFnType, callbackProductFnType, IArrayValueObject } from './base-value-object';
 import { BaseValueObject, ErrorValueObject } from './base-value-object';
-import { BooleanValueObject, NumberValueObject, StringValueObject } from './primitive-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>>): BaseValueObject[][];
-export declare function transformToValue(array?: BaseValueObject[][]): (string | number | boolean)[][];
+export declare function transformToValueObject(array?: Array<Array<number | string | boolean | null>>): BaseValueObject[][];
+export declare function transformToValue(array?: BaseValueObject[][]): (string | number | boolean | null)[][];
 export declare class ArrayValueObject extends BaseValueObject {
-    private _value;
+    private _values;
     private _rowCount;
     private _columnCount;
     private _unitId;
     private _sheetId;
     private _currentRow;
     private _currentColumn;
+    private _sliceCache;
+    private _flattenCache;
     constructor(rawValue: string | IArrayValueObject);
     dispose(): void;
     getRowCount(): number;
@@ -75,7 +78,7 @@ export declare class ArrayValueObject extends BaseValueObject {
      * @columnParam start:stop:step
      * @param takeArray
      */
-    slice(rowParam: Nullable<Array<Nullable<number>>>, columnParam: Nullable<Array<Nullable<number>>>): ArrayValueObject;
+    slice(rowParam: Nullable<Array<Nullable<number>>>, columnParam: Nullable<Array<Nullable<number>>>): ArrayValueObject | undefined;
     sum(): BaseValueObject;
     max(): BaseValueObject;
     min(): BaseValueObject;
@@ -85,6 +88,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     sortByRow(index: number): void;
     sortByColumn(index: number): void;
     transpose(): ArrayValueObject;
+    binarySearch(valueObject: BaseValueObject, searchType?: ArrayBinarySearchType): number | null | undefined;
     getNegative(): BaseValueObject;
     getReciprocal(): BaseValueObject;
     plus(valueObject: BaseValueObject): BaseValueObject;
@@ -132,7 +136,8 @@ export declare class ArrayValueObject extends BaseValueObject {
     floorInverse(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
     ceilInverse(valueObject: BaseValueObject): BaseValueObject;
-    toValue(): (string | number | boolean)[][];
+    toValue(): (string | number | boolean | null)[][];
+    private _clearCache;
     private _sort;
     private _transposeArray;
     private _batchOperator;
@@ -143,5 +148,5 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _createNewArray;
 }
 export declare class ValueObjectFactory {
-    static create(rawValue: string | number | boolean): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    static create(rawValue: string | number | boolean | null): NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
 }

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

@@ -33,6 +33,16 @@ export declare class BaseValueObject extends ObjectClassType {
     private _rawValue;
     constructor(_rawValue: string | number | boolean);
     isValueObject(): boolean;
+    toUnitRange(): {
+        range: {
+            startColumn: number;
+            startRow: number;
+            endRow: number;
+            endColumn: number;
+        };
+        sheetId: string;
+        unitId: string;
+    };
     getValue(): string | number | boolean;
     getArrayValue(): BaseValueObject[][];
     setValue(value: string | number | boolean): void;
@@ -125,7 +135,11 @@ export declare class ErrorValueObject extends BaseValueObject {
     private _errorType;
     private _errorContent;
     constructor(_errorType: ErrorType, _errorContent?: string);
+    /**
+     * @deprecated use 'new' to replace.
+     */
     static create(errorType: ErrorType, errorContent?: string): ErrorValueObject;
+    getValue(): ErrorType;
     getErrorType(): ErrorType;
     getErrorContent(): string;
     isEqualType(object: ObjectClassType): boolean;

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

@@ -15,6 +15,7 @@
  */
 import { compareToken } from '../../basics/token';
 import { BaseValueObject } from './base-value-object';
+export type PrimitiveValueType = string | boolean | number | null;
 export declare class NullValueObject extends BaseValueObject {
     isNull(): boolean;
     plus(valueObject: BaseValueObject): BaseValueObject;

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

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

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

@@ -14,5 +14,4 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_ARRAY {
-    MAKEARRAY = "MAKEARRAY"
 }