@univerjs/engine-formula 0.2.4 → 0.2.6

package/lib/types/functions/text/rept/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/rept/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export declare class Rept extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject, numberTimes: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/text/textafter/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/textafter/index.d.ts

@@ -0,0 +1,15 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { StringValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+
+export declare class Textafter extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject, delimiter: BaseValueObject, instanceNum?: BaseValueObject, matchMode?: BaseValueObject, matchEnd?: BaseValueObject, ifNotFound?: BaseValueObject): StringValueObject | ArrayValueObject;
+    private _getResultArray;
+    private _checkVariantsError;
+    private _getStringValue;
+    private _getVariantsNumberFloorValue;
+    private _getResult;
+}

package/lib/types/functions/text/textbefore/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/textbefore/index.d.ts

@@ -0,0 +1,15 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { StringValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+
+export declare class Textbefore extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject, delimiter: BaseValueObject, instanceNum?: BaseValueObject, matchMode?: BaseValueObject, matchEnd?: BaseValueObject, ifNotFound?: BaseValueObject): StringValueObject | ArrayValueObject;
+    private _getResultArray;
+    private _checkVariantsError;
+    private _getStringValue;
+    private _getVariantsNumberFloorValue;
+    private _getResult;
+}

package/lib/types/functions/text/textsplit/__test__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/text/textsplit/index.d.ts

@@ -0,0 +1,15 @@
+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 Textsplit extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(text: BaseValueObject, colDelimiter: BaseValueObject, rowDelimiter?: BaseValueObject, ignoreEmpty?: BaseValueObject, matchMode?: BaseValueObject, padWith?: BaseValueObject): BaseValueObject | ArrayValueObject;
+    private _getStringValues;
+    private _getResultArray;
+    private _getResult;
+    private _checkVariantsError;
+    private _getRegExpStringValue;
+    private _escapeRegExp;
+}

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, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, } from './basics/common';
+export type { IArrayFormulaRangeType, IArrayFormulaUnitCellType, IDirtyUnitFeatureMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDataItem, IFormulaDatasetConfig, IRuntimeUnitDataType, ISheetData, IUnitData, IUnitSheetNameMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IFeatureDirtyRangeType, } from './basics/common';
 export { isInDirtyRange } from './basics/dirty';
 export { ErrorType, ERROR_TYPE_SET } from './basics/error-type';
 export { FunctionType, type IFunctionInfo, type IFunctionParam } from './basics/function';
@@ -83,7 +83,7 @@ export { matchRefDrawToken } from './basics/match-token';
 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 { IFormulaCurrentConfigService, FormulaCurrentConfigService, type IFormulaDirtyData } from './services/current-data.service';
 export { IActiveDirtyManagerService } from './services/active-dirty-manager.service';
 export type { IRangeChange } from './models/formula-data.model';
 export { handleNumfmtInCell } from './engine/utils/numfmt-kit';
@@ -94,7 +94,7 @@ export { RegisterFunctionMutation } from './commands/mutations/register-function
 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 { SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, type IFormulaDirtyData, } from './commands/mutations/set-formula-calculation.mutation';
