@univerjs/core 0.1.7 → 0.1.8

package/lib/types/common/boolean.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 declare function isBooleanString(str: string): boolean;

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

@@ -1,11 +1,11 @@
-import { Nullable } from './type-utils';
+import { Nullable } from './type-util';
 
 export type InterceptorHandler<M = unknown, C = unknown> = (value: Nullable<M>, context: C, next: (value: Nullable<M>) => Nullable<M>) => Nullable<M>;
 export interface IInterceptor<M, C> {
     priority?: number;
     handler: InterceptorHandler<M, C>;
 }
-export declare const createInterceptorKey: <T = any, C = any>(key: string) => IInterceptor<T, C>;
+export declare function createInterceptorKey<T, C>(key: string): IInterceptor<T, C>;
 export type IComposeInterceptors<T = any, C = any> = (interceptors: Array<IInterceptor<T, C>>) => (initValue: Nullable<T>, initContext: C) => Nullable<T>;
 /**
  * A helper to compose a certain type of interceptors.

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

@@ -0,0 +1,17 @@
+/**
+ * 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 declare function isNumeric(str: string): boolean;
+export declare function isSafeNumeric(str: string): boolean;

package/lib/types/{basics/index.d.ts → common/set.d.ts}

@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './registry';
-export * from './univer';
-export * from './univer-doc';
-export * from './univer-sheet';
-export * from './univer-slide';
+/**
+ * Merge the second set to the first set.
+ * @param s1 the first set
+ * @param s2 the second set
+ * @returns the merged set
+ */
+export declare function mergeSets<T>(s1: Set<T>, s2: Set<T>): Set<T>;

package/lib/types/common/type-util.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 type Nullable<T> = T | null | undefined | void;

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

@@ -0,0 +1,9 @@
+import { Disposable } from '../shared';
+import { UniverType } from '@univerjs/protocol';
+
+export { UniverType as UniverInstanceType } from '@univerjs/protocol';
+export type UnitType = UniverType | number;
+export declare abstract class UnitModel<_D = object, T extends UnitType = UnitType> extends Disposable {
+    abstract readonly type: T;
+    abstract getUnitId(): string;
+}

package/lib/types/docs/data-model/document-data-model.d.ts

@@ -1,4 +1,5 @@
 import { TextXAction } from './action-types';
+import { UnitModel, UniverInstanceType } from '../../common/unit';
 import { IPaddingData } from '../../types/interfaces/i-style-data';
 import { IDocumentBody, IDocumentData, IDocumentRenderConfig, IDocumentStyle } from '../../types/interfaces/i-document-data';
 import { Nullable } from '../../shared';
@@ -13,7 +14,9 @@ interface IDrawingUpdateConfig {
     height: number;
     width: number;
 }
