@univerjs/engine-formula 0.1.0-alpha.1 → 0.1.0-alpha.2

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

@@ -0,0 +1,52 @@
+/**
+ * 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 { ICellData, Nullable, ObjectMatrixPrimitiveType } from '@univerjs/core';
+import { Disposable, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
+import type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IFormulaData, IFormulaDataItem, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap } from '../basics/common';
+import { LexerTreeBuilder } from '../engine/analysis/lexer-tree-builder';
+export interface IFormulaIdMap {
+    f: string;
+    r: number;
+    c: number;
+}
+export declare class FormulaDataModel extends Disposable {
+    private readonly _currentUniverService;
+    private readonly _lexerTreeBuilder;
+    private _formulaData;
+    private _arrayFormulaRange;
+    private _arrayFormulaCellData;
+    constructor(_currentUniverService: IUniverInstanceService, _lexerTreeBuilder: LexerTreeBuilder);
+    clearPreviousArrayFormulaCellData(clearArrayFormulaCellData: IRuntimeUnitDataType): void;
+    mergeArrayFormulaCellData(unitData: IRuntimeUnitDataType): void;
+    getFormulaData(): IFormulaData;
+    setFormulaData(value: IFormulaData): void;
+    setArrayFormulaRange(value: IArrayFormulaRangeType): void;
+    getArrayFormulaRange(): IArrayFormulaRangeType;
+    setArrayFormulaCellData(value: IArrayFormulaUnitCellType): void;
+    getArrayFormulaCellData(): IArrayFormulaUnitCellType;
+    mergeArrayFormulaRange(formulaData: IArrayFormulaRangeType): void;
+    deleteArrayFormulaRange(unitId: string, sheetId: string, row: number, column: number): void;
+    initFormulaData(): void;
+    getCalculateData(): {
+        allUnitData: IUnitData;
+        unitSheetNameMap: IUnitSheetNameMap;
+    };
+    updateFormulaData(unitId: string, sheetId: string, cellValue: ObjectMatrixPrimitiveType<ICellData | null>): void;
+    getFormulaItemBySId(sId: string, sheetId: string, unitId: string): Nullable<IFormulaDataItem>;
+    getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): IFormulaDataItem;
+    getFormulaIdMap(unitId: string, sheetId: string): Map<string, IFormulaIdMap>;
+}
+export declare function initSheetFormulaData(formulaData: IFormulaData, unitId: string, sheetId: string, cellMatrix: ObjectMatrix<ICellData>): void;

package/lib/types/plugin.d.ts

@@ -1,8 +1,29 @@
+/**
+ * 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 { Plugin } from '@univerjs/core';
 import { Injector } from '@wendellhu/redi';
-export declare class BaseFormulaEnginePlugin extends Plugin {
+interface IUniverFormulaEngine {
+    notExecuteFormula?: boolean;
+}
+export declare class UniverFormulaEnginePlugin extends Plugin {
+    private _config;
     protected _injector: Injector;
-    constructor(_config: undefined, _injector: Injector);
-    onStarting(injector: Injector): void;
+    constructor(_config: IUniverFormulaEngine, _injector: Injector);
+    onStarting(): void;
+    private _initialize;
+    onReady(): void;
 }
-//# sourceMappingURL=plugin.d.ts.map
+export {};

package/lib/types/services/calculate-formula.service.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 { Disposable, IConfigService } from '@univerjs/core';
+import type { IFeatureDirtyRangeType, IFormulaDatasetConfig, IRuntimeUnitDataType } from '../basics/common';
+import { Lexer } from '../engine/analysis/lexer';
+import { AstTreeBuilder } from '../engine/analysis/parser';
+import { ErrorNode } from '../engine/ast-node/base-ast-node';
+import { FormulaDependencyGenerator } from '../engine/dependency/formula-dependency';
+import { Interpreter } from '../engine/interpreter/interpreter';
+import { IFormulaCurrentConfigService } from './current-data.service';
+import type { IAllRuntimeData, IExecutionInProgressParams } from './runtime.service';
+import { IFormulaRuntimeService } from './runtime.service';
+export declare const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
+export declare const CYCLE_REFERENCE_COUNT = "cycleReferenceCount";
+export declare const EVERY_N_FUNCTION_EXECUTION_PAUSE = 100;
+export declare class CalculateFormulaService extends Disposable {
+    private readonly _configService;
+    private readonly _lexer;
+    private readonly _currentConfigService;
+    private readonly _runtimeService;
+    private readonly _formulaDependencyGenerator;
+    private readonly _interpreter;
+    private readonly _astTreeBuilder;
+    private readonly _executionStartListener$;
+    readonly executionStartListener$: import("rxjs").Observable<boolean>;
+    private readonly _executionCompleteListener$;
+    readonly executionCompleteListener$: import("rxjs").Observable<IAllRuntimeData>;
+    private readonly _executionInProgressListener$;
+    readonly executionInProgressListener$: import("rxjs").Observable<IExecutionInProgressParams>;
+    constructor(_configService: IConfigService, _lexer: Lexer, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _formulaDependencyGenerator: FormulaDependencyGenerator, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder);
+    dispose(): void;
+    /**
+     * Stop the execution of the formula.
+     */
+    stopFormulaExecution(): void;
+    /**
+     * When the feature is loading,
+     * the pre-calculated content needs to be input to the formula engine in advance,
+     * so that the formula can read the correct values.
+     * @param featureId
+     * @param featureData
+     */
+    setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+    execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
+    private _execute;
+    private _getArrayFormulaDirtyRangeAndExcludedRange;
+    private _apply;
+    calculate(formulaString: string, transformSuffix?: boolean): ErrorNode | undefined;
+}

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