+export { SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaCalculationNotificationMutation, SetFormulaCalculationResultMutation, type ISetFormulaCalculationStartMutation, type ISetFormulaCalculationNotificationMutation, type ISetFormulaCalculationResultMutation, } from './commands/mutations/set-formula-calculation.mutation';
 export { SetFormulaDataMutation, type ISetFormulaDataMutationParams } from './commands/mutations/set-formula-data.mutation';
 export { SetOtherFormulaMutation, RemoveOtherFormulaMutation, type ISetOtherFormulaMutationParams, type IRemoveOtherFormulaMutationParams } from './commands/mutations/set-other-formula.mutation';
 export { SetSuperTableMutation, RemoveSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';

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

@@ -1,15 +1,14 @@
-import { IWorkbookData, Univer } from '@univerjs/core';
-import { Dependency } from '@wendellhu/redi';
+import { Dependency, IWorkbookData, Univer } from '@univerjs/core';
 
 export declare function createCommandTestBed(workbookData?: IWorkbookData, dependencies?: Dependency[]): {
     univer: Univer;
     get: {
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp): T;
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp): T[];
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp): T | null;
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp): T;
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity?: import('@wendellhu/redi').Quantity, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, lookUp?: import('@univerjs/core').LookUp): T;
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, quantity: import("@univerjs/core").Quantity.MANY, lookUp?: import('@univerjs/core').LookUp): T[];
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, quantity: import("@univerjs/core").Quantity.OPTIONAL, lookUp?: import('@univerjs/core').LookUp): T | null;
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, quantity: import("@univerjs/core").Quantity.REQUIRED, lookUp?: import('@univerjs/core').LookUp): T;
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, quantity?: import('@univerjs/core').Quantity, lookUp?: import('@univerjs/core').LookUp): T[] | T | null;
+        <T>(id: import('@univerjs/core').DependencyIdentifier<T>, quantityOrLookup?: import('@univerjs/core').Quantity | import('@univerjs/core').LookUp, lookUp?: import('@univerjs/core').LookUp): T[] | T | null;
     };
     sheet: import('@univerjs/core').Workbook;
 };

package/lib/types/plugin.d.ts

@@ -1,5 +1,4 @@
-import { Plugin } from '@univerjs/core';
-import { Ctor, Injector } from '@wendellhu/redi';
+import { Injector, Plugin, Ctor } from '@univerjs/core';
 import { IFunctionNames } from './basics/function';
 import { BaseFunction } from './functions/base-function';
 

package/lib/types/services/active-dirty-manager.service.d.ts

@@ -32,4 +32,4 @@ export declare class ActiveDirtyManagerService extends Disposable implements IAc
     register(commandId: string, dirtyConversion: IDirtyConversionManagerParams): void;
     getDirtyConversionMap(): Map<string, IDirtyConversionManagerParams>;
 }
-export declare const IActiveDirtyManagerService: import('@wendellhu/redi').IdentifierDecorator<ActiveDirtyManagerService>;
+export declare const IActiveDirtyManagerService: import('@univerjs/core').IdentifierDecorator<ActiveDirtyManagerService>;

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

@@ -1,6 +1,14 @@
 import { IUnitRange, Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
 import { IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetDefinedNameMap, IDirtyUnitSheetNameMap, IFormulaData, IFormulaDatasetConfig, IRuntimeUnitDataType, IUnitData, IUnitExcludedCell, IUnitSheetNameMap, IUnitStylesData } from '../basics/common';
 
+export interface IFormulaDirtyData {
+    forceCalculation: boolean;
+    dirtyRanges: IUnitRange[];
+    dirtyNameMap: IDirtyUnitSheetNameMap;
+    dirtyDefinedNameMap: IDirtyUnitSheetDefinedNameMap;
+    dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
+    dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
+}
 export interface IFormulaCurrentConfigService {
     load(config: IFormulaDatasetConfig): void;
     getUnitData(): IUnitData;
@@ -27,6 +35,7 @@ export interface IFormulaCurrentConfigService {
     getExecuteSubUnitId(): Nullable<string>;
     setExecuteUnitId(unitId: string): void;
     setExecuteSubUnitId(subUnitId: string): void;
+    getDirtyData(): IFormulaDirtyData;
 }
 export declare class FormulaCurrentConfigService extends Disposable implements IFormulaCurrentConfigService {
     private readonly _univerInstanceService;
@@ -65,6 +74,7 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     getDirtyUnitOtherFormulaMap(): IDirtyUnitOtherFormulaMap;
     getSheetName(unitId: string, sheetId: string): string;
     load(config: IFormulaDatasetConfig): void;
+    getDirtyData(): IFormulaDirtyData;
     loadDirtyRangesAndExcludedCell(dirtyRanges: IUnitRange[], excludedCell?: IUnitExcludedCell): void;
     registerUnitData(unitData: IUnitData): void;
     registerFormulaData(formulaData: IFormulaData): void;
@@ -72,4 +82,4 @@ export declare class FormulaCurrentConfigService extends Disposable implements I
     private _mergeNameMap;
     private _loadSheetData;
 }
-export declare const IFormulaCurrentConfigService: import('@wendellhu/redi').IdentifierDecorator<FormulaCurrentConfigService>;
+export declare const IFormulaCurrentConfigService: import('@univerjs/core').IdentifierDecorator<FormulaCurrentConfigService>;

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

@@ -60,4 +60,4 @@ export declare class DefinedNamesService extends Disposable implements IDefinedN
     hasDefinedName(unitId: string): boolean;
     private _update;
 }
-export declare const IDefinedNamesService: import('@wendellhu/redi').IdentifierDecorator<DefinedNamesService>;
+export declare const IDefinedNamesService: import('@univerjs/core').IdentifierDecorator<DefinedNamesService>;

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

@@ -8,6 +8,13 @@ export interface IOtherFormulaDependencyParam {
         };
     }>;
 }
