@univerjs/engine-formula - npm Package Compare versions

Comparing version 0.1.0-alpha.2 to 0.1.0-alpha.3

lib/types/basics/common.d.ts

@@ -16,3 +16,3 @@ /**
  */
-import type { BooleanNumber, ICellData, IRange, IUnitRange, Nullable, ObjectMatrix, ObjectMatrixPrimitiveType } from '@univerjs/core';
+import type { BooleanNumber, ICellData, IObjectMatrixPrimitiveType, IRange, IUnitRange, Nullable, ObjectMatrix } from '@univerjs/core';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
@@ -47,3 +47,3 @@ export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
     [unitId: string]: {
-        [sheetId: string]: ObjectMatrix<ICellData>;
+        [sheetId: string]: ObjectMatrix<Nullable<ICellData>>;
     };
@@ -77,3 +77,3 @@ }
     [unitId: string]: {
-        [sheetId: string]: ObjectMatrixPrimitiveType<IRange>;
+        [sheetId: string]: IObjectMatrixPrimitiveType<IRange>;
     };
@@ -88,3 +88,3 @@ }
     [unitId: string]: {
-        [sheetId: string]: ObjectMatrixPrimitiveType<ICellData>;
+        [sheetId: string]: IObjectMatrixPrimitiveType<Nullable<ICellData>>;
     };
@@ -94,3 +94,3 @@ }
     [unitId: string]: {
-        [sheetId: string]: ObjectMatrixPrimitiveType<IFormulaDataItem>;
+        [sheetId: string]: IObjectMatrixPrimitiveType<IFormulaDataItem>;
     };
@@ -97,0 +97,0 @@ }

lib/types/basics/error-type.d.ts

@@ -23,3 +23,3 @@ /**
     NUM = "#NUM!",
-    NA = "#NA!",
+    NA = "#N/A",
     /** Cyclic dependency. */
@@ -26,0 +26,0 @@ CYCLE = "#CYCLE!",

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