@@ -1,14 +1,31 @@
+/**
+ * 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 { IUnitRange, Nullable } from '@univerjs/core';
 import { Disposable, IUniverInstanceService } from '@univerjs/core';
-import type { IFormulaData, IFormulaDatasetConfig, IOtherFormulaData, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap } from '../basics/common';
+import type { IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap } from '../basics/common';
 export declare const DEFAULT_DOCUMENT_SUB_COMPONENT_ID = "__default_document_sub_component_id20231101__";
 export interface IFormulaCurrentConfigService {
+    load(config: IFormulaDatasetConfig): void;
     getUnitData(): IUnitData;
     getFormulaData(): IFormulaData;
-    getOtherFormulaData(): IOtherFormulaData;
     getSheetNameMap(): IUnitSheetNameMap;
     isForceCalculate(): boolean;
     getDirtyRanges(): IUnitRange[];
+    getDirtyNameMap(): IDirtyUnitSheetNameMap;
+    getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
     registerUnitData(unitData: IUnitData): void;
     registerFormulaData(formulaData: IFormulaData): void;
     registerSheetNameMap(sheetNameMap: IUnitSheetNameMap): void;
@@ -19,12 +36,12 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     private readonly _currentUniverService;
     private _unitData;
     private _arrayFormulaCellData;
-    private _otherFormulaData;
     private _formulaData;
     private _sheetNameMap;
     private _forceCalculate;
     private _dirtyRanges;
     private _dirtyNameMap;
+    private _dirtyUnitFeatureMap;
     private _excludedCell;
     constructor(_currentUniverService: IUniverInstanceService);
     dispose(): void;
@@ -32,18 +49,17 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     getUnitData(): IUnitData;
     getFormulaData(): IFormulaData;
     getArrayFormulaCellData(): IRuntimeUnitDataType;
-    getOtherFormulaData(): IOtherFormulaData;
     getSheetNameMap(): IUnitSheetNameMap;
     isForceCalculate(): boolean;
     getDirtyRanges(): IUnitRange[];
+    getDirtyNameMap(): IDirtyUnitSheetNameMap;
+    getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
     load(config: IFormulaDatasetConfig): void;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;
     registerFormulaData(formulaData: IFormulaData): void;
     registerSheetNameMap(sheetNameMap: IUnitSheetNameMap): void;
     private _dataToRuntime;
-    private _loadOtherFormulaData;
     private _loadSheetData;
 }
 export declare const IFormulaCurrentConfigService: import("@wendellhu/redi").IdentifierDecorator<FormulaCurrentConfigService>;
-//# sourceMappingURL=current-data.service.d.ts.map

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

@@ -1,13 +1,34 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 export interface IDefinedNamesService {
-    registerDefinedName(name: string, reference: string): void;
-    getDefinedNameMap(): Map<string, string>;
+    registerDefinedName(unitId: string, name: string, formulaOrRefString: string): void;
+    getDefinedNameMap(unitId: string): Nullable<Map<string, string>>;
+    getValue(unitId: string, name: string): Nullable<string>;
+    removeDefinedName(unitId: string, name: string): void;
+    hasDefinedName(unitId: string): boolean;
 }
 export declare class DefinedNamesService extends Disposable implements IDefinedNamesService {
     private _definedNameMap;
     dispose(): void;
-    registerDefinedName(name: string, reference: string): void;
-    getDefinedNameMap(): Map<string, string>;
+    registerDefinedName(unitId: string, name: string, formulaOrRefString: string): void;
+    removeDefinedName(unitId: string, name: string): void;
+    getDefinedNameMap(unitId: string): Map<string, string> | undefined;
+    getValue(unitId: string, name: string): string | undefined;
+    hasDefinedName(unitId: string): boolean;
 }
 export declare const IDefinedNamesService: import("@wendellhu/redi").IdentifierDecorator<DefinedNamesService>;
-//# sourceMappingURL=defined-names.service.d.ts.map

package/lib/types/services/feature-calculation-manager.service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { IUnitRange, Nullable } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+import type { IFeatureDirtyRangeType, IRuntimeUnitDataType } from '../basics/common';
+import type { FormulaDependencyTree } from '../engine/dependency/dependency-tree';
+export interface IFeatureCalculationManagerParam {
+    unitId: string;
+    subComponentId: string;
+    dependencyRanges: IUnitRange[];
+    getDirtyData: (currentDependencyTree: FormulaDependencyTree) => {
+        runtimeCellData: IRuntimeUnitDataType;
+        dirtyRanges: IFeatureDirtyRangeType;
+    };
+}
+export interface IFeatureCalculationManagerService {
+    dispose(): void;
+    remove(featureId: string): void;
+    get(featureId: string): Nullable<IFeatureCalculationManagerParam>;
+    has(featureId: string): boolean;
+    register(featureId: string, referenceExecutor: IFeatureCalculationManagerParam): void;
+    getReferenceExecutorMap(): Map<string, IFeatureCalculationManagerParam>;
+}
+/**
+ * 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 FeatureCalculationManagerService extends Disposable implements IFeatureCalculationManagerService {
+    private _referenceExecutorMap;
+    dispose(): void;
+    remove(featureId: string): void;
+    get(featureId: string): IFeatureCalculationManagerParam | undefined;
+    has(featureId: string): boolean;
+    register(featureId: string, referenceExecutor: IFeatureCalculationManagerParam): void;
+    getReferenceExecutorMap(): Map<string, IFeatureCalculationManagerParam>;
+}
+export declare const IFeatureCalculationManagerService: import("@wendellhu/redi").IdentifierDecorator<FeatureCalculationManagerService>;

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

@@ -1,29 +1,56 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
-import type { FUNCTION_NAMES, IFunctionInfo } from '../basics/function';
+import type { IFunctionInfo, IFunctionNames } from '../basics/function';
 import type { BaseFunction } from '../functions/base-function';
 export interface IFunctionService {
+    /**
+     * Use register to register a function, new CustomFunction(inject, name)
+     */
     registerExecutors(...functions: BaseFunction[]): void;
