@univerjs/core 0.5.2 → 0.5.3

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

@@ -5,6 +5,7 @@ export declare enum InterceptorEffectEnum {
     Value = 2
 }
 export interface IInterceptor<M, C> {
+    id?: string;
     priority?: number;
     handler: InterceptorHandler<M, C>;
 }
@@ -26,7 +27,14 @@ export declare class InterceptorManager<P extends Record<string, IInterceptor<an
     private _interceptorsByName;
     private _interceptorPoints;
     constructor(interceptorPoints: P);
-    fetchThroughInterceptors<T, C>(name: IInterceptor<T, C>): (initValue: Nullable<T>, initContext: C) => Nullable<T>;
+    /**
+     * Get the interceptors.
+     * @param name Name of the intercepted point.
+     * @param filter A callback function to filter the interceptors.
+     * @returns It will return a composed interceptor function. If you will perform the interceptor repeatedly,
+     * you should cache the result instead of calling this function multiple times.
+     */
+    fetchThroughInterceptors<T, C>(name: IInterceptor<T, C>, filter?: (interceptor: IInterceptor<any, any>) => boolean): (initValue: Nullable<T>, initContext: C) => Nullable<T>;
     intercept<T extends IInterceptor<any, any>>(name: T, interceptor: T): () => boolean;
     getInterceptPoints(): P;
     dispose(): void;
@@ -47,7 +55,14 @@ export declare class AsyncInterceptorManager<P extends Record<string, IAsyncInte
     private _asyncInterceptorsByName;
     private _asyncInterceptorPoints;
     constructor(asyncInterceptorPoints: P);
-    fetchThroughAsyncInterceptors<T, C>(name: IAsyncInterceptor<T, C>): (initialValue: Nullable<T>, context: C) => Promise<Nullable<T>>;
+    /**
+     * Get the interceptors.
+     * @param name Name of the intercepted point.
+     * @param filter A callback function to filter the interceptors.
+     * @returns It will return a composed interceptor function. If you will perform the interceptor repeatedly,
+     * you should cache the result instead of calling this function multiple times.
+     */
+    fetchThroughAsyncInterceptors<T, C>(name: IAsyncInterceptor<T, C>, filter?: (interceptor: IAsyncInterceptor<any, any>) => boolean): (initialValue: Nullable<T>, context: C) => Promise<Nullable<T>>;
     interceptAsync<T extends IAsyncInterceptor<any, any>>(name: T, interceptor: T): Promise<() => boolean>;
     getInterceptPoints(): P;
     dispose(): void;

package/lib/types/facade/f-base.d.ts

@@ -1,26 +1,19 @@
-/**
- * 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.
- */
+import { Injector } from '@wendellhu/redi';
+import { Disposable } from '../shared';
 /**
  * `FBase` is a base class for all facade classes.
  * It provides a way to extend classes with static and instance methods.
  * The `_initialize` as a special method that will be called after the constructor. You should never call it directly.
  */
