@univerjs/core 0.1.13 → 0.1.14

package/lib/types/index.d.ts

@@ -17,7 +17,6 @@ export { DEFAULT_DOCUMENT_SUB_COMPONENT_ID } from './docs/data-model/subdocument
 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 { isNumeric, isSafeNumeric } from './common/number';
 export { isBooleanString } from './common/boolean';
@@ -40,7 +39,7 @@ export type { JSONXActions, JSONXPath } from './docs/data-model/json-x/json-x';
 export { replaceInDocumentBody } from './docs/data-model/replacement';
 export * from './observer';
 export { Plugin } from './services/plugin/plugin';
-export { PluginService } from './services/plugin/plugin.service';
+export { PluginService, DependentOn } 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';
@@ -101,7 +100,7 @@ export { DataValidationImeMode } from './types/enum/data-validation-ime-mode';
 export { DataValidationOperator } from './types/enum/data-validation-operator';
 export { DataValidationType } from './types/enum/data-validation-type';
 export { DataValidationStatus } from './types/enum/data-validation-status';
-export type { IPermissionTypes } from './services/permission/type';
+export type { IPermissionTypes, WorkbookPermissionPointConstructor } from './services/permission/type';
 export { AuthzIoLocalService } from './services/authz-io/authz-io-local.service';
 export { IAuthzIoService } from './services/authz-io/type';
 export { createDefaultUser } from './services/user-manager/const';

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

@@ -8,9 +8,9 @@ export declare enum PermissionStatus {
     FETCHING = "fetching",
     DONE = "done"
 }
