@netless/window-manager 0.3.17-canary.1 → 0.4.0-canary.0

package/src/BoxManager.ts

@@ -1,22 +1,22 @@
-import { callbacks, emitter, WindowManager } from "./index";
-import { debounce, maxBy } from "lodash";
 import { AppAttributes, DEFAULT_COLLECTOR_STYLE, Events, MIN_HEIGHT, MIN_WIDTH } from "./constants";
+import { debounce, maxBy } from "lodash";
 import {
     TELE_BOX_MANAGER_EVENT,
     TELE_BOX_STATE,
     TeleBoxCollector,
     TeleBoxManager,
 } from "@netless/telebox-insider";
-import type { AddAppOptions, AppInitState } from "./index";
+import { WindowManager } from "./index";
+import type { AddAppOptions, AppInitState, EmitterType, CallbacksType } from "./index";
 import type {
     TeleBoxManagerUpdateConfig,
     TeleBoxManagerCreateConfig,
     ReadonlyTeleBox,
     TeleBoxManagerConfig,
     TeleBoxColorScheme,
+    TeleBoxRect,
 } from "@netless/telebox-insider";
 import type Emittery from "emittery";
-import type { AppManager } from "./AppManager";
 import type { NetlessApp } from "./typings";
 import type { View } from "white-web-sdk";
 
@@ -48,27 +48,63 @@ export type CreateTeleBoxManagerConfig = {
     prefersColorScheme?: TeleBoxColorScheme;
 };
 
