@univerjs/slides-ui 0.2.5 → 0.2.8

package/lib/types/controllers/slide-editor-bridge.render-controller.d.ts

@@ -0,0 +1,39 @@
+import { UnitModel, ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IRenderContext, IRenderModule, RichText } from '@univerjs/engine-render';
+import { Subject } from 'rxjs';
+import { ISlideEditorBridgeService } from '../services/slide-editor-bridge.service';
+import { ISlideRichTextProps } from '../type';
+export declare class SlideEditorBridgeRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _instanceSrv;
+    private readonly _commandService;
+    private readonly _editorBridgeService;
+    /**
+     * It is used to distinguish whether the user has actively moved the cursor in the editor, mainly through mouse clicks.
+     */
+    /** If the corresponding unit is active and prepared for editing. */
+    setSlideTextEditor$: Subject<ISlideRichTextProps>;
+    private _curRichText;
+    private _d;
+    constructor(_renderContext: IRenderContext<UnitModel>, _instanceSrv: IUniverInstanceService, _commandService: ICommandService, _editorBridgeService: ISlideEditorBridgeService);
+    private _init;
+    private _disposeCurrent;
+    private _setEditorRect;
+    private _initEventListener;
+    pickOtherObjects(): void;
+    /**
+     * invoked when picking other object.
+     *
+     * save editing state to curr richText.
+     */
+    endEditing(): false | undefined;
+    /**
+     * TODO calling twice ？？？？
+     * editingParam derives from RichText object.
+     *
+     * TODO @lumixraku need scale param
+     * @param target
+     */
+    startEditing(pageId: string, target: RichText): void;
+    setEditorVisible(visible: boolean): void;
+}

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

@@ -1,14 +1,25 @@
-import { Disposable, ICommandService, Injector } from '@univerjs/core';
-import { IUIPartsService } from '@univerjs/ui';
-
+import { DependencyOverride, Disposable, ICommandService, Injector } from '@univerjs/core';
+import { MenuConfig, ComponentManager, IMenuService, IShortcutService, IUIPartsService } from '@univerjs/ui';
+export interface IUniverSlidesDrawingConfig {
+    menu?: MenuConfig;
+    override?: DependencyOverride;
+}
+export declare const DefaultSlidesDrawingConfig: IUniverSlidesDrawingConfig;
 /**
  * This controller registers UI parts of slide workbench to the base-ui workbench.
  */
