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

package/lib/types/basics/__tests__/date.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

@@ -60,7 +60,7 @@ export interface IUnitSheetNameMap {
 }
 export interface IDirtyUnitSheetNameMap {
     [unitId: string]: Nullable<{
-        [sheetId: string]: Nullable<string>;
+        [sheetId: string]: string;
     }>;
 }
 export interface IDirtyUnitFeatureMap {
@@ -97,6 +97,11 @@ export interface IOtherFormulaData {
         }>;
     }>;
 }
+export interface INumfmtItemMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<Nullable<string>>;
+    }>;
+}
 /**
  * @f  formulaString, the text string of the formula.
  * @si The formula ID can be utilized in scenarios such as copy-pasting and drag-filling to convert formulas into references, eliminating the need for recreating the formulaString.
@@ -131,6 +136,7 @@ export interface IFormulaDatasetConfig {
     dirtyRanges: IUnitRange[];
     dirtyNameMap: IDirtyUnitSheetNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
+    numfmtItemMap: INumfmtItemMap;
     excludedCell?: IUnitExcludedCell;
     allUnitData?: IUnitData;
     unitSheetNameMap?: IUnitSheetNameMap;

package/lib/types/basics/date.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.
+ */
+export declare const DEFFAULT_DATE_FORMAT = "yyyy-mm-dd;@";
+/**
+ * Excel stores dates as sequential serial numbers so they can be used in calculations. By default, January 1, 1900 is serial number 1, and January 1, 2008 is serial number 39448 because it is 39,447 days after January 1, 1900.
+ *
+ * Excel has a leap year error in 1900. February 29, 1900 is considered a legal date. In fact, there is no February 29 in 1900.
+ * 1900.2.28 Date Serial 59
+ * 1900.2.29 Date Serial 61
+ * 1900.3.1 Date Serial 61
+ * 1901.1.1 Date Serial 367
+ * @param date
+ * @returns
+ */
+export declare function excelDateSerial(date: Date): number;
+export declare function excelSerialToDate(serial: number): Date;
+export declare function formatDateDefault(date: Date): string;

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/basics/object-class-type.d.ts