-    getExecutors(): Map<string, BaseFunction>;
-    getExecutor(functionToken: string): Nullable<BaseFunction>;
-    hasExecutor(functionToken: string): boolean;
+    getExecutors(): Map<IFunctionNames, BaseFunction>;
+    /**
+     * Obtain the operator of the function to reuse the calculation logic.
+     * The argument type accepted by the function is: FunctionVariantType.
+     * For instance, the sum formula capability is needed for the statistics bar.
+     * You can obtain the calculation result by using
+     * const sum = formulaService.getExecutor(FUNCTION_NAMES_MATH.SUM);
+     * sum.calculate(new RangeReferenceObject(range, sheetId, unitId), ref2, re3).
+     * @param functionName Function name, which can be obtained through the FUNCTION_NAMES enumeration.
+     * @returns
+     */
+    getExecutor(functionToken: IFunctionNames): Nullable<BaseFunction>;
+    hasExecutor(functionToken: IFunctionNames): boolean;
     registerDescriptions(...functions: IFunctionInfo[]): void;
-    getDescriptions(): Map<string, IFunctionInfo>;
-    getDescription(functionToken: string): Nullable<IFunctionInfo>;
-    hasDescription(functionToken: string): boolean;
+    getDescriptions(): Map<IFunctionNames, IFunctionInfo>;
+    getDescription(functionToken: IFunctionNames): Nullable<IFunctionInfo>;
+    hasDescription(functionToken: IFunctionNames): boolean;
 }
 export declare class FunctionService extends Disposable implements IFunctionService {
     private _functionExecutors;
     private _functionDescriptions;
     dispose(): void;
     registerExecutors(...functions: BaseFunction[]): void;
-    getExecutors(): Map<string, BaseFunction>;
-    getExecutor(functionToken: string | FUNCTION_NAMES): BaseFunction | undefined;
-    hasExecutor(functionToken: string | FUNCTION_NAMES): boolean;
+    getExecutors(): Map<IFunctionNames, BaseFunction>;
+    getExecutor(functionToken: IFunctionNames): BaseFunction | undefined;
+    hasExecutor(functionToken: IFunctionNames): boolean;
     registerDescriptions(...descriptions: IFunctionInfo[]): void;
-    getDescriptions(): Map<string, IFunctionInfo>;
-    getDescription(functionToken: string): IFunctionInfo | undefined;
-    hasDescription(functionToken: string): boolean;
+    getDescriptions(): Map<IFunctionNames, IFunctionInfo>;
+    getDescription(functionToken: IFunctionNames): IFunctionInfo | undefined;
+    hasDescription(functionToken: IFunctionNames): boolean;
 }
 export declare const IFunctionService: import("@wendellhu/redi").IdentifierDecorator<FunctionService>;
