@univerjs/engine-formula 0.1.6 → 0.1.8

package/lib/types/functions/text/lower/__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/lower/index.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunction } from '../../base-function';
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+
+export declare class Lower extends BaseFunction {
+    calculate(text: BaseValueObject): BaseValueObject;
+    private _handleSingleText;
+}

package/lib/types/index.d.ts

@@ -13,17 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitSheetNameMap, INumfmtItemMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, } from './basics/common';
+export type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitSheetNameMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, } from './basics/common';
 export { isInDirtyRange } from './basics/dirty';
-export { ErrorType } from './basics/error-type';
+export { ErrorType, ERROR_TYPE_SET } from './basics/error-type';
 export { FunctionType, type IFunctionInfo, type IFunctionParam } from './basics/function';
 export { type IFunctionNames } from './basics/function';
 export { includeFormulaLexerToken, isFormulaLexerToken, normalizeSheetName } from './basics/match-token';
 export { convertUnitDataToRuntime } from './basics/runtime';
 export { matchToken, compareToken, operatorToken } from './basics/token';
 export { RegisterFunctionMutation } from './commands/mutations/register-function.mutation';
-export { type ISetArrayFormulaDataMutationParams, SetArrayFormulaDataMutation, SetArrayFormulaDataUndoMutationFactory, } from './commands/mutations/set-array-formula-data.mutation';
-export { RemoveDefinedNameMutation, SetDefinedNameMutation, SetDefinedNameCurrentMutation, type ISetDefinedNameMutationSearchParam, type ISetDefinedNameMutationParam } from './commands/mutations/set-defined-name.mutation';
+export { type ISetArrayFormulaDataMutationParams, SetArrayFormulaDataMutation, } from './commands/mutations/set-array-formula-data.mutation';
+export { RemoveDefinedNameMutation, SetDefinedNameMutation, type ISetDefinedNameMutationSearchParam, type ISetDefinedNameMutationParam } from './commands/mutations/set-defined-name.mutation';
 export { RemoveFeatureCalculationMutation, SetFeatureCalculationMutation, } from './commands/mutations/set-feature-calculation.mutation';
 export { type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, } from './commands/mutations/set-formula-calculation.mutation';
 export { type ISetFormulaDataMutationParams, SetFormulaDataMutation, } from './commands/mutations/set-formula-data.mutation';
@@ -35,7 +35,7 @@ export { LexerTreeBuilder } from './engine/analysis/lexer-tree-builder';
 export { BaseReferenceObject, type FunctionVariantType } from './engine/reference-object/base-reference-object';
 export { RangeReferenceObject } from './engine/reference-object/range-reference-object';
 export { deserializeRangeForR1C1 } from './engine/utils/r1c1-reference';
-export { deserializeRangeWithSheet, getAbsoluteRefTypeWithSingleString, getAbsoluteRefTypeWitString, type IAbsoluteRefTypeForRange, serializeRange, serializeRangeToRefString, serializeRangeWithSheet, serializeRangeWithSpreadsheet, } from './engine/utils/reference';
+export { deserializeRangeWithSheet, getAbsoluteRefTypeWithSingleString, getAbsoluteRefTypeWitString, type IAbsoluteRefTypeForRange, serializeRange, serializeRangeToRefString, serializeRangeWithSheet, serializeRangeWithSpreadsheet, isReferenceStringWithEffectiveColumn, getRangeWithRefsString, isReferenceStrings, } from './engine/utils/reference';
 export { generateStringWithSequence, type ISequenceNode, sequenceNodeType } from './engine/utils/sequence';
 export { ArrayValueObject, ValueObjectFactory } from './engine/value-object/array-value-object';
 export { BaseValueObject, ErrorValueObject } from './engine/value-object/base-value-object';
@@ -86,8 +86,6 @@ export { IFunctionService } from './services/function.service';
 export { IOtherFormulaManagerService, OtherFormulaManagerService } from './services/other-formula-manager.service';
 export { FormulaExecuteStageType, type IExecutionInProgressParams } from './services/runtime.service';
 export { FormulaExecutedStateType, type IAllRuntimeData } from './services/runtime.service';
-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, type IDefinedNamesServiceParam, type IDefinedNameMapItem } from './services/defined-names.service';
@@ -95,3 +93,4 @@ export { isFormulaTransformable, transformFormula } from './engine/utils/relativ
 export { IFormulaRuntimeService, FormulaRuntimeService } from './services/runtime.service';
 export { IFormulaCurrentConfigService, FormulaCurrentConfigService } from './services/current-data.service';
 export { IActiveDirtyManagerService } from './services/active-dirty-manager.service';
+export type { IRangeChange } from './models/formula-data.model';

package/lib/types/models/__tests__/create-command-test-bed.d.ts

