@netless/window-manager 0.3.4 → 0.3.5-canary.0

package/dist/typings.d.ts

@@ -56,6 +56,7 @@ export declare type RegisterEvents<SetupResult = any> = {
         result: SetupResult;
     };
     destroy: RegisterEventData;
+    focus: RegisterEventData;
 };
 export declare type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any> = {
     kind: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netless/window-manager",
-  "version": "0.3.4",
+  "version": "0.3.5-canary.0",
   "description": "",
   "main": "dist/index.es.js",
   "module": "dist/index.es.js",

package/src/AppContext.ts

@@ -102,7 +102,7 @@ export class AppContext<TAttrs extends Record<string, any>, AppOptions = any> {
     public async setScenePath(scenePath: string): Promise<void> {
         if (!this.appProxy.box) return;
         this.appProxy.setFullPath(scenePath);
-        this.manager.viewManager.switchAppToWriter(this.appId);
+        this.appProxy.context.switchAppToWriter(this.appId);
     }
 
     public mountView(dom: HTMLDivElement): void {

package/src/AppListener.ts

@@ -28,10 +28,6 @@ export class AppListeners {
                     this.appResizeHandler(data.payload);
                     break;
                 }
-                case Events.AppBoxStateChange: {
-                    this.appBoxStateHandler(data.payload);
-                    break;
-                }
                 case Events.SwitchViewsToFreedom: {
                     this.switchViewsToFreedomHandler();
                     break;
@@ -51,10 +47,6 @@ export class AppListeners {
         this.manager.room?.refreshViewSize();
     };
 
-    private appBoxStateHandler = (payload: any) => {
-        this.boxManager.setBoxState(payload.state);
-    };
-
     private switchViewsToFreedomHandler = () => {
         this.manager.viewManager.freedomAllViews();
     };

package/src/AppManager.ts

@@ -1,31 +1,20 @@
-import {
-    AppAttributes,
-    AppStatus,
-    Events,
-    MagixEventName
-    } from './constants';
-import { AppListeners } from './AppListener';
-import { AppProxy } from './AppProxy';
-import { AttributesDelegate } from './AttributesDelegate';
-import { BoxManager, TELE_BOX_STATE } from './BoxManager';
-import { callbacks, emitter } from './index';
-import { CameraStore } from './Utils/CameraStore';
-import { genAppId, makeValidScenePath, setScenePath } from './Utils/Common';
-import {
-    autorun,
-    isPlayer,
-    isRoom,
-    ScenePathType,
-    ViewVisionMode
-    } from 'white-web-sdk';
-import { log } from './Utils/log';
-import { MainViewProxy } from './MainView';
-import { onObjectInserted, onObjectRemoved } from './Utils/Reactive';
-import { ReconnectRefresher } from './ReconnectRefresher';
-import { ViewManager } from './ViewManager';
+import { AppAttributes, AppStatus, Events, MagixEventName } from "./constants";
+import { AppListeners } from "./AppListener";
+import { AppProxy } from "./AppProxy";
+import { AttributesDelegate } from "./AttributesDelegate";
+import { BoxManager, TELE_BOX_STATE } from "./BoxManager";
+import { callbacks, emitter } from "./index";
+import { CameraStore } from "./Utils/CameraStore";
+import { genAppId, makeValidScenePath, setScenePath } from "./Utils/Common";
+import { autorun, isPlayer, isRoom, ScenePathType, ViewVisionMode } from "white-web-sdk";
+import { log } from "./Utils/log";
+import { MainViewProxy } from "./MainView";
+import { onObjectInserted, onObjectRemoved } from "./Utils/Reactive";
+import { ReconnectRefresher } from "./ReconnectRefresher";
+import { ViewManager } from "./ViewManager";
 import type { Displayer, DisplayerState, Room } from "white-web-sdk";
 import type { CreateCollectorConfig } from "./BoxManager";
-import type { AddAppParams, BaseInsertParams, WindowManager , TeleBoxRect } from "./index";
+import type { AddAppParams, BaseInsertParams, WindowManager, TeleBoxRect } from "./index";
 export class AppManager {
     public displayer: Displayer;
     public boxManager: BoxManager;
@@ -39,7 +28,6 @@ export class AppManager {
 
     private appListeners: AppListeners;
 
-
     constructor(public windowManger: WindowManager, options: CreateCollectorConfig) {
         this.displayer = windowManger.displayer;
         this.cameraStore = new CameraStore();
@@ -78,24 +66,30 @@ export class AppManager {
             });
         });
         this.refresher?.add("maximized", () => {
-            return autorun(
-                () => {
-                    const maximized = this.attributes.maximized;
-                    if (this.boxManager.maximized !== maximized) {
-                        this.boxManager.setMaximized(Boolean(maximized));
+            return autorun(() => {
+                const maximized = this.attributes.maximized;
+                if (this.boxManager.maximized !== maximized) {
+                    if (maximized === true && this.boxManager.minimized === false) {
+                        const topBox = this.boxManager.getTopBox();
+                        if (topBox) {
+                            emitter.emit("focus", { appId: topBox.id });
+                        }
                     }
+                    this.boxManager.setMaximized(Boolean(maximized));
                 }
-            )
+            });
         });
         this.refresher?.add("minimized", () => {
-            return autorun(
-                () => {
-                    const minimized = this.attributes.minimized;
-                    if (this.boxManager.minimized !== minimized) {
-                        this.boxManager.setMinimized(Boolean(minimized));
+            return autorun(() => {
+                const minimized = this.attributes.minimized;
+                if (this.boxManager.minimized !== minimized) {
+                    if (minimized === true) {
+                        this.store.cleanFocus();
+                        this.boxManager.blurFocusBox();
                     }
+                    this.boxManager.setMinimized(Boolean(minimized));
                 }
-            )
+            });
         });
         if (!this.attributes.apps || Object.keys(this.attributes.apps).length === 0) {
             const mainScenePath = this.store.getMainViewScenePath();
@@ -142,7 +136,7 @@ export class AppManager {
                 appProxy.destroy(true, false);
             }
         });
-    }
+    };
 
     public bindMainView(divElement: HTMLDivElement, disableCameraTransform: boolean) {
         const mainView = this.mainViewProxy.view;
@@ -151,10 +145,7 @@ export class AppManager {
         if (!mainView.focusScenePath) {
             this.store.setMainViewFocusPath();
         }
-        if (
-            this.store.focus === undefined &&
-            mainView.mode !== ViewVisionMode.Writable
-        ) {
+        if (this.store.focus === undefined && mainView.mode !== ViewVisionMode.Writable) {
             this.viewManager.switchMainViewToWriter();
         }
         this.mainViewProxy.addMainViewListener();
@@ -172,16 +163,16 @@ export class AppManager {
     private async beforeAddApp(params: AddAppParams, isDynamicPPT: boolean) {
         const appId = await genAppId(params.kind);
         this.appStatus.set(appId, AppStatus.StartCreate);
+        const attrs = params.attributes ?? {};
+        this.safeUpdateAttributes([appId], attrs);
         this.store.setupAppAttributes(params, appId, isDynamicPPT);
-        if (this.boxManager.boxState === TELE_BOX_STATE.Minimized) {
-            this.boxManager.setBoxState(TELE_BOX_STATE.Normal);
+        if (this.boxManager.minimized) {
+            this.boxManager.setMinimized(false);
         }
-        const needFocus = this.boxManager.boxState !== TELE_BOX_STATE.Minimized;
+        const needFocus = !this.boxManager.minimized;
         if (needFocus) {
             this.store.setAppFocus(appId, true);
         }
-        const attrs = params.attributes ?? {};
-        this.safeUpdateAttributes([appId], attrs);
         return { appId, needFocus };
     }
 
@@ -243,7 +234,7 @@ export class AppManager {
             appProxy.appEmitter.emit("roomStateChange", state);
         });
         emitter.emit("observerIdChange", this.displayer.observerId);
-    }
+    };
 
     private displayerWritableListener = (isReadonly: boolean) => {
         const isWritable = !isReadonly;
@@ -265,7 +256,7 @@ export class AppManager {
         } else {
             this.mainView.disableCameraTransform = true;
         }
-    }
+    };
 
     private get eventName() {
         return isRoom(this.displayer) ? "onRoomStateChanged" : "onPlayerStateChanged";
@@ -359,10 +350,6 @@ export class AppManager {
                 this.windowManger.safeSetAttributes({ focus: payload.appId });
                 break;
             }
-            case "blur": {
-                this.dispatchInternalEvent(Events.AppBlur, payload);
-                break;
-            }
             case "resize": {
                 if (payload.width && payload.height) {
                     this.dispatchInternalEvent(Events.AppResize, payload);
@@ -373,44 +360,6 @@ export class AppManager {
                 }
                 break;
             }
-            case TELE_BOX_STATE.Minimized: {
-                this.safeDispatchMagixEvent(MagixEventName, {
-                    eventName: Events.AppBoxStateChange,
-                    payload: {
-                        ...payload,
-                        state: eventName,
-                    },
-                });
-
-                this.store.cleanFocus();
-                this.boxManager.blurFocusBox();
-                break;
-            }
-            case TELE_BOX_STATE.Maximized: {
-                this.safeDispatchMagixEvent(MagixEventName, {
-                    eventName: Events.AppBoxStateChange,
-                    payload: {
-                        ...payload,
-                        state: eventName,
-                    },
-                });
-                const topBox = this.boxManager.getTopBox();
-                if (topBox) {
-                    emitter.emit("focus", { appId: topBox.id });
-                }
-                break;
-            }
-            case TELE_BOX_STATE.Normal: {
-                this.safeDispatchMagixEvent(MagixEventName, {
-                    eventName: Events.AppBoxStateChange,
-                    payload: {
-                        ...payload,
-                        state: eventName,
-                    },
-                });
-                this.safeSetAttributes({ boxState: eventName });
-                break;
-            }
             case "close": {
                 const appProxy = this.appProxies.get(payload.appId);
                 if (appProxy) {

package/src/AppProxy.ts

@@ -211,6 +211,7 @@ export class AppProxy extends Base {
     }
 
     public switchToWritable() {
+        appRegister.notifyApp(this.kind, "focus", { appId: this.id });
         this.cameraStore.switchView(this.id, this.view, () => {
             if (this.view) {
                 if (this.view.mode === ViewVisionMode.Writable) return;

package/src/Base/Context.ts

@@ -1,4 +1,3 @@
-import { memoize } from "lodash";
 import { emitter } from "../index";
 import type { AppManager } from "../AppManager";
 
@@ -27,10 +26,6 @@ export class Context {
         return roomMembers?.find(member => member.payload?.uid === uid);
     }
 
-    public memoizeFindMember = memoize(this.findMember);
-
-    public memoizeFindMemberByUid = memoize(this.findMemberByUid);
-
     public updateManagerRect() {
         this.manager.boxManager.updateManagerRect();
     }

package/src/BoxManager.ts

@@ -225,9 +225,6 @@ export class BoxManager {
                 this.teleBoxManager.setMaximized(Boolean(state.maximized), true);
                 this.teleBoxManager.setMinimized(Boolean(state.minimized), true);
             } 
-            if (state.boxState) {
-                this.teleBoxManager.setState(state.boxState, true);
-            }
             setTimeout(() => {
                 if (state.focus) {
                     this.teleBoxManager.update(box.id, { focus: true }, true);
@@ -289,11 +286,6 @@ export class BoxManager {
         this.teleBoxManager.updateAll(config);
     }
 
-    public setBoxState(state: TELE_BOX_STATE): void {
-        this.teleBoxManager.setState(state, true);
-        callbacks.emit("boxStateChange", state);
-    }
-
     public setMaximized(maximized: boolean) {
         this.teleBoxManager.setMaximized(maximized, true);
     }

package/src/Cursor/Cursor.ts

@@ -36,7 +36,7 @@ export class Cursor extends Base {
         pRetry(() => {
             this.disposer && this.disposer();
             if (!this.cursorPosition) {
-                throw new Error();
+                console.warn(`${memberId} not exist`);
             }
             this.startReaction();
         }, { retries: 3 });
@@ -180,8 +180,8 @@ export class Cursor extends Base {
     }
 
     public setMember() {
-        this.member = this.context.memoizeFindMemberByUid(this.memberId);
-        this.component?.$set(omit(this.initProps(), ["x", "y", "visible"]));
+        this.member = this.context.findMemberByUid(this.memberId);
+        this.component?.$set(omit(this.initProps(), ["x", "y"]));
     }
 
     public destroy() {

package/src/Cursor/index.ts

@@ -1,7 +1,7 @@
 import { Base } from '../Base';
 import { Cursor } from './Cursor';
 import { CursorState } from '../constants';
-import { debounce } from 'lodash';
+import { compact, debounce, uniq } from 'lodash';
 import { Fields } from '../AttributesDelegate';
 import { onObjectInserted } from '../Utils/Reactive';
 import { WindowManager } from '../index';
@@ -54,8 +54,12 @@ export class CursorManager extends Base {
         })
     }
 
+    private getUids = (members: readonly RoomMember[] | undefined) => {
+        return compact(uniq(members?.map(member => member.payload?.uid)));
+    }
+
     private handleRoomMembersChange = debounce((wrapper: HTMLElement) => {
-        const uids = this.roomMembers?.map(member => member.payload?.uid);
+        const uids = this.getUids(this.roomMembers);
         const cursors = Object.keys(this.cursors);
         if (uids?.length) {
             cursors.map(uid => {
@@ -199,14 +203,15 @@ export class CursorManager extends Base {
     }
 
     public cleanMemberAttributes(members: readonly RoomMember[]) {
-        const uids = members.map(member => member.payload?.uid);
-        const needDeleteIds = [];
-        for (const uid in this.cursors) {
-            const index = uids.findIndex(id => id === uid);
+        const uids = this.getUids(members);
+        const needDeleteIds: string[] = [];
+        const cursors = Object.keys(this.cursors);
+        cursors.map(cursorId => {
+            const index = uids.findIndex(id => id === cursorId);
             if (index === -1) {
-                needDeleteIds.push(uid);
+                needDeleteIds.push(cursorId);
             }
-        }
+        });
         needDeleteIds.forEach(uid => {
             const instance = this.cursorInstances.get(uid);
             if (instance) {

package/src/index.ts

@@ -170,7 +170,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> {
     public static containerSizeRatio = DEFAULT_CONTAINER_RATIO;
     private static isCreated = false;
 
-    public version = "0.3.4";
+    public version = "0.3.5-canary.0";
 
     public appListeners?: AppListeners;
 
@@ -384,7 +384,8 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> {
                 if (!isValidScenePath(scenePath)) {
                     throw new InvalidScenePath();
                 }
-                for (const appId in this.apps) {
+                const apps = Object.keys(this.apps || {});
+                for (const appId of apps) {
                     const appScenePath = appManager.store.getAppScenePath(appId);
                     if (appScenePath && appScenePath === scenePath) {
                         console.warn(`[WindowManager]: ScenePath ${scenePath} Already opened`);

package/src/typings.ts

@@ -59,6 +59,7 @@ export type RegisterEventData = {
 export type RegisterEvents<SetupResult = any> = {
     created: RegisterEventData & { result: SetupResult; };
     destroy: RegisterEventData;
+    focus: RegisterEventData;
 };
 
 export type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any> = {

package/src/viewManager.ts

@@ -104,7 +104,7 @@ export class ViewManager extends Base {
         });
         if (this.mainView.mode === ViewVisionMode.Writable) {
             notifyMainViewModeChange(callbacks, ViewVisionMode.Freedom);
-            this.mainView.mode = ViewVisionMode.Freedom;
+            setViewMode(this.mainView, ViewVisionMode.Freedom);
         }
         if (!this.mainView.focusScenePath) {
             this.store.setMainViewFocusPath();