@univerjs/ui 0.2.8 → 0.2.10

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/index.d.ts

@@ -59,7 +59,7 @@ export { IEditorService, EditorService, Editor } from './services/editor/editor.
 export { TextEditor } from './components/editor/TextEditor';
 export { RangeSelector } from './components/range-selector/RangeSelector';
 export { ProgressBar } from './components/progress-bar/ProgressBar';
-export { type IMenuGroup, useToolbarGroups, useToolbarItemStatus, useToolbarCollapseObserver } from './views/components/doc-bars/hook';
+export { type IMenuGroup, useSimpleToolbarGroups, useToolbarGroups, useToolbarItemStatus, useToolbarCollapseObserver } from './views/components/doc-bars/hook';
 export { mergeMenuConfigs } from './common/menu-merge-configs';
 export { ShortcutPanelController } from './controllers/shortcut-display/shortcut-panel.controller';
 export { ShortcutPanelService } from './services/shortcut/shortcut-panel.service';

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/dom/canvas-dom-layer.service.d.ts

@@ -19,6 +19,7 @@ export interface IFloatDom {
     onWheel: (evt: WheelEvent) => void;
     props?: Record<string, any>;
     data?: Serializable;
+    unitId: string;
 }
 export declare class CanvasFloatDomService {
     private _domLayerMap;

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

@@ -9,7 +9,8 @@ export declare enum MenuPosition {
     TOOLBAR_DATA = "uiToolbar.data",
     TOOLBAR_VIEW = "uiToolbar.view",
     TOOLBAR_OTHERS = "uiToolbar.others",
-    CONTEXT_MENU = "contextMenu"
+    CONTEXT_MENU = "contextMenu",
+    FOOTER = "footer"
 }
 export declare enum MenuGroup {
     TOOLBAR_HISTORY = 0,
@@ -48,8 +49,10 @@ interface IMenuItemBase<V> {
     icon?: string | Observable<string>;
     tooltip?: string;
     /** The group that the item belongs to. */
+    /** @deprecated group will be removed in the future. */
     group?: MenuGroup;
     /** In what menu should the item display. */
+    /** @deprecated positions will be removed in the future. */
     positions: OneOrMany<MenuPosition | string>;
     type: MenuItemType;
     /**
@@ -92,6 +95,12 @@ export interface ICustomComponentProps<T> {
 }
 export interface IMenuSelectorItem<V = MenuItemDefaultValueType, T = undefined> extends IMenuItemBase<V> {
     type: MenuItemType.SELECTOR | MenuItemType.BUTTON_SELECTOR | MenuItemType.SUBITEMS;
+    /**
+     * If this property is set, changing the value of the selection will trigger the command with this id,
+     * instead of {@link IMenuItemBase.id} or {@link IMenuItemBase.commandId}. At the same title,
+     * clicking the button will trigger IMenuItemBase.id or IMenuItemBase.commandId.
+     */
+    selectionsCommandId?: string;
     /** Options or IDs of registered components. */
     selections?: Array<IValueOption<T>> | Observable<Array<IValueOption<T>>>;
     /** If `type` is `MenuItemType.BUTTON_SELECTOR`, this determines if the button is activated. */

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

@@ -3,30 +3,49 @@ import { Observable } from 'rxjs';
 import { IShortcutService } from '../shortcut/shortcut.service';
 import { IDisplayMenuItem, IMenuItem, MenuConfig, MenuPosition } from './menu';
 export declare const IMenuService: import('@univerjs/core').IdentifierDecorator<IMenuService>;
+/**
+ * Breaking changes to IMenuService are expected in the next version. Use with caution. by @jikkai
+ */
 export interface IMenuService {
     menuChanged$: Observable<void>;
+    /** @deprecated */
     addMenuItem(item: IMenuItem, config: MenuConfig): IDisposable;
+    /** @deprecated */
     setMenuItem(item: IMenuItem): void;
     /** Get menu items for display at a given position or a submenu. */
+    /** @deprecated */
     getMenuItems(position: MenuPosition | string): Array<IDisplayMenuItem<IMenuItem>>;
+    /** @deprecated */
     getMenuItem(id: string): IMenuItem | null;
 }
 export declare class MenuService extends Disposable implements IMenuService {
     private readonly _shortcutService;
+    /** @deprecated */
     private readonly _menuItemMap;
+    /** @deprecated */
     private readonly _menuByPositions;
+    /** @deprecated */
     private readonly _menuConfigs;
     private _menuChanged$;
     menuChanged$: Observable<void>;
     constructor(_shortcutService: IShortcutService);
     dispose(): void;
+    /** @deprecated */
     addMenuItem(item: IMenuItem, config: MenuConfig): IDisposable;
+    /** @deprecated */
     getMenuItems(positions: MenuPosition | string): Array<IDisplayMenuItem<IMenuItem>>;
+    /** @deprecated */
     setMenuItem(item: IMenuItem): void;
+    /** @deprecated */
     getMenuItem(id: string): IMenuItem | null;
+    /** @deprecated */
     setMenuConfigs(id: string, config: MenuConfig): void;
+    /** @deprecated */
     getMenuConfig(id: string): MenuConfig | null;
+    /** @deprecated */
     private _getDisplayMenuItems;
+    /** @deprecated */
     private _appendMenuToPosition;
+    /** @deprecated */
     private _updateMenuItems;
 }

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

@@ -10,7 +10,8 @@ export declare enum BuiltInUIPart {
     CONTENT = "content",
     FOOTER = "footer",
     LEFT_SIDEBAR = "left-sidebar",
-    FLOATING = "floating"
+    FLOATING = "floating",
+    UNIT = "unit"
 }
 export interface IUIPartsService {
     componentRegistered$: Observable<ComponentPartKey>;

package/lib/types/services/popup/canvas-popup.service.d.ts

@@ -1,9 +1,9 @@
-import { Disposable } from '@univerjs/core';
+import { Nullable, Disposable } from '@univerjs/core';
 import { IRectPopupProps } from '@univerjs/design';
 import { IBoundRectNoAngle } from '@univerjs/engine-render';
 import { Observable } from 'rxjs';
 export interface IPopup extends Pick<IRectPopupProps, 'closeOnSelfTarget' | 'direction' | 'excludeOutside' | 'onClickOutside'> {
-    anchorRect: IBoundRectNoAngle;
+    anchorRect: Nullable<IBoundRectNoAngle>;
     anchorRect$: Observable<IBoundRectNoAngle>;
     excludeRects?: IBoundRectNoAngle[];
     excludeRects$?: Observable<IBoundRectNoAngle[]>;

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/doc-bars/hook.d.ts

@@ -14,6 +14,7 @@ export interface IToolbarRenderHookHandler {
     groups: IMenuGroup[];
     groupsByKey: Record<MenuGroup, Array<IDisplayMenuItem<IMenuItem>>>;
 }
+export declare function useSimpleToolbarGroups(category: MenuPositionWithCustom): IDisplayMenuItem<IMenuItem>[];
 /**
  * If your custom toolbar component need to render menu items by their category,
  * you can use this hook to get the toolbar status.

package/lib/types/views/components/dom/FloatDom.d.ts

@@ -1,2 +1,4 @@
 import { default as React } from 'react';
-export declare const FloatDom: () => React.JSX.Element;
+export declare const FloatDom: ({ unitId }: {
+    unitId?: string;
+}) => React.JSX.Element[] | undefined;

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;