@univerjs/engine-formula 0.1.1 → 0.1.3

package/lib/types/basics/__tests__/regex.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/basics/common.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { BooleanNumber, ICellData, IObjectMatrixPrimitiveType, IRange, IUnitRange, Nullable, ObjectMatrix } from '@univerjs/core';
+import type { BooleanNumber, ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix } from '@univerjs/core';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
 export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
 export declare const REFERENCE_OBJECT_CLASS_TYPE = "referenceObject";
@@ -30,6 +30,8 @@ export interface ISheetItem {
     cellData: ObjectMatrix<ICellData>;
     rowCount: number;
     columnCount: number;
+    rowData: IObjectArrayPrimitiveType<Partial<IRowData>>;
+    columnData: IObjectArrayPrimitiveType<Partial<IColumnData>>;
 }
 export interface ISheetData {
     [sheetId: string]: ISheetItem;
@@ -46,6 +48,11 @@ export interface IRuntimeUnitDataType {
         [sheetId: string]: ObjectMatrix<Nullable<ICellData>>;
     }>;
 }
+export interface IRuntimeUnitDataPrimitiveType {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<Nullable<ICellData>>;
+    }>;
+}
 export interface IRuntimeOtherUnitDataType {
     [unitId: string]: Nullable<{
         [sheetId: string]: Nullable<{
@@ -80,10 +87,7 @@ export interface IFeatureDirtyRangeType {
         [sheetId: string]: IRange[];
     }>;
 }
-export interface IArrayFormulaUnitCellType {
-    [unitId: string]: Nullable<{
-        [sheetId: string]: IObjectMatrixPrimitiveType<Nullable<ICellData>>;
-    }>;
+export interface IArrayFormulaUnitCellType extends IRuntimeUnitDataPrimitiveType {
 }
 export interface IFormulaData {
     [unitId: string]: Nullable<{

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

@@ -28,3 +28,11 @@ export declare const DEFFAULT_DATE_FORMAT = "yyyy-mm-dd;@";
 export declare function excelDateSerial(date: Date): number;
 export declare function excelSerialToDate(serial: number): Date;
 export declare function formatDateDefault(date: Date): string;
+/**
+ * Validate date string
+ *
+ * TODO @Dushusir: Internationalization and more format support, can be reused when editing and saving cells, like "2020年1月1日"
+ * @param dateStr
+ * @returns
+ */
+export declare function isValidDateStr(dateStr: string): boolean;

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

@@ -18,3 +18,8 @@ export declare const FORMULA_LEXER_TOKENS: (operatorToken | suffixToken | compar
 export declare function isFormulaLexerToken(str: string): boolean;
 export declare function includeFormulaLexerToken(str: string): boolean;
 export declare function normalizeSheetName(sheetName: string): string;
+/**
+ * Determine whether the character is a token keyword for the formula engine.
+ * @param char
+ */
+export declare function matchRefDrawToken(char: string): boolean;

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

@@ -13,16 +13,18 @@
  * 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 UNIT_NAME_SHEET_NAME_REGEX = "'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?";
 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_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*?\\[((?<!#).)*\\]\\])?$";

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

@@ -13,5 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IArrayFormulaUnitCellType, IRuntimeUnitDataType } from './common';
+import type { IArrayFormulaUnitCellType, IRuntimeUnitDataPrimitiveType, IRuntimeUnitDataType } from './common';
 export declare function convertUnitDataToRuntime(unitData: IArrayFormulaUnitCellType): IRuntimeUnitDataType;
+export declare function convertRuntimeToUnitData(unitData: IRuntimeUnitDataType): IRuntimeUnitDataPrimitiveType;

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

@@ -20,3 +20,4 @@ export declare const DEFAULT_TOKEN_TYPE_LAMBDA_RUNTIME_PARAMETER = "LR_1";
 export declare const DEFAULT_TOKEN_TYPE_LAMBDA_OMIT_PARAMETER = "LO_1";
 export declare const DEFAULT_TOKEN_LET_FUNCTION_NAME = "LET";
 export declare const DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME = "LAMBDA";
+export declare const DEFAULT_TOKEN_CUBE_FUNCTION_NAME = "CUBE";

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

@@ -59,3 +59,4 @@ export declare enum prefixToken {
     AT = "@",
     MINUS = "-"
 }
+export declare const SPACE_TOKEN = " ";

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import type { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
-import type { IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../../basics/common';
+import type { IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
 import type { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation {
     dirtyRanges: IUnitRange[];
@@ -38,7 +38,7 @@ export interface ISetFormulaCalculationNotificationMutation {
 }
 export declare const SetFormulaCalculationNotificationMutation: IMutation<ISetFormulaCalculationNotificationMutation>;
 export interface ISetFormulaCalculationResultMutation {
-    unitData: IRuntimeUnitDataType;
+    unitData: IRuntimeUnitDataPrimitiveType;
     unitOtherData: IRuntimeOtherUnitDataType;
 }
 export declare const SetFormulaCalculationResultMutation: IMutation<ISetFormulaCalculationResultMutation>;

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

@@ -52,7 +52,6 @@ export declare class LexerTreeBuilder extends Disposable {
     /**
      * Estimate the number of right brackets that need to be automatically added to the end of the formula.
      * @param formulaString
-     * @returns
      */
     checkIfAddBracket(formulaString: string): number;
     sequenceNodesBuilder(formulaString: string): (string | ISequenceNode)[] | undefined;
@@ -72,6 +71,10 @@ export declare class LexerTreeBuilder extends Disposable {
         hasDefinedName: boolean;
     }): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
     private _suffixExpressionHandler;
+    private _checkCloseBracket;
+    private _checkOpenBracket;
+    private _checkOperator;
+    private _deletePlusForPreNode;
     private _resetCurrentLexerNode;
     private _resetSegment;
     private _openBracket;
@@ -79,6 +82,7 @@ export declare class LexerTreeBuilder extends Disposable {
     private _openSquareBracket;
     private _closeSquareBracket;
     private _getCurrentBracket;
+    private _changeCurrentBracket;
     private _openBraces;
     private _closeBraces;
     private _openSingleQuotation;

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

@@ -48,7 +48,6 @@ export declare class AstTreeBuilder extends Disposable {
     parse(lexerNode: LexerNode, refOffsetX?: number, refOffsetY?: number): Nullable<BaseAstNode>;
     private _lambdaParameterHandler;
     private _changeLetToLambda;
-    private _getTopParent;
     private _parse;
     private _checkAstNode;
     private _initializeAstNode;

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

@@ -18,9 +18,9 @@ import { Injector } from '@wendellhu/redi';
 import { IDefinedNamesService } from '../../services/defined-names.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { ISuperTableService } from '../../services/super-table.service';
-import { Lexer } from '../analysis/lexer';
 import { LexerNode } from '../analysis/lexer-node';
 import type { BaseReferenceObject } from '../reference-object/base-reference-object';
+import { IFunctionService } from '../../services/function.service';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
@@ -37,9 +37,9 @@ export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
     private readonly _definedNamesService;
     private readonly _superTableService;
     private readonly _formulaRuntimeService;
-    private readonly _lexer;
+    private readonly _functionService;
     private readonly _injector;
-    constructor(_definedNamesService: IDefinedNamesService, _superTableService: ISuperTableService, _formulaRuntimeService: IFormulaRuntimeService, _lexer: Lexer, _injector: Injector);
+    constructor(_definedNamesService: IDefinedNamesService, _superTableService: ISuperTableService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService, _injector: Injector);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ReferenceNode | undefined;
 }

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

@@ -89,6 +89,8 @@ export declare class BaseReferenceObject extends ObjectClassType {
     setNumfmtItemData(numfmtItemData: INumfmtItemMap): void;
     getRowCount(): number;
     getColumnCount(): number;
+    getRowData(): import("@univerjs/core").IObjectArrayPrimitiveType<Partial<import("@univerjs/core").IRowData>>;
+    getColumnData(): import("@univerjs/core").IObjectArrayPrimitiveType<Partial<import("@univerjs/core").IColumnData>>;
     isCell(): boolean;
     isColumn(): boolean;
     isRow(): boolean;

package/lib/types/engine/utils/__tests__/math-kit.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/utils/__tests__/object-covert.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/utils/ast-node-tool.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
+import type { BaseAstNode } from '../ast-node/base-ast-node';
+export declare function getAstNodeTopParent(node: BaseAstNode): Nullable<BaseAstNode>;

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

@@ -28,3 +28,4 @@ export declare function isWildcard(str: string): boolean;
 export declare function isMatchWildcard(currentValue: string, value: string): boolean;
 export declare function replaceWildcard(value: string): string;
 export declare function compareWithWildcard(currentValue: string, value: string, operator: compareToken): boolean;
+export declare function escapeRegExp(str: string): string;

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

@@ -27,4 +27,11 @@ export declare function multiply(a: number, b: number): number;
 export declare function round(base: number, precision: number): number;
 export declare function floor(base: number, precision: number): number;
 export declare function ceil(base: number, precision: number): number;
+export declare function mod(base: number, divisor: number): number;
 export declare function pow(base: number, exponent: number): number;
+/**
+ * Excel can display numbers with up to about 15 digits of precision. This includes the sum of the integer part and the decimal part
+ * @param input
+ * @returns
+ */
+export declare function truncateNumber(input: number | string): number;

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

@@ -0,0 +1,18 @@
+/**
+ * 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 '../value-object/base-value-object';
+import { NumberValueObject } from '../value-object/primitive-object';
+export declare function convertTonNumber(valueObject: BaseValueObject): NumberValueObject;

package/lib/types/engine/utils/prefixHandler.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 { Injector } from '@wendellhu/redi';
+import type { Nullable } from '@univerjs/core';
+import type { IFunctionService } from '../../services/function.service';
+import { PrefixNode } from '../ast-node/prefix-node';
+export declare function prefixHandler(tokenTrim: string, functionService: IFunctionService, injector: Injector): {
+    tokenTrim: string;
+    minusPrefixNode: Nullable<PrefixNode>;
+    atPrefixNode: Nullable<PrefixNode>;
+};

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { type IRange } from '@univerjs/core';
-import type { IGridRangeName } from './reference';
-export declare function deserializeRangeForR1C1(refString: string, currentRow?: number, currentColumn?: number): IGridRangeName;
+import type { IRange, IUnitRangeName } from '@univerjs/core';
+export declare function deserializeRangeForR1C1(refString: string, currentRow?: number, currentColumn?: number): IUnitRangeName;
 export declare function serializeRangeToR1C1(range: IRange): string;

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

@@ -13,14 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IRange } from '@univerjs/core';
+import type { IRange, IUnitRangeName } from '@univerjs/core';
 import { AbsoluteRefType } from '@univerjs/core';
-export declare const UNIT_NAME_REGEX = "\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]";
-export interface IGridRangeName {
-    unitId: string;
-    sheetName: string;
-    range: IRange;
-}
 export interface IAbsoluteRefTypeForRange {
     startAbsoluteRefType: AbsoluteRefType;
     endAbsoluteRefType?: AbsoluteRefType;
@@ -44,7 +38,6 @@ export declare function serializeRange(range: IRange): string;
  * Serialize an `IRange` and a sheetID into a string.
  * @param sheetName
  * @param range
- * @returns
  */
 export declare function serializeRangeWithSheet(sheetName: string, range: IRange): string;
 /**
@@ -52,16 +45,15 @@ export declare function serializeRangeWithSheet(sheetName: string, range: IRange
  * @param unit unitId or unitName
  * @param sheetName
  * @param range
- * @returns
  */
 export declare function serializeRangeWithSpreadsheet(unit: string, sheetName: string, range: IRange): string;
-export declare function serializeRangeToRefString(gridRangeName: IGridRangeName): string;
+export declare function serializeRangeToRefString(gridRangeName: IUnitRangeName): string;
 export declare function handleRefStringInfo(refString: string): {
     refBody: string;
     sheetName: string;
     unitId: string;
 };
-export declare function deserializeRangeWithSheet(refString: string): IGridRangeName;
+export declare function deserializeRangeWithSheet(refString: string): IUnitRangeName;
 /**
  * Determine whether the sheet name needs to be wrapped in quotes
  * Excel will quote the worksheet name if any of the following is true:

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

@@ -128,6 +128,8 @@ export declare class ArrayValueObject extends BaseValueObject {
     minus(valueObject: BaseValueObject): BaseValueObject;
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
+    mod(valueObject: BaseValueObject): BaseValueObject;
+    modInverse(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
@@ -155,18 +157,37 @@ export declare class ArrayValueObject extends BaseValueObject {
     atanh(): BaseValueObject;
     atan2(valueObject: BaseValueObject): BaseValueObject;
     atan2Inverse(valueObject: BaseValueObject): BaseValueObject;
-    mean(): BaseValueObject;
+    mean(ddof?: number): BaseValueObject;
     median(): BaseValueObject;
-    var(): BaseValueObject;
     /**
-     * STDEV.P: ddof=0, ignore strings and booleans
-     * STDEV.S: ddof=1, ignore strings and booleans
+     * ┌──────────────┬────────────────────────────────┬───────────────────┐
+     * │ Function     │ Ignore logical values and text │ Type              │
+     * ├──────────────┼────────────────────────────────┼───────────────────┤
+     * │ VAR.S (VAR)  │ TRUE                           │ sample            │
+     * │ VAR.P (VARP) │ TRUE                           │ entire population │
+     * │ VARA         │ FALSE                          │ sample            │
+     * │ VARPA        │ FALSE                          │ entire population │
+     * └──────────────┴────────────────────────────────┴───────────────────┘
+     *
+     * for VARPA and VARA, strings and FALSE are counted as 0, TRUE is counted as 1
+     * for VAR.S/VAR, or VAR.P/VARP, strings,TRUE and FALSE are ignored
+     * Since sum ignores strings and booleans, they are ignored here too, and VAR.S and VAR.P are used more
+     *
+     * VAR.S assumes that its arguments are a sample of the population, like numpy.var(data, ddof=1)
+     * VAR.P assumes that its arguments are the entire population, like numpy.var(data, ddof=0)
+     * numpy.var uses ddof=0 (Delta Degrees of Freedom) by default, so we use ddof=0 here
+     *
+     */
+    var(ddof?: number): BaseValueObject;
+    /**
+     * STDEV.P (STDEVP): ddof=0, ignore strings and booleans
+     * STDEV.S (STDEV): ddof=1, ignore strings and booleans
      *
      * STDEVPA: ddof=0,
      * STDEVA: ddof=1,
      * @returns
      */
-    std(): BaseValueObject;
+    std(ddof?: number): BaseValueObject;
     log(): BaseValueObject;
     log10(): BaseValueObject;
     exp(): BaseValueObject;

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

@@ -46,6 +46,7 @@ export declare class BaseValueObject extends ObjectClassType {
     getArrayValue(): BaseValueObject[][];
     setValue(value: string | number | boolean): void;
     setArrayValue(value: BaseValueObject[][]): void;
+    isCube(): boolean;
     isArray(): boolean;
     isString(): boolean;
     isNumber(): boolean;
@@ -65,7 +66,18 @@ export declare class BaseValueObject extends ObjectClassType {
     minus(valueObject: BaseValueObject): BaseValueObject;
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
+    mod(valueObject: BaseValueObject): BaseValueObject;
+    /**
+     * return every value in the array after the callback function, excluding the error value
+     * @param callbackFn
+     * @returns
+     */
     map(callbackFn: callbackMapFnType): BaseValueObject;
+    /**
+     * return every value in the array after the callback function
+     * @param callbackFn
+     * @returns
+     */
     mapValue(callbackFn: callbackMapFnType): BaseValueObject;
     product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
@@ -81,6 +93,7 @@ export declare class BaseValueObject extends ObjectClassType {
     minusBy(value: string | number | boolean): BaseValueObject;
     multiplyBy(value: string | number | boolean): BaseValueObject;
     dividedBy(value: string | number | boolean): BaseValueObject;
+    modInverse(valueObject: BaseValueObject): BaseValueObject;
     compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
     concatenate(value: string | number | boolean, concatenateType?: ConcatenateType): string;
     pow(valueObject: BaseValueObject): BaseValueObject;

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

@@ -0,0 +1,29 @@
+/**
+ * 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 './array-value-object';
+import { BaseValueObject } from './base-value-object';
+import { NumberValueObject } from './primitive-object';
+export declare class CubeValueObject extends BaseValueObject {
+    isCube(): boolean;
+    private _values;
+    constructor(values: ArrayValueObject[]);
+    sum(): NumberValueObject;
+    max(): NumberValueObject;
+    min(): NumberValueObject;
+    count(): NumberValueObject;
+    countA(): NumberValueObject;
+    countBlank(): NumberValueObject;
+}

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

@@ -22,6 +22,7 @@ export declare class NullValueObject extends BaseValueObject {
     minus(valueObject: BaseValueObject): BaseValueObject;
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
+    mod(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
@@ -63,6 +64,7 @@ export declare class BooleanValueObject extends BaseValueObject {
     minus(valueObject: BaseValueObject): BaseValueObject;
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
+    mod(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
@@ -102,6 +104,7 @@ export declare class NumberValueObject extends BaseValueObject {
     minus(valueObject: BaseValueObject): BaseValueObject;
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
+    mod(valueObject: BaseValueObject): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;

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

@@ -21,13 +21,21 @@ 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';
+import { type PrimitiveValueType } from '../engine/value-object/primitive-object';
 export declare class BaseFunction extends Disposable {
     private _name;
     private _unitId;
     private _subUnitId;
     private _row;
     private _column;
+    /**
+     * Whether the function needs to expand the parameters
+     */
+    needsExpandParams: boolean;
+    /**
+     * Whether the function needs to pass in reference object
+     */
+    needsReferenceObject: boolean;
     constructor(_name: IFunctionNames);
     get name(): IFunctionNames;
     get unitId(): Nullable<string>;
@@ -82,4 +90,6 @@ export declare class BaseFunction extends Disposable {
     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;
 }

package/lib/types/functions/compatibility/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 functionCompatibility: never[];
+import { StdevS } from '../statistical/stdev-s';
+import { FUNCTION_NAMES_COMPATIBILITY } from './function-names';
+export declare const functionCompatibility: (FUNCTION_NAMES_COMPATIBILITY | typeof StdevS)[][];

package/lib/types/functions/date/day/index.d.ts

@@ -17,4 +17,5 @@ import type { BaseValueObject } from '../../../engine/value-object/base-value-ob
 import { BaseFunction } from '../../base-function';
 export declare class Day extends BaseFunction {
     calculate(serialNumber: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
 }

package/lib/types/functions/date/month/index.d.ts

@@ -17,4 +17,5 @@ import type { BaseValueObject } from '../../../engine/value-object/base-value-ob
 import { BaseFunction } from '../../base-function';
 export declare class Month extends BaseFunction {
     calculate(serialNumber: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
 }

package/lib/types/functions/date/year/index.d.ts

@@ -17,4 +17,5 @@ import type { BaseValueObject } from '../../../engine/value-object/base-value-ob
 import { BaseFunction } from '../../base-function';
 export declare class Year extends BaseFunction {
     calculate(serialNumber: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
 }

package/lib/types/functions/information/iserr/__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 {};