@univerjs/engine-formula 1.0.0-alpha.1 → 1.0.0-alpha.3

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

@@ -33,8 +33,8 @@ export declare const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[A-Za-z]+$";
 export declare const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING: RegExp;
 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_TABLE_SINGLE_COLUMN_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[((?<!#)[\\s\\S])*\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\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])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$|^((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\s\\S])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$";
 export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_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_ALL_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX_PRECOMPILING: RegExp;

package/lib/types/commands/mutations/set-super-table.mutation.d.ts

@@ -20,6 +20,9 @@ export interface ISetSuperTableMutationSearchParam {
     unitId: string;
     tableName: string;
 }
+export interface IRemoveSuperTableMutationParam extends ISetSuperTableMutationSearchParam {
+    reference?: Pick<ISuperTable, 'sheetId' | 'range'>;
+}
 export interface ISetSuperTableMutationParam extends ISetSuperTableMutationSearchParam {
     oldTableName?: string;
     reference: ISuperTable;
@@ -29,5 +32,5 @@ export interface ISetSuperTableMutationParam extends ISetSuperTableMutationSearc
  * It requires setting local to true during execution.
  */
 export declare const SetSuperTableMutation: IMutation<ISetSuperTableMutationParam>;
-export declare const RemoveSuperTableMutation: IMutation<ISetSuperTableMutationSearchParam>;
+export declare const RemoveSuperTableMutation: IMutation<IRemoveSuperTableMutationParam>;
 export declare const SetSuperTableOptionMutation: IMutation<ISuperTableOptionParam>;

package/lib/types/controllers/super-table-active-dirty.controller.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 } from '@univerjs/core';
+import { IActiveDirtyManagerService } from '../services/active-dirty-manager.service';
+export declare class SuperTableActiveDirtyController extends Disposable {
+    private readonly _activeDirtyManagerService;
+    constructor(_activeDirtyManagerService: IActiveDirtyManagerService);
+    private _initialize;
+}

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

@@ -26,7 +26,8 @@ export declare const FormulaLexerNodeCache: FormulaAstLRU<LexerNode>;
 export declare const FormulaSequenceNodeCache: FormulaAstLRU<(string | ISequenceNode)[]>;
 interface IInjectDefinedNameParam {
     unitId: Nullable<string>;
-    getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
+    sheetId?: Nullable<string>;
+    getValueByName(unitId: string, name: string, sheetId?: Nullable<string>): Nullable<IDefinedNamesServiceParam>;
     getDirtyDefinedNameMap(): IDirtyUnitDefinedNameMap;
     getSheetName: (unitId: string, sheetId: string) => string;
 }

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

@@ -13,6 +13,7 @@
  * 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 { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDefinedNamesService } from '../../services/defined-names.service';
@@ -22,5 +23,5 @@ export declare class Lexer extends Disposable {
     private readonly _lexerTreeBuilder;
     private readonly _formulaCurrentConfigService;
     constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService);
-    treeBuilder(formulaString: string, transformSuffix?: boolean): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
+    treeBuilder(formulaString: string, transformSuffix?: boolean, unitId?: Nullable<string>): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
 }

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

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 import type { Nullable } from '@univerjs/core';
-import type { BaseAstNode } from '../ast-node/base-ast-node';
 import { Disposable } from '@univerjs/core';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { AstRootNodeFactory } from '../ast-node/ast-root-node';
+import { BaseAstNode } from '../ast-node/base-ast-node';
 import { FunctionNodeFactory } from '../ast-node/function-node';
 import { LambdaNodeFactory } from '../ast-node/lambda-node';
 import { LambdaParameterNodeFactory } from '../ast-node/lambda-parameter-node';
@@ -48,5 +48,6 @@ export declare class AstTreeBuilder extends Disposable {
     private _changeLetToLambda;
     private _parse;
     private _checkAstNode;
+    private _createGroupByAggregatorTokenNode;
     private _initializeAstNode;
 }

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

@@ -35,11 +35,14 @@ export declare class FunctionNode extends BaseAstNode {
     get nodeType(): NodeType;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
+    private _collectVariants;
+    private _getChildVariant;
     isFunctionExecutorArgumentsIgnoreNumberPattern(): boolean;
     /**
      * If it contains an array formula, set the current cell to the cache and send itself as a ref outward
      */
     private _setEmbeddedArrayFormulaToResult;
+    private _normalizeTopLevelLegacyArrayResult;
     /**
      * Compatibility handling for special functions.
      */
@@ -59,6 +62,7 @@ export declare class FunctionNode extends BaseAstNode {
     private _handleAddressFunction;
     private _mapVariantsToValues;
     private _calculate;
+    private _calculateAst;
     private _calculateAsync;
     private _setDefinedNamesForFunction;
     private _setRefInfo;

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

@@ -26,6 +26,7 @@ export declare class OperatorNode extends BaseAstNode {
     constructor(operatorString: string, _functionExecutor: BaseFunction, _runtimeService: IFormulaRuntimeService);
     get nodeType(): NodeType;
     execute(): void;
+    private _referenceToOperatorValue;
     /**
      * If it contains an array formula, set the current cell to the cache and send itself as a ref outward
      */

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

@@ -29,6 +29,7 @@ export declare class PrefixNode extends BaseAstNode {
     get nodeType(): NodeType;
     execute(): void;
     private _handlerAT;
+    private _preserveAtRangeForFormula2LookupArray;
 }
 export declare class PrefixNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;

package/lib/types/engine/interpreter/interpreter.d.ts

@@ -30,4 +30,15 @@ export declare class Interpreter extends Disposable {
     private _checkAsyncNode;
     private _executeAsync;
     private _execute;
+    private _executeLazyFunctionAsync;
+    private _executeLazyFunction;
+    private _executeLazyIfAsync;
+    private _executeLazyIf;
+    private _executeLazyIfErrorAsync;
+    private _executeLazyIfError;
+    private _toLazyIfErrorValue;
+    private _toLazyIfSelectedValue;
+    private _implicitLazyIfReferenceValue;
+    private _preserveLazyIfSelectedReferenceArray;
+    private _implicitLazyIfArrayValue;
 }

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

@@ -20,6 +20,7 @@ import { RangeReferenceObject } from './range-reference-object';
 export declare class CellReferenceObject extends BaseReferenceObject {
     constructor(token: string);
     isCell(): boolean;
+    isExceedRange(): boolean;
     unionBy(referenceObject: BaseReferenceObject): ErrorValueObject | RangeReferenceObject;
     unionRange(rangeData1: IRange, rangeData2: IRange): IRange;
     private _createRange;

package/lib/types/engine/utils/generate-ast-node.d.ts

@@ -21,5 +21,5 @@ import type { AstRootNode } from '../ast-node/ast-root-node';
 import type { IFormulaDependencyTree } from '../dependency/dependency-tree';
 import { FormulaAstLRU } from '../../basics/cache-lru';
 export declare const FORMULA_AST_CACHE: FormulaAstLRU<AstRootNode>;
-export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService): AstRootNode;
+export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService, subUnitId?: string): AstRootNode;
 export declare function includeDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>, currentConfigService: IFormulaCurrentConfigService): boolean;

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

@@ -13,6 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * Since Excel follows the IEEE 754 specification, it only handles precision issues when displaying cells. For example, =0.1+0.2, the stored value in XML is 0.30000000000000004, and the displayed value is 0.3. The accuracy of the calculation process does not need to be considered. We only focus on the accuracy of the calculation results. Any result is processed within 15 digits.
+
+ Reference https://en.wikipedia.org/wiki/Numeric_precision_in_Microsoft_Excel
+ */
 export declare function plus(a: number, b: number): number;
 export declare function minus(a: number, b: number): number;
 export declare function multiply(a: number, b: number): number;

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

@@ -41,6 +41,8 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _sheetId;
     private _currentRow;
     private _currentColumn;
+    private _useInvertedIndexCache;
+    private _legacyImplicitForAggregate;
     private _sliceCache;
     private _flattenCache;
     /**
@@ -62,6 +64,9 @@ export declare class ArrayValueObject extends BaseValueObject {
     getSheetId(): string;
     getCurrentRow(): number;
     getCurrentColumn(): number;
+    usesInvertedIndexCache(): boolean;
+    usesLegacyImplicitForAggregate(): boolean;
+    setLegacyImplicitForAggregate(value: boolean): void;
     getArrayValue(): Nullable<BaseValueObject>[][];
     setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;

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

@@ -28,6 +28,8 @@ export interface IArrayValueObject {
     sheetId: string;
     row: number;
     column: number;
+    legacyImplicitForAggregate?: boolean;
+    useInvertedIndexCache?: boolean;
 }
 export declare class BaseValueObject extends ObjectClassType {
     private _rawValue;
@@ -158,6 +160,8 @@ export declare class BaseValueObject extends ObjectClassType {
     convertToNumberObjectValue(): BaseValueObject;
     convertToBooleanObjectValue(): BaseValueObject;
 }
+export declare function formatValueForFormulaText(value: string | number | boolean | null): string;
+export declare function formatNumberForFormulaText(value: number): string;
 export declare const ErrorValueObjectCache: FormulaAstLRU<ErrorValueObject>;
 export declare class ErrorValueObject extends BaseValueObject {
     private _errorType;
@@ -169,4 +173,6 @@ export declare class ErrorValueObject extends BaseValueObject {
     getErrorContent(): string;
     isEqualType(object: ObjectClassType): boolean;
     isError(): boolean;
+    concatenateFront(_valueObject: BaseValueObject): BaseValueObject;
+    concatenateBack(_valueObject: BaseValueObject): BaseValueObject;
 }

package/lib/types/facade/f-formula.d.ts

@@ -119,10 +119,13 @@ export declare class FFormula extends FBase {
     calculationEnd(callback: (functionsExecutedState: FormulaExecutedStateType) => void): IDisposable;
     /**
      * @deprecated Use `onCalculationResultApplied` instead.
+     * @param {number} [timeout] The timeout in milliseconds. Defaults to 30000.
+     * @returns {Promise<boolean>} Whether computing completed before timeout.
      */
     whenComputingCompleteAsync(timeout?: number): Promise<boolean>;
     /**
      * @deprecated Use `onCalculationResultApplied` instead.
+     * @returns {Promise<void>} A promise that resolves when calculation ends.
      */
     onCalculationEnd(): Promise<void>;
     /**
@@ -249,11 +252,11 @@ export declare class FFormula extends FBase {
      * dependency-calculation command for the given unit, sheet, and cell location,
      * and returns the computed dependency tree when the calculation is completed.
      *
-     * @param param The target cell location:
-     *   - `unitId`  The workbook ID.
-     *   - `sheetId` The sheet ID.
-     *   - `row`     The zero-based row index.
-     *   - `column`  The zero-based column index.
+     * @param {object} param The target cell location.
+     * @param {string} param.unitId The workbook ID.
+     * @param {string} param.sheetId The sheet ID.
+     * @param {number} param.row The zero-based row index.
+     * @param {number} param.column The zero-based column index.
      *
      * @param {number} [timeout]
      *        Optional timeout in milliseconds. If no result is received within this
@@ -462,6 +465,7 @@ export declare class FFormula extends FBase {
      * ```
      *
      * @param formulaString The formula string to parse (with or without leading `=`)
+     * @param unitId The workbook unit id used to resolve defined names and tables.
      * @returns A formula expression tree describing the hierarchical structure of the formula
      */
     getFormulaExpressTree(formulaString: string, unitId: string): IExprTreeNode | null;

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

@@ -15,6 +15,7 @@
  */
 import type { IRange, LocaleType, Nullable } from '@univerjs/core';
 import type { IFunctionNames } from '../basics/function';
+import type { BaseAstNode } from '../engine/ast-node/base-ast-node';
 import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 import type { ArrayBinarySearchType } from '../engine/utils/compare';
 import type { ArrayValueObject } from '../engine/value-object/array-value-object';
@@ -30,6 +31,8 @@ export declare class BaseFunction {
     private _subUnitId;
     private _row;
     private _column;
+    private _currentFormulaRowCount;
+    private _currentFormulaColumnCount;
     private _definedNames;
     private _locale;
     private _sheetOrder;
@@ -65,6 +68,15 @@ export declare class BaseFunction {
      * Whether the function needs to filter out rows
      */
     needsFilteredOutRows: boolean;
+    /**
+     * Whether the function needs unevaluated AST children.
+     */
+    needsAstChildren: boolean;
+    /**
+     * Legacy CSE-style array functions should write only the first result cell
+     * when they are used as a top-level normal formula.
+     */
+    returnsLegacyArrayAsScalar: boolean;
     /**
      * Minimum number of parameters
      */
@@ -79,6 +91,8 @@ export declare class BaseFunction {
     get subUnitId(): Nullable<string>;
     get row(): number;
     get column(): number;
+    get currentFormulaRowCount(): number;
+    get currentFormulaColumnCount(): number;
     dispose(): void;
     /**
      * In Excel, to inject a defined name into a function that has positioning capabilities,
@@ -108,9 +122,10 @@ export declare class BaseFunction {
     isAddress(): boolean;
     isCustom(): boolean;
     isArgumentsIgnoreNumberPattern(): boolean;
-    setRefInfo(unitId: string, subUnitId: string, row: number, column: number): void;
+    setRefInfo(unitId: string, subUnitId: string, row: number, column: number, rowCount?: number, columnCount?: number): void;
     calculateCustom(...arg: Array<FormulaFunctionValueType>): FormulaFunctionResultValueType | Promise<FormulaFunctionResultValueType>;
     calculate(...arg: BaseValueObject[]): NodeValueType;
+    calculateAst(_children: BaseAstNode[], _getVariant: (node: BaseAstNode) => Nullable<FunctionVariantType>): NodeValueType;
     checkArrayType(variant: FunctionVariantType): boolean;
     /**
      * Starting with 1

package/lib/types/functions/cube/cubekpimember/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubekpimember extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cubemember/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubemember extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cubememberproperty/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubememberproperty extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cuberankedmember/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cuberankedmember extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cubeset/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubeset extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cubesetcount/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubesetcount extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/cube/cubevalue/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Cubevalue extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/financial/amordegrc/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Amordegrc extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/information/info/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Info extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

package/lib/types/functions/information/isomitted/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { NotImplementedFunction } from '../../not-implemented-function';
+export declare class Isomitted extends NotImplementedFunction {
+    minParams: number;
+    maxParams: number;
+}

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

@@ -15,7 +15,8 @@
  */
 import { And } from './and';
 import { FUNCTION_NAMES_LOGICAL } from './function-names';
+import { Groupby } from './groupby';
 import { If } from './if';
-import { Iferror } from './iferror';
+import { Ifna } from './ifna';
 import { Makearray } from './makearray';
-export declare const functionLogical: ((FUNCTION_NAMES_LOGICAL | typeof And)[] | (FUNCTION_NAMES_LOGICAL | typeof If)[] | (FUNCTION_NAMES_LOGICAL | typeof Iferror)[] | (FUNCTION_NAMES_LOGICAL | typeof Makearray)[])[];
+export declare const functionLogical: ((FUNCTION_NAMES_LOGICAL | typeof And)[] | (FUNCTION_NAMES_LOGICAL | typeof Groupby)[] | (FUNCTION_NAMES_LOGICAL | typeof If)[] | (FUNCTION_NAMES_LOGICAL | typeof Ifna)[] | (FUNCTION_NAMES_LOGICAL | typeof Makearray)[])[];

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

@@ -18,6 +18,7 @@ export declare enum FUNCTION_NAMES_LOGICAL {
     BYCOL = "BYCOL",
     BYROW = "BYROW",
     FALSE = "FALSE",
+    GROUPBY = "GROUPBY",
     IF = "IF",
     IFERROR = "IFERROR",
     IFNA = "IFNA",
@@ -28,6 +29,7 @@ export declare enum FUNCTION_NAMES_LOGICAL {
     MAP = "MAP",
     NOT = "NOT",
     OR = "OR",
+    PERCENTOF = "PERCENTOF",
     REDUCE = "REDUCE",
     SCAN = "SCAN",
     SWITCH = "SWITCH",

package/lib/types/functions/logical/groupby/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { BaseAstNode } from '../../../engine/ast-node/base-ast-node';
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Groupby extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    needsReferenceObject: boolean;
+    needsAstChildren: boolean;
+    calculateAst(children: BaseAstNode[], getVariant: (node: BaseAstNode) => FunctionVariantType | null): ErrorValueObject | ArrayValueObject;
+    private _arrayInput;
+    private _aggregators;
+    private _normalizedFunctionName;
+    private _isAggregatorName;
+    private _outputValueColumnCount;
+    private _valueColumnForOutput;
+    private _aggregatorForOutput;
+    private _aggregatorHeader;
+    private _applyAggregator;
+    private _sum;
+    private _numericValue;
+    private _numberValue;
+    private _truthy;
+    private _keysEqual;
+    private _keyValue;
+    private _sortGroups;
+    private _compareKey;
+    private _compareValue;
+    private _textValue;
+}

package/lib/types/functions/logical/if/index.d.ts

@@ -21,4 +21,9 @@ export declare class If extends BaseFunction {
     maxParams: number;
     calculate(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse?: BaseValueObject): BaseValueObject | ArrayValueObject;
     private _handleSingleObject;
+    private _coerceSelectedValue;
+    private _coerceLogicalTest;
+    private _legacyImplicitSelectedValue;
+    private _legacyImplicitArrayValue;
+    private _isCurrentArrayFormula;
 }