-type WorkbookPermissionPointConstructor = new (unitId: string) => IPermissionPoint;
-type WorkSheetPermissionPointConstructor = new (unitId: string, subUnitId: string) => IPermissionPoint;
-type RangePermissionPointConstructor = new (unitId: string, subUnitId: string, permissionId: string) => IPermissionPoint;
+export type WorkbookPermissionPointConstructor = new (unitId: string) => IPermissionPoint;
+export type WorkSheetPermissionPointConstructor = new (unitId: string, subUnitId: string) => IPermissionPoint;
+export type RangePermissionPointConstructor = new (unitId: string, subUnitId: string, permissionId: string) => IPermissionPoint;
 export interface IPermissionTypes {
     rangeTypes?: RangePermissionPointConstructor[];
     worksheetTypes?: WorkSheetPermissionPointConstructor[];
@@ -40,4 +40,3 @@ export interface IPermissionService {
     composePermission(permissionId: string[]): IPermissionPoint<unknown>[];
 }
 export declare const IPermissionService: import('@wendellhu/redi').IdentifierDecorator<IPermissionService>;
-export {};

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

@@ -2,9 +2,11 @@ import { Ctor, Injector } from '@wendellhu/redi';
 import { Disposable } from '../../shared';
 import { UniverInstanceType } from '../../common/unit';
 
-export type PluginCtor<T extends Plugin> = Ctor<T> & {
+export declare const DependentOnSymbol: unique symbol;
+export type PluginCtor<T extends Plugin = Plugin> = Ctor<T> & {
     type: UniverInstanceType;
     pluginName: string;
+    [DependentOnSymbol]?: PluginCtor[];
 };
 /**
  * Plug-in base class, all plug-ins must inherit from this base class. Provide basic methods.
@@ -13,7 +15,7 @@ export declare abstract class Plugin extends Disposable {
     static pluginName: string;
     static type: UniverInstanceType;
     protected abstract _injector: Injector;
-    onStarting(_injector: Injector): void;
+    onStarting(injector: Injector): void;
     onReady(): void;
     onRendered(): void;
     onSteady(): void;

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

@@ -1,8 +1,23 @@
 import { IDisposable, Injector } from '@wendellhu/redi';
-import { UnitType, UniverInstanceType } from '../../common/unit';
-import { PluginHolder } from './plugin-holder';
-import { Plugin, PluginCtor } from './plugin';
+import { Disposable } from '../../shared/lifecycle';
+import { UniverInstanceType } from '../../common/unit';
+import { LifecycleInitializerService, LifecycleService } from '../lifecycle/lifecycle.service';
+import { ILogService } from '../log/log.service';
+import { Plugin, PluginCtor, PluginRegistry, PluginStore } from './plugin';
 
+/**
+ * Use this decorator to declare dependencies among plugins. If a dependent plugin is not registered yet,
+ * Univer will automatically register it with no configuration.
+ *
+ * For example:
+ *
+ * ```ts
+ * ⁣@DependentOn(UniverDrawingPlugin, UniverDrawingUIPlugin, UniverSheetsDrawingPlugin)
+ * export class UniverSheetsDrawingUIPlugin extends Plugin {
+ * }
+ * ```
+ */
+export declare function DependentOn(...plugins: PluginCtor<Plugin>[]): (target: PluginCtor<Plugin>) => void;
 /**
  * This service manages plugin registration.
  */
@@ -10,15 +25,40 @@ export declare class PluginService implements IDisposable {
     private readonly _injector;
     private readonly _pluginHolderForUniver;
     private readonly _pluginHoldersForTypes;
+    private readonly _seenPlugins;
     constructor(_injector: Injector);
     dispose(): void;
     /** Register a plugin into univer. */
-    registerPlugin<T extends PluginCtor<Plugin>>(plugin: T, config?: ConstructorParameters<T>[0]): void;
+    registerPlugin<T extends PluginCtor>(ctor: T, config?: ConstructorParameters<T>[0]): void;
     startPluginForType(type: UniverInstanceType): void;
-    _ensurePluginHolderForType(type: UnitType): PluginHolder;
+    private _ensurePluginHolderForType;
+    private _immediateInitPlugin;
+    private _checkPluginSeen;
     private _assertPluginValid;
     private _flushTimer?;
     private _scheduleInitPlugin;
     private _clearFlushTimer;
     private _flushPlugins;
 }
+export declare class PluginHolder extends Disposable {
+    private _checkPluginRegistered;
+    private _registerPlugin;
+    protected readonly _logService: ILogService;
+    protected readonly _injector: Injector;
+    protected readonly _lifecycleService: LifecycleService;
+    protected readonly _lifecycleInitializerService: LifecycleInitializerService;
+    protected _started: boolean;
+    get started(): boolean;
+    /** Plugin constructors waiting to be initialized. */
+    protected readonly _pluginRegistry: PluginRegistry;
+    /** Stores initialized plugin instances. */
+    protected readonly _pluginStore: PluginStore;
+    constructor(_checkPluginRegistered: (pluginCtor: PluginCtor) => boolean, _registerPlugin: <T extends PluginCtor>(plugin: T, config?: ConstructorParameters<T>[0]) => void, _logService: ILogService, _injector: Injector, _lifecycleService: LifecycleService, _lifecycleInitializerService: LifecycleInitializerService);
+    dispose(): void;
+    register<T extends PluginCtor<Plugin>>(pluginCtor: T, config?: ConstructorParameters<T>[0]): void;
+    immediateInitPlugin<T extends Plugin>(plugin: PluginCtor<T>): void;
+    start(): void;
+    flush(): void;
+    private _initPlugin;
+    protected _pluginsRunLifecycle(plugins: Plugin[]): void;
+}

package/lib/types/shared/debounce.d.ts

@@ -14,5 +14,14 @@
  * limitations under the License.
  */
 type debounceFn<T extends (...args: any[]) => any> = (this: ThisParameterType<T>, ...args: Parameters<T>) => void;
-export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): debounceFn<T>;
+/**
+ * Creates a debounced function that delays invoking the provided function until after `wait` milliseconds have elapsed since the last time the debounced function was invoked.
+ * @template T - The type of the function to be debounced.
+ * @param {T} func - The function to be debounced.
+ * @param {number} wait - The number of milliseconds to wait before invoking the function.
+ * @returns {debounceFn<T> & { cancel: () => void }} - The debounced function, which also has a `cancel` method to cancel the scheduled function call.
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): debounceFn<T> & {
+    cancel: () => void;
+};
 export {};

package/lib/types/shared/tools.d.ts

@@ -97,4 +97,12 @@ export declare class Tools {
     static hasIntersectionBetweenTwoRanges(range1Start: number, range1End: number, range2Start: number, range2End: number): boolean;
     static isStartValidPosition(name: string): boolean;
     static isValidParameter(name: string): boolean;
+    /**
+     * As lodash set, via a path string to set value to deep property
+     * set(obj, 'xx.yy', val)
+     * @param data
+     * @param propertyPath
+     * @param value
+     */
+    static set(data: Record<string, any>, propertyPath: string, value: any): void;
 }

package/lib/types/types/interfaces/i-document-data.d.ts

@@ -291,6 +291,7 @@ export interface IDocumentRenderConfig {
     background?: IColorStyle;
     wrapStrategy?: WrapStrategy;
     cellValueType?: CellValueType;
+    isRenderStyle?: BooleanNumber;
 }
 export interface ISectionBreakBase {
     columnProperties?: ISectionColumnProperties[];