@univerjs/engine-formula 0.1.5 → 0.1.7

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

@@ -61,6 +61,11 @@ export interface IDirtyUnitSheetNameMap {
         [sheetId: string]: string;
     }>;
 }
+export interface IDirtyUnitSheetDefinedNameMap {
+    [unitId: string]: Nullable<{
+        [name: string]: string;
+    }>;
+}
 export interface IDirtyUnitFeatureMap {
     [unitId: string]: Nullable<{
         [sheetId: string]: {
@@ -137,6 +142,7 @@ export interface IFormulaDatasetConfig {
     forceCalculate: boolean;
     dirtyRanges: IUnitRange[];
     dirtyNameMap: IDirtyUnitSheetNameMap;
+    dirtyDefinedNameMap: IDirtyUnitSheetNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
     numfmtItemMap: INumfmtItemMap;

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

@@ -83,7 +83,11 @@ export declare enum FunctionType {
     /**
      * User-defined functions
      */
-    User = 15
+    User = 15,
+    /**
+     * Defined name
+     */
+    DefinedName = 16
 }
 export interface IFunctionParam {
     /**

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

@@ -1,10 +1,11 @@
 import { IArrayFormulaRangeType, IArrayFormulaUnitCellType } from '../../basics/common';
-import { IAccessor } from '@wendellhu/redi';
 import { IMutation } from '@univerjs/core';
 
 export interface ISetArrayFormulaDataMutationParams {
     arrayFormulaRange: IArrayFormulaRangeType;
     arrayFormulaCellData: IArrayFormulaUnitCellType;
 }
-export declare const SetArrayFormulaDataUndoMutationFactory: (accessor: IAccessor) => ISetArrayFormulaDataMutationParams;
+/**
+ * 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 SetArrayFormulaDataMutation: IMutation<ISetArrayFormulaDataMutationParams>;

package/lib/types/commands/mutations/set-defined-name.mutation.d.ts

@@ -2,14 +2,18 @@ import { IMutation } from '@univerjs/core';
 
 export interface ISetDefinedNameMutationSearchParam {
     unitId: string;
-    name: string;
+    id: string;
 }
 export interface ISetDefinedNameMutationParam extends ISetDefinedNameMutationSearchParam {
+    name: string;
     formulaOrRefString: string;
+    comment?: string;
+    localSheetId?: string;
+    hidden?: boolean;
 }
 /**
  * In the formula engine, the mutation is solely responsible for communication between the worker and the main thread.
  * It requires setting local to true during execution.
  */
 export declare const SetDefinedNameMutation: IMutation<ISetDefinedNameMutationParam>;
-export declare const RemoveDefinedNameMutation: IMutation<ISetDefinedNameMutationSearchParam>;
+export declare const RemoveDefinedNameMutation: IMutation<ISetDefinedNameMutationParam>;

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

@@ -1,10 +1,11 @@
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
-import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetNameMap, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, INumfmtItemMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
 import { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
 
 export interface ISetFormulaCalculationStartMutation {
     dirtyRanges: IUnitRange[];
     dirtyNameMap: IDirtyUnitSheetNameMap;
+    dirtyDefinedNameMap: IDirtyUnitSheetDefinedNameMap;
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
     options: Nullable<IExecutionOptions>;

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

@@ -4,4 +4,7 @@ import { IMutation } from '@univerjs/core';
 export interface ISetFormulaDataMutationParams {
     formulaData: IFormulaData;
 }
+/**
+ * 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 SetFormulaDataMutation: IMutation<ISetFormulaDataMutationParams>;

package/lib/types/engine/analysis/lexer-node.d.ts

@@ -18,7 +18,9 @@ export declare class LexerNode {
     private _lambdaParameter;
     private _startIndex;
     private _endIndex;
+    private _definedNames;
     dispose(): void;
+    getDefinedNames(): string[];
     getStartIndex(): number;
     getLambdaId(): Nullable<string>;
     setLambdaId(lambdaId: string): void;
@@ -35,6 +37,8 @@ export declare class LexerNode {
     getToken(): string;
     setToken(token: string): void;
     setIndex(st: number, ed: number): void;
+    setDefinedNames(definedNames: Array<string>): void;
+    hasDefinedNames(): boolean;
     replaceChild(lexerNode: LexerNode, newLexerNode: LexerNode): void;
     changeToParent(newParentLexerNode: LexerNode): void;
     removeChild(lexerNode: LexerNode): void;

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

@@ -2,7 +2,7 @@ import { LexerNode } from './lexer-node';
 import { ISequenceArray, ISequenceNode } from '../utils/sequence';
 import { ErrorType } from '../../basics/error-type';
 import { FormulaAstLRU } from '../../basics/cache-lru';
-import { Disposable } from '@univerjs/core';
+import { AbsoluteRefType, Disposable } from '@univerjs/core';
 
 export declare const FormulaLexerNodeCache: FormulaAstLRU<LexerNode>;
 export declare const FormulaSequenceNodeCache: FormulaAstLRU<(string | ISequenceNode)[]>;
@@ -40,6 +40,7 @@ export declare class LexerTreeBuilder extends Disposable {
      * @param formulaString
      */
     checkIfAddBracket(formulaString: string): number;
+    convertRefersToAbsolute(formulaString: string, startAbsoluteRefType: AbsoluteRefType, endAbsoluteRefType: AbsoluteRefType): string;
     sequenceNodesBuilder(formulaString: string): (string | ISequenceNode)[] | undefined;
     getSequenceNode(sequenceArray: ISequenceArray[]): (string | ISequenceNode)[];
     private _getCurrentParamIndex;
@@ -55,7 +56,8 @@ export declare class LexerTreeBuilder extends Disposable {
     treeBuilder(formulaString: string, transformSuffix?: boolean, injectDefinedName?: (sequenceArray: ISequenceArray[]) => {
         sequenceString: string;
         hasDefinedName: boolean;
-    }): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
+        definedNames: string[];
+    }, simpleCheckDefinedName?: (formulaString: string) => boolean): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
     private _suffixExpressionHandler;
     private _checkCloseBracket;
     private _checkOpenBracket;
@@ -99,4 +101,5 @@ export declare class LexerTreeBuilder extends Disposable {
     private _resetTemp;
     private _checkSimilarErrorToken;
     private _nodeMaker;
+    private _addSequenceArray;
 }

package/lib/types/engine/analysis/lexer.d.ts

@@ -1,13 +1,16 @@
 import { LexerTreeBuilder } from './lexer-tree-builder';
-import { IFormulaRuntimeService } from '../../services/runtime.service';
+import { ErrorType } from '../../basics/error-type';
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDefinedNamesService } from '../../services/defined-names.service';
 import { Disposable } from '@univerjs/core';
 
 export declare class Lexer extends Disposable {
     private readonly _definedNamesService;
-    private readonly _runtimeService;
     private readonly _lexerTreeBuilder;
-    constructor(_definedNamesService: IDefinedNamesService, _runtimeService: IFormulaRuntimeService, _lexerTreeBuilder: LexerTreeBuilder);
-    treeBuilder(formulaString: string, transformSuffix?: boolean): import("../..").ErrorType.VALUE | import('./lexer-node').LexerNode | (string | import('./lexer-node').LexerNode)[] | undefined;
+    private readonly _formulaCurrentConfigService;
+    constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService);
+    treeBuilder(formulaString: string, transformSuffix?: boolean): ErrorType.VALUE | import('./lexer-node').LexerNode | (string | import('./lexer-node').LexerNode)[] | undefined;
+    private _simpleCheckDefinedName;
+    private _checkDefinedNameDirty;
     private _injectDefinedName;
 }

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

@@ -14,6 +14,7 @@ export type LambdaPrivacyVarType = Map<string, Nullable<BaseAstNode>>;
 export declare class BaseAstNode extends Disposable {
     private _token;
     private _children;
+    private _definedNames;
     private _parent;
     private _valueObject;
     private _calculateState;
@@ -46,6 +47,8 @@ export declare class BaseAstNode extends Disposable {
     };
     executeAsync(): Promise<AstNodePromiseType>;
     serialize(): IAstNodeNodeJson;
+    hasDefinedName(definedName: string): boolean;
+    setDefinedNames(definedNames: Array<string>): void;
 }
 export declare class ErrorNode extends BaseAstNode {
     private _errorValueObject;

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

@@ -6,7 +6,6 @@ import { BaseReferenceObject } from '../reference-object/base-reference-object';
 import { LexerNode } from '../analysis/lexer-node';
 import { ISuperTableService } from '../../services/super-table.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
-import { IDefinedNamesService } from '../../services/defined-names.service';
 import { IAccessor, Injector } from '@wendellhu/redi';
 
 export declare class ReferenceNode extends BaseAstNode {
@@ -19,12 +18,11 @@ export declare class ReferenceNode extends BaseAstNode {
     execute(): void;
 }
 export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
-    private readonly _definedNamesService;
     private readonly _superTableService;
     private readonly _formulaRuntimeService;
     private readonly _functionService;
     private readonly _injector;
-    constructor(_definedNamesService: IDefinedNamesService, _superTableService: ISuperTableService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService, _injector: Injector);
+    constructor(_superTableService: ISuperTableService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService, _injector: Injector);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ReferenceNode | undefined;
 }

package/lib/types/engine/dependency/formula-dependency.d.ts

@@ -47,6 +47,7 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * @param node
      */
     private _getRangeListByNode;
+    private _isDirtyDefinedForNode;
     /**
      * Build a formula dependency tree based on the dependency relationships.
      * @param treeList

package/lib/types/engine/utils/relative-formula.d.ts

@@ -0,0 +1,4 @@
+import { LexerTreeBuilder } from '../analysis/lexer-tree-builder';
+
+export declare function isFormulaTransformable(lexerTreeBuilder: LexerTreeBuilder, formula: string): boolean;
+export declare function transformFormula(lexerTreeBuilder: LexerTreeBuilder, formula: string, originRow: number, originCol: number, targetRow: number, targetCol: number): string;

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

@@ -18,6 +18,10 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _currentColumn;
     private _sliceCache;
     private _flattenCache;
+    /**
+     * The default value of the array, null values in comparison results support setting to false
+     */
+    private _defaultValue;
     private _flattenPosition;
     constructor(rawValue: string | IArrayValueObject);
     dispose(): void;
@@ -36,6 +40,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     getArrayValue(): Nullable<BaseValueObject>[][];
     setArrayValue(value: BaseValueObject[][]): void;
     isArray(): boolean;
+    setDefaultValue(value: Nullable<BaseValueObject>): void;
     get(row: number, column: number): BaseValueObject | null;
     getRealValue(row: number, column: number): BaseValueObject | null;
     set(row: number, column: number, value: Nullable<BaseValueObject>): void;

package/lib/types/functions/information/isref/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseFunction } from '../../base-function';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
-import { BooleanValueObject } from '../../..';
 
 export declare class Isref extends BaseFunction {
     needsReferenceObject: boolean;

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

@@ -1,4 +1,4 @@
-import { ArrayValueObject } from '../../..';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 

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

@@ -0,0 +1,7 @@
+import { BaseFunction } from '../../base-function';
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+
+export declare class Maxifs extends BaseFunction {
+    calculate(maxRange: BaseValueObject, ...variants: BaseValueObject[]): ErrorValueObject | ArrayValueObject;
+}

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, } from './basics/common';
+export type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitSheetNameMap, INumfmtItemMap, 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 } 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';
@@ -90,7 +90,9 @@ export { SetNumfmtFormulaDataMutation } from './commands/mutations/set-numfmt-fo
 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 { IDefinedNamesService, DefinedNamesService, type IDefinedNamesServiceParam, type IDefinedNameMapItem } from './services/defined-names.service';
+export { isFormulaTransformable, transformFormula } from './engine/utils/relative-formula';
 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/formula-data.model.d.ts

@@ -1,11 +1,11 @@
+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 { 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;
@@ -28,13 +28,14 @@ export declare class FormulaDataModel extends Disposable {
     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;
@@ -42,4 +43,8 @@ export declare class FormulaDataModel extends Disposable {
     getFormulaDataItem(row: number, column: number, sheetId: string, unitId: string): IFormulaDataItem | undefined;
     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<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/services/active-dirty-manager.service.d.ts

@@ -1,4 +1,4 @@
-import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetNameMap } from '@univerjs/engine-formula';
+import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap } from '../basics/common';
 import { ICommandInfo, IUnitRange, Nullable, Disposable } from '@univerjs/core';
 
 export interface IDirtyConversionManagerParams {
@@ -6,6 +6,7 @@ export interface IDirtyConversionManagerParams {
     getDirtyData: (command: ICommandInfo) => {
         dirtyRanges?: IUnitRange[];
         dirtyNameMap?: IDirtyUnitSheetNameMap;
+        dirtyDefinedNameMap?: IDirtyUnitSheetDefinedNameMap;
         dirtyUnitFeatureMap?: IDirtyUnitFeatureMap;
         dirtyUnitOtherFormulaMap?: IDirtyUnitOtherFormulaMap;
     };

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

@@ -1,4 +1,4 @@
-import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap } from '../basics/common';
+import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, INumfmtItemMap, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap } from '../basics/common';
 import { IUnitRange, Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
 
 export declare const DEFAULT_DOCUMENT_SUB_COMPONENT_ID = "__default_document_sub_component_id20231101__";
@@ -10,6 +10,7 @@ export interface IFormulaCurrentConfigService {
     isForceCalculate(): boolean;
     getDirtyRanges(): IUnitRange[];
     getDirtyNameMap(): IDirtyUnitSheetNameMap;
+    getDirtyDefinedNameMap(): IDirtyUnitSheetDefinedNameMap;
     getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
     registerUnitData(unitData: IUnitData): void;
     registerFormulaData(formulaData: IFormulaData): void;
@@ -19,6 +20,10 @@ export interface IFormulaCurrentConfigService {
     getArrayFormulaCellData(): IRuntimeUnitDataType;
     getSheetName(unitId: string, sheetId: string): string;
     getDirtyUnitOtherFormulaMap(): IDirtyUnitOtherFormulaMap;
+    getExecuteUnitId(): Nullable<string>;
+    getExecuteSubUnitId(): Nullable<string>;
+    setExecuteUnitId(unitId: string): void;
+    setExecuteSubUnitId(subUnitId: string): void;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _currentUniverService;
@@ -29,13 +34,20 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     private _forceCalculate;
     private _dirtyRanges;
     private _dirtyNameMap;
+    private _dirtyDefinedNameMap;
     private _numfmtItemMap;
     private _dirtyUnitFeatureMap;
     private _dirtyUnitOtherFormulaMap;
     private _excludedCell;
     private _sheetIdToNameMap;
+    private _executeUnitId;
+    private _executeSubUnitId;
     constructor(_currentUniverService: IUniverInstanceService);
     dispose(): void;
+    getExecuteUnitId(): Nullable<string>;
+    getExecuteSubUnitId(): Nullable<string>;
+    setExecuteUnitId(unitId: string): void;
+    setExecuteSubUnitId(subUnitId: string): void;
     getExcludedRange(): Nullable<IUnitExcludedCell>;
     getUnitData(): IUnitData;
     getFormulaData(): IFormulaData;
@@ -44,10 +56,11 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     isForceCalculate(): boolean;
     getDirtyRanges(): IUnitRange[];
     getDirtyNameMap(): IDirtyUnitSheetNameMap;
+    getDirtyDefinedNameMap(): IDirtyUnitSheetDefinedNameMap;
     getNumfmtItemMap(): INumfmtItemMap;
     getDirtyUnitFeatureMap(): IDirtyUnitFeatureMap;
-    getSheetName(unitId: string, sheetId: string): string;
     getDirtyUnitOtherFormulaMap(): IDirtyUnitOtherFormulaMap;
+    getSheetName(unitId: string, sheetId: string): string;
     load(config: IFormulaDatasetConfig): void;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;

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

@@ -1,19 +1,61 @@
-import { Nullable, Disposable } from '@univerjs/core';
+import { Observable } from 'rxjs';
+import { IUnitRange, Nullable, Disposable } from '@univerjs/core';
 
+export interface IDefinedNamesServiceParam {
+    id: string;
+    name: string;
+    formulaOrRefString: string;
+    comment?: string;
+    localSheetId?: string;
+    hidden?: boolean;
+}
+export interface IDefinedNamesServiceFocusParam extends IDefinedNamesServiceParam {
+    unitId: string;
+}
+export interface IDefinedNameMap {
+    [unitId: string]: IDefinedNameMapItem;
+}
+export interface IDefinedNameMapItem {
+    [id: string]: IDefinedNamesServiceParam;
+}
 export interface IDefinedNamesService {
-    registerDefinedName(unitId: string, name: string, formulaOrRefString: string): void;
-    getDefinedNameMap(unitId: string): Nullable<Map<string, string>>;
-    getValue(unitId: string, name: string): Nullable<string>;
+    registerDefinedName(unitId: string, param: IDefinedNamesServiceParam): void;
+    registerDefinedNames(unitId: string, params: IDefinedNameMapItem): void;
+    getDefinedNameMap(unitId: string): Nullable<IDefinedNameMapItem>;
+    getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
+    getValueById(unitId: string, id: string): Nullable<IDefinedNamesServiceParam>;
     removeDefinedName(unitId: string, name: string): void;
     hasDefinedName(unitId: string): boolean;
+    setCurrentRange(range: IUnitRange): void;
+    getCurrentRange(): IUnitRange;
+    getCurrentRangeForString(): string;
+    currentRange$: Observable<IUnitRange>;
+    update$: Observable<unknown>;
+    focusRange$: Observable<IDefinedNamesServiceFocusParam>;
+    focusRange(unitId: string, id: string): void;
 }
 export declare class DefinedNamesService extends Disposable implements IDefinedNamesService {
     private _definedNameMap;
+    private readonly _update$;
+    readonly update$: Observable<unknown>;
+    private _currentRange;
+    private readonly _currentRange$;
+    readonly currentRange$: Observable<IUnitRange>;
+    private readonly _focusRange$;
+    readonly focusRange$: Observable<IDefinedNamesServiceFocusParam>;
+    constructor();
     dispose(): void;
-    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;
+    focusRange(unitId: string, id: string): void;
+    setCurrentRange(range: IUnitRange): void;
+    getCurrentRange(): IUnitRange;
+    getCurrentRangeForString(): string;
+    registerDefinedNames(unitId: string, params: IDefinedNameMapItem): void;
+    registerDefinedName(unitId: string, param: IDefinedNamesServiceParam): void;
+    removeDefinedName(unitId: string, id: string): void;
+    getDefinedNameMap(unitId: string): IDefinedNameMapItem;
+    getValueByName(unitId: string, name: string): IDefinedNamesServiceParam | null;
+    getValueById(unitId: string, id: string): IDefinedNamesServiceParam;
     hasDefinedName(unitId: string): boolean;
+    private _update;
 }
 export declare const IDefinedNamesService: import('@wendellhu/redi').IdentifierDecorator<DefinedNamesService>;