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

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

@@ -0,0 +1,80 @@
+/**
+ * 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 { IRange } 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;
+}
+/**
+ *
+ * @param singleRefString for example A1 or B10,  not A1:B10
+ */
+export declare function getAbsoluteRefTypeWithSingleString(singleRefString: string): AbsoluteRefType;
+/**
+ *
+ * @param refString for example A1:B10
+ */
+export declare function getAbsoluteRefTypeWitString(refString: string): IAbsoluteRefTypeForRange;
+/**
+ * Serialize an `IRange` into a string.
+ * @param range The `IRange` to be serialized
+ */
+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;
+/**
+ * Serialize an `IRange` and a sheetID into a string.
+ * @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 handleRefStringInfo(refString: string): {
+    refBody: string;
+    sheetName: string;
+    unitId: string;
+};
+export declare function deserializeRangeWithSheet(refString: string): IGridRangeName;
+/**
+ * Determine whether the sheet name needs to be wrapped in quotes
+ * Excel will quote the worksheet name if any of the following is true:
+ *  - It contains any space or punctuation characters, such as  ()$,;-{}"'（）【】“”‘’%… and many more
+ *  - It is a valid cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
+ *  - It is a valid cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
+ *  - It starts with a non-letter, e.g. 99, 1.5, 12a, 💩a
+ *  - Excel will not quote worksheet names if they only contain non-punctuation, non-letter characters in non-initial positions. For example, a💩 remains unquoted.*
+ *  In addition, if a worksheet name contains single quotes, these will be doubled up within the name itself. For example, the sheet name a'b'c becomes 'a''b''c'.
+ *
+ *  reference https://stackoverflow.com/questions/41677779/when-does-excel-surround-sheet-names-with-single-quotes-in-workbook-xml-or-othe
+ *
+ * @param name Sheet name
+ * @returns Result
+ */
+export declare function needsQuoting(name: 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,16 +78,17 @@ 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;
+    sortByRow(index: number): void;
+    sortByColumn(index: number): void;
+    transpose(): ArrayValueObject;
+    binarySearch(valueObject: BaseValueObject, searchType?: ArrayBinarySearchType): number | null | undefined;
     sum(): BaseValueObject;
     max(): BaseValueObject;
     min(): BaseValueObject;
     count(): BaseValueObject;
     countA(): BaseValueObject;
     countBlank(): BaseValueObject;
-    sortByRow(index: number): void;
-    sortByColumn(index: number): void;
-    transpose(): ArrayValueObject;
     getNegative(): BaseValueObject;
     getReciprocal(): BaseValueObject;
     plus(valueObject: BaseValueObject): BaseValueObject;
@@ -92,7 +96,6 @@ export declare class ArrayValueObject extends BaseValueObject {
     multiply(valueObject: BaseValueObject): BaseValueObject;
     divided(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
-    wildcard(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
@@ -132,7 +135,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 +147,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): ErrorValueObject | NullValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
 }

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

@@ -17,7 +17,6 @@ import { ConcatenateType } from '../../basics/common';
 import { ErrorType } from '../../basics/error-type';
 import { ObjectClassType } from '../../basics/object-class-type';
 import { compareToken } from '../../basics/token';
-import type { StringValueObject } from './primitive-object';
 export type callbackMapFnType = (currentValue: BaseValueObject, row: number, column: number) => BaseValueObject;
 export type callbackProductFnType = (currentValue: BaseValueObject, operationValue: BaseValueObject) => BaseValueObject;
 export interface IArrayValueObject {
@@ -33,6 +32,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;
@@ -44,6 +53,12 @@ export declare class BaseValueObject extends ObjectClassType {
     isLambda(): boolean;
     isError(): boolean;
     isNull(): boolean;
+    sum(): BaseValueObject;
+    max(): BaseValueObject;
+    min(): BaseValueObject;
+    count(): BaseValueObject;
+    countA(): BaseValueObject;
+    countBlank(): BaseValueObject;
     getNegative(): BaseValueObject;
     getReciprocal(): BaseValueObject;
     plus(valueObject: BaseValueObject): BaseValueObject;
@@ -53,7 +68,6 @@ export declare class BaseValueObject extends ObjectClassType {
     map(callbackFn: callbackMapFnType): BaseValueObject;
     product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
-    wildcard(valueObject: StringValueObject, operator: compareToken): BaseValueObject;
     isEqual(valueObject: BaseValueObject): BaseValueObject;
     isNotEqual(valueObject: BaseValueObject): BaseValueObject;
     isGreaterThanOrEqual(valueObject: BaseValueObject): BaseValueObject;
@@ -94,20 +108,20 @@ export declare class BaseValueObject extends ObjectClassType {
     /**
      * Calculate the median of the entire array.
      *
-     * https://numpy.org/doc/stable/reference/generated/numpy.median.html
+     * reference https://numpy.org/doc/stable/reference/generated/numpy.median.html
      *
      */
     median(): BaseValueObject;
     /**
      * Calculate the variance of the entire array.
      *
-     * https://numpy.org/doc/stable/reference/generated/numpy.var.html
+     * reference https://numpy.org/doc/stable/reference/generated/numpy.var.html
      */
     var(): BaseValueObject;
     /**
      * Calculate the standard deviation of the entire array.
      *
-     * https://numpy.org/doc/stable/reference/generated/numpy.std.html
+     * reference https://numpy.org/doc/stable/reference/generated/numpy.std.html
      */
     std(): BaseValueObject;
     log(): BaseValueObject;
@@ -125,7 +139,7 @@ export declare class ErrorValueObject extends BaseValueObject {
     private _errorType;
     private _errorContent;
     constructor(_errorType: ErrorType, _errorContent?: string);
-    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;
@@ -140,7 +141,6 @@ export declare class StringValueObject extends BaseValueObject {
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
-    wildcard(valueObject: StringValueObject, operator: compareToken): BaseValueObject;
     compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
     private _checkWildcard;
 }

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"
 }

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

@@ -13,16 +13,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
-import type { IFunctionNames } from '..';
+import type { IFunctionNames } from '../basics/function';
 import type { FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
-import { type BaseValueObject } from '../engine/value-object/base-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 {
     private _name;
+    private _unitId;
+    private _subUnitId;
+    private _row;
+    private _column;
     constructor(_name: IFunctionNames);
     get name(): IFunctionNames;
+    get unitId(): Nullable<string>;
+    get subUnitId(): Nullable<string>;
+    get row(): number;
+    get column(): number;
     isAsync(): boolean;
     isAddress(): boolean;
+    isCustom(): boolean;
+    setRefInfo(unitId: string, subUnitId: string, row: number, column: number): void;
+    calculateCustom(...arg: Array<PrimitiveValueType | PrimitiveValueType[][]>): PrimitiveValueType | PrimitiveValueType[][];
     calculate(...arg: BaseValueObject[]): NodeValueType;
     checkArrayType(variant: FunctionVariantType): boolean;
+    /**
+     * Starting with 1
+     * For instance, The column number (starting with 1 for the left-most column of table_array) that contains the return value.
+     * https://support.microsoft.com/en-us/office/vlookup-function-0bbc8083-26fe-4963-8ab8-93a18ad188a1
+     * @param indexNum
+     * @returns
+     */
+    getIndexNumValue(indexNum: BaseValueObject): 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
+     * Approximate match - 1/TRUE
+     * Exact match - 0/FALSE
+     * https://support.microsoft.com/en-us/office/vlookup-function-0bbc8083-26fe-4963-8ab8-93a18ad188a1
+     * For instance A1, A logical value that specifies what type of reference is contained in the cell ref_text.
+     * If a1 is TRUE or omitted, ref_text is interpreted as an A1-style reference.
+     * If a1 is FALSE, ref_text is interpreted as an R1C1-style reference.
+     * https://support.microsoft.com/zh-cn/office/indirect-%E5%87%BD%E6%95%B0-474b3a3a-8a26-4f44-b491-92b6306fa261
+     * @param logicValueObject
+     * @returns
+     */
+    getZeroOrOneByOneDefault(logicValueObject?: BaseValueObject): number | undefined;
 }

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

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

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

@@ -14,5 +14,42 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_COMPATIBILITY {
-    CONCATENATE = "CONCATENATE"
+    BETADIST = "BETADIST",
+    BETAINV = "BETAINV",
+    BINOMDIST = "BINOMDIST",
+    CHIDIST = "CHIDIST",
+    CHIINV = "CHIINV",
+    CHITEST = "CHITEST",
+    CONFIDENCE = "CONFIDENCE",
+    COVAR = "COVAR",
+    CRITBINOM = "CRITBINOM",
+    EXPONDIST = "EXPONDIST",
+    FDIST = "FDIST",
+    FINV = "FINV",
+    FTEST = "FTEST",
+    GAMMADIST = "GAMMADIST",
+    GAMMAINV = "GAMMAINV",
+    HYPGEOMDIST = "HYPGEOMDIST",
+    LOGINV = "LOGINV",
+    LOGNORMDIST = "LOGNORMDIST",
+    MODE = "MODE",
+    NEGBINOMDIST = "NEGBINOMDIST",
+    NORMDIST = "NORMDIST",
+    NORMINV = "NORMINV",
+    NORMSDIST = "NORMSDIST",
+    NORMSINV = "NORMSINV",
+    PERCENTILE = "PERCENTILE",
+    PERCENTRANK = "PERCENTRANK",
+    POISSON = "POISSON",
+    QUARTILE = "QUARTILE",
+    RANK = "RANK",
+    STDEV = "STDEV",
+    STDEVP = "STDEVP",
+    TDIST = "TDIST",
+    TINV = "TINV",
+    TTEST = "TTEST",
+    VAR = "VAR",
+    VARP = "VARP",
+    WEIBULL = "WEIBULL",
+    ZTEST = "ZTEST"
 }

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

@@ -14,4 +14,11 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_CUBE {
+    CUBEKPIMEMBER = "CUBEKPIMEMBER",
+    CUBEMEMBER = "CUBEMEMBER",
+    CUBEMEMBERPROPERTY = "CUBEMEMBERPROPERTY",
+    CUBERANKEDMEMBER = "CUBERANKEDMEMBER",
+    CUBESET = "CUBESET",
+    CUBESETCOUNT = "CUBESETCOUNT",
+    CUBEVALUE = "CUBEVALUE"
 }

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

@@ -14,4 +14,16 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_DATABASE {
+    DAVERAGE = "DAVERAGE",
+    DCOUNT = "DCOUNT",
+    DCOUNTA = "DCOUNTA",
+    DGET = "DGET",
+    DMAX = "DMAX",
+    DMIN = "DMIN",
+    DPRODUCT = "DPRODUCT",
+    DSTDEV = "DSTDEV",
+    DSTDEVP = "DSTDEVP",
+    DSUM = "DSUM",
+    DVAR = "DVAR",
+    DVARP = "DVARP"
 }

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

@@ -14,4 +14,29 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_DATE {
+    DATE = "DATE",
+    DATEDIF = "DATEDIF",
+    DATEVALUE = "DATEVALUE",
+    DAY = "DAY",
+    DAYS = "DAYS",
+    DAYS360 = "DAYS360",
+    EDATE = "EDATE",
+    EOMONTH = "EOMONTH",
+    HOUR = "HOUR",
+    ISOWEEKNUM = "ISOWEEKNUM",
+    MINUTE = "MINUTE",
+    MONTH = "MONTH",
+    NETWORKDAYS = "NETWORKDAYS",
+    NETWORKDAYS_INTL = "NETWORKDAYS.INTL",
+    NOW = "NOW",
+    SECOND = "SECOND",
+    TIME = "TIME",
+    TIMEVALUE = "TIMEVALUE",
+    TODAY = "TODAY",
+    WEEKDAY = "WEEKDAY",
+    WEEKNUM = "WEEKNUM",
+    WORKDAY = "WORKDAY",
+    WORKDAY_INTL = "WORKDAY.INTL",
+    YEAR = "YEAR",
+    YEARFRAC = "YEARFRAC"
 }

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

@@ -14,4 +14,58 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_ENGINEERING {
+    BESSELI = "BESSELI",
+    BESSELJ = "BESSELJ",
+    BESSELK = "BESSELK",
+    BESSELY = "BESSELY",
+    BIN2DEC = "BIN2DEC",
+    BIN2HEX = "BIN2HEX",
+    BIN2OCT = "BIN2OCT",
+    BITAND = "BITAND",
+    BITLSHIFT = "BITLSHIFT",
+    BITOR = "BITOR",
+    BITRSHIFT = "BITRSHIFT",
+    BITXOR = "BITXOR",
+    COMPLEX = "COMPLEX",
+    CONVERT = "CONVERT",
+    DEC2BIN = "DEC2BIN",
+    DEC2HEX = "DEC2HEX",
+    DEC2OCT = "DEC2OCT",
+    DELTA = "DELTA",
+    ERF = "ERF",
+    ERF_PRECISE = "ERF.PRECISE",
+    ERFC = "ERFC",
+    ERFC_PRECISE = "ERFC.PRECISE",
+    GESTEP = "GESTEP",
+    HEX2BIN = "HEX2BIN",
+    HEX2DEC = "HEX2DEC",
+    HEX2OCT = "HEX2OCT",
+    IMABS = "IMABS",
+    IMAGINARY = "IMAGINARY",
+    IMARGUMENT = "IMARGUMENT",
+    IMCONJUGATE = "IMCONJUGATE",
+    IMCOS = "IMCOS",
+    IMCOSH = "IMCOSH",
+    IMCOT = "IMCOT",
+    IMCSC = "IMCSC",
+    IMCSCH = "IMCSCH",
+    IMDIV = "IMDIV",
+    IMEXP = "IMEXP",
+    IMLN = "IMLN",
+    IMLOG10 = "IMLOG10",
+    IMLOG2 = "IMLOG2",
+    IMPOWER = "IMPOWER",
+    IMPRODUCT = "IMPRODUCT",
+    IMREAL = "IMREAL",
+    IMSEC = "IMSEC",
+    IMSECH = "IMSECH",
+    IMSIN = "IMSIN",
+    IMSINH = "IMSINH",
+    IMSQRT = "IMSQRT",
+    IMSUB = "IMSUB",
+    IMSUM = "IMSUM",
+    IMTAN = "IMTAN",
+    OCT2BIN = "OCT2BIN",
+    OCT2DEC = "OCT2DEC",
+    OCT2HEX = "OCT2HEX"
 }

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

@@ -14,4 +14,59 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_FINANCIAL {
+    ACCRINT = "ACCRINT",
+    ACCRINTM = "ACCRINTM",
+    AMORDEGRC = "AMORDEGRC",
+    AMORLINC = "AMORLINC",
+    COUPDAYBS = "COUPDAYBS",
+    COUPDAYS = "COUPDAYS",
+    COUPDAYSNC = "COUPDAYSNC",
+    COUPNCD = "COUPNCD",
+    COUPNUM = "COUPNUM",
+    COUPPCD = "COUPPCD",
+    CUMIPMT = "CUMIPMT",
+    CUMPRINC = "CUMPRINC",
+    DB = "DB",
+    DDB = "DDB",
+    DISC = "DISC",
+    DOLLARDE = "DOLLARDE",
+    DOLLARFR = "DOLLARFR",
+    DURATION = "DURATION",
+    EFFECT = "EFFECT",
+    FV = "FV",
+    FVSCHEDULE = "FVSCHEDULE",
+    INTRATE = "INTRATE",
+    IPMT = "IPMT",
+    IRR = "IRR",
+    ISPMT = "ISPMT",
+    MDURATION = "MDURATION",
+    MIRR = "MIRR",
+    NOMINAL = "NOMINAL",
+    NPER = "NPER",
+    NPV = "NPV",
+    ODDFPRICE = "ODDFPRICE",
+    ODDFYIELD = "ODDFYIELD",
+    ODDLPRICE = "ODDLPRICE",
+    ODDLYIELD = "ODDLYIELD",
+    PDURATION = "PDURATION",
+    PMT = "PMT",
+    PPMT = "PPMT",
+    PRICE = "PRICE",
+    PRICEDISC = "PRICEDISC",
+    PRICEMAT = "PRICEMAT",
+    PV = "PV",
+    RATE = "RATE",
+    RECEIVED = "RECEIVED",
+    RRI = "RRI",
+    SLN = "SLN",
+    SYD = "SYD",
+    TBILLEQ = "TBILLEQ",
+    TBILLPRICE = "TBILLPRICE",
+    TBILLYIELD = "TBILLYIELD",
+    VDB = "VDB",
+    XIRR = "XIRR",
+    XNPV = "XNPV",
+    YIELD = "YIELD",
+    YIELDDISC = "YIELDDISC",
+    YIELDMAT = "YIELDMAT"
 }

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

@@ -14,4 +14,25 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_INFORMATION {
+    CELL = "CELL",
+    ERROR_TYPE = "ERROR.TYPE",
+    INFO = "INFO",
+    ISBLANK = "ISBLANK",
+    ISERR = "ISERR",
+    ISERROR = "ISERROR",
+    ISEVEN = "ISEVEN",
+    ISFORMULA = "ISFORMULA",
+    ISLOGICAL = "ISLOGICAL",
+    ISNA = "ISNA",
+    ISNONTEXT = "ISNONTEXT",
+    ISNUMBER = "ISNUMBER",
+    ISODD = "ISODD",
+    ISOMITTED = "ISOMITTED",
+    ISREF = "ISREF",
+    ISTEXT = "ISTEXT",
+    N = "N",
+    NA = "NA",
+    SHEET = "SHEET",
+    SHEETS = "SHEETS",
+    TYPE = "TYPE"
 }

package/lib/types/functions/logical/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 functionLogical: never[];
+import { FUNCTION_NAMES_LOGICAL } from './function-names';
+import { Makearray } from './makearray';
+export declare const functionLogical: (FUNCTION_NAMES_LOGICAL | typeof Makearray)[][];

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

@@ -14,4 +14,23 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_LOGICAL {
+    AND = "AND",
+    BYCOL = "BYCOL",
+    BYROW = "BYROW",
+    FALSE = "FALSE",
+    IF = "IF",
+    IFERROR = "IFERROR",
+    IFNA = "IFNA",
+    IFS = "IFS",
+    LAMBDA = "LAMBDA",
+    LET = "LET",
+    MAKEARRAY = "MAKEARRAY",
+    MAP = "MAP",
+    NOT = "NOT",
+    OR = "OR",
+    REDUCE = "REDUCE",
+    SCAN = "SCAN",
+    SWITCH = "SWITCH",
+    TRUE = "TRUE",
+    XOR = "XOR"
 }

package/lib/types/functions/logical/lambda/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 BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+/**
+ * Lambda functions are unique and are generated directly by the higher level.
+ * Please refer to the lambdaNode; here, it serves the purpose of a placeholder for the formula.
+ */
+export declare class Lambda extends BaseFunction {
+    calculate(...variants: BaseValueObject[]): ErrorValueObject;
+}

package/lib/types/functions/logical/makearray/__test__/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 {};