-//# sourceMappingURL=function.service.d.ts.map

package/lib/types/services/other-formula-manager.service.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+import type { IFormulaDataItem, IOtherFormulaData } from '../basics/common';
+export interface IOtherFormulaManagerSearchParam {
+    unitId: string;
+    subComponentId: string;
+    formulaId: string;
+}
+export interface IOtherFormulaManagerInsertParam extends IOtherFormulaManagerSearchParam {
+    item: IFormulaDataItem;
+}
+export interface IOtherFormulaManagerService {
+    dispose(): void;
+    remove(searchParam: IOtherFormulaManagerSearchParam): void;
+    get(searchParam: IOtherFormulaManagerSearchParam): Nullable<IFormulaDataItem>;
+    has(searchParam: IOtherFormulaManagerSearchParam): boolean;
+    register(insertParam: IOtherFormulaManagerInsertParam): void;
+    getOtherFormulaData(): IOtherFormulaData;
+}
+/**
+ * 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 OtherFormulaManagerService extends Disposable implements IOtherFormulaManagerService {
+    private _otherFormulaData;
+    dispose(): void;
+    remove(searchParam: IOtherFormulaManagerSearchParam): void;
+    get(searchParam: IOtherFormulaManagerSearchParam): IFormulaDataItem;
+    has(searchParam: IOtherFormulaManagerSearchParam): boolean;
+    register(insertParam: IOtherFormulaManagerInsertParam): void;
+    getOtherFormulaData(): IOtherFormulaData;
+}
+export declare const IOtherFormulaManagerService: import("@wendellhu/redi").IdentifierDecorator<OtherFormulaManagerService>;

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

@@ -1,8 +1,23 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
-import type { BaseAstNode } from '../ast-node/base-ast-node';
-import type { IArrayFormulaRangeType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
-import type { FunctionVariantType } from '../reference-object/base-reference-object';
+import type { IArrayFormulaRangeType, IFeatureDirtyRangeType, IRuntimeOtherUnitDataType, IRuntimeUnitDataType } from '../basics/common';
+import type { BaseAstNode } from '../engine/ast-node/base-ast-node';
+import type { FunctionVariantType } from '../engine/reference-object/base-reference-object';
 import { IFormulaCurrentConfigService } from './current-data.service';
 /**
  * IDLE: Idle phase of the formula engine.
@@ -36,6 +51,12 @@ export interface IAllRuntimeData {
     functionsExecutedState: FormulaExecutedStateType;
     arrayFormulaCellData: IRuntimeUnitDataType;
     clearArrayFormulaCellData: IRuntimeUnitDataType;
+    runtimeFeatureRange: {
+        [featureId: string]: IFeatureDirtyRangeType;
+    };
+    runtimeFeatureCellData: {
+        [featureId: string]: IRuntimeUnitDataType;
+    };
 }
 export interface IExecutionInProgressParams {
     totalFormulasToCalculate: number;
@@ -81,6 +102,14 @@ export interface IFormulaRuntimeService {
     disableCycleDependency(): void;
     isCycleDependency(): boolean;
     getRuntimeArrayFormulaCellData(): IRuntimeUnitDataType;
+    getRuntimeFeatureRange(): {
+        [featureId: string]: IFeatureDirtyRangeType;
+    };
+    getRuntimeFeatureCellData(): {
+        [featureId: string]: IRuntimeUnitDataType;
+    };
+    setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
+    setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
 }
 export declare class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {
     private readonly _currentConfigService;
@@ -95,6 +124,8 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _unitArrayFormulaRange;
     private _runtimeArrayFormulaCellData;
     private _runtimeClearArrayFormulaCellData;
+    private _runtimeFeatureRange;
+    private _runtimeFeatureCellData;
     private _functionsExecutedState;
     private _functionDefinitionPrivacyVar;
     private _totalFormulasToCalculate;
@@ -139,6 +170,14 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     getRuntimeOtherData(): IRuntimeOtherUnitDataType;
     getRuntimeArrayFormulaCellData(): IRuntimeUnitDataType;
     getRuntimeClearArrayFormulaCellData(): IRuntimeUnitDataType;
+    getRuntimeFeatureRange(): {
+        [featureId: string]: IFeatureDirtyRangeType;
+    };
+    setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+    getRuntimeFeatureCellData(): {
+        [featureId: string]: IRuntimeUnitDataType;
+    };
+    setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
     getAllRuntimeData(): IAllRuntimeData;
     getRuntimeState(): IExecutionInProgressParams;
     private _objectValueToCellValue;
@@ -146,4 +185,3 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _isInDirtyRange;
 }
 export declare const IFormulaRuntimeService: import("@wendellhu/redi").IdentifierDecorator<FormulaRuntimeService>;
-//# sourceMappingURL=runtime.service.d.ts.map

package/lib/types/services/super-table.service.d.ts

@@ -1,19 +1,40 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 import type { ISuperTable, TableOptionType } from '../basics/common';
+export interface ISuperTableOptionParam {
+    tableOption: string;
+    tableOptionType: TableOptionType;
+}
 export interface ISuperTableService {
-    getTableMap(): Map<string, ISuperTable>;
+    getTableMap(unitId: string): Nullable<Map<string, ISuperTable>>;
     getTableOptionMap(): Map<string, TableOptionType>;
-    registerTable(tableName: string, reference: ISuperTable): void;
+    registerTable(unitId: string, tableName: string, reference: ISuperTable): void;
     registerTableOptionMap(tableOption: string, tableOptionType: TableOptionType): void;
+    remove(unitId: string, tableName: string): void;
 }
 export declare class SuperTableService extends Disposable implements ISuperTableService {
     private _tableMap;
     private _tableOptionMap;
     dispose(): void;
-    getTableMap(): Map<string, ISuperTable>;
+    remove(unitId: string, tableName: string): void;
+    getTableMap(unitId: string): Map<string, ISuperTable> | undefined;
     getTableOptionMap(): Map<string, TableOptionType>;
-    registerTable(tableName: string, reference: ISuperTable): void;
+    registerTable(unitId: string, tableName: string, reference: ISuperTable): void;
     registerTableOptionMap(tableOption: string, tableOptionType: TableOptionType): void;
 }
 export declare const ISuperTableService: import("@wendellhu/redi").IdentifierDecorator<ISuperTableService>;
-//# sourceMappingURL=super-table.service.d.ts.map