@@ -1,7 +1,7 @@
 import { Dependency } from '@wendellhu/redi';
 import { IWorkbookData, Univer } from '@univerjs/core';
 
-export declare function createCommandTestBed(workbookConfig?: IWorkbookData, dependencies?: Dependency[]): {
+export declare function createCommandTestBed(workbookData?: IWorkbookData, dependencies?: Dependency[]): {
     univer: Univer;
     get: {
         <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp | undefined): T;

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

@@ -1,20 +1,19 @@
+import { IFormulaIdMap } from './utils/formula-data-util';
 import { LexerTreeBuilder } from '../engine/analysis/lexer-tree-builder';
-import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../basics/common';
-import { ICellData, IObjectMatrixPrimitiveType, Nullable, Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
+import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../basics/common';
+import { ICellData, IObjectMatrixPrimitiveType, IRange, Nullable, Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
 
-export interface IFormulaIdMap {
-    f: string;
-    r: number;
-    c: number;
+export interface IRangeChange {
+    oldCell: IRange;
+    newCell: IRange;
 }
 export declare class FormulaDataModel extends Disposable {
-    private readonly _currentUniverService;
+    private readonly _univerInstanceService;
     private readonly _lexerTreeBuilder;
     private _formulaData;
     private _arrayFormulaRange;
     private _arrayFormulaCellData;
-    private _numfmtItemMap;
-    constructor(_currentUniverService: IUniverInstanceService, _lexerTreeBuilder: LexerTreeBuilder);
+    constructor(_univerInstanceService: IUniverInstanceService, _lexerTreeBuilder: LexerTreeBuilder);
     clearPreviousArrayFormulaCellData(clearArrayFormulaCellData: IRuntimeUnitDataType): void;
     mergeArrayFormulaCellData(unitData: IRuntimeUnitDataType): void;
     getFormulaData(): IFormulaData;
@@ -23,23 +22,23 @@ export declare class FormulaDataModel extends Disposable {
     setArrayFormulaRange(value: IArrayFormulaRangeType): void;
     getArrayFormulaCellData(): IArrayFormulaUnitCellType;
     setArrayFormulaCellData(value: IArrayFormulaUnitCellType): void;
-    getNumfmtItemMap(): INumfmtItemMap;
-    getNumfmtValue(unitId: string, sheetId: string, row: number, column: number): Nullable<string>;
-    setNumfmtItemMap(value: INumfmtItemMap): void;
-    updateNumfmtItemMap(value: INumfmtItemMap): void;
     mergeArrayFormulaRange(formulaData: IArrayFormulaRangeType): void;
+    mergeFormulaData(formulaData: IFormulaData): void;
     deleteArrayFormulaRange(unitId: string, sheetId: string, row: number, column: number): void;
     initFormulaData(): void;
     getCalculateData(): {
         allUnitData: IUnitData;
         unitSheetNameMap: IUnitSheetNameMap;
     };
-    updateFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
+    updateFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): IObjectMatrixPrimitiveType<IFormulaDataItem | null>;
     updateArrayFormulaRange(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
     updateArrayFormulaCellData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
-    updateNumfmtData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
     getFormulaItemBySId(sId: string, sheetId: string, unitId: string): Nullable<IFormulaDataItem>;
-    getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): IFormulaDataItem | undefined;
+    getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): Nullable<IFormulaDataItem>;
     getFormulaIdMap(unitId: string, sheetId: string): Map<string, IFormulaIdMap>;
 }
-export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<Nullable<ICellData>>): void;
+export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<Nullable<ICellData>>): {
+    [x: string]: {
+        [x: string]: IObjectMatrixPrimitiveType<IFormulaDataItem>;
+    };
+};

package/lib/types/models/utils/formula-data-util.d.ts

@@ -0,0 +1,10 @@
+import { IFormulaDataItem } from '../../basics/common';
+import { ICellData, IRange, Nullable, ObjectMatrix } from '@univerjs/core';
+
+export interface IFormulaIdMap {
+    f: string;
+    r: number;
+    c: number;
+}
+export declare function updateFormulaDataByCellValue(sheetFormulaDataMatrix: ObjectMatrix<Nullable<IFormulaDataItem>>, newSheetFormulaDataMatrix: ObjectMatrix<IFormulaDataItem | null>, formulaIdMap: Map<string, IFormulaIdMap>, deleteFormulaIdMap: Map<string, string | IFormulaIdMap>, r: number, c: number, cell: Nullable<ICellData>): void;
+export declare function clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix: ObjectMatrix<IRange>, arrayFormulaCellDataMatrix: ObjectMatrix<Nullable<ICellData>>, r: number, c: number): true | undefined;

package/lib/types/plugin.d.ts

@@ -10,9 +10,9 @@ interface IUniverFormulaEngine {
 export declare class UniverFormulaEnginePlugin extends Plugin {
     private _config;
     protected _injector: Injector;
+    static pluginName: string;
     constructor(_config: IUniverFormulaEngine, _injector: Injector);
     onStarting(): void;
     private _initialize;
-    onReady(): void;
 }
 export {};

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

@@ -1,10 +1,14 @@
-import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap } from '../basics/common';
+import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 import { IUnitRange, Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
 
 export declare const DEFAULT_DOCUMENT_SUB_COMPONENT_ID = "__default_document_sub_component_id20231101__";
 export interface IFormulaCurrentConfigService {
     load(config: IFormulaDatasetConfig): void;
     getUnitData(): IUnitData;
+    /**
+     * Get the unit styles data.
+     */
+    getUnitStylesData(): IUnitStylesData;
     getFormulaData(): IFormulaData;
     getSheetNameMap(): IUnitSheetNameMap;
     isForceCalculate(): boolean;
@@ -26,8 +30,9 @@ export interface IFormulaCurrentConfigService {
     setExecuteSubUnitId(subUnitId: string): void;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
-    private readonly _currentUniverService;
+    private readonly _univerInstanceService;
     private _unitData;
+    private _unitStylesData;
     private _arrayFormulaCellData;
     private _formulaData;
     private _sheetNameMap;
@@ -35,14 +40,13 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     private _dirtyRanges;
     private _dirtyNameMap;
     private _dirtyDefinedNameMap;
-    private _numfmtItemMap;
     private _dirtyUnitFeatureMap;
     private _dirtyUnitOtherFormulaMap;
     private _excludedCell;
     private _sheetIdToNameMap;
     private _executeUnitId;
     private _executeSubUnitId;
-    constructor(_currentUniverService: IUniverInstanceService);
+    constructor(_univerInstanceService: IUniverInstanceService);
     dispose(): void;
     getExecuteUnitId(): Nullable<string>;
     getExecuteSubUnitId(): Nullable<string>;
@@ -50,6 +54,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     setExecuteSubUnitId(subUnitId: string): void;
     getExcludedRange(): Nullable<IUnitExcludedCell>;
     getUnitData(): IUnitData;
+    getUnitStylesData(): IUnitStylesData;
     getFormulaData(): IFormulaData;
     getArrayFormulaCellData(): IRuntimeUnitDataType;
     getSheetNameMap(): IUnitSheetNameMap;
@@ -57,7 +62,6 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     getDirtyRanges(): IUnitRange[];
     getDirtyNameMap(): IDirtyUnitSheetNameMap;
     getDirtyDefinedNameMap(): IDirtyUnitSheetDefinedNameMap;
-    getNumfmtItemMap(): INumfmtItemMap;
     getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
     getDirtyUnitOtherFormulaMap(): IDirtyUnitOtherFormulaMap;
     getSheetName(unitId: string, sheetId: string): string;

package/lib/types/services/defined-names.service.d.ts

@@ -25,6 +25,7 @@ export interface IDefinedNamesService {
     getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
     getValueById(unitId: string, id: string): Nullable<IDefinedNamesServiceParam>;
     removeDefinedName(unitId: string, name: string): void;
+    removeUnitDefinedName(unitId: string): void;
     hasDefinedName(unitId: string): boolean;
     setCurrentRange(range: IUnitRange): void;
     getCurrentRange(): IUnitRange;
@@ -52,6 +53,7 @@ export declare class DefinedNamesService extends Disposable implements IDefinedN
     registerDefinedNames(unitId: string, params: IDefinedNameMapItem): void;
     registerDefinedName(unitId: string, param: IDefinedNamesServiceParam): void;
     removeDefinedName(unitId: string, id: string): void;
+    removeUnitDefinedName(unitId: string): void;
     getDefinedNameMap(unitId: string): IDefinedNameMapItem;
     getValueByName(unitId: string, name: string): IDefinedNamesServiceParam | null;
     getValueById(unitId: string, id: string): IDefinedNamesServiceParam;

package/lib/types/services/dependency-manager.service.d.ts

@@ -0,0 +1,74 @@
+import { FormulaDependencyTreeCache, FormulaDependencyTree } from '../engine/dependency/dependency-tree';
+import { Nullable, Disposable, ObjectMatrix } from '@univerjs/core';
+
+export interface IOtherFormulaDependencyParam {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: {
+            [formulaId: string]: Nullable<FormulaDependencyTree>;
+        };
+    }>;
+}
+export interface IFormulaDependencyParam {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: ObjectMatrix<Nullable<FormulaDependencyTree>>;
+    }>;
+}
+export interface IDependencyManagerService {
+    dispose(): void;
+    getAllTree(): FormulaDependencyTree[];
+    buildDependencyTree(shouldBeBuildTrees: FormulaDependencyTree[] | FormulaDependencyTreeCache): FormulaDependencyTree[];
+    clearDependencyForTree(shouldBeClearTree: Nullable<FormulaDependencyTree>): void;
+    reset(): void;
+    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
+    removeOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string[]): void;
+    hasOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): boolean;
+    addFeatureFormulaDependency(featureId: string, dependencyTree: FormulaDependencyTree): void;
+    removeFeatureFormulaDependency(featureId: string): void;
+    hasFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): boolean;
+    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
+    removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
+    hasFormulaDependency(unitId: string, sheetId: string, row: number, column: number): boolean;
+    clearFormulaDependency(unitId: string, sheetId: string): void;
+}
+/**
+ * Passively marked as dirty, register the reference and execution actions of the feature plugin.
+ * After execution, a dirty area and calculated data will be returned,
+ * causing the formula to be marked dirty again,
+ * thereby completing the calculation of the entire dependency tree.
+ */
+export declare class DependencyManagerService extends Disposable implements IDependencyManagerService {
+    private _otherFormulaData;
+    private _featureFormulaData;
+    private _formulaData;
+    dispose(): void;
+    /**
+     * Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
+     * return FormulaDependencyTree[]
+     */
+    getAllTree(): FormulaDependencyTree[];
+    buildDependencyTree(shouldBeBuildTrees: FormulaDependencyTree[] | FormulaDependencyTreeCache): FormulaDependencyTree[];
+    /**
+     * Build the dependency relationship between the trees.
+     * @param allTrees  all FormulaDependencyTree
+     * @param shouldBeBuildTrees  FormulaDependencyTree[] | FormulaDependencyTreeCache
+     */
+    private _buildDependencyTree;
+    /**
+     * Clear the dependency relationship of the tree.
+     * establish the relationship between the parent and the child.
+     * @param shouldBeClearTree
+     */
+    clearDependencyForTree(shouldBeClearTree: Nullable<FormulaDependencyTree>): void;
+    reset(): void;
+    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
+    removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]): void;
+    hasOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): boolean;
+    addFeatureFormulaDependency(featureId: string, dependencyTree: FormulaDependencyTree): void;
+    removeFeatureFormulaDependency(featureId: string): void;
+    hasFeatureFormulaDependency(featureId: string): boolean;
+    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
+    removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
+    clearFormulaDependency(unitId: string, sheetId: string): void;
+    hasFormulaDependency(unitId: string, sheetId: string, row: number, column: number): boolean;
+}
+export declare const IDependencyManagerService: import('@wendellhu/redi').IdentifierDecorator<DependencyManagerService>;

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