+export interface IFeatureFormulaDependencyParam {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: {
+            [featureId: string]: Nullable<FormulaDependencyTree>;
+        };
+    }>;
+}
 export interface IFormulaDependencyParam {
     [unitId: string]: Nullable<{
         [sheetId: string]: ObjectMatrix<Nullable<FormulaDependencyTree>>;
@@ -22,8 +29,9 @@ export interface IDependencyManagerService {
     addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string[]): void;
     hasOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): boolean;
-    addFeatureFormulaDependency(featureId: string, dependencyTree: FormulaDependencyTree): void;
-    removeFeatureFormulaDependency(featureId: string): void;
+    addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
+    removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
+    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): Nullable<FormulaDependencyTree>;
     hasFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): boolean;
     addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
     removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
@@ -68,13 +76,15 @@ export declare class DependencyManagerService extends Disposable implements IDep
     reset(): void;
     addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree): void;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]): void;
+    getOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): Nullable<FormulaDependencyTree>;
     hasOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string): boolean;
-    addFeatureFormulaDependency(featureId: string, dependencyTree: FormulaDependencyTree): void;
-    removeFeatureFormulaDependency(featureId: string): void;
-    hasFeatureFormulaDependency(featureId: string): boolean;
+    addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
+    removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
+    getFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): Nullable<FormulaDependencyTree>;
+    hasFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string): boolean;
     addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: FormulaDependencyTree): void;
     removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
     clearFormulaDependency(unitId: string, sheetId: string): void;
     hasFormulaDependency(unitId: string, sheetId: string, row: number, column: number): boolean;
 }
-export declare const IDependencyManagerService: import('@wendellhu/redi').IdentifierDecorator<DependencyManagerService>;
+export declare const IDependencyManagerService: import('@univerjs/core').IdentifierDecorator<DependencyManagerService>;

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

@@ -1,23 +1,28 @@
 import { IUnitRange, Nullable, Disposable } from '@univerjs/core';
+import { Observable } from 'rxjs';
 import { IFeatureDirtyRangeType, IRuntimeUnitDataType } from '../basics/common';
+import { IRemoveFeatureCalculationMutationParam } from '../commands/mutations/set-feature-calculation.mutation';
 import { FormulaDependencyTree } from '../engine/dependency/dependency-tree';