-export declare abstract class FBase {
-    private static _constructorQueue;
-    constructor();
-    _initialize(): void;
+export declare abstract class FBase extends Disposable {
+    static extend(source: any): void;
+}
+declare const InitializerSymbol: unique symbol;
+export declare class FBaseInitialable extends Disposable {
+    protected _injector: Injector;
+    private [InitializerSymbol];
+    constructor(_injector: Injector);
+    _initialize(injector: Injector): void;
     static extend(source: any): void;
 }
+export {};

package/lib/types/facade/f-enum.d.ts

@@ -0,0 +1,20 @@
+import { UniverInstanceType } from '../common/unit';
+import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { DataValidationErrorStyle } from '../types/enum/data-validation-error-style';
+import { DataValidationOperator } from '../types/enum/data-validation-operator';
+import { DataValidationRenderMode } from '../types/enum/data-validation-render-mode';
+import { DataValidationStatus } from '../types/enum/data-validation-status';
+import { DataValidationType } from '../types/enum/data-validation-type';
+export declare class FEnum {
+    static _instance: FEnum | null;
+    static get(): FEnum;
+    static extend(source: any): void;
+    constructor();
+    get UniverInstanceType(): typeof UniverInstanceType;
+    get LifecycleStages(): typeof LifecycleStages;
+    get DataValidationType(): typeof DataValidationType;
+    get DataValidationErrorStyle(): typeof DataValidationErrorStyle;
+    get DataValidationRenderMode(): typeof DataValidationRenderMode;
+    get DataValidationOperator(): typeof DataValidationOperator;
+    get DataValidationStatus(): typeof DataValidationStatus;
+}

package/lib/types/facade/f-event.d.ts

@@ -0,0 +1,33 @@
+import { UniverInstanceType } from '../common/unit';
+import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { IWorkbookData } from '../sheets/typedef';
+import { IDocumentData } from '../types/interfaces';
+export interface ISheetCreateParam {
+    unitId: string;
+    type: UniverInstanceType.UNIVER_SHEET;
+    data: IWorkbookData;
+}
+export interface IDocumentCreateParam {
+    unitId: string;
+    type: UniverInstanceType.UNIVER_DOC;
+    data: IDocumentData;
+}
+export interface ILifeCycleChangedParam {
+    stage: LifecycleStages;
+}
+export interface IEventBase {
+    cancel?: boolean;
+}
+export type IUnitCreateEvent = IEventBase & (ISheetCreateParam | IDocumentCreateParam);
+export type ILifeCycleChangedEvent = IEventBase & ILifeCycleChangedParam;
+export declare class FEventName {
+    static _instance: FEventName | null;
+    static get(): FEventName;
+    static extend(source: any): void;
+    constructor();
+    get UnitCreated(): "UnitCreated";
+    get LifeCycleChanged(): "LifeCycleChanged";
+}
+export interface IEventParamConfig {
+    LifeCycleChanged: ILifeCycleChangedEvent;
+}

package/lib/types/facade/f-univer.d.ts

@@ -1,16 +1,21 @@
 import { IDisposable, Injector } from '../common/di';
 import { CommandListener, IExecutionOptions, ICommandService } from '../services/command/command.service';
 import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { IEventParamConfig, FEventName } from './f-event';
 import { IUniverInstanceService } from '../services/instance/instance.service';
+import { LifecycleService } from '../services/lifecycle/lifecycle.service';
+import { ColorBuilder } from '../shared';
 import { Univer } from '../univer';
-import { FBase } from './f-base';
+import { FBaseInitialable } from './f-base';
 import { FBlob } from './f-blob';
+import { FEnum } from './f-enum';
 import { FHooks } from './f-hooks';
 import { FUserManager } from './f-usermanager';
-export declare class FUniver extends FBase {
+export declare class FUniver extends FBaseInitialable {
     protected readonly _injector: Injector;
     protected readonly _commandService: ICommandService;
     protected readonly _univerInstanceService: IUniverInstanceService;
+    protected readonly _lifecycleService: LifecycleService;
     /**
      * Create an FUniver instance, if the injector is not provided, it will create a new Univer instance.
      *
@@ -20,7 +25,9 @@ export declare class FUniver extends FBase {
      * @returns {FUniver} - The FUniver instance.
      */
     static newAPI(wrapped: Univer | Injector): FUniver;
-    constructor(_injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
+    private _eventRegistry;
+    private _ensureEventRegistry;
+    constructor(_injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _lifecycleService: LifecycleService);
     /**
      * Dispose the UniverSheet by the `unitId`. The UniverSheet would be unload from the application.
      *
@@ -48,14 +55,14 @@ export declare class FUniver extends FBase {
     redo(): Promise<boolean>;
     /**
      * Register a callback that will be triggered before invoking a command.
-     *
+     * @deprecated use `addEvent(univerAPI.event.BeforeCommandExecute, () => {})` instead.
      * @param {CommandListener} callback The callback.
      * @returns {IDisposable} The disposable instance.
      */
     onBeforeCommandExecute(callback: CommandListener): IDisposable;
     /**
      * Register a callback that will be triggered when a command is invoked.
-     *
+     * @deprecated use `addEvent(univerAPI.event.CommandExecuted, () => {})` instead.
      * @param {CommandListener} callback The callback.
      * @returns {IDisposable} The disposable instance.
      */
@@ -78,7 +85,7 @@ export declare class FUniver extends FBase {
     syncExecuteCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): R;
     /**
      * Get hooks.
-     *
+     * @deprecated use `addEvent` instead.
      * @returns {FHooks} FHooks instance
      */
     getHooks(): FHooks;
@@ -92,5 +99,32 @@ export declare class FUniver extends FBase {
      * ```
      */
     newBlob(): FBlob;
+    newColor(): ColorBuilder;
+    get Enum(): FEnum;
+    get Event(): FEventName;
+    /**
+     * Add an event listener
+     * @param event key of event
+     * @param callback callback when event triggered
+     * @returns {Disposable} The Disposable instance, for remove the listener
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.UnitCreated, (params) => {
+     *     console.log('unit created', params);
+     * });
+     * ```
+     */
+    addEvent(event: keyof IEventParamConfig, callback: (params: IEventParamConfig[typeof event]) => void): IDisposable;
+    /**
+     * Fire an event, used in internal only.
+     * @param event {string} key of event
+     * @param params {any} parmas of event
+     * @returns {boolean} should cancel
+     * @example
+     * ```ts
+     * this.fireEvent(univerAPI.event.UnitCreated, params);
+     * ```
+     */
+    protected fireEvent<T extends keyof IEventParamConfig>(event: T, params: IEventParamConfig[T]): boolean | undefined;
     getUserManager(): FUserManager;
 }

package/lib/types/facade/f-usermanager.d.ts

@@ -8,7 +8,9 @@ export declare class FUserManager extends FBase {
     /**
      * Get current user info
      * @example
-     * `univerAPI.getUserManager().getCurrentUser()`
+     * ```
+     * univerAPI.getUserManager().getCurrentUser()
+     * ```
      */
     getCurrentUser(): IUser;
 }

package/lib/types/facade/f-util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 class FUtil {
+    static Range: {
+        new (): Range;
+        prototype: Range;
+        readonly START_TO_START: 0;
+        readonly START_TO_END: 1;
+        readonly END_TO_END: 2;
+        readonly END_TO_START: 3;
+    };
+}

package/lib/types/index.d.ts

@@ -27,10 +27,12 @@ export { AsyncInterceptorManager, composeInterceptors, createAsyncInterceptorKey
 export type { Serializable } from './common/json';
 export { MemoryCursor } from './common/memory-cursor';
 export { mixinClass } from './common/mixin';
-export { FBase } from './facade/f-base';
+export { FBase, FBaseInitialable } from './facade/f-base';
 export { FUniver } from './facade/f-univer';
 export { FHooks } from './facade/f-hooks';
 export { FBlob, type IFBlobSource } from './facade/f-blob';
+export { FEventName, type IEventBase, type IEventParamConfig } from './facade/f-event';
+export { FEnum } from './facade/f-enum';
 export { isNumeric, isSafeNumeric } from './common/number';
 export { Registry, RegistryAsMap } from './common/registry';
 export { requestImmediateMacroTask } from './common/request-immediate-macro-task';

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

@@ -55,14 +55,14 @@ export declare const UndoCommandId = "univer.command.undo";
 export declare const UndoCommand: {
     readonly type: CommandType.COMMAND;
     readonly id: "univer.command.undo";
-    handler(accessor: IAccessor): Promise<boolean>;
+    handler(accessor: IAccessor): boolean;
     dispose(): void;
     dispatchToHandlers(): Promise<boolean>;
 };
 export declare const RedoCommand: {
     readonly type: CommandType.COMMAND;
     readonly id: "univer.command.redo";
-    handler(accessor: IAccessor): Promise<boolean>;
+    handler(accessor: IAccessor): boolean;
     dispose(): void;
     dispatchToHandlers(): Promise<boolean>;
 };

package/lib/types/sheets/typedef.d.ts

@@ -210,6 +210,13 @@ export interface ICellMarks {
     br?: ICellMarksStyle;
     isSkip?: boolean;
 }
+export interface IFontRenderExtension {
+    leftOffset?: number;
+    rightOffset?: number;
+    topOffset?: number;
+    downOffset?: number;
+    isSkip?: boolean;
+}
 export interface ICellDataForSheetInterceptor extends ICellData {
     interceptorStyle?: Nullable<IStyleData>;
     isInArrayFormulaRange?: Nullable<boolean>;
@@ -223,22 +230,29 @@ export interface ICellDataForSheetInterceptor extends ICellData {
     coverable?: boolean;
     linkUrl?: string;
     linkId?: string;
-    fontRenderExtension?: {
-        leftOffset?: number;
-        rightOffset?: number;
-        topOffset?: number;
-        downOffset?: number;
-        isSkip?: boolean;
-    };
+    fontRenderExtension?: IFontRenderExtension;
+    themeStyle?: Nullable<IStyleData>;
 }
 export declare function isICellData(value: any): value is ICellData;
 export declare function getCellValueType(cell: ICellData): CellValueType | null | undefined;
 export declare function isNullCell(cell: Nullable<ICellData>): boolean;
 export declare function isCellV(cell: Nullable<ICellData | CellValue>): cell is string | number | boolean;
 export interface IFreeze {
+    /**
+     * count of fixed cols
+     */
     xSplit: number;
+    /**
+     * count of fixed rows
+     */
     ySplit: number;
+    /**
+     * scrollable start row
+     */
     startRow: number;
+    /**
+     * scrollable start column
+     */
     startColumn: number;
 }
 export declare enum RANGE_TYPE {

package/lib/types/sheets/view-model.d.ts

@@ -1,26 +1,15 @@
 import { IDisposable } from '../common/di';
+import { IInterceptor, InterceptorEffectEnum } from '../common/interceptor';
 import { Nullable } from '../shared/types';
 import { ICellData, ICellDataForSheetInterceptor } from './typedef';
-import { InterceptorEffectEnum } from '../common/interceptor';
 import { Disposable } from '../shared/lifecycle';
 /**
+ * A cell content interceptor is used to intercept the cell content. It can change or completely replace the cell content.
+ *
  * @internal
  */
 export interface ICellContentInterceptor {
-    getCell: (row: number, col: number, effect: InterceptorEffectEnum) => Nullable<ICellDataForSheetInterceptor>;
-}
-export interface IRowFilteredInterceptor {
-}
-export interface IRowVisibleInterceptor {
-}
-export interface IColVisibleInterceptor {
-}
-export interface ISheetViewModel {
-    registerCellContentInterceptor: (interceptor: ICellContentInterceptor) => IDisposable;
-    registerRowFilteredInterceptor: (interceptor: IRowFilteredInterceptor) => IDisposable;
-    registerRowVisibleInterceptor: (interceptor: IRowVisibleInterceptor) => IDisposable;
-    registerColVisibleInterceptor: (interceptor: IColVisibleInterceptor) => IDisposable;
-    getCell: (row: number, col: number) => Nullable<ICellDataForSheetInterceptor>;
+    getCell: (row: number, col: number, effect: InterceptorEffectEnum, key?: string, filter?: (interceptor: IInterceptor<any, any>) => boolean) => Nullable<ICellDataForSheetInterceptor>;
 }
 /**
  * @internal
@@ -28,6 +17,12 @@ export interface ISheetViewModel {
 export interface IRowFilteredInterceptor {
     getRowFiltered(row: number): boolean;
 }
+export interface IRowFilteredInterceptor {
+}
+export interface IRowVisibleInterceptor {
+}
+export interface IColVisibleInterceptor {
+}
 /**
  * @internal
  */
@@ -38,6 +33,7 @@ export declare class SheetViewModel extends Disposable {
     constructor(getRawCell: (row: number, col: number) => Nullable<ICellData>);
     dispose(): void;
     getCell(row: number, col: number): Nullable<ICellDataForSheetInterceptor>;
+    getCell(row: number, col: number, key: string, filter: (interceptor: IInterceptor<any, any>) => boolean): Nullable<ICellDataForSheetInterceptor>;
     getCellValueOnly(row: number, col: number): Nullable<ICellDataForSheetInterceptor>;
     getCellStyleOnly(row: number, col: number): Nullable<ICellDataForSheetInterceptor>;
     getRowFiltered(row: number): boolean;

package/lib/types/sheets/worksheet.d.ts

@@ -1,3 +1,4 @@
+import { IInterceptor } from '../common/interceptor';
 import { Nullable, ObjectMatrix } from '../shared';
 import { IPaddingData, IStyleData, ITextRotation } from '../types/interfaces';
 import { Styles } from './styles';
@@ -228,6 +229,7 @@ export declare class Worksheet {
      */
     getCellStyleOnly(row: number, col: number): Nullable<ICellDataForSheetInterceptor>;
     getCellRaw(row: number, col: number): Nullable<ICellData>;
+    getCellWithFilteredInterceptors(row: number, col: number, key: string, filter: (interceptor: IInterceptor<any, any>) => boolean): Nullable<ICellDataForSheetInterceptor>;
     getRowFiltered(row: number): boolean;
     /**
      * Get cell matrix from a given range and pick out non-first cells of merged cells.