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

package/lib/types/basics/object-class-type.d.ts

@@ -17,6 +17,7 @@ import { Disposable } from '@univerjs/core';
 export declare class ObjectClassType extends Disposable {
     isError(): boolean;
     isAsyncObject(): boolean;
+    isAsyncArrayObject(): boolean;
     isReferenceObject(): boolean;
     isValueObject(): boolean;
     isEqualType(object: ObjectClassType): boolean;

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

@@ -53,6 +53,7 @@ export declare class BaseAstNode extends Disposable {
     isCalculated(): boolean;
     setCalculated(): void;
     execute(): void;
+    setNotEmpty(state?: boolean): void;
     setRefOffset(x?: number, y?: number): void;
     getRefOffset(): {
         x: number;

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

@@ -13,23 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { AstNodePromiseType } from '../../basics/common';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { LexerNode } from '../analysis/lexer-node';
+import { Interpreter } from '../interpreter/interpreter';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
-export declare const LAMBDA_TOKEN: string;
 export declare class LambdaNode extends BaseAstNode {
     private _lambdaId;
-    constructor(token: string, _lambdaId: string);
+    private _interpreter;
+    private _lambdaPrivacyVarKeys;
+    private _isNotEmpty;
+    constructor(token: string, _lambdaId: string, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[]);
     get nodeType(): NodeType;
+    setNotEmpty(state?: boolean): void;
+    isEmptyParamFunction(): boolean;
     isFunctionParameter(): boolean;
     getLambdaId(): string;
     execute(): void;
+    executeAsync(): Promise<AstNodePromiseType>;
 }
 export declare class LambdaNodeFactory extends BaseAstNodeFactory {
     private readonly _runtimeService;
-    constructor(_runtimeService: IFormulaRuntimeService);
+    private readonly _interpreter;
+    constructor(_runtimeService: IFormulaRuntimeService, _interpreter: Interpreter);
     get zIndex(): number;
     create(param: LexerNode): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { BaseFunction } from '../../functions/base-function';
 import { IFunctionService } from '../../services/function.service';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode } from './base-ast-node';
@@ -21,10 +20,10 @@ import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class UnionNode extends BaseAstNode {
     private _operatorString;
-    private _functionExecutor;
-    constructor(_operatorString: string, _functionExecutor: BaseFunction);
+    constructor(_operatorString: string);
     get nodeType(): NodeType;
     execute(): void;
+    private _unionFunction;
 }
 export declare class UnionNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;

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

@@ -20,7 +20,7 @@ import { ObjectClassType } from '../../basics/object-class-type';
 import { ArrayValueObject } from '../value-object/array-value-object';
 import { type BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
 import { BooleanValueObject, NumberValueObject, StringValueObject } from '../value-object/primitive-object';
-export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject;
+export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject | AsyncArrayObject;
 export type FunctionVariantType = BaseValueObject | BaseReferenceObject;
 export declare const FORMULA_REF_TO_ARRAY_CACHE: FormulaAstLRU<ArrayValueObject>;
 export declare class BaseReferenceObject extends ObjectClassType {
@@ -114,7 +114,13 @@ export declare class BaseReferenceObject extends ObjectClassType {
 }
 export declare class AsyncObject extends ObjectClassType {
     private _promise;
-    constructor(_promise: Promise<FunctionVariantType>);
+    constructor(_promise: Promise<BaseValueObject>);
     isAsyncObject(): boolean;
-    getValue(): Promise<FunctionVariantType>;
+    getValue(): Promise<BaseValueObject>;
+}
+export declare class AsyncArrayObject extends ObjectClassType {
+    private _promiseList;
+    constructor(_promiseList: Array<Array<BaseValueObject | AsyncObject>>);
+    isAsyncArrayObject(): boolean;
+    getValue(): Promise<ArrayValueObject>;
 }

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

@@ -121,6 +121,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     mean(): BaseValueObject;
     median(): BaseValueObject;
     var(): BaseValueObject;
+    std(): BaseValueObject;
     log(): BaseValueObject;
     log10(): BaseValueObject;
     exp(): BaseValueObject;

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

@@ -41,6 +41,7 @@ export declare class BaseValueObject extends ObjectClassType {
     isString(): boolean;
     isNumber(): boolean;
     isBoolean(): boolean;
+    isLambda(): boolean;
     isError(): boolean;
     isNull(): boolean;
     getNegative(): BaseValueObject;

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

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { BaseAstNode } from '../ast-node/base-ast-node';
+import type { Interpreter } from '../interpreter/interpreter';
+import { AsyncObject } from '../reference-object/base-reference-object';
+import { BaseValueObject } from './base-value-object';
+export declare class LambdaValueObjectObject extends BaseValueObject {
+    private _lambdaNode;
+    private _interpreter;
+    private _lambdaPrivacyVarKeys;
+    private _lambdaPrivacyValueMap;
+    constructor(_lambdaNode: BaseAstNode, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[]);
+    isLambda(): boolean;
+    execute(...variants: BaseValueObject[]): BaseValueObject | AsyncObject;
+    private _setLambdaNodeValue;
+    private _setLambdaPrivacyValueMap;
+}

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

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

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

package/lib/types/functions/array/makearray/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { AsyncArrayObject } from '../../../engine/reference-object/base-reference-object';
+import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Makearray extends BaseFunction {
+    calculate(...variants: BaseValueObject[]): ErrorValueObject | AsyncArrayObject;
+    isAsync(): boolean;
+}

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

@@ -16,12 +16,13 @@
 import { Disposable } from '@univerjs/core';
 import type { IFunctionNames } from '..';
 import type { FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
+import { type BaseValueObject } from '../engine/value-object/base-value-object';
 export declare class BaseFunction extends Disposable {
     private _name;
     constructor(_name: IFunctionNames);
     get name(): IFunctionNames;
     isAsync(): boolean;
     isAddress(): boolean;
-    calculate(...arg: FunctionVariantType[]): NodeValueType;
+    calculate(...arg: BaseValueObject[]): NodeValueType;
     checkArrayType(variant: FunctionVariantType): boolean;
 }

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

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

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

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
-import { Offset } from './offset/offset';
+import { Offset } from './offset';
 export declare const functionLookup: (FUNCTION_NAMES_LOOKUP | typeof Offset)[][];

package/lib/types/functions/{statistical/count/count.d.ts → math/abs/index.d.ts}

@@ -16,6 +16,6 @@
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
-export declare class Count extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): BaseValueObject;
+export declare class Abs extends BaseFunction {
+    calculate(variant: FunctionVariantType): BaseValueObject;
 }

package/lib/types/functions/{statistical/counta/counta.d.ts → math/acos/index.d.ts}

@@ -16,6 +16,6 @@
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
-export declare class CountA extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): BaseValueObject;
+export declare class Acos extends BaseFunction {
+    calculate(variant: FunctionVariantType): BaseValueObject;
 }

package/lib/types/functions/math/acosh/__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/{statistical/min/min.d.ts → math/acosh/index.d.ts}

@@ -16,7 +16,6 @@
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
-export declare class Min extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): BaseValueObject;
-    private _validator;
+export declare class Acosh extends BaseFunction {
+    calculate(variant: FunctionVariantType): BaseValueObject;
 }

package/lib/types/functions/math/acot/__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/math/acot/index.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 { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Acot extends BaseFunction {
+    calculate(variant: FunctionVariantType): BaseValueObject;
+}

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

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import { FUNCTION_NAMES_MATH } from './function-names';
-import { Sum } from './sum/sum';
+import { Sum } from './sum';
 export declare const functionMath: (FUNCTION_NAMES_MATH | typeof Sum)[][];

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

@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 export declare enum FUNCTION_NAMES_MATH {
+    ABS = "ABS",
+    ACOS = "ACOS",
+    ACOSH = "ACOSH",
+    ACOT = "ACOT",
     SUM = "SUM",
     SUMIF = "SUMIF",
     SUMIFS = "SUMIFS",

package/lib/types/functions/math/sum/{sum.d.ts → index.d.ts}

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sum extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
 }

package/lib/types/functions/math/sumif/__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/math/sumifs/__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/meta/function-map.d.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Divided } from './divided/divided';
+import { Divided } from './divided';
 import { FUNCTION_NAMES_META } from './function-names';
-import { Union } from './union/union';
-export declare const functionMeta: ((FUNCTION_NAMES_META | typeof Divided)[] | (FUNCTION_NAMES_META | typeof Union)[])[];
+export declare const functionMeta: (FUNCTION_NAMES_META | typeof Divided)[][];

package/lib/types/functions/statistical/average/{average.d.ts → index.d.ts}

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Average extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
 }

package/lib/types/functions/statistical/count/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 Count extends BaseFunction {
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
+}

package/lib/types/functions/statistical/counta/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 CountA extends BaseFunction {
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
+}

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

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Average } from './average/average';
+import { Average } from './average';
 import { FUNCTION_NAMES_STATISTICAL } from './function-names';
 export declare const functionStatistical: (FUNCTION_NAMES_STATISTICAL | typeof Average)[][];

package/lib/types/functions/statistical/max/{max.d.ts → index.d.ts}

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Max extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
     private _validator;
 }

package/lib/types/functions/statistical/min/index.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 { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Min extends BaseFunction {
+    calculate(...variants: BaseValueObject[]): BaseValueObject;
+    private _validator;
+}