@univerjs/engine-formula 0.12.0 → 0.12.1-nightly.202511221011

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

@@ -1,4 +1,5 @@
 import { ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix, Styles } from '@univerjs/core';
+import { IImageFormulaInfo } from '../engine/value-object/primitive-object';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
 export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
 export declare const REFERENCE_OBJECT_CLASS_TYPE = "referenceObject";
@@ -102,6 +103,17 @@ export interface IFeatureDirtyRangeType {
         [sheetId: string]: IRange[];
     }>;
 }
+export interface IRuntimeImageFormulaDataType extends IImageFormulaInfo {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface IUnitImageFormulaDataType {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: ObjectMatrix<Nullable<IImageFormulaInfo>>;
+    }>;
+}
 export interface IArrayFormulaUnitCellType extends IRuntimeUnitDataPrimitiveType {
 }
 export interface IFormulaData {

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

@@ -1,4 +1,7 @@
+import { BaseReferenceObject, FunctionVariantType } from '../engine/reference-object/base-reference-object';
+import { MultiAreaReferenceObject } from '../engine/reference-object/multi-area-reference-object';
 import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
+import { FormulaDataModel } from '../models/formula-data.model';
 export declare function betaCDF(x: number, alpha: number, beta: number): number;
 export declare function betaPDF(x: number, alpha: number, beta: number): number;
 export declare function betaINV(probability: number, alpha: number, beta: number): number;
@@ -67,3 +70,53 @@ export declare function getKnownsArrayCoefficients(knownYsValues: number[][], kn
     newX: number[][];
     XTXInverse: number[][];
 };
+/**
+ * Parse aggregate data references into multi-area refs and normal refs, currently only used in functions like SUBTOTAL and AGGREGATE.
+ * If there is any invalid reference, return isError as true.
+ */
+export declare function parseAggregateDataRefs(refs: FunctionVariantType[]): {
+    isError: boolean;
+    multiAreaRefs: MultiAreaReferenceObject[];
+    normalRefs: BaseReferenceObject[];
+};
+export declare enum AggregateFunctionType {
+    AVERAGE = "AVERAGE",
+    COUNT = "COUNT",
+    COUNTA = "COUNTA",
+    MAX = "MAX",
+    MIN = "MIN",
+    PRODUCT = "PRODUCT",
+    STDEV = "STDEV",
+    STDEV_S = "STDEV.S",
+    STDEVP = "STDEVP",
+    STDEV_P = "STDEV.P",
+    SUM = "SUM",
+    VAR = "VAR",
+    VAR_S = "VAR.S",
+    VARP = "VARP",
+    VAR_P = "VAR.P",
+    MEDIAN = "MEDIAN",
+    MODE_SNGL = "MODE.SNGL"
+}
+export type modeSnglValueCountMapType = Record<number, {
+    count: number;
+    order: number;
+}>;
+export declare function getModeSnglResult(valueCountMap: modeSnglValueCountMapType, valueMaxCount: number): BaseValueObject;
+export interface IAggregateIgnoreOptions {
+    ignoreRowHidden: boolean;
+    ignoreErrorValues: boolean;
+    ignoreNested: boolean;
+}
+export declare function getAggregateResult(options: {
+    type: AggregateFunctionType;
+    formulaDataModel: FormulaDataModel;
+} & IAggregateIgnoreOptions, refs: BaseReferenceObject[]): BaseValueObject;
+export declare function getArrayValuesByAggregateIgnoreOptions(array: FunctionVariantType, options?: IAggregateIgnoreOptions, formulaDataModel?: FormulaDataModel): number[] | ErrorValueObject;
+export declare function getMedianResult(array: number[]): BaseValueObject;
+export declare function getLargeResult(array: number[], k: number): BaseValueObject;
+export declare function getSmallResult(array: number[], k: number): BaseValueObject;
+export declare function getPercentileIncResult(array: number[], k: number): BaseValueObject;
+export declare function getPercentileExcResult(array: number[], k: number): BaseValueObject;
+export declare function getQuartileIncResult(array: number[], quart: number): BaseValueObject;
+export declare function getQuartileExcResult(array: number[], quart: number): BaseValueObject;

package/lib/types/commands/mutations/set-image-formula-data.mutation.d.ts

@@ -0,0 +1,9 @@
+import { IMutation } from '@univerjs/core';
+import { IRuntimeImageFormulaDataType } from '../../basics/common';
+export interface ISetImageFormulaDataMutationParams {
+    imageFormulaData: IRuntimeImageFormulaDataType[];
+}
+/**
+ * There is no need to process data here, it is used as the main thread to send data to the worker. The main thread has already updated the data in advance, and there is no need to update it again here.
+ */
+export declare const SetImageFormulaDataMutation: IMutation<ISetImageFormulaDataMutationParams>;

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

@@ -12,6 +12,7 @@ interface IInjectDefinedNameParam {
     unitId: Nullable<string>;
     getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
     getDirtyDefinedNameMap(): IDirtyUnitSheetDefinedNameMap;
+    getSheetName: (unitId: string, sheetId: string) => string;
 }
 export declare class LexerTreeBuilder extends Disposable {
     private _currentLexerNode;
@@ -55,6 +56,10 @@ export declare class LexerTreeBuilder extends Disposable {
      * =sum({}{})
      */
     private _formulaSpellCheck;
+    /**
+     * ={0,1,2,3,4,5,6} + {0;1;2;3;4;5;6}*7
+     */
+    private _passArrayOperator;
     getSequenceNode(sequenceArray: ISequenceArray[]): (string | ISequenceNode)[];
     private _processPushSequenceNode;
     private _getCurrentParamIndex;
@@ -72,6 +77,7 @@ export declare class LexerTreeBuilder extends Disposable {
     nodeMakerTest(formulaString: string): ErrorType.VALUE | (string | LexerNode)[] | undefined;
     treeBuilder(formulaString: string, transformSuffix?: boolean, injectDefinedNameParam?: IInjectDefinedNameParam): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
     private _handleDefinedName;
+    private _getHasSheetNameDefinedName;
     private _handleNestedDefinedName;
     private _simpleCheckDefinedName;
     private _checkDefinedNameDirty;

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

@@ -172,6 +172,11 @@ export declare class ArrayValueObject extends BaseValueObject {
     atan2(valueObject: BaseValueObject): BaseValueObject;
     atan2Inverse(valueObject: BaseValueObject): BaseValueObject;
     mean(ddof?: number): BaseValueObject;
+    /**
+     * TODO: @DR-Univer
+     * This calculation method contains an error, please note.
+     * Please refer `getMedianResult` function in /engine-formula/src/basics/statistical.ts
+     */
     median(): BaseValueObject;
     /**
      * ┌──────────────┬────────────────────────────────┬───────────────────┐

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

@@ -44,6 +44,7 @@ export declare class BaseValueObject extends ObjectClassType {
     isError(): boolean;
     isNull(): boolean;
     isHyperlink(): boolean;
+    isImage(): boolean;
     sum(): BaseValueObject;
     max(): BaseValueObject;
     min(): BaseValueObject;

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

@@ -149,15 +149,35 @@ export declare class NumberValueObject extends BaseValueObject {
     convertToBooleanObjectValue(): BooleanValueObject;
     private _compareInfinity;
 }
-interface IStringValueObjectOptions {
+export interface IImageFormulaInfo {
+    source: string;
+    altText: string;
+    sizing: number;
+    height: number;
+    width: number;
+    isErrorImage?: boolean;
+    imageNaturalHeight?: number;
+    imageNaturalWidth?: number;
+}
+export interface IStringValueObjectOptions {
+    /**
+     * Whether it is a hyperlink value from HYPERLINK function
+     */
     isHyperlink?: boolean;
     hyperlinkUrl?: string;
+    /**
+     * Whether it is an image value from IMAGE function
+     */
+    isImage?: boolean;
+    imageInfo?: IImageFormulaInfo;
 }
 export declare const StringValueObjectCache: FormulaAstLRU<StringValueObject>;
 export declare class StringValueObject extends BaseValueObject {
     private _value;
     private _isHyperlink;
     private _hyperlinkUrl;
+    private _isImage;
+    private _imageInfo;
     static create(value: string, options?: IStringValueObjectOptions): StringValueObject;
     static checkCacheByOptions(cached: StringValueObject, options: IStringValueObjectOptions): boolean;
     constructor(rawValue: string);
@@ -165,6 +185,8 @@ export declare class StringValueObject extends BaseValueObject {
     isString(): boolean;
     isHyperlink(): boolean;
     getHyperlinkUrl(): string;
+    isImage(): boolean;
+    getImageInfo(): IStringValueObjectOptions['imageInfo'];
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
     plus(valueObject: BaseValueObject): BaseValueObject;
@@ -183,4 +205,3 @@ export declare class StringValueObject extends BaseValueObject {
 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, pattern?: string): ErrorValueObject | NumberValueObject;
-export {};

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

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class ImageFunction extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(source: BaseValueObject, altText?: BaseValueObject, sizing?: BaseValueObject, height?: BaseValueObject, width?: BaseValueObject): BaseValueObject;
+    private _handleSingleObject;
+}

package/lib/types/functions/math/aggregate/index.d.ts

@@ -0,0 +1,14 @@
+import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Aggregate extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    needsReferenceObject: boolean;
+    needsFilteredOutRows: boolean;
+    needsFormulaDataModel: boolean;
+    calculate(functionNum: FunctionVariantType, options: FunctionVariantType, ...refs: FunctionVariantType[]): BaseValueObject;
+    private _handleSingleObject;
+    private _getAggregateOptions;
+    private _handleLargeSmallPercentileQuartile;
+}

package/lib/types/functions/math/subtotal/index.d.ts

@@ -1,5 +1,6 @@
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Subtotal extends BaseFunction {
     minParams: number;
@@ -7,21 +8,8 @@ export declare class Subtotal extends BaseFunction {
     needsReferenceObject: boolean;
     needsFilteredOutRows: boolean;
     needsFormulaDataModel: boolean;
-    calculate(functionNum: FunctionVariantType, ...refs: FunctionVariantType[]): ArrayValueObject | FunctionVariantType;
+    calculate(functionNum: FunctionVariantType, ...refs: FunctionVariantType[]): BaseValueObject | ArrayValueObject;
     private _handleSingleObject;
-    private _getIndexNumValue;
-    private _average;
-    private _count;
-    private _counta;
-    private _max;
-    private _min;
-    private _product;
-    private _stdev;
-    private _stdevp;
-    private _sum;
-    private _var;
-    private _varp;
-    private _flattenRefArray;
-    private _isRowHidden;
-    private _isBlankArrayObject;
+    private _handleMultiAreaRefs;
+    private _getMultiAreaInfo;
 }

package/lib/types/functions/statistical/large/index.d.ts

@@ -5,5 +5,4 @@ export declare class Large extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/functions/statistical/median/index.d.ts

@@ -4,5 +4,4 @@ export declare class Median extends BaseFunction {
     minParams: number;
     maxParams: number;
     calculate(...variants: BaseValueObject[]): BaseValueObject;
-    private _getResult;
 }

package/lib/types/functions/statistical/mode-sngl/index.d.ts

@@ -4,5 +4,4 @@ export declare class ModeSngl extends BaseFunction {
     minParams: number;
     maxParams: number;
     calculate(...variants: BaseValueObject[]): BaseValueObject;
-    private _getResult;
 }

package/lib/types/functions/statistical/percentile-exc/index.d.ts

@@ -5,5 +5,4 @@ export declare class PercentileExc extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/functions/statistical/percentile-inc/index.d.ts

@@ -5,5 +5,4 @@ export declare class PercentileInc extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/functions/statistical/quartile-exc/index.d.ts

@@ -5,5 +5,4 @@ export declare class QuartileExc extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, quart: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/functions/statistical/quartile-inc/index.d.ts

@@ -5,5 +5,4 @@ export declare class QuartileInc extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, quart: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/functions/statistical/small/index.d.ts

@@ -5,5 +5,4 @@ export declare class Small extends BaseFunction {
     maxParams: number;
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
-    private _getValues;
 }

package/lib/types/index.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export type { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitSheetNameMap, } from './basics/common';
+export type { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeImageFormulaDataType, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitImageFormulaDataType, IUnitSheetNameMap, } from './basics/common';
 export { BooleanValue } from './basics/common';
 export { type IOtherFormulaData } from './basics/common';
 export { type IUnitRowData } from './basics/common';
@@ -35,6 +35,7 @@ export { SetDefinedNameMutationFactory } from './commands/mutations/set-defined-
 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';
+export { type ISetImageFormulaDataMutationParams, SetImageFormulaDataMutation } from './commands/mutations/set-image-formula-data.mutation';
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';
 export { RemoveSuperTableMutation, SetSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';
 export type { ISetSuperTableMutationParam, ISetSuperTableMutationSearchParam } from './commands/mutations/set-super-table.mutation';
@@ -77,7 +78,7 @@ export { generateStringWithSequence, type ISequenceNode, sequenceNodeType } from
 export { ArrayValueObject, ValueObjectFactory } from './engine/value-object/array-value-object';
 export { BaseValueObject, ErrorValueObject } from './engine/value-object/base-value-object';
 export { LambdaValueObjectObject } from './engine/value-object/lambda-value-object';
-export type { FormulaFunctionResultValueType, FormulaFunctionValueType, PrimitiveValueType } from './engine/value-object/primitive-object';
+export type { FormulaFunctionResultValueType, FormulaFunctionValueType, IImageFormulaInfo, PrimitiveValueType } from './engine/value-object/primitive-object';
 export { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from './engine/value-object/primitive-object';
 export { functionArray } from './functions/array/function-map';
 export { FUNCTION_NAMES_ARRAY } from './functions/array/function-names';

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

@@ -1,5 +1,5 @@
 import { ICellData, IObjectMatrixPrimitiveType, IRange, IUnitRange, Nullable, Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
-import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitRowData, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
+import { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitImageFormulaDataType, IUnitRowData, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 import { LexerTreeBuilder } from '../engine/analysis/lexer-tree-builder';
 export interface IRangeChange {
     oldCell: IRange;
@@ -10,6 +10,7 @@ export declare class FormulaDataModel extends Disposable {
     private readonly _lexerTreeBuilder;
     private _arrayFormulaRange;
     private _arrayFormulaCellData;
+    private _unitImageFormulaData;
     constructor(_univerInstanceService: IUniverInstanceService, _lexerTreeBuilder: LexerTreeBuilder);
     dispose(): void;
     clearPreviousArrayFormulaCellData(clearArrayFormulaCellData: IRuntimeUnitDataType): void;
@@ -20,7 +21,10 @@ export declare class FormulaDataModel extends Disposable {
     setArrayFormulaRange(value: IArrayFormulaRangeType): void;
     getArrayFormulaCellData(): IArrayFormulaUnitCellType;
     setArrayFormulaCellData(value: IArrayFormulaUnitCellType): void;
+    getUnitImageFormulaData(): IUnitImageFormulaDataType;
+    setUnitImageFormulaData(value: IUnitImageFormulaDataType): void;
     mergeArrayFormulaRange(formulaData: IArrayFormulaRangeType): void;
+    mergeUnitImageFormulaData(formulaData: IUnitImageFormulaDataType): void;
     deleteArrayFormulaRange(unitId: string, sheetId: string, row: number, column: number): void;
     getCalculateData(): {
         allUnitData: IUnitData;
@@ -36,6 +40,7 @@ export declare class FormulaDataModel extends Disposable {
     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;
+    updateImageFormulaData(unitId: string, sheetId: string, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>): void;
     getFormulaStringByCell(row: number, column: number, sheetId: string, unitId: string): Nullable<string>;
     /**
      * Function to get all formula ranges

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

@@ -1,5 +1,5 @@
 import { IUnitRange, LocaleType, Nullable, Disposable, IUniverInstanceService, LocaleService } from '@univerjs/core';
-import { IArrayFormulaRangeType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
+import { IArrayFormulaRangeType, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitRowData, IUnitSheetIdToNameMap, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 import { FormulaDataModel } from '../models/formula-data.model';
 import { ISheetRowFilteredService } from './sheet-row-filtered.service';
 export interface IFormulaDirtyData {
@@ -54,6 +54,7 @@ export interface IFormulaCurrentConfigService {
         columnCount: number;
     };
     getFilteredOutRows(unitId: string, sheetId: string, startRow: number, endRow: number): number[];
+    setSheetNameMap(sheetIdToNameMap: IUnitSheetIdToNameMap): void;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _univerInstanceService;
@@ -97,6 +98,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
     getDirtyUnitOtherFormulaMap(): IDirtyUnitOtherFormulaMap;
     getSheetName(unitId: string, sheetId: string): string;
+    setSheetNameMap(sheetIdToNameMap: IUnitSheetIdToNameMap): void;
     getClearDependencyTreeCache(): IDirtyUnitSheetNameMap;
     getLocale(): LocaleType;
     getSheetsInfo(): {

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

@@ -1,5 +1,5 @@
 import { Nullable, Disposable } from '@univerjs/core';
-import { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IFeatureDirtyRangeType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
+import { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IFeatureDirtyRangeType, IRuntimeImageFormulaDataType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
 import { BaseAstNode } from '../engine/ast-node/base-ast-node';
 import { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IFormulaCurrentConfigService } from './current-data.service';
@@ -33,6 +33,7 @@ export interface IAllRuntimeData {
     functionsExecutedState: FormulaExecutedStateType;
     arrayFormulaCellData: IRuntimeUnitDataType;
     clearArrayFormulaCellData: IRuntimeUnitDataType;
+    imageFormulaData: IRuntimeImageFormulaDataType[];
     runtimeFeatureRange: {
         [featureId: string]: IFeatureDirtyRangeType;
     };
@@ -98,6 +99,7 @@ export interface IFormulaRuntimeService {
     getUnitArrayFormulaEmbeddedMap(): IArrayFormulaEmbeddedMap;
     setUnitArrayFormulaEmbeddedMap(): void;
     clearArrayObjectCache(): void;
+    getRuntimeImageFormulaData(): IRuntimeImageFormulaDataType[];
 }
 export declare class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {
     private readonly _currentConfigService;
@@ -118,6 +120,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _runtimeClearArrayFormulaCellData;
     private _runtimeFeatureRange;
     private _runtimeFeatureCellData;
+    private _runtimeImageFormulaData;
     private _functionsExecutedState;
     private _functionDefinitionPrivacyVar;
     private _totalFormulasToCalculate;
@@ -179,6 +182,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
         [featureId: string]: IRuntimeUnitDataType;
     };
     setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    getRuntimeImageFormulaData(): IRuntimeImageFormulaDataType[];
     getAllRuntimeData(): IAllRuntimeData;
     getRuntimeState(): IExecutionInProgressParams;
     clearArrayObjectCache(): void;