@@ -18,7 +18,7 @@ /**
 export declare class ObjectClassType extends Disposable {
-    isErrorObject(): boolean;
+    isError(): boolean;
     isAsyncObject(): boolean;
     isReferenceObject(): boolean;
     isValueObject(): boolean;
-    isEqual(object: ObjectClassType): boolean;
+    isEqualType(object: ObjectClassType): boolean;
 }

lib/types/basics/regex.d.ts

@@ -30,4 +30,4 @@ /**
 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 $SUPER_TABLE_COLUMN_REGEX: RegExp;
-export declare const $ARRAY_VALUE_REGEX: RegExp;
+export declare const $SUPER_TABLE_COLUMN_REGEX = "[.*?]";
+export declare const $ARRAY_VALUE_REGEX = "{.*?}";
 export declare function isReferenceString(refString: string): boolean;

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

@@ -23,4 +23,4 @@ /**
     get zIndex(): number;
-    create(param: LexerNode | string): BaseAstNode;
+    create(param: LexerNode | string, currentRow?: number, currentColumn?: number): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): Nullable<BaseAstNode>;
 }

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

@@ -20,4 +20,4 @@ /**
 import type { ErrorType } from '../../basics/error-type';
-import { ErrorValueObject } from '../other-object/error-value-object';
 import type { FunctionVariantType } from '../reference-object/base-reference-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { NodeType } from './node-type';
@@ -24,0 +24,0 @@ interface IAstNodeNodeJson {

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

@@ -24,3 +24,3 @@ /**
 import type { BaseReferenceObject } from '../reference-object/base-reference-object';
-import { BaseAstNode, ErrorNode } from './base-ast-node';
+import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
@@ -44,3 +44,3 @@ import { NodeType } from './node-type';
     get zIndex(): number;
-    checkAndCreateNodeType(param: LexerNode | string): ErrorNode | ReferenceNode | undefined;
+    checkAndCreateNodeType(param: LexerNode | string): ReferenceNode | undefined;
 }

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

@@ -17,10 +17,11 @@ /**
 import type { ICellData, IRange, Nullable } from '@univerjs/core';
+import { FormulaAstLRU } from '../../basics/cache-lru';
 import type { IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../../basics/common';
 import { ObjectClassType } from '../../basics/object-class-type';
-import { ErrorValueObject } from '../other-object/error-value-object';
 import { ArrayValueObject } from '../value-object/array-value-object';
-import type { BaseValueObject, CalculateValueType } from '../value-object/base-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 | ErrorValueObject | AsyncObject;
-export type FunctionVariantType = BaseValueObject | BaseReferenceObject | ErrorValueObject;
+export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject;
+export type FunctionVariantType = BaseValueObject | BaseReferenceObject;
+export declare const FORMULA_REF_TO_ARRAY_CACHE: FormulaAstLRU<ArrayValueObject>;
 export declare class BaseReferenceObject extends ObjectClassType {
@@ -57,4 +58,4 @@ private _token;
     isReferenceObject(): boolean;
-    iterator(callback: (valueObject: CalculateValueType, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
-    getFirstCell(): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject;
+    iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
+    getFirstCell(): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
     getRangeData(): IRange;
@@ -98,12 +99,12 @@ setRangeData(range: IRange): void;
     unionRange(rangeData1: IRange, rangeData2: IRange): IRange;
-    getCellValueObject(cell: ICellData): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject;
-    getCellByRow(row: number): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject;
-    getCellByColumn(column: number): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject;
+    getCellValueObject(cell: ICellData): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getCellByRow(row: number): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
+    getCellByColumn(column: number): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
     getCurrentActiveSheetData(): import("../../basics/common").ISheetItem;
-    getCurrentRuntimeSheetData(): import("@univerjs/core").ObjectMatrix<ICellData>;
-    getCurrentActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<ICellData>;
-    getCurrentRuntimeActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<ICellData>;
-    getCellData(row: number, column: number): Nullable<ICellData>;
+    getCurrentRuntimeSheetData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
+    getCurrentActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
+    getCurrentRuntimeActiveArrayFormulaCellData(): import("@univerjs/core").ObjectMatrix<Nullable<ICellData>>;
+    getCellData(row: number, column: number): ICellData;
     getRuntimeFeatureCellValue(row: number, column: number): ICellData | undefined;
-    getCellByPosition(row?: number, column?: number): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject;
+    getCellByPosition(row?: number, column?: number): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
     toArrayValueObject(): ArrayValueObject;
@@ -110,0 +111,0 @@ toUnitRange(): {

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

@@ -17,3 +17,3 @@ /**
 import type { IRange } from '@univerjs/core';
-import { ErrorValueObject } from '../other-object/error-value-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { BaseReferenceObject } from './base-reference-object';
@@ -20,0 +20,0 @@ import { RangeReferenceObject } from './range-reference-object';

lib/types/engine/reference-object/column-reference-object.d.ts

@@ -16,3 +16,3 @@ /**
  */