+export type BoxManagerContext = {
+    safeSetAttributes: (attributes: any) => void;
+    getMainView: () => View;
+    updateAppState: (appId: string, field: AppAttributes, value: any) => void;
+    emitter: EmitterType;
+    callbacks: CallbacksType;
+    canOperate: () => boolean;
+    notifyContainerRectUpdate: (rect: TeleBoxRect) => void;
+    cleanFocus: () => void;
+};
+
+export const createBoxManager = (
+    manager: WindowManager,
+    callbacks: CallbacksType,
+    emitter: EmitterType,
+    options: CreateTeleBoxManagerConfig
+) => {
+    return new BoxManager(
+        {
+            safeSetAttributes: (attributes: any) => manager.safeSetAttributes(attributes),
+            getMainView: () => manager.mainView,
+            updateAppState: (...args) => manager.appManager?.store.updateAppState(...args),
+            canOperate: () => manager.canOperate,
+            notifyContainerRectUpdate: (rect: TeleBoxRect) =>
+                manager.appManager?.notifyContainerRectUpdate(rect),
+            cleanFocus: () => manager.appManager?.store.cleanFocus(),
+            callbacks,
+            emitter,
+        },
+        options
+    );
+};
+
 export class BoxManager {
     public teleBoxManager: TeleBoxManager;
-    public appBoxMap: Map<string, string> = new Map();
-    private mainView = this.manager.mainView;
 
     constructor(
-        private manager: AppManager,
-        createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig
+        private context: BoxManagerContext,
+        private createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig
     ) {
+        const { emitter, callbacks } = context;
         this.teleBoxManager = this.setupBoxManager(createTeleBoxManagerConfig);
         this.teleBoxManager.events.on(TELE_BOX_MANAGER_EVENT.State, state => {
             if (state) {
-                callbacks.emit("boxStateChange", state);
-                emitter.emit("boxStateChange", state);
+                this.context.callbacks.emit("boxStateChange", state);
+                this.context.emitter.emit("boxStateChange", state);
             }
         });
         this.teleBoxManager.events.on("minimized", minimized => {
-            this.manager.safeSetAttributes({ minimized });
+            this.context.safeSetAttributes({ minimized });
+            if (minimized) {
+                this.context.cleanFocus();
+                this.blurAllBox();
+            }
         });
         this.teleBoxManager.events.on("maximized", maximized => {
-            this.manager.safeSetAttributes({ maximized });
+            this.context.safeSetAttributes({ maximized });
         });
         this.teleBoxManager.events.on("removed", boxes => {
             boxes.forEach(box => {
@@ -93,7 +129,7 @@ export class BoxManager {
         );
         this.teleBoxManager.events.on("focused", box => {
             if (box) {
-                if (this.manager.canOperate) {
+                if (this.canOperate) {
                     emitter.emit("focus", { appId: box.id });
                 } else {
                     this.teleBoxManager.blurBox(box.id);
@@ -107,10 +143,19 @@ export class BoxManager {
             callbacks.emit("prefersColorSchemeChange", colorScheme);
         });
         this.teleBoxManager.events.on("z_index", box => {
-            this.manager.store.updateAppState(box.id, AppAttributes.ZIndex, box.zIndex);
+            console.log("on z_index", box.id, box.zIndex);
+            this.context.updateAppState(box.id, AppAttributes.ZIndex, box.zIndex);
         });
     }
 
+    private get mainView() {
+        return this.context.getMainView();
+    }
+
+    private get canOperate() {
+        return this.context.canOperate();
+    }
+
     public get boxState() {
         return this.teleBoxManager.state;
     }
@@ -131,6 +176,10 @@ export class BoxManager {
         return this.teleBoxManager.prefersColorScheme;
     }
 
+    public get boxSize() {
+        return this.teleBoxManager.boxes.length;
+    }
+
     public createBox(params: CreateBoxParams): void {
         if (!this.teleBoxManager) return;
         let { minwidth = MIN_WIDTH, minheight = MIN_HEIGHT } = params.app.config ?? {};
@@ -155,14 +204,14 @@ export class BoxManager {
             id: params.appId,
         };
         this.teleBoxManager.create(createBoxConfig, params.smartPosition);
-        emitter.emit(`${params.appId}${Events.WindowCreated}` as any);
+        this.context.emitter.emit(`${params.appId}${Events.WindowCreated}` as any);
     }
 
     public setBoxInitState(appId: string): void {
         const box = this.teleBoxManager.queryOne({ id: appId });
         if (box) {
             if (box.state === TELE_BOX_STATE.Maximized) {
-                emitter.emit("resize", {
+                this.context.emitter.emit("resize", {
                     appId: appId,
                     x: box.x,
                     y: box.y,
@@ -189,24 +238,30 @@ export class BoxManager {
             fence: false,
             prefersColorScheme: createTeleBoxManagerConfig?.prefersColorScheme,
         };
-        const container = createTeleBoxManagerConfig?.collectorContainer || WindowManager.wrapper;
-        const styles = {
-            ...DEFAULT_COLLECTOR_STYLE,
-            ...createTeleBoxManagerConfig?.collectorStyles,
-        };
-        const teleBoxCollector = new TeleBoxCollector({
-            styles: styles,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        }).mount(container!);
-        initManagerState.collector = teleBoxCollector;
+
         const manager = new TeleBoxManager(initManagerState);
         if (this.teleBoxManager) {
             this.teleBoxManager.destroy();
         }
         this.teleBoxManager = manager;
+        const container = createTeleBoxManagerConfig?.collectorContainer || WindowManager.wrapper;
+        if (container) {
+            this.setCollectorContainer(container);
+        }
         return manager;
     }
 
+    public setCollectorContainer(container: HTMLElement) {
+        const styles = {
+            ...DEFAULT_COLLECTOR_STYLE,
+            ...this.createTeleBoxManagerConfig?.collectorStyles,
+        };
+        const collector = new TeleBoxCollector({
+            styles
+        }).mount(container);
+        this.teleBoxManager.setCollector(collector);
+    }
+
     public getBox(appId: string): ReadonlyTeleBox | undefined {
         return this.teleBoxManager.queryOne({ id: appId });
     }
@@ -245,16 +300,18 @@ export class BoxManager {
                 },
                 true
             );
-            if (state.maximized != null) {
-                this.teleBoxManager.setMaximized(Boolean(state.maximized), true);
-                this.teleBoxManager.setMinimized(Boolean(state.minimized), true);
-            }
             setTimeout(() => {
                 if (state.focus) {
-                    this.teleBoxManager.focusBox(box.id, true)
+                    this.teleBoxManager.focusBox(box.id, true);
+                }
+                if (state.maximized != null) {
+                    this.teleBoxManager.setMaximized(Boolean(state.maximized), true);
+                }
+                if (state.minimized != null) {
+                    this.teleBoxManager.setMinimized(Boolean(state.minimized), true);
                 }
             }, 50);
-            callbacks.emit("boxStateChange", this.teleBoxManager.state);
+            this.context.callbacks.emit("boxStateChange", this.teleBoxManager.state);
         }
     }
 
@@ -263,7 +320,7 @@ export class BoxManager {
         if (rect && rect.width > 0 && rect.height > 0) {
             const containerRect = { x: 0, y: 0, width: rect.width, height: rect.height };
             this.teleBoxManager.setContainerRect(containerRect);
-            this.manager.notifyContainerRectUpdate(this.teleBoxManager.containerRect);
+            this.context.notifyContainerRectUpdate(this.teleBoxManager.containerRect);
         }
     }
 
@@ -303,7 +360,9 @@ export class BoxManager {
     }
 
     public setMaximized(maximized: boolean) {
-        this.teleBoxManager.setMaximized(maximized, true);
+        if (maximized !== this.maximized) {
+            this.teleBoxManager.setMaximized(maximized, true);
+        }
     }
 
     public setMinimized(minimized: boolean, skipUpdate = true) {
@@ -328,6 +387,10 @@ export class BoxManager {
         this.teleBoxManager.setPrefersColorScheme(colorScheme);
     }
 
+    public setZIndex(id: string, zIndex: number, skipUpdate = true) {
+        this.teleBoxManager.update(id, { zIndex }, skipUpdate);
+    }
+
     public destroy() {
         this.teleBoxManager.destroy();
     }

package/src/Cursor/Cursor.ts

@@ -70,13 +70,20 @@ export class Cursor extends Base {
     }
 
     private moveCursor(cursor: Position, rect: DOMRect, view: any) {
-        const { x, y } = cursor;
+        const { x, y, type } = cursor;
         const point = view?.screen.convertPointToScreen(x, y);
         if (point) {
-            const translateX = point.x + rect.x - 2;
-            const translateY = point.y + rect.y - 18;
+            let translateX = point.x - 2;
+            let translateY = point.y - 18;
+            if (type === "app") {
+                const wrapperRect = this.cursorManager.wrapperRect;
+                if (wrapperRect) {
+                    translateX = translateX + rect.x - wrapperRect.x;
+                    translateY = translateY + rect.y - wrapperRect.y;
+                }
+            }
             if (point.x < 0 || point.x > rect.width || point.y < 0 || point.y > rect.height) {
-                this.component?.$set({ visible: false });
+                this.component?.$set({ visible: false, x: translateX, y: translateY });
             } else {
                 this.component?.$set({ visible: true, x: translateX, y: translateY });
             }
@@ -149,7 +156,7 @@ export class Cursor extends Base {
     private async createCursor() {
         if (this.member && this.wrapper) {
             this.component = new App({
-                target: document.documentElement,
+                target: this.wrapper,
                 props: this.initProps(),
             });
         }

package/src/Cursor/index.ts

@@ -31,17 +31,24 @@ export class CursorManager extends Base {
         this.roomMembers = this.appManager.room?.state.roomMembers;
         const wrapper = WindowManager.wrapper;
         if (wrapper) {
-            wrapper.addEventListener("mousemove", this.mouseMoveListener);
-            wrapper.addEventListener("touchstart", this.touchMoveListener);
-            wrapper.addEventListener("touchmove", this.touchMoveListener);
-            wrapper.addEventListener("mouseleave", this.mouseLeaveListener);
-            wrapper.addEventListener("touchend", this.mouseLeaveListener);
-            this.initCursorAttributes();
-            this.wrapperRect = wrapper.getBoundingClientRect();
-            this.startReaction(wrapper);
+          this.setupWrapper(wrapper);
         }
     }
 
+    public setupWrapper(wrapper: HTMLElement) {
+        if (this.manager.refresher?.hasReactor("cursors")) {
+            this.destroy();
+        }
+        wrapper.addEventListener("mousemove", this.mouseMoveListener);
+        wrapper.addEventListener("touchstart", this.touchMoveListener);
+        wrapper.addEventListener("touchmove", this.touchMoveListener);
+        wrapper.addEventListener("mouseleave", this.mouseLeaveListener);
+        wrapper.addEventListener("touchend", this.mouseLeaveListener);
+        this.initCursorAttributes();
+        this.wrapperRect = wrapper.getBoundingClientRect();
+        this.startReaction(wrapper);
+    }
+
     public setMainViewDivElement(div: HTMLDivElement) {
         this.mainViewElement = div;
     }

package/src/ReconnectRefresher.ts

@@ -1,8 +1,8 @@
-import { isFunction } from 'lodash';
-import { RoomPhase } from 'white-web-sdk';
+import { isFunction, debounce } from "lodash";
+import { log } from "./Utils/log";
+import { RoomPhase } from "white-web-sdk";
 import type { Room } from "white-web-sdk";
-import type { AppManager } from './AppManager';
-import { log } from './Utils/log';
+import type { AppManager } from "./AppManager";
 
 // 白板重连之后会刷新所有的对象，导致 listener 失效, 所以这里在重连之后重新对所有对象进行监听
 export class ReconnectRefresher {
@@ -22,9 +22,9 @@ export class ReconnectRefresher {
             this.onReconnected();
         }
         this.phase = phase;
-    }
+    };
 
-    private onReconnected = () => {
+    private onReconnected = debounce(() => {
         log("onReconnected refresh reactors");
         this.releaseDisposers();
         this.reactors.forEach((func, id) => {
@@ -33,14 +33,14 @@ export class ReconnectRefresher {
             }
         });
         this.manager.notifyReconnected();
-    }
+    }, 3000);
 
     private releaseDisposers() {
         this.disposers.forEach(disposer => {
             if (isFunction(disposer)) {
                 disposer();
             }
-        })
+        });
         this.disposers.clear();
     }
 
@@ -64,6 +64,10 @@ export class ReconnectRefresher {
         }
     }
 
+    public hasReactor(id: string) {
+        return this.reactors.has(id);
+    }
+
     public destroy() {
         this.room?.callbacks.off("onPhaseChanged", this.onPhaseChanged);
         this.releaseDisposers();

package/src/Utils/RoomHacker.ts

@@ -1,10 +1,10 @@
-import { emitter } from '../index';
-import { isPlayer } from 'white-web-sdk';
+import { emitter } from "../index";
+import { isPlayer } from "white-web-sdk";
+import type { WindowManager } from '../index';
 import type { Camera, Room , Player , PlayerSeekingResult } from "white-web-sdk";
-import type { AppManager } from "../AppManager";
 
 // 修改多窗口状态下一些失效的方法实现到 manager 的 mainview 上, 降低迁移成本
-export const replaceRoomFunction = (room: Room, manager: AppManager) => {
+export const replaceRoomFunction = (room: Room, manager: WindowManager) => {
     if (isPlayer(room)) {
         const player = room as unknown as Player;
         const originSeek = player.seekToProgressTime;
@@ -30,7 +30,7 @@ export const replaceRoomFunction = (room: Room, manager: AppManager) => {
         });
 
         room.moveCamera = (camera: Camera) => manager.mainView.moveCamera(camera);
-        room.moveCameraToContain = (...args) => manager.mainView.moveCameraToContain(...args);
+        room.moveCameraToContain = (...args) => manager.moveCameraToContain(...args);
         room.convertToPointInWorld = (...args) => manager.mainView.convertToPointInWorld(...args);
         room.setCameraBound = (...args) => manager.mainView.setCameraBound(...args);
         room.scenePreview = (...args) => manager.mainView.scenePreview(...args);

package/src/Utils/error.ts

@@ -1,3 +1,4 @@
+
 export class AppCreateError extends Error {
     override message = "[WindowManager]: app duplicate exists and cannot be created again";
 }
@@ -28,4 +29,8 @@ export class BoxNotCreatedError extends Error {
 
 export class InvalidScenePath extends Error {
     override message = `[WindowManager]: ScenePath should start with "/"`;
-}
+}
+
+export class BoxManagerNotFoundError extends Error {
+    override message = "[WindowManager]: boxManager not found";
+}