@@ -15,6 +15,9 @@
  */
 import { Disposable } from '@univerjs/core';
 export declare class ObjectClassType extends Disposable {
+    pattern: string;
+    getPattern(): string;
+    setPattern(pattern: string): void;
     isError(): boolean;
     isAsyncObject(): boolean;
     isAsyncArrayObject(): boolean;

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

@@ -14,13 +14,14 @@
  * limitations under the License.
  */
 import type { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
-import type { IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../../basics/common';
+import type { IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../../basics/common';
 import type { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation {
     dirtyRanges: IUnitRange[];
     dirtyNameMap: IDirtyUnitSheetNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     options: Nullable<IExecutionOptions>;
+    numfmtItemMap: INumfmtItemMap;
     forceCalculation?: boolean;
 }
 /**

package/lib/types/commands/mutations/set-numfmt-formula-data.mutation.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 { IMutation } from '@univerjs/core';
+import type { INumfmtItemMap } from '../../basics/common';
+export interface ISetNumfmtFormulaDataMutationParams {
+    numfmtItemMap: INumfmtItemMap;
+}
+export declare const SetNumfmtFormulaDataMutation: IMutation<ISetNumfmtFormulaDataMutationParams>;

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

@@ -31,6 +31,18 @@ export declare class FunctionNode extends BaseAstNode {
     get nodeType(): NodeType;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
+    /**
+     * Compatibility handling for special functions.
+     */
+    private _compatibility;
+    /**
+     * The LOOKUP function follows the following rules when dealing with vectors of different sizes:
+     *    If the lookup_vector is larger than the result_vector,
+     *    the LOOKUP function will ignore the extra portion of the lookup_vector and only use the portion of the result_vector that is the same size as the lookup_vector for lookup and returning results.
+     *    If the lookup_vector is smaller than the result_vector,
+     *    the LOOKUP function will continue using the last value of the result_vector for lookup and returning results after the last value of the lookup_vector.
+     */
+    private _lookupCompatibility;
     private _calculate;
     private _setRefInfo;
     private _setRefData;

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/reference-object/base-reference-object.d.ts

@@ -15,7 +15,7 @@
  */
 import type { ICellData, IRange, Nullable } from '@univerjs/core';
 import { FormulaAstLRU } from '../../basics/cache-lru';
-import type { IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../../basics/common';
+import type { INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../../basics/common';
 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';
@@ -36,6 +36,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     private _arrayFormulaCellData;
     private _runtimeArrayFormulaCellData;
     private _runtimeFeatureCellData;
+    private _numfmtItemData;
     private _refOffsetX;
     private _refOffsetY;
     constructor(_token: string);
@@ -84,6 +85,8 @@ export declare class BaseReferenceObject extends ObjectClassType {
     setRuntimeFeatureCellData(unitData: {
         [featureId: string]: IRuntimeUnitDataType;
     }): void;
+    getNumfmtItemData(): INumfmtItemMap;
+    setNumfmtItemData(numfmtItemData: INumfmtItemMap): void;
     getRowCount(): number;
     getColumnCount(): number;
     isCell(): boolean;

package/lib/types/engine/utils/__tests__/cell.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/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/cell.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { ICellData, Nullable } from '@univerjs/core';
+export declare function getCellValue(cell: Nullable<ICellData>): string | number | true;

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;
     /**
      *
@@ -124,6 +158,14 @@ export declare class ArrayValueObject extends BaseValueObject {
     mean(): BaseValueObject;
     median(): BaseValueObject;
     var(): BaseValueObject;
+    /**
+     * STDEV.P: ddof=0, ignore strings and booleans
+     * STDEV.S: ddof=1, ignore strings and booleans
+     *
+     * STDEVPA: ddof=0,
+     * STDEVA: ddof=1,
+     * @returns
+     */
     std(): BaseValueObject;
     log(): BaseValueObject;
     log10(): 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/__tests__/nested-functions.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/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,23 @@ export declare class BaseFunction extends Disposable {
      * @returns
      */
     getZeroOrOneByOneDefault(logicValueObject?: BaseValueObject): number | undefined;
+    /**
+     * A logical value that specifies 1/TRUE , 0/FALSE, -1, default 1.
+     * The difference from getZeroOrOneByOneDefault is that we need to get -1
+     * @param logicValueObject
+     * @returns
+     */
+    getMatchTypeValue(logicValueObject?: BaseValueObject): number | undefined;
+    binarySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayBinarySearchType): BaseValueObject;
+    equalSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
+    fuzzySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
+    orderSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean): BaseValueObject;
+    /**
+     * @param axis 0 row, 1 column
+     * @returns
+     */
+    binarySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, axis?: number, searchType?: ArrayBinarySearchType): ErrorValueObject | ArrayValueObject | undefined;
+    equalSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
+    fuzzySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
+    orderSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
 }

package/lib/types/functions/date/date/__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/date/date/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 DateFunction extends BaseFunction {
+    calculate(year: BaseValueObject, month: BaseValueObject, day: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/date/day/__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/date/day/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 Day extends BaseFunction {
+    calculate(serialNumber: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/date/edate/__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/date/edate/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 { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+/**
+ * TODO@Dushusir: support plaine text date: =EDATE("2020-1-1",1), =EDATE("2020/1/1",1) and other formats
+ */
+export declare class Edate extends BaseFunction {
+    calculate(startDate: BaseValueObject, months: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/date/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 functionDate: never[];
+import { DateFunction } from './date';
+import { FUNCTION_NAMES_DATE } from './function-names';
+export declare const functionDate: (FUNCTION_NAMES_DATE | typeof DateFunction)[][];

package/lib/types/functions/date/month/__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/date/month/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 Month extends BaseFunction {
+    calculate(serialNumber: BaseValueObject): BaseValueObject;
+}

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