-import { ErrorValueObject } from '../other-object/error-value-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { BaseReferenceObject } from './base-reference-object';
@@ -19,0 +19,0 @@ export declare class ColumnReferenceObject extends BaseReferenceObject {

lib/types/engine/reference-object/row-reference-object.d.ts

@@ -16,3 +16,3 @@ /**
  */
-import { ErrorValueObject } from '../other-object/error-value-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { BaseReferenceObject } from './base-reference-object';
@@ -19,0 +19,0 @@ export declare class RowReferenceObject extends BaseReferenceObject {

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

@@ -16,9 +16,10 @@ /**
  */
-import type { Nullable } from '@univerjs/core';
-import type { compareToken } from '../../basics/token';
-import { ErrorValueObject } from '../other-object/error-value-object';
-import type { CalculateValueType, IArrayValueObject } from './base-value-object';
-import { BaseValueObject } from './base-value-object';
+import { type Nullable } from '@univerjs/core';
+import { compareToken } from '../../basics/token';
+import type { callbackMapFnType, callbackProductFnType, IArrayValueObject } from './base-value-object';
+import { BaseValueObject, ErrorValueObject } from './base-value-object';
 import { BooleanValueObject, 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 class ArrayValueObject extends BaseValueObject {
@@ -28,2 +29,6 @@ private _value;
     private _columnCount;
+    private _unitId;
+    private _sheetId;
+    private _currentRow;
+    private _currentColumn;
     constructor(rawValue: string | IArrayValueObject);
@@ -35,5 +40,14 @@ dispose(): void;
     setColumnCount(columnCount: number): void;
-    getArrayValue(): CalculateValueType[][];
-    setArrayValue(value: CalculateValueType[][]): void;
+    setCurrent(row: number, column: number): void;
+    setUnitId(unitId: string): void;
+    getUnitId(): string;
+    setSheetId(sheetId: string): void;
+    getSheetId(): string;
+    getCurrentRow(): number;
+    getCurrentColumn(): number;
+    getArrayValue(): BaseValueObject[][];
+    setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;
+    get(row: number, column: number): BaseValueObject;
+    set(row: number, column: number, value: BaseValueObject): void;
     getRangePosition(): {
@@ -45,16 +59,92 @@ startRow: number;
     };
-    iterator(callback: (valueObject: CalculateValueType, rowIndex: number, columnIndex: number) => Nullable<boolean>): void;
-    getFirstCell(): CalculateValueType;
-    plus(valueObject: BaseValueObject): CalculateValueType;
-    minus(valueObject: BaseValueObject): CalculateValueType;
-    multiply(valueObject: BaseValueObject): CalculateValueType;
-    divided(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
+    iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): void;
+    getFirstCell(): 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.
+     * implement x[x<10]
+     * https://numpy.org/doc/stable/user/basics.indexing.html
+     * @param takeArray
+     */
+    pick(takeArray: ArrayValueObject): ArrayValueObject;
+    /**
+     * Flatten a 2D array.
+     * https://numpy.org/doc/stable/reference/generated/numpy.chararray.flatten.html#numpy.chararray.flatten
+     */
+    flatten(): ArrayValueObject;
+    /**
+     * 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
+     * @rowParam start:stop:step
+     * @columnParam start:stop:step
+     * @param takeArray
+     */
+    slice(rowParam: Nullable<Array<Nullable<number>>>, columnParam: Nullable<Array<Nullable<number>>>): ArrayValueObject;
+    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;
+    minus(valueObject: BaseValueObject): 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;
+    map(callbackFn: callbackMapFnType): BaseValueObject;
+    pow(valueObject: BaseValueObject): BaseValueObject;
+    /**
+     *
+     * @param valueObject In the case of an inverse, it is certainly not an array.
+     * @returns
+     */
+    powInverse(valueObject: BaseValueObject): BaseValueObject;
+    sqrt(): BaseValueObject;
+    cbrt(): BaseValueObject;
+    cos(): BaseValueObject;
+    acos(): BaseValueObject;
+    acosh(): BaseValueObject;
+    sin(): BaseValueObject;
+    asin(): BaseValueObject;
+    asinh(): BaseValueObject;
+    tan(): BaseValueObject;
+    tanh(): BaseValueObject;
+    atan(): BaseValueObject;
+    atanh(): BaseValueObject;
+    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atan2Inverse(valueObject: BaseValueObject): BaseValueObject;
+    mean(): BaseValueObject;
+    median(): BaseValueObject;
+    var(): BaseValueObject;
+    log(): BaseValueObject;
+    log10(): BaseValueObject;
+    exp(): BaseValueObject;
+    abs(): BaseValueObject;
+    round(valueObject: BaseValueObject): BaseValueObject;
+    roundInverse(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): BaseValueObject;
+    floorInverse(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): BaseValueObject;
+    ceilInverse(valueObject: BaseValueObject): BaseValueObject;
+    toValue(): (string | number | boolean)[][];
+    private _sort;
+    private _transposeArray;
     private _batchOperator;
+    private _batchOperatorValue;
+    private _batchOperatorArray;
+    private _checkArrayCalculateType;
     private _formatValue;
+    private _createNewArray;
 }
 export declare class ValueObjectFactory {
-    static create(rawValue: string | number | boolean): ErrorValueObject | NumberValueObject | StringValueObject | BooleanValueObject | ArrayValueObject;
+    static create(rawValue: string | number | boolean): NumberValueObject | StringValueObject | BooleanValueObject | ErrorValueObject | ArrayValueObject;
 }

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

@@ -17,10 +17,16 @@ /**
 import { ConcatenateType } from '../../basics/common';
+import { ErrorType } from '../../basics/error-type';
 import { ObjectClassType } from '../../basics/object-class-type';
-import type { compareToken } from '../../basics/token';
-import { ErrorValueObject } from '../other-object/error-value-object';
-export type CalculateValueType = BaseValueObject | ErrorValueObject;
+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 {
-    calculateValueList: CalculateValueType[][];
+    calculateValueList: BaseValueObject[][];
     rowCount: number;
     columnCount: number;
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
 }
@@ -32,5 +38,5 @@ export declare class BaseValueObject extends ObjectClassType {
     getValue(): string | number | boolean;
-    getArrayValue(): CalculateValueType[][];
+    getArrayValue(): BaseValueObject[][];
     setValue(value: string | number | boolean): void;
-    setArrayValue(value: CalculateValueType[][]): void;
+    setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;
@@ -42,17 +48,88 @@ isString(): boolean;
     isNull(): boolean;
-    getNegative(): CalculateValueType;
-    getReciprocal(): CalculateValueType;
-    plus(valueObject: BaseValueObject): CalculateValueType;
-    minus(valueObject: BaseValueObject): CalculateValueType;
-    multiply(valueObject: BaseValueObject): CalculateValueType;
-    divided(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
-    plusBy(value: string | number | boolean): CalculateValueType;
-    minusBy(value: string | number | boolean): CalculateValueType;
-    multiplyBy(value: string | number | boolean): CalculateValueType;
-    dividedBy(value: string | number | boolean): CalculateValueType;
-    compareBy(value: string | number | boolean, operator: compareToken): CalculateValueType;
-    concatenate(value: string | number | boolean, concatenateType?: ConcatenateType): CalculateValueType;
+    getNegative(): BaseValueObject;
+    getReciprocal(): BaseValueObject;
+    plus(valueObject: BaseValueObject): BaseValueObject;
+    minus(valueObject: BaseValueObject): BaseValueObject;
+    multiply(valueObject: BaseValueObject): BaseValueObject;
+    divided(valueObject: BaseValueObject): BaseValueObject;
+    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;
+    isLessThanOrEqual(valueObject: BaseValueObject): BaseValueObject;
+    isLessThan(valueObject: BaseValueObject): BaseValueObject;
+    isGreaterThan(valueObject: BaseValueObject): BaseValueObject;
+    concatenateFront(valueObject: BaseValueObject): BaseValueObject;
+    concatenateBack(valueObject: BaseValueObject): BaseValueObject;
+    plusBy(value: string | number | boolean): BaseValueObject;
+    minusBy(value: string | number | boolean): BaseValueObject;
+    multiplyBy(value: string | number | boolean): BaseValueObject;
+    dividedBy(value: string | number | boolean): BaseValueObject;
+    compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    concatenate(value: string | number | boolean, concatenateType?: ConcatenateType): string;
+    pow(valueObject: BaseValueObject): BaseValueObject;
+    powInverse(valueObject: BaseValueObject): BaseValueObject;
+    sqrt(): BaseValueObject;
+    cbrt(): BaseValueObject;
+    cos(): BaseValueObject;
+    acos(): BaseValueObject;
+    acosh(): BaseValueObject;
+    sin(): BaseValueObject;
+    asin(): BaseValueObject;
+    asinh(): BaseValueObject;
+    tan(): BaseValueObject;
+    tanh(): BaseValueObject;
+    atan(): BaseValueObject;
+    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atan2Inverse(valueObject: BaseValueObject): BaseValueObject;
+    atanh(): BaseValueObject;
+    /**
+     * Calculate the mean of the entire array.
+     *
+     * reference https://numpy.org/doc/stable/reference/generated/numpy.mean.html#numpy.mean
+     *
+     */
+    mean(): BaseValueObject;
+    /**
+     * Calculate the median of the entire array.
+     *
+     * 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
+     */
+    var(): BaseValueObject;
+    /**
+     * Calculate the standard deviation of the entire array.
+     *
+     * https://numpy.org/doc/stable/reference/generated/numpy.std.html
+     */
+    std(): BaseValueObject;
+    log(): BaseValueObject;
+    log10(): BaseValueObject;
+    exp(): BaseValueObject;
+    abs(): BaseValueObject;
+    round(valueObject: BaseValueObject): BaseValueObject;
+    roundInverse(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): BaseValueObject;
+    floorInverse(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): BaseValueObject;
+    ceilInverse(valueObject: BaseValueObject): BaseValueObject;
 }
+export declare class ErrorValueObject extends BaseValueObject {
+    private _errorType;
+    private _errorContent;
+    constructor(_errorType: ErrorType, _errorContent?: string);
+    static create(errorType: ErrorType, errorContent?: string): ErrorValueObject;
+    getErrorType(): ErrorType;
+    getErrorContent(): string;
+    isEqualType(object: ObjectClassType): boolean;
+    isError(): boolean;
+}

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

@@ -17,18 +17,38 @@ /**
 import { compareToken } from '../../basics/token';
-import type { CalculateValueType } from './base-value-object';
 import { BaseValueObject } from './base-value-object';
 export declare class NullValueObject extends BaseValueObject {
     isNull(): boolean;
-    plus(valueObject: BaseValueObject): CalculateValueType;
-    minus(valueObject: BaseValueObject): CalculateValueType;
-    multiply(valueObject: BaseValueObject): CalculateValueType;
-    divided(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
-    plusBy(value: string | number | boolean): CalculateValueType;
-    minusBy(value: string | number | boolean): CalculateValueType;
-    multiplyBy(value: string | number | boolean): CalculateValueType;
-    dividedBy(value: string | number | boolean): CalculateValueType;
-    compareBy(value: string | number | boolean, operator: compareToken): CalculateValueType;
+    plus(valueObject: BaseValueObject): BaseValueObject;
+    minus(valueObject: BaseValueObject): BaseValueObject;
+    multiply(valueObject: BaseValueObject): BaseValueObject;
+    divided(valueObject: BaseValueObject): BaseValueObject;
+    compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
+    concatenateFront(valueObject: BaseValueObject): BaseValueObject;
+    concatenateBack(valueObject: BaseValueObject): BaseValueObject;
+    plusBy(value: string | number | boolean): BaseValueObject;
+    minusBy(value: string | number | boolean): BaseValueObject;
+    multiplyBy(value: string | number | boolean): BaseValueObject;
+    dividedBy(value: string | number | boolean): BaseValueObject;
+    compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    pow(valueObject: BaseValueObject): BaseValueObject;
+    sqrt(): BaseValueObject;
+    cbrt(): BaseValueObject;
+    cos(): BaseValueObject;
+    acos(): BaseValueObject;
+    acosh(): BaseValueObject;
+    sin(): BaseValueObject;
+    asin(): BaseValueObject;
+    asinh(): BaseValueObject;
+    tan(): BaseValueObject;
+    tanh(): BaseValueObject;
+    atan(): BaseValueObject;
+    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atanh(): BaseValueObject;
+    log(): BaseValueObject;
+    log10(): BaseValueObject;
+    exp(): BaseValueObject;
+    abs(): BaseValueObject;
+    round(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): BaseValueObject;
 }
@@ -40,12 +60,33 @@ export declare class BooleanValueObject extends BaseValueObject {
     isBoolean(): boolean;
-    getNegative(): CalculateValueType;
-    getReciprocal(): CalculateValueType;
-    plus(valueObject: BaseValueObject): CalculateValueType;
-    minus(valueObject: BaseValueObject): CalculateValueType;
-    multiply(valueObject: BaseValueObject): CalculateValueType;
-    divided(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
+    getNegative(): BaseValueObject;
+    getReciprocal(): BaseValueObject;
+    plus(valueObject: BaseValueObject): BaseValueObject;
+    minus(valueObject: BaseValueObject): BaseValueObject;
+    multiply(valueObject: BaseValueObject): BaseValueObject;
+    divided(valueObject: BaseValueObject): BaseValueObject;
+    compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
+    concatenateFront(valueObject: BaseValueObject): BaseValueObject;
+    concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     private _convertTonNumber;
+    pow(valueObject: BaseValueObject): BaseValueObject;
+    sqrt(): BaseValueObject;
+    cbrt(): BaseValueObject;
+    cos(): BaseValueObject;
+    acos(): BaseValueObject;
+    acosh(): BaseValueObject;
+    sin(): BaseValueObject;
+    asin(): BaseValueObject;
+    asinh(): BaseValueObject;
+    tan(): BaseValueObject;
+    tanh(): BaseValueObject;
+    atan(): BaseValueObject;
+    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atanh(): BaseValueObject;
+    log(): BaseValueObject;
+    log10(): BaseValueObject;
+    exp(): BaseValueObject;
+    abs(): BaseValueObject;
+    round(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): BaseValueObject;
 }
@@ -58,17 +99,39 @@ export declare class NumberValueObject extends BaseValueObject {
     isNumber(): boolean;
-    getNegative(): CalculateValueType;
-    getReciprocal(): CalculateValueType;
-    plus(valueObject: BaseValueObject): CalculateValueType;
+    getNegative(): BaseValueObject;
+    getReciprocal(): BaseValueObject;
+    plus(valueObject: BaseValueObject): BaseValueObject;
     equalZero(): boolean;
-    minus(valueObject: BaseValueObject): CalculateValueType;
-    multiply(valueObject: BaseValueObject): CalculateValueType;
-    divided(valueObject: BaseValueObject): CalculateValueType;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    plusBy(value: string | number | boolean): CalculateValueType;
-    minusBy(value: string | number | boolean): CalculateValueType;
-    multiplyBy(value: string | number | boolean): CalculateValueType;
-    dividedBy(value: string | number | boolean): CalculateValueType;
-    compareBy(value: string | number | boolean, operator: compareToken): CalculateValueType;
+    minus(valueObject: BaseValueObject): BaseValueObject;
+    multiply(valueObject: BaseValueObject): BaseValueObject;
+    divided(valueObject: BaseValueObject): BaseValueObject;
+    concatenateFront(valueObject: BaseValueObject): BaseValueObject;
+    concatenateBack(valueObject: BaseValueObject): BaseValueObject;
+    compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
+    plusBy(value: string | number | boolean): BaseValueObject;
+    minusBy(value: string | number | boolean): BaseValueObject;
+    multiplyBy(value: string | number | boolean): BaseValueObject;
+    dividedBy(value: string | number | boolean): BaseValueObject;
+    compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    pow(valueObject: BaseValueObject): BaseValueObject;
+    sqrt(): BaseValueObject;
+    cbrt(): BaseValueObject;
+    cos(): BaseValueObject;
+    acos(): BaseValueObject;
+    acosh(): BaseValueObject;
+    sin(): BaseValueObject;
+    asin(): BaseValueObject;
+    asinh(): BaseValueObject;
+    tan(): BaseValueObject;
+    tanh(): BaseValueObject;
+    atan(): BaseValueObject;
+    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atanh(): BaseValueObject;
+    log(): BaseValueObject;
+    log10(): BaseValueObject;
+    exp(): BaseValueObject;
+    abs(): BaseValueObject;
+    round(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): BaseValueObject;
+    private _compareInfinity;
 }
@@ -80,6 +143,8 @@ export declare class StringValueObject extends BaseValueObject {
     isString(): boolean;
-    concatenateFront(valueObject: BaseValueObject): CalculateValueType;
-    concatenateBack(valueObject: BaseValueObject): CalculateValueType;
-    compare(valueObject: BaseValueObject, operator: compareToken): CalculateValueType;
-    compareBy(value: string | number | boolean, operator: compareToken): CalculateValueType;
+    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;
 }

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

@@ -17,9 +17,7 @@ /**
 import { Disposable } from '@univerjs/core';
-import type { IAccessor } from '@wendellhu/redi';
 import type { IFunctionNames } from '..';
 import type { FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 export declare class BaseFunction extends Disposable {
-    readonly accessor: IAccessor;
     private _name;
-    constructor(accessor: IAccessor, _name: IFunctionNames);
+    constructor(_name: IFunctionNames);
     get name(): IFunctionNames;
@@ -26,0 +24,0 @@ isAsync(): boolean;

lib/types/functions/compatibility/concatenate/concatenate.d.ts

@@ -16,4 +16,4 @@ /**
  */
-import { ErrorValueObject } from '../../../engine/other-object/error-value-object';
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
@@ -20,0 +20,0 @@ export declare class Concatenate extends BaseFunction {

lib/types/functions/math/power/power.d.ts

@@ -16,4 +16,4 @@ /**
  */
-import { ErrorValueObject } from '../../../engine/other-object/error-value-object';
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
@@ -20,0 +20,0 @@ export declare class Power extends BaseFunction {

lib/types/functions/math/sum/sum.d.ts

@@ -16,8 +16,6 @@ /**
  */
-import { ErrorValueObject } from '../../../engine/other-object/error-value-object';
 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[]): ErrorValueObject | BaseValueObject;
+    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
 }

lib/types/functions/math/sumif/sumif.d.ts

@@ -16,9 +16,8 @@ /**
  */
-import { ErrorValueObject } from '../../../engine/other-object/error-value-object';
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { type BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sumif extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): ErrorValueObject | BaseValueObject;
+    calculate(...variants: FunctionVariantType[]): BaseValueObject;
     private _validator;
 }

lib/types/functions/math/sumifs/sumifs.d.ts

@@ -16,4 +16,4 @@ /**
  */
-import { ErrorValueObject } from '../../../engine/other-object/error-value-object';
 import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
@@ -20,0 +20,0 @@ export declare class Sumifs extends BaseFunction {

lib/types/functions/meta/compare/compare.d.ts

@@ -18,2 +18,3 @@ /**
 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';
@@ -23,3 +24,3 @@ export declare class Compare extends BaseFunction {
     setCompareType(token: compareToken): void;
-    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): BaseValueObject;
 }

lib/types/functions/meta/divided/divided.d.ts

@@ -17,5 +17,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 Divided extends BaseFunction {
-    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): BaseValueObject;
 }

lib/types/functions/meta/minus/minus.d.ts

@@ -17,5 +17,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 Minus extends BaseFunction {
-    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): BaseValueObject;
 }

lib/types/functions/meta/multiply/multiply.d.ts

@@ -17,5 +17,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 Multiply extends BaseFunction {
-    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): BaseValueObject;
 }

lib/types/functions/meta/plus/plus.d.ts

@@ -17,5 +17,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 Plus extends BaseFunction {
-    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(variant1: FunctionVariantType, variant2: FunctionVariantType): BaseValueObject;
 }

lib/types/functions/statistical/average/average.d.ts

@@ -19,3 +19,3 @@ /**
 export declare class Average extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): import("../../../engine/value-object/base-value-object").CalculateValueType;
+    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
 }

lib/types/functions/statistical/function-names.d.ts

@@ -20,3 +20,4 @@ /**
     MAX = "MAX",
-    MIN = "MIN"
+    MIN = "MIN",
+    COUNTA = "COUNTA"
 }

lib/types/functions/statistical/max/max.d.ts

@@ -17,7 +17,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 Max extends BaseFunction {
-    calculate(...variants: FunctionVariantType[]): BaseValueObject;
+    calculate(...variants: FunctionVariantType[]): FunctionVariantType;
     private _validator;
 }

lib/types/index.d.ts

@@ -22,2 +22,3 @@ /**
 export { includeFormulaLexerToken, isFormulaLexerToken, normalizeSheetName } from './basics/match-token';
+export { convertUnitDataToRuntime } from './basics/runtime';
 export { matchToken } from './basics/token';
@@ -34,3 +35,2 @@ export { compareToken } from './basics/token';
 export { LexerTreeBuilder } from './engine/analysis/lexer-tree-builder';
-export { ErrorValueObject } from './engine/other-object/error-value-object';
 export { BaseReferenceObject, type FunctionVariantType } from './engine/reference-object/base-reference-object';
@@ -40,3 +40,3 @@ export { RangeReferenceObject } from './engine/reference-object/range-reference-object';
 export { ArrayValueObject, ValueObjectFactory } from './engine/value-object/array-value-object';
-export { BaseValueObject } from './engine/value-object/base-value-object';
+export { BaseValueObject, ErrorValueObject } from './engine/value-object/base-value-object';
 export { NumberValueObject } from './engine/value-object/primitive-object';
@@ -43,0 +43,0 @@ export { BooleanValueObject } from './engine/value-object/primitive-object';

lib/types/models/formula-data.model.d.ts

@@ -16,3 +16,3 @@ /**
  */
-import type { ICellData, Nullable, ObjectMatrixPrimitiveType } from '@univerjs/core';
+import type { ICellData, IObjectMatrixPrimitiveType, Nullable } from '@univerjs/core';
 import { Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
@@ -48,3 +48,3 @@ import type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../basics/common';
     };
-    updateFormulaData(unitId: string, sheetId: string, cellValue: ObjectMatrixPrimitiveType<ICellData | null>): void;
+    updateFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
     getFormulaItemBySId(sId: string, sheetId: string, unitId: string): Nullable<IFormulaDataItem>;
@@ -54,2 +54,2 @@ getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): IFormulaDataItem;
 }