-declare class DocumentDataModelSimple {
+declare class DocumentDataModelSimple extends UnitModel<IDocumentData, UniverInstanceType.UNIVER_DOC> {
+    type: UniverInstanceType.UNIVER_DOC;
+    getUnitId(): string;
     snapshot: IDocumentData;
     constructor(snapshot: Partial<IDocumentData>);
     get drawings(): import('../../types/interfaces/i-document-data').IDrawings | undefined;

package/lib/types/index.d.ts

@@ -13,9 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export { type UnitType, UnitModel, UniverInstanceType } from './common/unit';
+export { Registry, RegistryAsMap } from './common/registry';
+export { Univer } from './univer';
+export { PluginHolder } from './services/plugin/plugin-holder';
 export { shallowEqual, isRangesEqual, isUnitRangesEqual } from './common/equal';
-export * from './basics';
+export { isNumeric, isSafeNumeric } from './common/number';
+export { isBooleanString } from './common/boolean';
 export { dedupe, remove, rotate, groupBy } from './common/array';
+export { mergeSets } from './common/set';
 export { DEFAULT_EMPTY_DOCUMENT_VALUE, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, createInternalEditorID, isInternalEditorID, } from './common/const';
 export { throttle } from './common/function';
 export { MemoryCursor } from './common/memory-cursor';
@@ -29,7 +35,8 @@ export { getBodySlice, composeBody } from './docs/data-model/text-x/utils';
 export { TextX } from './docs/data-model/text-x/text-x';
 export { replaceInDocumentBody } from './docs/data-model/replacement';
 export * from './observer';
-export { Plugin, PluginType } from './plugin/plugin';
+export { Plugin } from './services/plugin/plugin';
+export { PluginService } from './services/plugin/plugin.service';
 export { type CommandListener, CommandService, CommandType, type ICommand, type ICommandInfo, ICommandService, type IExecutionOptions, type IMultiCommand, type IMutation, type IMutationCommonParams, type IMutationInfo, type IOperation, type IOperationInfo, NilCommand, sequenceExecute, sequenceExecuteAsync, } from './services/command/command.service';
 export { IConfigService } from './services/config/config.service';
 export * from './services/context/context';
@@ -37,16 +44,17 @@ export { ContextService, IContextService } from './services/context/context.serv
 export { ErrorService, type IError } from './services/error/error.service';
 export type { IOffset, IScale, ISize, ITransformState } from './services/floating-object/floating-object-interfaces';
 export { DEFAULT_DOCUMENT_SUB_COMPONENT_ID, FloatingObjectManagerService, type IFloatingObjectManagerParam, type IFloatingObjectManagerSearchItemParam, IFloatingObjectManagerService, } from './services/floating-object/floating-object-manager.service';
-export { IUniverInstanceService, UniverInstanceType } from './services/instance/instance.service';
+export { IUniverInstanceService } from './services/instance/instance.service';
 export { LifecycleStages, OnLifecycle, runOnLifecycle } from './services/lifecycle/lifecycle';
 export { LifecycleService } from './services/lifecycle/lifecycle.service';
 export { ILocalStorageService } from './services/local-storage/local-storage.service';
 export { LocaleService } from './services/locale/locale.service';
 export { DesktopLogService, ILogService, LogLevel } from './services/log/log.service';
 export { IPermissionService, PermissionService, UniverEditablePermission, UniverEditablePermissionPoint, UniverPermissionService, } from './services/permission';
+export { IResourceLoaderService } from './services/resource-loader/type';
 export { ResourceManagerService } from './services/resource-manager/resource-manager.service';
 export type { IResourceHook } from './services/resource-manager/type';
-export { IResourceManagerService, ISnapshotPersistenceService } from './services/resource-manager/type';
+export { IResourceManagerService } from './services/resource-manager/type';
 export { type IStyleSheet, ThemeService } from './services/theme/theme.service';
 export { type IUndoRedoCommandInfos, type IUndoRedoCommandInfosByInterceptor, type IUndoRedoItem, IUndoRedoService, type IUndoRedoStatus, LocalUndoRedoService, RedoCommand, UndoCommand, RedoCommandId, UndoCommandId, } from './services/undoredo/undoredo.service';
 export * from './shared';
@@ -54,20 +62,24 @@ export { fromCallback } from './shared/rxjs';
 export type { IComposeInterceptors, IInterceptor, InterceptorHandler } from './common/interceptor';
 export { composeInterceptors, createInterceptorKey, InterceptorManager } from './common/interceptor';
 export { normalizeTextRuns } from './docs/data-model/apply-utils/common';
-export type { PluginCtor } from './plugin/plugin';
+export type { PluginCtor } from './services/plugin/plugin';
+export { type DependencyOverride, mergeOverrideWithDependencies } from './services/plugin/plugin-override';
+export * from './types/const';
+export * from './types/enum';
+export * from './types/interfaces';
+export { UniverInstanceService } from './services/instance/instance.service';
+export { LifecycleInitializerService } from './services/lifecycle/lifecycle.service';
+export { ConfigService } from './services/config/config.service';
 export { Range } from './sheets/range';
 export { Styles } from './sheets/styles';
 export { DEFAULT_WORKSHEET_COLUMN_COUNT, DEFAULT_WORKSHEET_COLUMN_COUNT_KEY, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT_KEY, DEFAULT_WORKSHEET_COLUMN_WIDTH_KEY, DEFAULT_WORKSHEET_ROW_COUNT_KEY, DEFAULT_WORKSHEET_ROW_HEIGHT_KEY, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH_KEY, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT, DEFAULT_WORKSHEET_COLUMN_WIDTH, DEFAULT_WORKSHEET_ROW_COUNT, DEFAULT_WORKSHEET_ROW_HEIGHT, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH, mergeWorksheetSnapshotWithDefault, } from './sheets/sheet-snapshot-utils';
 export { SheetViewModel } from './sheets/view-model';
 export { getWorksheetUID, Workbook } from './sheets/workbook';
 export { Worksheet, extractPureTextFromCell } from './sheets/worksheet';
-export * from './slides/domain';
+export { SlideDataModel } from './slides/slide-model';
 export * from './types/const';
 export * from './types/enum';
 export * from './types/interfaces';
-export { UniverInstanceService } from './services/instance/instance.service';
-export { LifecycleInitializerService } from './services/lifecycle/lifecycle.service';
-export { ConfigService } from './services/config/config.service';
 export { ISnapshotServerService } from './services/snapshot/snapshot-server.service';
 export { transformSnapshotToWorkbookData, transformWorkbookDataToSnapshot, transformDocumentDataToSnapshot, transformSnapshotToDocumentData, generateTemporarySnap, } from './services/snapshot/snapshot-transform';
 export { textEncoder, textDecoder } from './services/snapshot/snapshot-utils';

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

@@ -97,6 +97,7 @@ export interface ICommandService {
     registerCommand(command: ICommand<object, unknown>): IDisposable;
     registerMultipleCommand(command: ICommand<object, unknown>): IDisposable;
     executeCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): Promise<R>;
+    hasCommand(id: string): boolean;
     syncExecuteCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): R;
     /**
      * Register a callback function that will be executed after a command is executed.

package/lib/types/services/floating-object/floating-object-manager.service.d.ts

@@ -1,5 +1,5 @@
 import { ITransformState } from './floating-object-interfaces';
-import { Nullable } from '../../common/type-utils';
+import { Nullable } from '../../common/type-util';
 import { Observable } from 'rxjs';
 import { IDisposable } from '@wendellhu/redi';
 

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

@@ -1,113 +1,90 @@
+import { UnitModel, UnitType, UniverInstanceType } from '../../common/unit';
 import { IContextService } from '../context/context.service';
-import { IDocumentData, ISlideData, IWorkbookData } from '../../types/interfaces';
-import { SlideDataModel } from '../../slides/domain/slide-model';
 import { Workbook } from '../../sheets/workbook';
 import { Disposable } from '../../shared/lifecycle';
 import { Nullable } from '../../shared';
 import { DocumentDataModel } from '../../docs/data-model/document-data-model';
 import { Observable } from 'rxjs';
+import { IDisposable, Injector } from '@wendellhu/redi';
 
-export declare enum UniverInstanceType {
-    UNKNOWN = 0,
-    DOC = 1,
-    SHEET = 2,
-    SLIDE = 3
-}
-export interface IUniverHandler {
-    createUniverDoc(data: Partial<IDocumentData>): DocumentDataModel;
-    createUniverSheet(data: Partial<IWorkbookData>): Workbook;
-    createUniverSlide(data: Partial<ISlideData>): SlideDataModel;
-}
 /**
- * IUniverInstanceService holds all the current univer instances. And it also manages
- * the focused univer instance.
+ * IUniverInstanceService holds all the current univer instances and provides a set of
+ * methods to add and remove univer instances.
+ *
+ * It also manages the focused univer instance.
  */
 export interface IUniverInstanceService {
+    /** Omits value when a new UnitModel is created. */
+    unitAdded$: Observable<UnitModel>;
+    /** Subscribe to curtain type of units' creation. */
+    getTypeOfUnitAdded$<T extends UnitModel>(type: UnitType): Observable<T>;
+    /** @interal */
+    __addUnit(unit: UnitModel): void;
+    /** Omits value when a UnitModel is disposed. */
+    unitDisposed$: Observable<UnitModel>;
+    /** Subscribe to curtain type of units' disposing. */
+    getTypeOfUnitDisposed$<T extends UnitModel>(type: UnitType): Observable<T>;
     focused$: Observable<Nullable<string>>;
-    currentSheet$: Observable<Nullable<Workbook>>;
-    currentDoc$: Observable<Nullable<DocumentDataModel>>;
-    currentSlide$: Observable<Nullable<SlideDataModel>>;
-    sheetAdded$: Observable<Workbook>;
-    docAdded$: Observable<DocumentDataModel>;
-    slideAdded$: Observable<SlideDataModel>;
-    sheetDisposed$: Observable<Workbook>;
-    docDisposed$: Observable<DocumentDataModel>;
-    slideDisposed$: Observable<SlideDataModel>;
-    focusUniverInstance(id: string | null): void;
-    getFocusedUniverInstance(): Nullable<Workbook | DocumentDataModel | SlideDataModel>;
-    createDoc(data: Partial<IDocumentData>): DocumentDataModel;
-    createSheet(data: Partial<IWorkbookData>): Workbook;
-    createSlide(data: Partial<ISlideData>): SlideDataModel;
+    focusUnit(unitId: string | null): void;
+    getFocusedUnit(): Nullable<UnitModel>;
+    getCurrentUnitForType<T extends UnitModel>(type: UnitType): Nullable<T>;
+    setCurrentUnitForType(unitId: string): void;
+    getCurrentTypeOfUnit$<T extends UnitModel>(type: UnitType): Observable<Nullable<T>>;
+    /** Create a unit with snapshot info. */
+    createUnit<T, U extends UnitModel>(type: UnitType, data: Partial<T>): U;
+    /** Dispose a unit  */
+    disposeUnit(unitId: string): boolean;
+    registerCtorForType<T extends UnitModel>(type: UnitType, ctor: new (...args: any[]) => T): IDisposable;
+    /** @deprecated */
     changeDoc(unitId: string, doc: DocumentDataModel): void;
-    addDoc(doc: DocumentDataModel): void;
-    addSheet(sheet: Workbook): void;
-    addSlide(slide: SlideDataModel): void;
-    getUniverSheetInstance(id: string): Nullable<Workbook>;
-    getUniverDocInstance(id: string): Nullable<DocumentDataModel>;
-    getUniverSlideInstance(id: string): Nullable<SlideDataModel>;
-    getCurrentUniverSheetInstance(): Workbook;
-    getCurrentUniverDocInstance(): DocumentDataModel;
-    getCurrentUniverSlideInstance(): SlideDataModel;
-    setCurrentUniverSheetInstance(id: string): void;
-    setCurrentUniverDocInstance(id: string): void;
-    setCurrentUniverSlideInstance(id: string): void;
-    getAllUniverSheetsInstance(): Workbook[];
-    getAllUniverDocsInstance(): DocumentDataModel[];
-    getAllUniverSlidesInstance(): SlideDataModel[];
-    getDocumentType(unitId: string): UniverInstanceType;
-    disposeDocument(unitId: string): boolean;
+    getUnit<T extends UnitModel>(id: string, type?: UnitType): Nullable<T>;
+    getAllUnitsForType<T>(type: UnitType): T[];
+    getUnitType(unitId: string): UnitType;
+    /** @deprecated */
+    getUniverSheetInstance(unitId: string): Nullable<Workbook>;
+    /** @deprecated */
+    getUniverDocInstance(unitId: string): Nullable<DocumentDataModel>;
+    /** @deprecated */
+    getCurrentUniverDocInstance(): Nullable<DocumentDataModel>;
 }
 export declare const IUniverInstanceService: import('@wendellhu/redi').IdentifierDecorator<IUniverInstanceService>;
 export declare class UniverInstanceService extends Disposable implements IUniverInstanceService {
-    private readonly _handler;
+    private readonly _injector;
     private readonly _contextService;
-    private _focused;
-    private readonly _focused$;
-    readonly focused$: Observable<Nullable<string>>;
-    private readonly _currentSheet$;
-    readonly currentSheet$: Observable<Nullable<Workbook>>;
-    private readonly _currentDoc$;
-    readonly currentDoc$: Observable<Nullable<DocumentDataModel>>;
-    private readonly _currentSlide$;
-    readonly currentSlide$: Observable<Nullable<SlideDataModel>>;
-    private readonly _sheetAdded$;
-    readonly sheetAdded$: Observable<Workbook>;
-    private readonly _docAdded$;
-    readonly docAdded$: Observable<DocumentDataModel>;
-    private readonly _slideAdded$;
-    readonly slideAdded$: Observable<SlideDataModel>;
-    private readonly _sheetDisposed$;
-    readonly sheetDisposed$: Observable<Workbook>;
-    private readonly _docDisposed$;
-    readonly docDisposed$: Observable<DocumentDataModel>;
-    private readonly _slideDisposed$;
-    readonly slideDisposed$: Observable<SlideDataModel>;
-    private readonly _sheets;
-    private readonly _docs;
-    private readonly _slides;
-    constructor(_handler: IUniverHandler, _contextService: IContextService);
+    private readonly _unitsByType;
+    constructor(_injector: Injector, _contextService: IContextService);
     dispose(): void;
-    createDoc(data: Partial<IDocumentData>): DocumentDataModel;
-    createSheet(data: Partial<IWorkbookData>): Workbook;
-    createSlide(data: Partial<ISlideData>): SlideDataModel;
-    addSheet(sheet: Workbook): void;
+    private _createHandler;
+    __setCreateHandler(handler: (type: UnitType, data: unknown, ctor: new (...args: any[]) => UnitModel) => UnitModel): void;
+    createUnit<T, U extends UnitModel>(type: UnitType, data: T): U;
+    private readonly _ctorByType;
+    registerCtorForType<T extends UnitModel>(type: UnitType, ctor: new () => T): IDisposable;
+    private readonly _currentUnits$;
+    readonly currentUnits$: Observable<{
+        [type: number]: Nullable<UnitModel<object, number>>;
+    }>;
+    getCurrentTypeOfUnit$<T>(type: number): Observable<Nullable<T>>;
+    getCurrentUnitForType<T>(type: UnitType): Nullable<T>;
+    setCurrentUnitForType(unitId: string): void;
+    private readonly _unitAdded$;
+    readonly unitAdded$: Observable<UnitModel<object, number>>;
+    getTypeOfUnitAdded$<T extends UnitModel<object, number>>(type: UnitType): Observable<T>;
+    __addUnit(unit: UnitModel): void;
+    private _unitDisposed$;
+    unitDisposed$: Observable<UnitModel<object, number>>;
+    getTypeOfUnitDisposed$<T extends UnitModel<object, number>>(type: UniverInstanceType): Observable<T>;
+    getUnit<T extends UnitModel = UnitModel>(id: string, type?: UnitType): Nullable<T>;
+    getCurrentUniverDocInstance(): Nullable<DocumentDataModel>;
+    getUniverDocInstance(unitId: string): Nullable<DocumentDataModel>;
+    getUniverSheetInstance(unitId: string): Nullable<Workbook>;
+    getAllUnitsForType<T>(type: UnitType): T[];
     changeDoc(unitId: string, doc: DocumentDataModel): void;
-    addDoc(doc: DocumentDataModel): void;
-    addSlide(slide: SlideDataModel): void;
-    getUniverSheetInstance(id: string): Nullable<Workbook>;
-    getUniverDocInstance(id: string): Nullable<DocumentDataModel>;
-    getUniverSlideInstance(id: string): Nullable<SlideDataModel>;
-    getAllUniverSheetsInstance(): Workbook[];
-    getAllUniverDocsInstance(): DocumentDataModel[];
-    getAllUniverSlidesInstance(): SlideDataModel[];
-    setCurrentUniverSheetInstance(id: string): void;
-    setCurrentUniverSlideInstance(id: string): void;
-    setCurrentUniverDocInstance(id: string): void;
-    getCurrentUniverSheetInstance(): Workbook;
-    getCurrentUniverDocInstance(): DocumentDataModel;
-    getCurrentUniverSlideInstance(): SlideDataModel;
-    focusUniverInstance(id: string | null): void;
-    getFocusedUniverInstance(): Nullable<Workbook | DocumentDataModel | SlideDataModel>;
-    getDocumentType(unitId: string): UniverInstanceType;
-    disposeDocument(unitId: string): boolean;
+    private readonly _focused$;
+    readonly focused$: Observable<Nullable<string>>;
+    get focused(): Nullable<UnitModel>;
+    focusUnit(id: string | null): void;
+    getFocusedUnit(): Nullable<UnitModel>;
+    getUnitType(unitId: string): UniverInstanceType;
+    disposeUnit(unitId: string): boolean;
+    private _getUnitById;
 }

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

@@ -13,6 +13,7 @@ export declare class LifecycleService extends Disposable {
     private readonly _logService;
     private _lifecycle$;
     readonly lifecycle$: Observable<LifecycleStages>;
+    private _lock;
     constructor(_logService: ILogService);
     get stage(): LifecycleStages;
     set stage(stage: LifecycleStages);
@@ -34,8 +35,7 @@ export declare class LifecycleService extends Disposable {
 export declare class LifecycleInitializerService extends Disposable {
     private _lifecycleService;
     private readonly _injector;
-    private _started;
+    private _seenTokens;
     constructor(_lifecycleService: LifecycleService, _injector: Injector);
-    start(): void;
     initModulesOnStage(stage: LifecycleStages): void;
 }

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

@@ -18,7 +18,6 @@ export declare class PermissionService extends Disposable implements IPermission
     private _univerInstanceService;
     private _permissionPointMap;
     constructor(_resourceManagerService: IResourceManagerService, _univerInstanceService: IUniverInstanceService);
-    private _init;
     private _toJson;
     private _parseJson;
     deletePermissionPoint: (unitID: string, id: string) => void;

package/lib/types/services/permission/univer.permission.service.d.ts

@@ -7,6 +7,6 @@ export declare class UniverPermissionService extends Disposable {
     private _univerInstanceService;
     constructor(_permissionService: IPermissionService, _univerInstanceService: IUniverInstanceService);
     private _init;
-    getEditable(unitID?: string): any;
-    setEditable(unitID: string, v: boolean): void;
+    getEditable(unitId?: string | undefined): any;
+    setEditable(unitId: string, v: boolean): void;
 }

package/lib/types/services/plugin/plugin-holder.d.ts

@@ -0,0 +1,25 @@
+import { Plugin, PluginCtor, PluginRegistry, PluginStore } from './plugin';
+import { ILogService } from '../log/log.service';
+import { Disposable } from '../../shared/lifecycle';
+import { LifecycleInitializerService, LifecycleService } from '../lifecycle/lifecycle.service';
+import { LifecycleStages } from '../lifecycle/lifecycle';
+import { Injector } from '@wendellhu/redi';
+
+export declare class PluginHolder extends Disposable {
+    protected readonly _logService: ILogService;
+    protected readonly _injector: Injector;
+    protected readonly _lifecycleService: LifecycleService;
+    protected readonly _lifecycleInitializerService: LifecycleInitializerService;
+    protected _started: boolean;
+    get started(): boolean;
+    protected readonly _pluginRegistered: Set<string>;
+    protected readonly _pluginStore: PluginStore;
+    protected readonly _pluginRegistry: PluginRegistry;
+    constructor(_logService: ILogService, _injector: Injector, _lifecycleService: LifecycleService, _lifecycleInitializerService: LifecycleInitializerService);
+    dispose(): void;
+    registerPlugin<T extends PluginCtor<Plugin>>(pluginCtor: T, config?: ConstructorParameters<T>[0]): void;
+    start(): void;
+    flush(): void;
+    protected _pluginsRunLifecycle(plugins: Plugin[], lifecycle: LifecycleStages): void;
+    protected _initPlugin<T extends Plugin>(plugin: PluginCtor<T>, options: any): Plugin;
+}

package/lib/types/services/plugin/plugin-override.d.ts

@@ -0,0 +1,8 @@
+import { Dependency, DependencyItem, IdentifierDecorator } from '@wendellhu/redi';
+
+/**
+ * Overrides the dependencies definited in the plugin. Only dependencies that are identified by `IdentifierDecorator` can be overridden.
+ * If you override a dependency with `null`, the original dependency will be removed.
+ */
+export type DependencyOverride = [identifier: IdentifierDecorator<any>, DependencyItem<any> | null][];
+export declare function mergeOverrideWithDependencies(dependencies: Dependency[], override?: DependencyOverride): Dependency[];

package/lib/types/{plugin → services/plugin}/plugin.d.ts

@@ -1,28 +1,23 @@
+import { UniverInstanceType } from '../../common/unit';
+import { Disposable } from '../../shared';
 import { Ctor, Injector } from '@wendellhu/redi';
 
 export type PluginCtor<T extends Plugin> = Ctor<T> & {
-    type: PluginType;
+    type: UniverInstanceType;
+    pluginName: string;
 };
-/** Plugin types for different kinds of business. */
-export declare enum PluginType {
-    Univer = 0,
-    Doc = 1,
-    Sheet = 2,
-    Slide = 3
-}
 /**
  * Plug-in base class, all plug-ins must inherit from this base class. Provide basic methods.
  */
-export declare abstract class Plugin {
-    static type: PluginType;
+export declare abstract class Plugin extends Disposable {
+    static pluginName: string;
+    static type: UniverInstanceType;
     protected abstract _injector: Injector;
-    private _name;
-    protected constructor(name: string);
     onStarting(injector: Injector): void;
     onReady(): void;
     onRendered(): void;
     onSteady(): void;
-    onDestroy(): void;
+    getUniverInstanceType(): UniverInstanceType;
     getPluginName(): string;
 }
 interface IPluginRegistryItem {
@@ -42,9 +37,9 @@ export declare class PluginStore {
  * Store plugin registry items.
  */
 export declare class PluginRegistry {
-    private readonly _pluginsRegisteredByBusiness;
+    private _pluginsRegistered;
     registerPlugin(pluginCtor: PluginCtor<any>, options: any): void;
-    getRegisterPlugins(type: PluginType): [IPluginRegistryItem];
-    clearPluginsOfType(type: PluginType): void;
+    getRegisterPlugins(): IPluginRegistryItem[];
+    removePlugins(): void;
 }
 export {};

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

@@ -0,0 +1,24 @@
+import { Plugin, PluginCtor } from './plugin';
+import { PluginHolder } from './plugin-holder';
+import { UnitType, UniverInstanceType } from '../../common/unit';
+import { IDisposable, Injector } from '@wendellhu/redi';
+
+/**
+ * This service manages plugin registration.
+ */
+export declare class PluginService implements IDisposable {
+    private readonly _injector;
+    private readonly _pluginHolderForUniver;
+    private readonly _pluginHoldersForTypes;
+    constructor(_injector: Injector);
+    dispose(): void;
+    /** Register a plugin into univer. */
+    registerPlugin<T extends PluginCtor<Plugin>>(plugin: T, config?: ConstructorParameters<T>[0]): void;
+    startPluginForType(type: UniverInstanceType): void;
+    _ensurePluginHolderForType(type: UnitType): PluginHolder;
+    private _assertPluginValid;
+    private _flushTimer?;
+    private _scheduleInitPlugin;
+    private _clearFlushTimer;
+    private _flushPlugins;
+}

package/lib/types/services/resource-loader/resource-loader.service.d.ts

@@ -0,0 +1,14 @@
+import { IResourceLoaderService } from './type';
+import { Disposable } from '../../shared/lifecycle';
+import { IUniverInstanceService } from '../instance/instance.service';
+import { IResourceManagerService } from '../resource-manager/type';
+import { IWorkbookData } from '../../types/interfaces';
+import { Workbook } from '../../sheets/workbook';
+
+export declare class ResourceLoaderService extends Disposable implements IResourceLoaderService {
+    private readonly _resourceManagerService;
+    private readonly _univerInstanceService;
+    constructor(_resourceManagerService: IResourceManagerService, _univerInstanceService: IUniverInstanceService);
+    private _init;
+    saveWorkbook: (workbook: Workbook) => IWorkbookData;
+}

package/lib/types/services/resource-loader/type.d.ts

@@ -0,0 +1,7 @@
+import { IWorkbookData } from '../../types/interfaces/i-workbook-data';
+import { Workbook } from '../../sheets/workbook';
+
+export interface IResourceLoaderService {
+    saveWorkbook: (workbook: Workbook) => IWorkbookData;
+}
+export declare const IResourceLoaderService: import('@wendellhu/redi').IdentifierDecorator<IResourceLoaderService>;

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

@@ -1,25 +1,19 @@
-import { IResourceHook, IResourceManagerService } from './type';
+import { IResourceHook, IResourceManagerService, IResourceName } from './type';
+import { IWorkbookData } from '../../types/interfaces/i-workbook-data';
 import { Disposable } from '../../shared/lifecycle';
 
 export declare class ResourceManagerService extends Disposable implements IResourceManagerService {
     private _resourceMap;
     private _register$;
-    register$: import('rxjs').Observable<{
-        resourceName: string;
-        hook: IResourceHook;
-        unitID: string;
-    }>;
-    getAllResource(unitID: string): {
-        unitID: string;
-        resourceName: string;
-        hook: IResourceHook;
+    register$: import('rxjs').Observable<IResourceHook<any>>;
+    getAllResourceHooks(): IResourceHook<any>[];
+    getResources(unitId: string): {
+        name: `SHEET_${string}_PLUGIN` | `DOC_${string}_PLUGIN`;
+        data: string;
     }[];
-    /**
-     * the pluginName is map to resourceId which is created by serve.
-     * @param {string} pluginName
-     * @param {ResourceHook<T>} hook
-     */
-    registerPluginResource<T = any>(unitID: string, resourceName: string, hook: IResourceHook<T>): import('@wendellhu/redi').IDisposable;
-    disposePluginResource(unitID: string, pluginName: string): void;
+    registerPluginResource<T = unknown>(hook: IResourceHook<T>): import('@wendellhu/redi').IDisposable;
+    disposePluginResource(pluginName: IResourceName): void;
+    loadResources(unitId: string, resources: IWorkbookData['resources']): void;
+    unloadResources(unitId: string): void;
     dispose(): void;
 }