@univerjs/ui 0.2.9 → 0.2.11

package/lib/es/index.js

@@ -956,6 +956,7 @@ const _ComponentManager = class _ComponentManager {
   // eslint-disable-next-line max-lines-per-function
   constructor() {
     __publicField(this, "_components", /* @__PURE__ */ new Map());
+    __publicField(this, "_componentsReverse", /* @__PURE__ */ new Map());
     const iconList = {
       AlignBottomSingle,
       AlignTopSingle,
@@ -1067,7 +1068,12 @@ const _ComponentManager = class _ComponentManager {
     return this._components.has(name) && console.warn(`Component ${name} already exists.`), this._components.set(name, {
       framework,
       component
-    }), toDisposable(() => this._components.delete(name));
+    }), this._componentsReverse.set(component, name), toDisposable(() => {
+      this._components.delete(name), this._componentsReverse.delete(component);
+    });
+  }
+  getKey(component) {
+    return this._componentsReverse.get(component);
   }
   get(name) {
     if (!name) return;
@@ -2111,7 +2117,7 @@ var MetaKeys = /* @__PURE__ */ ((MetaKeys2) => (MetaKeys2[MetaKeys2.SHIFT = 1024
     (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
   return kind && result && __defProp$f(target, key, result), result;
 }, "__decorateClass$f"), __decorateParam$f = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$f");
-const IShortcutService = createIdentifier("univer.shortcut");
+const IShortcutService = createIdentifier("ui.shortcut.service");
 var _a2;
 let ShortcutService = (_a2 = class extends Disposable {
   constructor(_commandService, _platformService, _contextService, _layoutService) {
@@ -2121,7 +2127,6 @@ let ShortcutService = (_a2 = class extends Disposable {
     __publicField(this, "_shortcutChanged$", new Subject());
     __publicField(this, "shortcutChanged$", this._shortcutChanged$.asObservable());
     __publicField(this, "_forceEscaped", !1);
-    __publicField(this, "_disable", !1);
     this._commandService = _commandService, this._platformService = _platformService, this._contextService = _contextService, this._layoutService = _layoutService, this.disposeWithMe(
       fromGlobalEvent("keydown", (e2) => {
         this._resolveKeyboardEvent(e2);
@@ -2130,9 +2135,6 @@ let ShortcutService = (_a2 = class extends Disposable {
       })
     );
   }
-  setDisable(disable) {
-    this._disable = disable;
-  }
   getAllShortcuts() {
     return Array.from(this._shortCutMapping.values()).map((v2) => Array.from(v2.values())).flat();
   }
@@ -2161,7 +2163,7 @@ let ShortcutService = (_a2 = class extends Disposable {
     return this._forceEscaped = !0, toDisposable(() => this._forceEscaped = !1);
   }
   _resolveKeyboardEvent(e2) {
-    if (this._forceEscaped || this._disable || this._layoutService && !this._layoutService.checkElementInCurrentContainers(e2.target))
+    if (this._forceEscaped || this._layoutService && !this._layoutService.checkElementInCurrentContainers(e2.target))
       return;
     this._dispatch(e2) && e2.preventDefault();
   }
@@ -3898,7 +3900,7 @@ function Sidebar() {
       options == null ? void 0 : options.header,
       /* @__PURE__ */ jsxRuntimeExports.jsx("a", { className: styles$a.sidebarHeaderClose, onClick: handleClose, children: /* @__PURE__ */ jsxRuntimeExports.jsx(CloseSingle, {}) })
     ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("section", { className: styles$a.sidebarBody, children: options == null ? void 0 : options.children }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("section", { className: styles$a.sidebarBody, style: options == null ? void 0 : options.bodyStyle, children: options == null ? void 0 : options.children }),
     (options == null ? void 0 : options.footer) && /* @__PURE__ */ jsxRuntimeExports.jsx("footer", { className: styles$a.sidebarFooter, children: options.footer })
   ] }) });
 }
@@ -4037,11 +4039,15 @@ var __defProp$c = Object.defineProperty, __getOwnPropDesc$c = Object.getOwnPrope
 const STEADY_TIMEOUT$1 = 3e3;
 var _a5;
 let DesktopUIController = (_a5 = class extends Disposable {
-  constructor(_config, _renderManagerService, _injector, _lifecycleService, _uiPartsService, _configService, _layoutService) {
-    super(), this._config = _config, this._renderManagerService = _renderManagerService, this._injector = _injector, this._lifecycleService = _lifecycleService, this._uiPartsService = _uiPartsService, this._configService = _configService, this._layoutService = _layoutService, this._configService.setConfig(UI_CONFIG_KEY, this._config), this._initBuiltinComponents(), Promise.resolve().then(() => this._bootstrapWorkbench());
+  constructor(_config, _renderManagerService, _instanceSrv, _injector, _lifecycleService, _uiPartsService, _configService, _layoutService) {
+    super();
+    __publicField(this, "_steadyTimeout");
+    this._config = _config, this._renderManagerService = _renderManagerService, this._instanceSrv = _instanceSrv, this._injector = _injector, this._lifecycleService = _lifecycleService, this._uiPartsService = _uiPartsService, this._configService = _configService, this._layoutService = _layoutService, this._configService.setConfig(UI_CONFIG_KEY, this._config), this._initBuiltinComponents(), Promise.resolve().then(() => this._bootstrapWorkbench());
   }
   _bootstrapWorkbench() {
-    this.disposeWithMe(
+    this.disposeWithMe(this._instanceSrv.unitDisposed$.subscribe(() => {
+      clearTimeout(this._steadyTimeout);
+    })), this.disposeWithMe(
       bootstrap$1(this._injector, this._config, (contentElement, containerElement) => {
         this._layoutService && (this.disposeWithMe(this._layoutService.registerRootContainerElement(containerElement)), this.disposeWithMe(this._layoutService.registerContentElement(contentElement))), this._renderManagerService.currentRender$.subscribe((renderId) => {
           if (renderId) {
@@ -4053,7 +4059,7 @@ let DesktopUIController = (_a5 = class extends Disposable {
           const allRenders = this._renderManagerService.getRenderAll();
           for (const [key, render2] of allRenders)
             isInternalEditorID(key) || !render2.isRenderUnit || render2.engine.setContainer(contentElement);
-          this._lifecycleService.stage = LifecycleStages.Rendered, setTimeout(() => this._lifecycleService.stage = LifecycleStages.Steady, STEADY_TIMEOUT$1);
+          this._lifecycleService.stage = LifecycleStages.Rendered, this._steadyTimeout = setTimeout(() => this._lifecycleService.stage = LifecycleStages.Steady, STEADY_TIMEOUT$1);
         }, 300);
       })
     );
@@ -4065,11 +4071,12 @@ let DesktopUIController = (_a5 = class extends Disposable {
 DesktopUIController = __decorateClass$c([
   OnLifecycle(LifecycleStages.Ready, DesktopUIController),
   __decorateParam$c(1, IRenderManagerService),
-  __decorateParam$c(2, Inject(Injector)),
-  __decorateParam$c(3, Inject(LifecycleService)),
-  __decorateParam$c(4, IUIPartsService),
-  __decorateParam$c(5, IConfigService),
-  __decorateParam$c(6, Optional(ILayoutService))
+  __decorateParam$c(2, IUniverInstanceService),
+  __decorateParam$c(3, Inject(Injector)),
+  __decorateParam$c(4, Inject(LifecycleService)),
+  __decorateParam$c(5, IUIPartsService),
+  __decorateParam$c(6, IConfigService),
+  __decorateParam$c(7, Optional(ILayoutService))
 ], DesktopUIController);
 function bootstrap$1(injector, options, callback) {
   let mountContainer;
@@ -4393,6 +4400,13 @@ let DesktopDialogService = (_a9 = class extends Disposable {
       visible: item.id === id ? !1 : item.visible
     })), this._dialogOptions$.next([...this._dialogOptions]);
   }
+  closeAll(expectIds) {
+    const expectIdSet = new Set(expectIds);
+    this._dialogOptions = this._dialogOptions.map((item) => ({
+      ...item,
+      visible: expectIdSet.has(item.id) ? item.visible : !1
+    })), this._dialogOptions$.next([...this._dialogOptions]);
+  }
   getDialogs$() {
     return this._dialogOptions$.asObservable();
   }

package/lib/types/common/component-manager.d.ts

@@ -17,8 +17,10 @@ export type ComponentType = React.ForwardRefExoticComponent<any> | ReturnType<ty
 export type ComponentList = Map<string, IVue3Component | IReactComponent>;
 export declare class ComponentManager {
     private _components;
+    private _componentsReverse;
     constructor();
     register(name: string, component: ComponentType, options?: IComponentOptions): IDisposable;
+    getKey(component: ComponentType): string | undefined;
     get(name: string): React.ForwardRefExoticComponent<any> | ((props: any) => React.FunctionComponentElement<{
         component: ReturnType<typeof defineComponent>;
         props: Record<string, any>;

package/lib/types/controllers/ui/ui-desktop.controller.d.ts

@@ -1,4 +1,4 @@
-import { Disposable, IConfigService, Injector, LifecycleService } from '@univerjs/core';
+import { Disposable, IConfigService, Injector, IUniverInstanceService, LifecycleService } from '@univerjs/core';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { ILayoutService } from '../../services/layout/layout.service';
 import { IUIPartsService } from '../../services/parts/parts.service';
@@ -6,12 +6,14 @@ import { IUniverUIConfig } from './ui.controller';
 export declare class DesktopUIController extends Disposable {
     private readonly _config;
     private readonly _renderManagerService;
+    private readonly _instanceSrv;
     private readonly _injector;
     private readonly _lifecycleService;
     private readonly _uiPartsService;
     private readonly _configService;
     private readonly _layoutService?;
-    constructor(_config: IUniverUIConfig, _renderManagerService: IRenderManagerService, _injector: Injector, _lifecycleService: LifecycleService, _uiPartsService: IUIPartsService, _configService: IConfigService, _layoutService?: ILayoutService | undefined);
+    private _steadyTimeout;
+    constructor(_config: IUniverUIConfig, _renderManagerService: IRenderManagerService, _instanceSrv: IUniverInstanceService, _injector: Injector, _lifecycleService: LifecycleService, _uiPartsService: IUIPartsService, _configService: IConfigService, _layoutService?: ILayoutService | undefined);
     private _bootstrapWorkbench;
     private _initBuiltinComponents;
 }

package/lib/types/services/dialog/desktop-dialog.service.d.ts

@@ -12,6 +12,7 @@ export declare class DesktopDialogService extends Disposable implements IDialogS
     dispose(): void;
     open(option: IDialogPartMethodOptions): IDisposable;
     close(id: string): void;
+    closeAll(expectIds?: string[]): void;
     getDialogs$(): import('rxjs').Observable<IDialogPartMethodOptions[]>;
     protected _initUIPart(): void;
 }

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

@@ -5,5 +5,10 @@ export declare const IDialogService: import('@univerjs/core').IdentifierDecorato
 export interface IDialogService {
     open(params: IDialogPartMethodOptions): IDisposable;
     close(id: string): void;
+    /**
+     * @description close all dialogs except the specified ones
+     * @param {string[]} [expectIds] The specified dialog ids
+     */
+    closeAll(expectIds?: string[]): void;
     getDialogs$(): Observable<IDialogPartMethodOptions[]>;
 }

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

@@ -3,38 +3,100 @@ import { Observable } from 'rxjs';
 import { ILayoutService } from '../layout/layout.service';
 import { IPlatformService } from '../platform/platform.service';
 import { KeyCode } from './keycode';
+/**
+ * A shortcut item that could be registered to the {@link IShortcutService}.
+ */
 export interface IShortcutItem<P extends object = object> {
-    /** This should reuse the corresponding command's id. */
+    /** Id of the shortcut item. It should reuse the corresponding {@link ICommand}'s id. */
     id: string;
     /** Description of the shortcut. */
     description?: string;
     /** If two shortcuts have the same binding, the one with higher priority would be check first. */
     priority?: number;
-    /** A callback that will be triggered to examine if the shortcut should be invoked. */
+    /**
+     * A callback that will be triggered to examine if the shortcut should be invoked. The `{@link IContextService}`
+     * would be passed to the callback.
+     */
     preconditions?: (contextService: IContextService) => boolean;
-    /** A command can be bound to several bindings, with different static parameters perhaps. */
+    /**
+     * The binding of the shortcut. It should be a combination of {@link KeyCode} and {@link MetaKeys}.
+     *
+     * A command can be bound to several bindings, with different static parameters perhaps.
+     *
+     * @example { binding: KeyCode.ENTER | MetaKeys.ALT }
+     */
     binding: KeyCode | number;
+    /**
+     * The binding of the shortcut for macOS. If the property is not specified, the default binding would be used.
+     */
     mac?: number;
+    /**
+     * The binding of the shortcut for Windows. If the property is not specified, the default binding would be used.
+     */
     win?: number;
+    /**
+     * The binding of the shortcut for Linux. If the property is not specified, the default binding would be used.
+     */
     linux?: number;
     /**
      * The group of the menu item should belong to. The shortcut item would be rendered in the
      * panel if this is set.
+     *
+     * @example { group: '10_global-shortcut' }
      */
     group?: string;
-    /** Static parameters of this shortcut. Would be send to `CommandService.executeCommand`. */
+    /**
+     * Static parameters of this shortcut. Would be send to {@link ICommandService.executeCommand} as the second
+     * parameter when the corresponding command is executed.
+     *
+     * You can define multi shortcuts with the same command id but different static parameters.
+     */
     staticParameters?: P;
 }
+/**
+ * The dependency injection identifier of the {@link IShortcutService}.
+ */
+export declare const IShortcutService: import('@univerjs/core').IdentifierDecorator<IShortcutService>;
+/**
+ * The interface of the shortcut service.
+ */
 export interface IShortcutService {
+    /**
+     * An observable that emits when the shortcuts are changed.
+     */
     shortcutChanged$: Observable<void>;
+    /**
+     * Make the shortcut service ignore all keyboard events.
+     * @returns {IDisposable} a disposable that could be used to cancel the force escaping.
+     */
     forceEscape(): IDisposable;
+    /**
+     * Register a shortcut item to the shortcut service.
+     * @param {IShortcutItem} shortcut - the shortcut item to be registered.
+     * @returns {IDisposable} a disposable that could be used to unregister the shortcut.
+     */
     registerShortcut(shortcut: IShortcutItem): IDisposable;
+    /**
+     * Get the display string of the shortcut item.
+     * @param shortcut - the shortcut item to get the display string.
+     * @returns {string} the display string of the shortcut. For example `Ctrl+Enter`.
+     */
     getShortcutDisplay(shortcut: IShortcutItem): string;
+    /**
+     * Get the display string of the shortcut of the command.
+     * @param id the id of the command to get the shortcut display.
+     * @returns {string | null} the display string of the shortcut. For example `Ctrl+Enter`.
+     */
     getShortcutDisplayOfCommand(id: string): string | null;
+    /**
+     * Get all the shortcuts registered in the shortcut service.
+     * @returns {IShortcutItem[]} all the shortcuts registered in the shortcut service.
+     */
     getAllShortcuts(): IShortcutItem[];
-    setDisable(disable: boolean): void;
 }
-export declare const IShortcutService: import('@univerjs/core').IdentifierDecorator<IShortcutService>;
+/**
+ * @ignore
+ */
 export declare class ShortcutService extends Disposable implements IShortcutService {
     private readonly _commandService;
     private readonly _platformService;
@@ -45,9 +107,7 @@ export declare class ShortcutService extends Disposable implements IShortcutServ
     private readonly _shortcutChanged$;
     readonly shortcutChanged$: Observable<void>;
     private _forceEscaped;
-    private _disable;
     constructor(_commandService: ICommandService, _platformService: IPlatformService, _contextService: IContextService, _layoutService?: ILayoutService | undefined);
-    setDisable(disable: boolean): void;
     getAllShortcuts(): IShortcutItem[];
     registerShortcut(shortcut: IShortcutItem): IDisposable;
     getShortcutDisplayOfCommand(id: string): string | null;

package/lib/types/views/components/sidebar/interface.d.ts

@@ -1,8 +1,10 @@
+import { CSSProperties } from 'react';
 import { ICustomLabelProps } from '../../../components/custom-label/CustomLabel';
 export interface ISidebarMethodOptions {
     id?: string;
     header?: ICustomLabelProps;
     children?: ICustomLabelProps;
+    bodyStyle?: CSSProperties;
     footer?: ICustomLabelProps;
     visible?: boolean;
     width?: number | string;