+import { IAllRuntimeData } from './runtime.service';
+import { IFormulaDirtyData } from './current-data.service';
 
 export interface IFeatureCalculationManagerParam {
     unitId: string;
     subUnitId: string;
     dependencyRanges: IUnitRange[];
-    getDirtyData: (currentDependencyTree: FormulaDependencyTree) => {
+    getDirtyData: (tree: FormulaDependencyTree, dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
         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>;
+    remove(unitId: string, subUnitId: string, featureIds: string[]): void;
+    get(unitId: string, subUnitId: string, featureId: string): Nullable<IFeatureCalculationManagerParam>;
+    has(unitId: string, subUnitId: string, featureId: string): boolean;
+    register(unitId: string, subUnitId: string, featureId: string, referenceExecutor: IFeatureCalculationManagerParam): void;
+    getReferenceExecutorMap(): Map<string, Map<string, Map<string, IFeatureCalculationManagerParam>>>;
+    onChanged$: Observable<IRemoveFeatureCalculationMutationParam>;
 }
 /**
  * Passively marked as dirty, register the reference and execution actions of the feature plugin.
@@ -27,11 +32,13 @@ export interface IFeatureCalculationManagerService {
  */
 export declare class FeatureCalculationManagerService extends Disposable implements IFeatureCalculationManagerService {
     private _referenceExecutorMap;
+    private _onChanged$;
+    readonly onChanged$: Observable<IRemoveFeatureCalculationMutationParam>;
     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>;
+    remove(unitId: string, subUnitId: string, featureIds: string[]): void;
+    get(unitId: string, subUnitId: string, featureId: string): IFeatureCalculationManagerParam | undefined;
+    has(unitId: string, subUnitId: string, featureId: string): boolean;
+    register(unitId: string, subUnitId: string, featureId: string, referenceExecutor: IFeatureCalculationManagerParam): void;
+    getReferenceExecutorMap(): Map<string, Map<string, Map<string, IFeatureCalculationManagerParam>>>;
 }
-export declare const IFeatureCalculationManagerService: import('@wendellhu/redi').IdentifierDecorator<FeatureCalculationManagerService>;
+export declare const IFeatureCalculationManagerService: import('@univerjs/core').IdentifierDecorator<FeatureCalculationManagerService>;

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

@@ -1,5 +1,4 @@
-import { Nullable, Disposable } from '@univerjs/core';
-import { IDisposable } from '@wendellhu/redi';
+import { IDisposable, Nullable, Disposable } from '@univerjs/core';
 import { IFunctionInfo, IFunctionNames } from '../basics/function';
 import { BaseFunction } from '../functions/base-function';
 
@@ -43,4 +42,4 @@ export declare class FunctionService extends Disposable implements IFunctionServ
     hasDescription(functionToken: IFunctionNames): boolean;
     unregisterDescriptions(...functionTokens: IFunctionNames[]): void;
 }
-export declare const IFunctionService: import('@wendellhu/redi').IdentifierDecorator<FunctionService>;
+export declare const IFunctionService: import('@univerjs/core').IdentifierDecorator<FunctionService>;

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

@@ -36,4 +36,4 @@ export declare class OtherFormulaManagerService extends Disposable implements IO
     batchRemove(formulaData: IDirtyUnitOtherFormulaMap): void;
     getOtherFormulaData(): IOtherFormulaData;
 }
-export declare const IOtherFormulaManagerService: import('@wendellhu/redi').IdentifierDecorator<OtherFormulaManagerService>;
+export declare const IOtherFormulaManagerService: import('@univerjs/core').IdentifierDecorator<OtherFormulaManagerService>;

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

@@ -179,4 +179,4 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     private _checkIfArrayFormulaExceeded;
     private _isInDirtyRange;
 }
-export declare const IFormulaRuntimeService: import('@wendellhu/redi').IdentifierDecorator<FormulaRuntimeService>;
+export declare const IFormulaRuntimeService: import('@univerjs/core').IdentifierDecorator<FormulaRuntimeService>;

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

@@ -22,4 +22,4 @@ export declare class SuperTableService extends Disposable implements ISuperTable
     registerTable(unitId: string, tableName: string, reference: ISuperTable): void;
     registerTableOptionMap(tableOption: string, tableOptionType: TableOptionType): void;
 }
-export declare const ISuperTableService: import('@wendellhu/redi').IdentifierDecorator<ISuperTableService>;
+export declare const ISuperTableService: import('@univerjs/core').IdentifierDecorator<ISuperTableService>;