@univerjs/engine-formula 0.1.5 → 0.1.6

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-defined-name.mutation.d.ts

@@ -1,15 +1,25 @@
-import { IMutation } from '@univerjs/core';
+import { IMutation, IRange } 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>;
+export interface ISetDefinedNameCurrentMutationParam {
+    unitId: string;
+    sheetId: string;
+    range: IRange;
+}
+export declare const SetDefinedNameCurrentMutation: IMutation<ISetDefinedNameCurrentMutationParam>;

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/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/index.d.ts

@@ -13,7 +13,7 @@
  * 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 { FunctionType, type IFunctionInfo, type IFunctionParam } from './basics/function';
@@ -23,7 +23,7 @@ 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 { RemoveDefinedNameMutation, SetDefinedNameMutation, SetDefinedNameCurrentMutation, 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,8 @@ 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';

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>;