-export declare class SlideUIController extends Disposable {
-    private readonly _injector;
-    private readonly _uiPartsService;
-    private readonly _commandService;
-    constructor(_injector: Injector, _uiPartsService: IUIPartsService, _commandService: ICommandService);
+export declare class SlidesUIController extends Disposable {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    protected readonly _menuService: IMenuService;
+    protected readonly _componentManager: ComponentManager;
+    protected readonly _uiPartsService: IUIPartsService;
+    protected readonly _commandService: ICommandService;
+    protected readonly _shortcutService: IShortcutService;
+    constructor(_config: Partial<IUniverSlidesDrawingConfig>, _injector: Injector, _menuService: IMenuService, _componentManager: ComponentManager, _uiPartsService: IUIPartsService, _commandService: ICommandService, _shortcutService: IShortcutService);
+    private _initMenus;
+    private _initCustomComponents;
     private _initCommands;
-    private _initUIComponents;
+    protected _initUIComponents(): void;
+    private _initShortcuts;
 }

package/lib/types/controllers/slide.render-controller.d.ts

@@ -0,0 +1,71 @@
+import { IPageElement, ISlidePage, Nullable, UnitModel, Injector, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { BaseObject, IRenderContext, IRenderModule, IRenderManagerService, Scene } from '@univerjs/engine-render';
+import { PageID } from '../type';
+export declare class SlideRenderController extends RxDisposable implements IRenderModule {
+    private readonly _renderContext;
+    private readonly _injector;
+    private readonly _univerInstanceService;
+    private readonly _renderManagerService;
+    private _objectProvider;
+    /**
+     * As a dep of UNIVER_SLIDE, init by RenderManagerService@createRender --> injector.get(dep)
+     * @param _renderContext
+     * @param _injector
+     * @param _univerInstanceService
+     * @param _renderManagerService
+     */
+    constructor(_renderContext: IRenderContext<UnitModel>, _injector: Injector, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService);
+    /**
+     * _initialize --> _create --> _addNewRender
+     */
+    private _addNewRender;
+    private _scrollToCenter;
+    private _currentRender;
+    private _refreshThumb;
+    /**
+     * init --> _addNewRender
+     * @param mainScene
+     */
+    private _createSlide;
+    private _addBackgroundRect;
+    private _getCenterPositionViewPort;
+    private _thumbSceneRender;
+    /**
+     * _createScene by pages, createScene --> set sceneMap
+     * invoked stack: initialize --> _create --> _addNewRender --> _createSlidePages
+     * @param slideDataModel
+     * @param slide
+     */
+    private _createSlidePages;
+    private _createThumb;
+    /**
+     * SlideDataModel is UnitModel
+     */
+    private _getCurrUnitModel;
+    activePage(_pageId?: string): void;
+    createThumbs(): void;
+    /**
+     * _initialize --> _create --> _addNewRender --> _createSlidePages --> page forEach --> createPageScene
+     * _sceneMap.set(pageId, pageScene);
+     *
+     * @param pageId
+     * @param page
+     * @returns pageScene: Scene
+     */
+    createPageScene(pageId: string, page: ISlidePage): Scene | undefined;
+    /**
+     * get pageScene from Slide
+     * pageScene was added to the mainComponent(Slide) in createPageScene --> slide.addPageScene
+     * @param pageId
+     * @returns {Scene, Engine, UnitModel}
+     */
+    getPageRenderUnit(pageId: PageID): {
+        scene: Scene;
+        engine: import('@univerjs/engine-render').Engine;
+        unit: UnitModel<object, number>;
+    };
+    createObjectToPage(element: IPageElement, pageID: PageID): Nullable<BaseObject>;
+    setObjectActiveByPage(obj: BaseObject, pageID: PageID): void;
+    removeObjectById(id: string, pageID: PageID): void;
+    appendPage(): void;
+}

package/lib/types/controllers/text.menu.d.ts

@@ -0,0 +1,4 @@
+import { IAccessor } from '@univerjs/core';
+import { IMenuButtonItem } from '@univerjs/ui';
+export declare const TEXT_ICON_ID = "text-single";
+export declare function SlideAddTextMenuItemFactory(_accessor: IAccessor): IMenuButtonItem;

package/lib/types/index.d.ts

@@ -14,5 +14,21 @@
  * limitations under the License.
  */
 export { UniverSlidesUIPlugin } from './slides-ui-plugin';
+export { SlidesUIController } from './controllers/slide-ui.controller';
+export { SlideSideBar } from './components/slide-bar/SlideBar';
+export { ISlideEditorBridgeService } from './services/slide-editor-bridge.service';
+export { SlideCanvasPopMangerService } from './services/slide-popup-manager.service';
+export type { IUniverSlidesDrawingConfig } from './controllers/slide-ui.controller';
+export { IMAGE_MENU_ID } from './controllers/image.menu';
+export { SHAPE_MENU_ID } from './controllers/shape.menu';
 export { ActivateSlidePageOperation } from './commands/operations/activate.operation';
+export { DeleteSlideElementOperation } from './commands/operations/delete-element.operation';
+export { InsertSlideFloatImageOperation } from './commands/operations/insert-image.operation';
+export { InsertSlideShapeRectangleOperation, InsertSlideShapeRectangleCommand } from './commands/operations/insert-shape.operation';
 export { SetSlidePageThumbOperation } from './commands/operations/set-thumb.operation';
+export { AppendSlideOperation } from './commands/operations/append-slide.operation';
+export { SlideAddTextOperation, SlideAddTextCommand } from './commands/operations/insert-text.operation';
+export { UpdateSlideElementOperation } from './commands/operations/update-element.operation';
+export { SlideEditorContainer } from './views/editor-container/EditorContainer';
+export { SLIDE_EDITOR_ID } from './const';
+export { CanvasView } from './controllers/canvas-view';

package/lib/types/locale/en-US.d.ts

@@ -1,4 +1,3 @@
 import { default as zhCN } from './zh-CN';
-
 declare const locale: typeof zhCN;
 export default locale;

package/lib/types/locale/ru-RU.d.ts

@@ -1,4 +1,3 @@
 import { default as zhCN } from './zh-CN';
-
 declare const locale: typeof zhCN;
 export default locale;

package/lib/types/locale/vi-VN.d.ts

@@ -1,4 +1,3 @@
 import { default as zhCN } from './zh-CN';
-
 declare const locale: typeof zhCN;
 export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -14,9 +14,39 @@
  * limitations under the License.
  */
 declare const locale: {
-    toolbar: {
-        undo: string;
-        redo: string;
+    slide: {
+        append: string;
+        text: {
+            insert: {
+                title: string;
+            };
+        };
+        shape: {
+            insert: {
+                title: string;
+                rectangle: string;
+            };
+        };
+        image: {
+            insert: {
+                title: string;
+                float: string;
+            };
+        };
+        popup: {
+            edit: string;
+            delete: string;
+        };
+        sidebar: {
+            text: string;
+            shape: string;
+            image: string;
+        };
+        panel: {
+            fill: {
+                title: string;
+            };
+        };
     };
 };
 export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -1,4 +1,3 @@
 import { default as zhCN } from './zh-CN';
-
 declare const locale: typeof zhCN;
 export default locale;

package/lib/types/services/slide-editor-bridge.service.d.ts

@@ -0,0 +1,100 @@
+import { IDisposable, IDocumentData, IPosition, Nullable, Disposable, IContextService } from '@univerjs/core';
+import { Engine, IDocumentLayoutObject, RichText, Scene, DeviceInputEventType, IRenderManagerService } from '@univerjs/engine-render';
+import { KeyCode, IEditorService } from '@univerjs/ui';
+import { Observable, Subject } from 'rxjs';
+export declare enum SLIDE_VIEW_KEY {
+    MAIN = "__SLIDERender__",
+    SCENE_VIEWER = "__SLIDEViewer__",
+    SCENE = "__SLIDEScene__",
+    VIEWPORT = "__SLIDEViewPort_"
+}
+export declare const ISlideEditorBridgeService: import('@univerjs/core').IdentifierDecorator<SlideEditorBridgeService>;
+export interface IEditorBridgeServiceParam {
+    unitId: string;
+    /**
+     * pos and size of editing area
+     */
+    position: IPosition;
+    slideCardOffset: {
+        left: number;
+        top: number;
+    };
+    documentLayoutObject: IDocumentLayoutObject;
+    scaleX: number;
+    scaleY: number;
+    editorUnitId: string;
+}
+export interface IEditorBridgeServiceVisibleParam {
+    visible: boolean;
+    eventType: DeviceInputEventType;
+    unitId: string;
+    keycode?: KeyCode;
+}
+export interface ISetEditorInfo {
+    scene: Scene;
+    engine: Engine;
+    unitId: string;
+    pageId: string;
+    richTextObj: RichText;
+}
+export interface ISlideEditorBridgeService {
+    currentEditRectState$: Observable<Nullable<IEditorBridgeServiceParam>>;
+    visible$: Observable<IEditorBridgeServiceVisibleParam>;
+    /**
+     * @deprecated This is a temp solution only for demo purposes. We should have mutations to directly write
+     * content to slides.
+     */
+    endEditing$: Subject<RichText>;
+    dispose(): void;
+    setEditorRect(param: ISetEditorInfo): void;
+    getEditorRect(): ISetEditorInfo;
+    getEditRectState(): Readonly<Nullable<IEditorBridgeServiceParam>>;
+    changeVisible(param: IEditorBridgeServiceVisibleParam): void;
+    changeEditorDirty(dirtyStatus: boolean): void;
+    getEditorDirty(): boolean;
+    isVisible(): boolean;
+    getCurrentEditorId(): Nullable<string>;
+}
+export declare class SlideEditorBridgeService extends Disposable implements ISlideEditorBridgeService, IDisposable {
+    private readonly _editorService;
+    private readonly _contextService;
+    private readonly _renderManagerService;
+    private _editorUnitId;
+    private _isForceKeepVisible;
+    private _editorIsDirty;
+    private _currentEditRectState;
+    private readonly _currentEditRectState$;
+    readonly currentEditRectState$: Observable<Nullable<IEditorBridgeServiceParam>>;
+    private _visibleParam;
+    private readonly _visible$;
+    readonly visible$: Observable<IEditorBridgeServiceVisibleParam>;
+    private readonly _afterVisible$;
+    readonly afterVisible$: Observable<IEditorBridgeServiceVisibleParam>;
+    readonly endEditing$: Subject<RichText>;
+    private _currentEditRectInfo;
+    constructor(_editorService: IEditorService, _contextService: IContextService, _renderManagerService: IRenderManagerService);
+    dispose(): void;
+    getEditorRect(): ISetEditorInfo;
+    /**
+     * 1st part of startEditing.
+     * editorBridgeRenderController@startEditing ---> editorBridgeRenderController@_updateEditor
+     * @editorInfo editorInfo
+     */
+    setEditorRect(editorInfo: ISetEditorInfo): void;
+    changeVisible(param: IEditorBridgeServiceVisibleParam): void;
+    /**
+     * get info from _currentEditRectInfo
+     *
+     * invoked by slide-editing.render-controller.ts@_handleEditorVisible
+     * && this@setEditorRect
+     */
+    getEditRectState(): Readonly<Nullable<IEditorBridgeServiceParam>>;
+    changeEditorDirty(dirtyStatus: boolean): void;
+    isVisible(): boolean;
+    getEditorDirty(): boolean;
+    getCurrentEditorId(): string;
+    /**
+     * @deprecated
+     */
+    genDocData(target: RichText): IDocumentData;
+}

package/lib/types/services/slide-editor-manager.service.d.ts

@@ -0,0 +1,41 @@
+import { IDisposable, IPosition, Nullable } from '@univerjs/core';
+import { Observable } from 'rxjs';
+export interface ICellEditorManagerParam extends Partial<IPosition> {
+    show: boolean;
+}
+export interface ICellEditorBoundingClientRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface ISlideEditorManagerService {
+    state$: Observable<Nullable<ICellEditorManagerParam>>;
+    rect$: Observable<Nullable<ICellEditorBoundingClientRect>>;
+    focus$: Observable<boolean>;
+    dispose(): void;
+    setState(param: ICellEditorManagerParam): void;
+    getState(): Readonly<Nullable<ICellEditorManagerParam>>;
+    setRect(param: ICellEditorBoundingClientRect): void;
+    getRect(): Readonly<Nullable<ICellEditorBoundingClientRect>>;
+    setFocus(param: boolean): void;
+}
+export declare class SlideEditorManagerService implements ISlideEditorManagerService, IDisposable {
+    private _state;
+    private _rect;
+    private readonly _state$;
+    readonly state$: Observable<Nullable<ICellEditorManagerParam>>;
+    private readonly _rect$;
+    readonly rect$: Observable<Nullable<ICellEditorBoundingClientRect>>;
+    private _focus;
+    private readonly _focus$;
+    readonly focus$: Observable<boolean>;
+    dispose(): void;
+    setState(param: ICellEditorManagerParam): void;
+    getRect(): Readonly<Nullable<ICellEditorBoundingClientRect>>;
+    setRect(param: ICellEditorBoundingClientRect): void;
+    getState(): Readonly<Nullable<ICellEditorManagerParam>>;
+    setFocus(param?: boolean): void;
+    private _refresh;
+}
+export declare const ISlideEditorManagerService: import('@univerjs/core').IdentifierDecorator<SlideEditorManagerService>;

package/lib/types/services/slide-popup-manager.service.d.ts

@@ -0,0 +1,21 @@
+import { IDisposable, Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { IRenderManagerService, BaseObject, IBoundRectNoAngle, Scene } from '@univerjs/engine-render';
+import { IPopup, ICanvasPopupService } from '@univerjs/ui';
+export interface ISlideCanvasPopup extends Pick<IPopup, 'direction' | 'excludeOutside' | 'closeOnSelfTarget' | 'componentKey' | 'offset' | 'onClickOutside' | 'hideOnInvisible'> {
+    mask?: boolean;
+    extraProps?: Record<string, any>;
+}
+export declare function transformBound2OffsetBound(originBound: IBoundRectNoAngle, scene: Scene): IBoundRectNoAngle;
+export declare function transformPosition2Offset(x: number, y: number, scene: Scene): {
+    x: number;
+    y: number;
+};
+export declare class SlideCanvasPopMangerService extends Disposable {
+    private readonly _globalPopupManagerService;
+    private readonly _renderManagerService;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    constructor(_globalPopupManagerService: ICanvasPopupService, _renderManagerService: IRenderManagerService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService);
+    private _createObjectPositionObserver;
+    attachPopupToObject(targetObject: BaseObject, popup: ISlideCanvasPopup): IDisposable;
+}

package/lib/types/services/slide-render.service.d.ts

@@ -0,0 +1,16 @@
+import { IContextService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+/**
+ * This controller is responsible for managing units of a specific kind to be rendered on the canvas.
+ */
+export declare class SlideRenderService extends RxDisposable {
+    private readonly _contextService;
+    private readonly _instanceSrv;
+    private readonly _renderManagerService;
+    constructor(_contextService: IContextService, _instanceSrv: IUniverInstanceService, _renderManagerService: IRenderManagerService);
+    private _init;
+    private _initSlideDataListener;
+    private _createRenderer;
+    private _disposeRenderer;
+    private _initContextListener;
+}

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

@@ -1,13 +1,17 @@
 import { Injector, IUniverInstanceService, Plugin, UniverInstanceType } from '@univerjs/core';
-
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IUniverSlidesDrawingConfig } from './controllers/slide-ui.controller';
 export declare const SLIDE_UI_PLUGIN_NAME = "SLIDE_UI";
 export declare class UniverSlidesUIPlugin extends Plugin {
+    private readonly _config;
     readonly _injector: Injector;
+    private readonly _renderManagerService;
     private readonly _univerInstanceService;
     static pluginName: string;
     static type: UniverInstanceType;
-    constructor(_config: unknown, _injector: Injector, _univerInstanceService: IUniverInstanceService);
-    onStarting(injector: Injector): void;
+    constructor(_config: Partial<IUniverSlidesDrawingConfig>, _injector: Injector, _renderManagerService: IRenderManagerService, _univerInstanceService: IUniverInstanceService);
+    onStarting(): void;
+    onReady(): void;
     onRendered(): void;
     private _markSlideAsFocused;
 }

package/lib/types/type.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 ISlideRichTextProps {
+    /**
+     * top offset value of PPT card area(px).
+     */
+    top: number;
+    /**
+     * left offset value of PPT card area(px).
+     */
+    left: number;
+    width: number;
+    height: number;
+    scaleX: number;
+    scaleY: number;
+    text: string;
+    fs: number;
+}
+export declare enum CursorChange {
+    InitialState = 0,
+    StartEditor = 1,
+    CursorChange = 2
+}
+export type PageID = string;

package/lib/types/views/editor-container/EditorContainer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface ICellIEditorProps {
+}
+/**
+ * Floating editor's container.
+ * @returns
+ */
+export declare const SlideEditorContainer: React.FC<ICellIEditorProps>;
+export {};

package/lib/types/views/editor-container/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 * from './EditorContainer';