@univerjs/ui 0.2.11 → 0.2.13

package/lib/types/services/global-zone/global-zone.service.d.ts

@@ -1,6 +1,6 @@
 import { IDisposable } from '@univerjs/core';
 import { Subject } from 'rxjs';
-export declare const IGlobalZoneService: import('@univerjs/core').IdentifierDecorator<IGlobalZoneService>;
+export declare const IGlobalZoneService: import('@wendellhu/redi').IdentifierDecorator<IGlobalZoneService>;
 export interface IGlobalZoneService {
     readonly visible$: Subject<boolean>;
     readonly componentKey$: Subject<string>;

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

@@ -19,7 +19,7 @@ export interface ILayoutService {
     checkElementInCurrentContainers(element: HTMLElement): boolean;
     checkContentIsFocused(): boolean;
 }
-export declare const ILayoutService: import('@univerjs/core').IdentifierDecorator<ILayoutService>;
+export declare const ILayoutService: import('@wendellhu/redi').IdentifierDecorator<ILayoutService>;
 /**
  * This service is responsible for storing layout information of the current
  * Univer application instance.

package/lib/types/services/local-file/desktop-file-opener.service.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, Injector } from '@univerjs/core';
+import { IUIPartsService } from '../parts/parts.service';
+import { ILocalFileService, IOpenFileOptions } from './file-opener.service';
+interface IOpenFileRequest extends IOpenFileOptions {
+    onFileSelected: (files: File[]) => void;
+}
+export declare class DesktopLocalFileService extends Disposable implements ILocalFileService {
+    private readonly _uiPartsService;
+    private readonly _fileOpenRequest$;
+    readonly fileOpenRequest$: import('rxjs').Observable<IOpenFileRequest | null>;
+    constructor(injector: Injector, _uiPartsService: IUIPartsService);
+    openFile(options?: IOpenFileOptions): Promise<File[]>;
+    downloadFile(data: Blob, fileName: string): void;
+}
+export {};

package/lib/types/services/local-file/file-opener.service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 interface IOpenFileOptions {
+    accept?: string;
+    multiple?: boolean;
+}
+export interface ILocalFileService {
+    openFile(options?: IOpenFileOptions): Promise<File[]>;
+    downloadFile(data: Blob, fileName: string): void;
+}
+/**
+ * This service is used to upload files.
+ */
+export declare const ILocalFileService: import('@wendellhu/redi').IdentifierDecorator<ILocalFileService>;

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

@@ -0,0 +1,44 @@
+import { IAccessor, Disposable, IConfigService, Injector } from '@univerjs/core';
+import { Observable, Subject } from 'rxjs';
+import { IMenuItem } from '../menu/menu';
+export declare const IMenuManagerService: import('@wendellhu/redi').IdentifierDecorator<IMenuManagerService>;
+export interface IMenuSchema {
+    key: string;
+    order: number;
+    item?: IMenuItem;
+    children?: IMenuSchema[];
+}
+export interface IMenuManagerService {
+    readonly menuChanged$: Observable<void>;
+    mergeMenu(source: MenuSchemaType, target?: MenuSchemaType): void;
+    appendRootMenu(source: MenuSchemaType): void;
+    getMenuByPositionKey(position: string): IMenuSchema[];
+}
+export type MenuSchemaType = {
+    order?: number;
+    menuItemFactory?: (accessor: IAccessor) => IMenuItem;
+} | {
+    [key: string]: MenuSchemaType;
+};
+export declare class MenuManagerService extends Disposable implements IMenuManagerService {
+    private readonly _injector;
+    private readonly _configService;
+    readonly menuChanged$: Subject<void>;
+    private _menu;
+    constructor(_injector: Injector, _configService: IConfigService);
+    dispose(): void;
+    /**
+     * Merge source menu to target menu recursively
+     * @param source
+     * @param target default is root menu
+     */
+    mergeMenu(source: MenuSchemaType, target?: MenuSchemaType): void;
+    appendRootMenu(source: MenuSchemaType): void;
+    private _buildMenuSchema;
+    /**
+     * Get menu schema by position key
+     * @param key
+     * @returns Menu schema array or empty array if not found
+     */
+    getMenuByPositionKey(key: string): IMenuSchema[];
+}

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

@@ -1,17 +1,19 @@
 import { IAccessor } from '@univerjs/core';
 import { Observable } from 'rxjs';
 export type OneOrMany<T> = T | T[];
+/** @deprecated */
 export declare enum MenuPosition {
     VOID = "void",
-    TOOLBAR_START = "uiToolbar.start",
-    TOOLBAR_INSERT = "uiToolbar.insert",
-    TOOLBAR_FORMULAS = "uiToolbar.formulas",
-    TOOLBAR_DATA = "uiToolbar.data",
-    TOOLBAR_VIEW = "uiToolbar.view",
-    TOOLBAR_OTHERS = "uiToolbar.others",
-    CONTEXT_MENU = "contextMenu",
+    TOOLBAR_START = "ribbon.start",
+    TOOLBAR_INSERT = "ribbon.insert",
+    TOOLBAR_FORMULAS = "ribbon.formulas",
+    TOOLBAR_DATA = "ribbon.data",
+    TOOLBAR_VIEW = "ribbon.view",
+    TOOLBAR_OTHERS = "ribbon.others",
+    CONTEXT_MENU = "contextMenu.mainArea",
     FOOTER = "footer"
 }
+/** @deprecated */
 export declare enum MenuGroup {
     TOOLBAR_HISTORY = 0,
     TOOLBAR_FORMAT = 1,
@@ -53,7 +55,7 @@ interface IMenuItemBase<V> {
     group?: MenuGroup;
     /** In what menu should the item display. */
     /** @deprecated positions will be removed in the future. */
-    positions: OneOrMany<MenuPosition | string>;
+    positions?: OneOrMany<MenuPosition | string>;
     type: MenuItemType;
     /**
      * Custom label component id.
@@ -108,7 +110,7 @@ export interface IMenuSelectorItem<V = MenuItemDefaultValueType, T = undefined>
 }
 export declare function isMenuSelectorItem<T extends MenuItemDefaultValueType>(v: IMenuItem): v is IMenuSelectorItem<T>;
 export type MenuItemDefaultValueType = string | number | undefined;
-export type IMenuItem = IMenuButtonItem<MenuItemDefaultValueType> | IMenuSelectorItem<MenuItemDefaultValueType>;
+export type IMenuItem = IMenuButtonItem<MenuItemDefaultValueType> | IMenuSelectorItem<MenuItemDefaultValueType, any>;
 export type IDisplayMenuItem<T extends IMenuItem> = T & {
     shortcut?: string;
 };

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

@@ -1,10 +1,13 @@
-import { Disposable, IDisposable } from '@univerjs/core';
+import { Disposable, ILogService, IDisposable } from '@univerjs/core';
 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>;
+import { IMenuManagerService } from './menu-manager.service';
+/** @deprecated */
+export declare const IMenuService: import('@wendellhu/redi').IdentifierDecorator<IMenuService>;
 /**
  * Breaking changes to IMenuService are expected in the next version. Use with caution. by @jikkai
+ * @deprecated
  */
 export interface IMenuService {
     menuChanged$: Observable<void>;
@@ -18,8 +21,11 @@ export interface IMenuService {
     /** @deprecated */
     getMenuItem(id: string): IMenuItem | null;
 }
+/** @deprecated */
 export declare class MenuService extends Disposable implements IMenuService {
     private readonly _shortcutService;
+    private readonly _menuManagerService;
+    protected readonly _logService: ILogService;
     /** @deprecated */
     private readonly _menuItemMap;
     /** @deprecated */
@@ -28,7 +34,7 @@ export declare class MenuService extends Disposable implements IMenuService {
     private readonly _menuConfigs;
     private _menuChanged$;
     menuChanged$: Observable<void>;
-    constructor(_shortcutService: IShortcutService);
+    constructor(_shortcutService: IShortcutService, _menuManagerService: IMenuManagerService, _logService: ILogService);
     dispose(): void;
     /** @deprecated */
     addMenuItem(item: IMenuItem, config: MenuConfig): IDisposable;

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

@@ -0,0 +1,64 @@
+/**
+ * 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 enum MenuManagerPosition {
+    RIBBON = "ribbon",
+    CONTEXT_MENU = "contextMenu"
+}
+export declare enum RibbonPosition {
+    START = "ribbon.start",
+    INSERT = "ribbon.insert",
+    FORMULAS = "ribbon.formulas",
+    DATA = "ribbon.data",
+    VIEW = "ribbon.view",
+    OTHERS = "ribbon.others"
+}
+export declare enum RibbonStartGroup {
+    HISTORY = "ribbon.start.history",
+    FORMAT = "ribbon.start.format",
+    LAYOUT = "ribbon.start.layout",
+    FORMULAS_INSERT = "ribbon.start.insert",
+    FORMULAS_VIEW = "ribbon.start.view",
+    FILE = "ribbon.start.file",
+    OTHERS = "ribbon.start.others"
+}
+export declare enum RibbonInsertGroup {
+    OTHERS = "ribbon.insert.others"
+}
+export declare enum RibbonFormulasGroup {
+    OTHERS = "ribbon.formulas.others"
+}
+export declare enum RibbonDataGroup {
+    OTHERS = "ribbon.data.others"
+}
+export declare enum RibbonViewGroup {
+    OTHERS = "ribbon.view.others"
+}
+export declare enum RibbonOthersGroup {
+    OTHERS = "ribbon.others.others"
+}
+export declare enum ContextMenuPosition {
+    MAIN_AREA = "contextMenu.mainArea",
+    COL_HEADER = "contextMenu.colHeader",
+    ROW_HEADER = "contextMenu.rowHeader",
+    FOOTER_TABS = "contextMenu.footerTabs",
+    FOOTER_MENU = "contextMenu.footerMenu"
+}
+export declare enum ContextMenuGroup {
+    FORMAT = "contextMenu.format",
+    LAYOUT = "contextMenu.layout",
+    DATA = "contextMenu.data",
+    OTHERS = "contextMenu.others"
+}

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

@@ -1,6 +1,6 @@
 import { IMessageOptions } from '@univerjs/design';
 import { IDisposable } from '@univerjs/core';
-export declare const IMessageService: import('@univerjs/core').IdentifierDecorator<IMessageService>;
+export declare const IMessageService: import('@wendellhu/redi').IdentifierDecorator<IMessageService>;
 export interface IMessageService {
     show(options: IMessageOptions): IDisposable;
     setContainer(container: HTMLElement): void;

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

@@ -1,6 +1,6 @@
 import { IDisposable } from '@univerjs/core';
 import { INotificationOptions } from '../../components/notification/Notification';
-export declare const INotificationService: import('@univerjs/core').IdentifierDecorator<INotificationService>;
+export declare const INotificationService: import('@wendellhu/redi').IdentifierDecorator<INotificationService>;
 export interface INotificationService {
     show(params: INotificationOptions): IDisposable;
 }

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

@@ -18,7 +18,7 @@ export interface IUIPartsService {
     registerComponent(part: ComponentPartKey, componentFactory: () => ComponentType): IDisposable;
     getComponents(part: ComponentPartKey): Set<ComponentRenderer>;
 }
-export declare const IUIPartsService: import('@univerjs/core').IdentifierDecorator<IUIPartsService>;
+export declare const IUIPartsService: import('@wendellhu/redi').IdentifierDecorator<IUIPartsService>;
 export declare class UIPartsService extends Disposable implements IUIPartsService {
     private _componentsByPart;
     private readonly _componentRegistered$;

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

@@ -21,7 +21,7 @@ export interface IPlatformService {
     readonly isWindows: boolean;
     readonly isLinux: boolean;
 }
-export declare const IPlatformService: import('@univerjs/core').IdentifierDecorator<IPlatformService>;
+export declare const IPlatformService: import('@wendellhu/redi').IdentifierDecorator<IPlatformService>;
 export declare class PlatformService implements IPlatformService {
     get isMac(): boolean;
     get isWindows(): boolean;

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

@@ -2,7 +2,7 @@ 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'> {
+export interface IPopup extends Pick<IRectPopupProps, 'direction' | 'excludeOutside' | 'onClickOutside'> {
     anchorRect: Nullable<IBoundRectNoAngle>;
     anchorRect$: Observable<IBoundRectNoAngle>;
     excludeRects?: IBoundRectNoAngle[];
@@ -13,6 +13,10 @@ export interface IPopup extends Pick<IRectPopupProps, 'closeOnSelfTarget' | 'dir
     offset?: [number, number];
     canvasElement: HTMLCanvasElement;
     hideOnInvisible?: boolean;
+    hiddenType?: 'hide' | 'destroy';
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    onClick?: () => void;
 }
 export interface ICanvasPopupService {
     addPopup(item: IPopup): string;
@@ -20,13 +24,19 @@ export interface ICanvasPopupService {
     removeAll(): void;
     popups$: Observable<[string, IPopup][]>;
     get popups(): [string, IPopup][];
+    /**
+     * which popup is under hovering now
+     */
+    get activePopupId(): Nullable<string>;
 }
-export declare const ICanvasPopupService: import('@univerjs/core').IdentifierDecorator<ICanvasPopupService>;
+export declare const ICanvasPopupService: import('@wendellhu/redi').IdentifierDecorator<ICanvasPopupService>;
 export declare class CanvasPopupService extends Disposable implements ICanvasPopupService {
     private readonly _popupMap;
     private readonly _popups$;
     readonly popups$: Observable<[string, IPopup][]>;
     get popups(): [string, IPopup][];
+    private _activePopupId;
+    get activePopupId(): Nullable<string>;
     private _update;
     dispose(): void;
     addPopup(item: IPopup): string;

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

@@ -49,4 +49,4 @@ export declare class ProgressService extends Disposable implements IProgressServ
     getTaskCount(): number;
     private _clear;
 }
-export declare const IProgressService: import('@univerjs/core').IdentifierDecorator<IProgressService>;
+export declare const IProgressService: import('@wendellhu/redi').IdentifierDecorator<IProgressService>;

package/lib/types/services/range-selector/range-selector.service.d.ts

@@ -10,6 +10,9 @@ export interface IRangeSelectorService {
     getCurrentSelectorId(): Nullable<string>;
     openSelector$: Observable<unknown>;
     openSelector(): void;
+    selectorModalVisible$: Observable<boolean>;
+    get selectorModalVisible(): boolean;
+    triggerModalVisibleChange(visible: boolean): void;
 }
 export declare class RangeSelectorService extends Disposable implements IRangeSelectorService, IDisposable {
     private _currentSelectorId;
@@ -17,9 +20,13 @@ export declare class RangeSelectorService extends Disposable implements IRangeSe
     readonly selectionChange$: Observable<IRangeSelectorRange[]>;
     private readonly _openSelector$;
     readonly openSelector$: Observable<unknown>;
+    private readonly _selectorModalVisible$;
+    readonly selectorModalVisible$: Observable<boolean>;
+    get selectorModalVisible(): boolean;
     setCurrentSelectorId(id: Nullable<string>): void;
     getCurrentSelectorId(): Nullable<string>;
     selectionChange(range: IRangeSelectorRange[]): void;
     openSelector(): void;
+    triggerModalVisibleChange(visible: boolean): void;
 }
-export declare const IRangeSelectorService: import('@univerjs/core').IdentifierDecorator<IRangeSelectorService>;
+export declare const IRangeSelectorService: import('@wendellhu/redi').IdentifierDecorator<IRangeSelectorService>;

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

@@ -56,7 +56,7 @@ export interface IShortcutItem<P extends object = object> {
 /**
  * The dependency injection identifier of the {@link IShortcutService}.
  */
-export declare const IShortcutService: import('@univerjs/core').IdentifierDecorator<IShortcutService>;
+export declare const IShortcutService: import('@wendellhu/redi').IdentifierDecorator<IShortcutService>;
 /**
  * The interface of the shortcut service.
  */

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

@@ -9,5 +9,5 @@ export interface ISidebarService {
     get visible(): boolean;
     get options(): ISidebarMethodOptions;
 }
-export declare const ILeftSidebarService: import('@univerjs/core').IdentifierDecorator<ISidebarService>;
-export declare const ISidebarService: import('@univerjs/core').IdentifierDecorator<ISidebarService>;
+export declare const ILeftSidebarService: import('@wendellhu/redi').IdentifierDecorator<ISidebarService>;
+export declare const ISidebarService: import('@wendellhu/redi').IdentifierDecorator<ISidebarService>;

package/lib/types/services/zen-zone/desktop-zen-zone.service.d.ts

@@ -1,15 +1,20 @@
 import { IDisposable } from '@univerjs/core';
-import { ForwardRefExoticComponent } from 'react';
 import { Subject } from 'rxjs';
+import { ForwardRefExoticComponent } from 'react';
 import { ComponentManager } from '../../common/component-manager';
 import { IZenZoneService } from './zen-zone.service';
 export declare class DesktopZenZoneService implements IZenZoneService {
     private readonly _componentManager;
     readonly visible$: Subject<boolean>;
     readonly componentKey$: Subject<string>;
+    private readonly _temporaryHidden$;
+    readonly temporaryHidden$: import('rxjs').Observable<boolean>;
     private _visible;
     get visible(): boolean;
+    get temporaryHidden(): boolean;
     constructor(_componentManager: ComponentManager);
+    hide(): void;
+    show(): void;
     set(key: string, component: ForwardRefExoticComponent<any>): IDisposable;
     open(): void;
     close(): void;

package/lib/types/services/zen-zone/zen-zone.service.d.ts

@@ -1,11 +1,21 @@
 import { IDisposable } from '@univerjs/core';
-import { Subject } from 'rxjs';
-export declare const IZenZoneService: import('@univerjs/core').IdentifierDecorator<IZenZoneService>;
+import { Observable, Subject } from 'rxjs';
+export declare const IZenZoneService: import('@wendellhu/redi').IdentifierDecorator<IZenZoneService>;
 export interface IZenZoneService {
     readonly visible$: Subject<boolean>;
     readonly componentKey$: Subject<string>;
+    readonly temporaryHidden$: Observable<boolean>;
     readonly visible: boolean;
+    readonly temporaryHidden: boolean;
     set(key: string, component: any): IDisposable;
     open(): void;
     close(): void;
+    /**
+     * temporarily hide the zen zone, often
+     */
+    hide(): void;
+    /**
+     * show the zen zone
+     */
+    show(): void;
 }

package/lib/types/ui-plugin.d.ts

@@ -1,15 +1,16 @@
-import { IContextService, Injector, Plugin } from '@univerjs/core';
-import { IUniverUIConfig } from './controllers/ui/ui.controller';
+import { IConfigService, IContextService, Injector, Plugin } from '@univerjs/core';
+import { IUniverUIConfig } from './controllers/config.schema';
 export declare const UNIVER_UI_PLUGIN_NAME = "UNIVER_UI_PLUGIN";
 export declare const DISABLE_AUTO_FOCUS_KEY = "DISABLE_AUTO_FOCUS";
 /**
  * UI plugin provides basic interaction with users. Including workbench (menus, UI parts, notifications etc.), copy paste, shortcut.
  */
 export declare class UniverUIPlugin extends Plugin {
-    private _config;
+    private readonly _config;
     private readonly _contextService;
     protected readonly _injector: Injector;
+    private readonly _configService;
     static pluginName: string;
-    constructor(_config: Partial<IUniverUIConfig>, _contextService: IContextService, _injector: Injector);
+    constructor(_config: Partial<IUniverUIConfig> | undefined, _contextService: IContextService, _injector: Injector, _configService: IConfigService);
     onStarting(): void;
 }

package/lib/types/views/components/ribbon/Ribbon.d.ts

@@ -0,0 +1,6 @@
+import { default as React, ComponentType } from 'react';
+interface IRibbonProps {
+    headerMenuComponents?: Set<ComponentType>;
+}
+export declare function Ribbon(props: IRibbonProps): React.JSX.Element;
+export {};

package/lib/types/views/components/{doc-bars → ribbon}/ToolbarItem.d.ts

@@ -1,3 +1,6 @@
 import { default as React } from 'react';
+import { IDropdownProps } from '@univerjs/design';
 import { IDisplayMenuItem, IMenuItem } from '../../../services/menu/menu';
-export declare const ToolbarItem: React.ForwardRefExoticComponent<IDisplayMenuItem<IMenuItem> & React.RefAttributes<any>>;
+export declare const ToolbarItem: React.ForwardRefExoticComponent<(IDisplayMenuItem<IMenuItem> & {
+    align?: IDropdownProps["align"];
+}) & React.RefAttributes<any>>;

package/lib/types/views/components/ribbon/TooltipButtonWrapper.d.ts

@@ -0,0 +1,4 @@
+import { IDropdownProps, ITooltipProps, NullableTooltipRef } from '@univerjs/design';
+import { default as React } from 'react';
+export declare const TooltipWrapper: React.ForwardRefExoticComponent<ITooltipProps & React.RefAttributes<NullableTooltipRef>>;
+export declare function DropdownWrapper(props: IDropdownProps): React.JSX.Element;

package/lib/types/views/components/{doc-bars → ribbon}/hook.d.ts

@@ -33,12 +33,4 @@ export interface IToolbarItemStatus {
  * @returns The menu item's status
  */
 export declare function useToolbarItemStatus(menuItem: IDisplayMenuItem<IMenuItem>): IToolbarItemStatus;
-export declare function useToolbarCollapseObserver(visibleItems: IToolbarRenderHookHandler['visibleItems']): {
-    toolbarRef: import('react').RefObject<HTMLDivElement>;
-    toolbarItemRefs: import('react').MutableRefObject<Record<string, {
-        el: HTMLDivElement;
-        key: string;
-    }>>;
-    collapsedId: string[];
-};
 export {};