@univerjs/engine-formula 0.1.2 → 0.1.4

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

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { Nullable } from '@univerjs/core';
+import { FormulaAstLRU } from '../../basics/cache-lru';
 import { ConcatenateType } from '../../basics/common';
 import { ErrorType } from '../../basics/error-type';
 import { ObjectClassType } from '../../basics/object-class-type';
 import { compareToken } from '../../basics/token';
 export type callbackMapFnType = (currentValue: BaseValueObject, row: number, column: number) => BaseValueObject;
-export type callbackProductFnType = (currentValue: BaseValueObject, operationValue: BaseValueObject) => BaseValueObject;
 export interface IArrayValueObject {
-    calculateValueList: BaseValueObject[][];
+    calculateValueList: Nullable<BaseValueObject>[][];
     rowCount: number;
     columnCount: number;
     unitId: string;
@@ -43,9 +44,10 @@ export declare class BaseValueObject extends ObjectClassType {
         unitId: string;
     };
     getValue(): string | number | boolean;
-    getArrayValue(): BaseValueObject[][];
+    getArrayValue(): Nullable<BaseValueObject>[][];
     setValue(value: string | number | boolean): void;
     setArrayValue(value: BaseValueObject[][]): void;
+    isCube(): boolean;
     isArray(): boolean;
     isString(): boolean;
     isNumber(): boolean;
@@ -78,7 +80,6 @@ export declare class BaseValueObject extends ObjectClassType {
      * @returns
      */
     mapValue(callbackFn: callbackMapFnType): BaseValueObject;
-    product(valueObject: BaseValueObject, callbackFn: callbackProductFnType): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     isEqual(valueObject: BaseValueObject): BaseValueObject;
     isNotEqual(valueObject: BaseValueObject): BaseValueObject;
@@ -147,10 +148,14 @@ export declare class BaseValueObject extends ObjectClassType {
     floorInverse(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
     ceilInverse(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): BaseValueObject;
+    convertToBooleanObjectValue(): BaseValueObject;
 }
+export declare const ErrorValueObjectCache: FormulaAstLRU<ErrorValueObject>;
 export declare class ErrorValueObject extends BaseValueObject {
     private _errorType;
     private _errorContent;
+    static create(errorType: ErrorType, errorContent?: string): ErrorValueObject;
     constructor(_errorType: ErrorType, _errorContent?: string);
     getValue(): ErrorType;
     getErrorType(): ErrorType;

package/lib/types/engine/value-object/cube-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 { ArrayValueObject } from './array-value-object';
+import { BaseValueObject } from './base-value-object';
+import { NumberValueObject } from './primitive-object';
+export declare class CubeValueObject extends BaseValueObject {
+    static create(values: ArrayValueObject[]): CubeValueObject;
+    isCube(): boolean;
+    private _values;
+    constructor(values: ArrayValueObject[]);
+    sum(): NumberValueObject;
+    max(): NumberValueObject;
+    min(): NumberValueObject;
+    count(): NumberValueObject;
+    countA(): NumberValueObject;
+    countBlank(): NumberValueObject;
+}

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

@@ -21,6 +21,7 @@ export declare class LambdaValueObjectObject extends BaseValueObject {
     private _lambdaNode;
     private _interpreter;
     private _lambdaPrivacyVarKeys;
+    static create(lambdaNode: BaseAstNode, interpreter: Interpreter, lambdaPrivacyVarKeys: string[]): LambdaValueObjectObject;
     private _lambdaPrivacyValueMap;
     constructor(_lambdaNode: BaseAstNode, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[]);
     isLambda(): boolean;

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

@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 import { compareToken } from '../../basics/token';
-import { BaseValueObject } from './base-value-object';
+import { FormulaAstLRU } from '../../basics/cache-lru';
+import { BaseValueObject, ErrorValueObject } from './base-value-object';
 export type PrimitiveValueType = string | boolean | number | null;
 export declare class NullValueObject extends BaseValueObject {
+    private static _instance;
+    static create(): NullValueObject;
     isNull(): boolean;
     plus(valueObject: BaseValueObject): BaseValueObject;
     minus(valueObject: BaseValueObject): BaseValueObject;
@@ -52,10 +55,15 @@ export declare class NullValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): NumberValueObject;
+    convertToBooleanObjectValue(): BooleanValueObject;
 }
 export declare class BooleanValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    private static _instanceTrue;
+    private static _instanceFalse;
+    static create(value: boolean): BooleanValueObject;
+    constructor(rawValue: boolean);
     getValue(): boolean;
     isBoolean(): boolean;
     getNegative(): BaseValueObject;
@@ -90,10 +98,14 @@ export declare class BooleanValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): ErrorValueObject | NumberValueObject;
+    convertToBooleanObjectValue(): this;
 }
+export declare const NumberValueObjectCache: FormulaAstLRU<NumberValueObject>;
 export declare class NumberValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    static create(value: number, pattern?: string): NumberValueObject;
+    constructor(rawValue: number);
     getValue(): number;
     setValue(value: number): void;
     isNumber(): boolean;
@@ -134,16 +146,25 @@ export declare class NumberValueObject extends BaseValueObject {
     round(valueObject: BaseValueObject): BaseValueObject;
     floor(valueObject: BaseValueObject): BaseValueObject;
     ceil(valueObject: BaseValueObject): BaseValueObject;
+    convertToNumberObjectValue(): this;
+    convertToBooleanObjectValue(): BooleanValueObject;
     private _compareInfinity;
 }
+export declare const StringValueObjectCache: FormulaAstLRU<StringValueObject>;
 export declare class StringValueObject extends BaseValueObject {
     private _value;
-    constructor(rawValue: string | number | boolean, isForce?: boolean);
+    static create(value: string): StringValueObject;
+    constructor(rawValue: string);
     getValue(): string;
     isString(): boolean;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    convertToNumberObjectValue(): ErrorValueObject | NumberValueObject;
+    convertToBooleanObjectValue(): BooleanValueObject;
     private _checkWildcard;
 }
+export declare function createBooleanValueObjectByRawValue(rawValue: string | number | boolean): BooleanValueObject;
+export declare function createStringValueObjectByRawValue(rawValue: string | number | boolean): StringValueObject;
+export declare function createNumberValueObjectByRawValue(rawValue: string | number | boolean): ErrorValueObject | NumberValueObject;

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

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Nullable } from '@univerjs/core';
+import type { IRange, Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 import type { IFunctionNames } from '../basics/function';
-import type { FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
+import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 import type { ArrayBinarySearchType } from '../engine/utils/compare';
 import { ArrayOrderSearchType } from '../engine/utils/compare';
 import type { ArrayValueObject } from '../engine/value-object/array-value-object';
@@ -54,7 +54,6 @@ export declare class BaseFunction extends Disposable {
      * For instance, The column number (starting with 1 for the left-most column of table_array) that contains the return value.
      * https://support.microsoft.com/en-us/office/vlookup-function-0bbc8083-26fe-4963-8ab8-93a18ad188a1
      * @param indexNum
-     * @returns
      */
     getIndexNumValue(indexNum: BaseValueObject, defaultValue?: number): number | ErrorValueObject;
     /**
@@ -68,28 +67,24 @@ export declare class BaseFunction extends Disposable {
      * If a1 is FALSE, ref_text is interpreted as an R1C1-style reference.
      * https://support.microsoft.com/zh-cn/office/indirect-%E5%87%BD%E6%95%B0-474b3a3a-8a26-4f44-b491-92b6306fa261
      * @param logicValueObject
-     * @returns
      */
     getZeroOrOneByOneDefault(logicValueObject?: BaseValueObject): number | undefined;
     /**
      * A logical value that specifies 1/TRUE , 0/FALSE, -1, default 1.
      * The difference from getZeroOrOneByOneDefault is that we need to get -1
      * @param logicValueObject
-     * @returns
      */
     getMatchTypeValue(logicValueObject?: BaseValueObject): number | undefined;
     binarySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayBinarySearchType): BaseValueObject;
     equalSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
     fuzzySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
     orderSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean): BaseValueObject;
-    /**
-     * @param axis 0 row, 1 column
-     * @returns
-     */
     binarySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, axis?: number, searchType?: ArrayBinarySearchType): ErrorValueObject | ArrayValueObject | undefined;
     equalSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     fuzzySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     orderSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     flattenArray(variants: BaseValueObject[], ignoreLogicalValuesAndText?: boolean): ArrayValueObject | BaseValueObject;
     private _includingLogicalValuesAndText;
+    createReferenceObject(reference: BaseReferenceObject, range: IRange): ErrorValueObject | BaseReferenceObject;
+    private _setReferenceDefault;
 }