-export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<ICellData>): void;
+export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<Nullable<ICellData>>): void;

lib/types/services/current-data.service.d.ts

@@ -62,5 +62,4 @@ /**
     registerSheetNameMap(sheetNameMap: IUnitSheetNameMap): void;
-    private _dataToRuntime;
     private _loadSheetData;
 }
 export declare const IFormulaCurrentConfigService: import("@wendellhu/redi").IdentifierDecorator<FormulaCurrentConfigService>;

lib/types/services/runtime.service.d.ts

@@ -20,3 +20,3 @@ /**
 import type { BaseAstNode } from '../engine/ast-node/base-ast-node';
-import type { FunctionVariantType } from '../engine/reference-object/base-reference-object';
+import { type FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IFormulaCurrentConfigService } from './current-data.service';
@@ -23,0 +23,0 @@ /**

package.json

 {
   "name": "@univerjs/engine-formula",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "description": "UniverSheet normal base-formula-engine",
@@ -33,4 +33,8 @@ "keywords": [],
   "private": false,
+  "dependencies": {
+    "big.js": "^6.2.1"
+  },
   "devDependencies": {
-    "@vitest/coverage-istanbul": "^1.0.2",
+    "@types/big.js": "^6.2.2",
+    "@vitest/coverage-istanbul": "^1.0.4",
     "@wendellhu/redi": "^0.12.12",
@@ -40,7 +44,7 @@ "less": "^4.2.0",
     "typescript": "^5.3.3",
-    "vite": "^5.0.7",
+    "vite": "^5.0.8",
     "vite-plugin-dts": "^3.6.4",
     "vite-plugin-externals": "^0.6.2",
-    "vitest": "^1.0.2",
-    "@univerjs/core": "0.1.0-alpha.2"
+    "vitest": "^1.0.4",
+    "@univerjs/core": "0.1.0-alpha.3"
   },
@@ -50,3 +54,3 @@ "peerDependencies": {
     "rxjs": ">=7.0.0",
-    "@univerjs/core": "0.1.0-alpha.2"
+    "@univerjs/core": "0.1.0-alpha.3"
   },
@@ -53,0 +57,0 @@ "scripts": {

README.md

 # @univerjs/engine-formula
 
-[![npm version](https://img.shields.io/npm/v/@univerjs/engine-formula)](https://npmjs.org/packages/@univerjs/engine-formula)
+[![npm version](https://img.shields.io/npm/v/@univerjs/engine-formula)](https://npmjs.org/package/@univerjs/engine-formula)
 [![license](https://img.shields.io/npm/l/@univerjs/engine-formula)](https://img.shields.io/npm/l/@univerjs/engine-formula)
@@ -5,0 +5,0 @@

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

693199

increased by20.6%

Number of package files

161

increased by20.15%

Lines of code

12439

increased by23.43%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Dependency count

4

increased by33.33%

Dev dependency count

11

increased by10%

Dependency changes

• + Addedbig.js@^6.2.1

• + Added@univerjs/core@0.1.0-alpha.3(transitive)

• + Addedbig.js@6.2.2(transitive)

• - Removed@univerjs/core@0.1.0-alpha.2(transitive)