@@ -1,7 +1,7 @@
 import { IFormulaCurrentConfigService } from './current-data.service';
 import { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { BaseAstNode } from '../engine/ast-node/base-ast-node';
-import { IArrayFormulaRangeType, IFeatureDirtyRangeType, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
+import { IArrayFormulaRangeType, IFeatureDirtyRangeType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
 import { Nullable, Disposable } from '@univerjs/core';
 
 /**
@@ -36,7 +36,6 @@ export interface IAllRuntimeData {
     functionsExecutedState: FormulaExecutedStateType;
     arrayFormulaCellData: IRuntimeUnitDataType;
     clearArrayFormulaCellData: IRuntimeUnitDataType;
-    numfmtItemMap: INumfmtItemMap;
     runtimeFeatureRange: {
         [featureId: string]: IFeatureDirtyRangeType;
     };
@@ -112,7 +111,6 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _unitArrayFormulaRange;
     private _runtimeArrayFormulaCellData;
     private _runtimeClearArrayFormulaCellData;
-    private _numfmtItemMap;
     private _runtimeFeatureRange;
     private _runtimeFeatureCellData;
     private _functionsExecutedState;
@@ -158,7 +156,6 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     setRuntimeData(functionVariant: FunctionVariantType): void;
     getUnitData(): IRuntimeUnitDataType;
     getUnitArrayFormula(): IArrayFormulaRangeType;
-    getNumfmtItemMap(): INumfmtItemMap;
     getRuntimeOtherData(): IRuntimeOtherUnitDataType;
     getRuntimeArrayFormulaCellData(): IRuntimeUnitDataType;
     getRuntimeClearArrayFormulaCellData(): IRuntimeUnitDataType;
@@ -172,7 +169,6 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
     getAllRuntimeData(): IAllRuntimeData;
     getRuntimeState(): IExecutionInProgressParams;
-    private _objectValueToCellValue;
     private _checkIfArrayFormulaRangeHasData;
     private _isInArrayFormulaRange;
     private _checkIfArrayFormulaExceeded;