package/lib/types/functions/logical/or/__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/logical/or/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 Or extends BaseFunction {
+    calculate(...logicalValues: BaseValueObject[]): BaseValueObject;
+}

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

@@ -13,14 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Address } from './address';
 import { Column } from './column';
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
-import { Indirect } from './indirect';
 import { Lookup } from './lookup';
 import { Match } from './match';
 import { Offset } from './offset';
 import { Xlookup } from './xlookup';
 import { Xmatch } from './xmatch';
-import { Index } from './index';
-export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Address)[] | (FUNCTION_NAMES_LOOKUP | typeof Column)[] | (FUNCTION_NAMES_LOOKUP | typeof Index)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Xlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Xmatch)[])[];
+export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Column)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Xlookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Xmatch)[])[];

package/lib/types/functions/lookup/index/index.d.ts

@@ -13,12 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';
 import { type BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
+/**
+ * The result of the INDEX function is a reference and is interpreted as such by other formulas. Depending on the formula, the return value of INDEX may be used as a reference or as a value.
+ *
+ * =INDEX(A2:A5,2,1):A1 same as =A1:A3
+ *
+ * OPTIMIZE: maybe we can remove some unknown type
+ */
 export declare class Index extends BaseFunction {
-    calculate(reference: BaseValueObject, rowNum: BaseValueObject, columnNum?: BaseValueObject, areaNum?: BaseValueObject): BaseValueObject | ArrayValueObject;
+    needsReferenceObject: boolean;
+    calculate(referenceObject: BaseValueObject, rowNum: BaseValueObject, columnNum?: BaseValueObject, areaNum?: BaseValueObject): BaseValueObject | BaseReferenceObject;
     private _calculateSingleCell;
     private _getNumberValue;
     private _getAreaNumberValue;
+    private _getReferenceObject;
 }

package/lib/types/functions/lookup/offset/index.d.ts

@@ -17,6 +17,6 @@ import type { BaseReferenceObject } from '../../../engine/reference-object/base-
 import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Offset extends BaseFunction {
-    calculate(reference: BaseValueObject, rows: BaseValueObject, columns: BaseValueObject, height?: BaseValueObject, width?: BaseValueObject): BaseValueObject | BaseReferenceObject;
-    private _setDefault;
+    needsReferenceObject: boolean;
+    calculate(referenceObject: BaseValueObject, rows: BaseValueObject, columns: BaseValueObject, height?: BaseValueObject, width?: BaseValueObject): BaseValueObject | BaseReferenceObject;
 }

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

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

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

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

@@ -19,5 +19,6 @@ export declare enum FUNCTION_NAMES_META {
     MINUS = "MINUS",
     MULTIPLY = "MULTIPLY",
     PLUS = "PLUS",
-    UNION = "UNION"
+    UNION = "UNION",
+    CUBE = "CUBE"
 }

package/lib/types/functions/text/len/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/len/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 Len extends BaseFunction {
+    calculate(text: BaseValueObject): BaseValueObject;
+    private _handleSingleText;
+}

package/lib/types/functions/text/lenb/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/lenb/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 Lenb extends BaseFunction {
+    calculate(text: BaseValueObject): BaseValueObject;
+    private _handleSingleText;
+}

package/lib/types/functions/text/text/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/text/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 Text extends BaseFunction {
+    calculate(text: BaseValueObject, formatText: BaseValueObject): BaseValueObject;
+}

package/lib/types/index.d.ts

@@ -88,3 +88,7 @@ export { FormulaExecutedStateType, type IAllRuntimeData } from './services/runti
 export { SetNumfmtFormulaDataMutation } from './commands/mutations/set-numfmt-formula-data.mutation';
 export type { ISetNumfmtFormulaDataMutationParams } from './commands/mutations/set-numfmt-formula-data.mutation';
 export { isReferenceString } from './basics/regex';
+export { matchRefDrawToken } from './basics/match-token';
+export { IDefinedNamesService, DefinedNamesService } from './services/defined-names.service';
+export { IFormulaRuntimeService, FormulaRuntimeService } from './services/runtime.service';
+export { IFormulaCurrentConfigService, FormulaCurrentConfigService } from './services/current-data.service';

package/lib/types/plugin.d.ts

@@ -20,7 +20,7 @@ import type { IFunctionNames } from './basics/function';
 import type { BaseFunction } from './functions/base-function';
 interface IUniverFormulaEngine {
     notExecuteFormula?: boolean;
-    function: Array<[Ctor<BaseFunction>, IFunctionNames]>;
+    function?: Array<[Ctor<BaseFunction>, IFunctionNames]>;
 }
 export declare class UniverFormulaEnginePlugin extends Plugin {
     private _config;

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

@@ -32,6 +32,7 @@ export interface IFormulaCurrentConfigService {
     getExcludedRange(): Nullable<IUnitExcludedCell>;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     getArrayFormulaCellData(): IRuntimeUnitDataType;
+    getSheetName(unitId: string, sheetId: string): string;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _currentUniverService;
@@ -45,6 +46,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     private _numfmtItemMap;
     private _dirtyUnitFeatureMap;
     private _excludedCell;
+    private _sheetIdToNameMap;
     constructor(_currentUniverService: IUniverInstanceService);
     dispose(): void;
     getExcludedRange(): Nullable<IUnitExcludedCell>;
@@ -57,6 +59,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     getDirtyNameMap(): IDirtyUnitSheetNameMap;
     getNumfmtItemMap(): INumfmtItemMap;
     getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
+    getSheetName(unitId: string, sheetId: string): string;
     load(config: IFormulaDatasetConfig): void;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;