@netless/window-manager 0.4.0-canary.2 → 0.4.0-canary.23

package/src/Cursor/index.ts

@@ -1,13 +1,10 @@
-import { autorun } from "white-web-sdk";
-import { Base } from "../Base";
-import { compact, debounce, get, uniq } from "lodash";
+import { throttle } from "lodash";
 import { Cursor } from "./Cursor";
-import { CursorState } from "../constants";
+import { CursorState, Events } from "../constants";
 import { emitter, WindowManager } from "../index";
-import { Fields } from "../AttributesDelegate";
-import { onObjectInserted } from "../Utils/Reactive";
 import { SideEffectManager } from "side-effect-manager";
-import type { PositionType, Position } from "../AttributesDelegate";
+import type { CursorMovePayload } from "../index";
+import type { PositionType } from "../AttributesDelegate";
 import type { Point, RoomMember, View } from "white-web-sdk";
 import type { AppManager } from "../AppManager";
 
@@ -21,30 +18,42 @@ export type MoveCursorParams = {
     x: number;
     y: number;
 };
-export class CursorManager extends Base {
+export class CursorManager {
     public containerRect?: DOMRect;
     public wrapperRect?: DOMRect;
     public cursorInstances: Map<string, Cursor> = new Map();
     public roomMembers?: readonly RoomMember[];
     private mainViewElement?: HTMLDivElement;
     private sideEffectManager = new SideEffectManager();
+    private store = this.manager.store;
 
-    constructor(private appManager: AppManager) {
-        super(appManager);
-        this.roomMembers = this.appManager.room?.state.roomMembers;
+    constructor(private manager: AppManager) {
+        this.roomMembers = this.manager.room?.state.roomMembers;
         const wrapper = WindowManager.wrapper;
         if (wrapper) {
             this.setupWrapper(wrapper);
         }
-        emitter.on("onReconnected", () => {
-            this.onReconnect();
+        emitter.on("cursorMove", payload => {
+            let cursorInstance = this.cursorInstances.get(payload.uid);
+            if (!cursorInstance) {
+                cursorInstance = new Cursor(this.manager, payload.uid, this, WindowManager.wrapper);
+                this.cursorInstances.set(payload.uid, cursorInstance);
+            }
+            if (payload.state === CursorState.Leave) {
+                cursorInstance.leave();
+            } else {
+                cursorInstance.move(payload.position);
+            }
         });
+        this.sideEffectManager.add(() => {
+            const unsubscribe = emitter.on("playgroundSizeChange", () => {
+                this.updateContainerRect();
+            });
+            return unsubscribe;
+        })
     }
 
     public setupWrapper(wrapper: HTMLElement) {
-        if (this.manager.refresher?.hasReactor("cursors")) {
-            this.destroy();
-        }
         this.sideEffectManager.add(() => {
             wrapper.addEventListener("pointerenter", this.mouseMoveListener);
             wrapper.addEventListener("pointermove", this.mouseMoveListener);
@@ -56,77 +65,38 @@ export class CursorManager extends Base {
             };
         });
 
-        this.initCursorAttributes();
         this.wrapperRect = wrapper.getBoundingClientRect();
-        this.startReaction(wrapper);
     }
 
     public setMainViewDivElement(div: HTMLDivElement) {
         this.mainViewElement = div;
     }
 
-    private startReaction(wrapper: HTMLElement) {
-        this.manager.refresher?.add("cursors", () => {
-            return onObjectInserted(this.cursors, () => {
-                this.handleRoomMembersChange(wrapper);
-            });
-        });
-    }
-
-    private getUids = (members: readonly RoomMember[] | undefined) => {
-        return compact(uniq(members?.map(member => member.payload?.uid)));
-    };
-
-    private handleRoomMembersChange = debounce((wrapper: HTMLElement) => {
-        const uids = this.getUids(this.roomMembers);
-        const cursors = Object.keys(this.cursors);
-        if (uids?.length) {
-            cursors.map(uid => {
-                if (uids.includes(uid) && !this.cursorInstances.has(uid)) {
-                    if (uid === this.context.uid) {
-                        return;
-                    }
-                    const component = new Cursor(
-                        this.appManager,
-                        this.addCursorChangeListener,
-                        this.cursors,
-                        uid,
-                        this,
-                        wrapper
-                    );
-                    this.cursorInstances.set(uid, component);
-                }
-            });
-        }
-    }, 100);
-
-    public get cursors() {
-        return this.manager.attributes?.[Fields.Cursors];
-    }
-
     public get boxState() {
         return this.store.getBoxState();
     }
 
     public get focusView() {
-        return this.appManager.focusApp?.view;
+        return this.manager.focusApp?.view;
     }
 
-    private mouseMoveListener = debounce((event: MouseEvent) => {
+    private mouseMoveListener = throttle((event: MouseEvent) => {
         this.updateCursor(this.getType(event), event.clientX, event.clientY);
-    }, 5);
+    }, 16);
 
     private updateCursor(event: EventType, clientX: number, clientY: number) {
         if (this.wrapperRect && this.manager.canOperate) {
-            const view = event.type === "main" ? this.appManager.mainView : this.focusView;
+            const view = event.type === "main" ? this.manager.mainView : this.focusView;
             const point = this.getPoint(view, clientX, clientY);
             if (point) {
-                this.setNormalCursorState();
-                this.store.updateCursor(this.context.uid, {
-                    x: point.x,
-                    y: point.y,
-                    ...event,
-                });
+                this.manager.dispatchInternalEvent(Events.CursorMove, {
+                    uid: this.manager.uid,
+                    position: {
+                        x: point.x,
+                        y: point.y,
+                        type: event.type,
+                    },
+                } as CursorMovePayload);
             }
         }
     }
@@ -151,7 +121,7 @@ export class CursorManager extends Base {
      */
     private getType = (event: MouseEvent | Touch): EventType => {
         const target = event.target as HTMLElement;
-        const focusApp = this.appManager.focusApp;
+        const focusApp = this.manager.focusApp;
         switch (target.parentElement) {
             case this.mainViewElement: {
                 return { type: "main" };
@@ -165,25 +135,8 @@ export class CursorManager extends Base {
         }
     };
 
-    private initCursorAttributes() {
-        this.store.updateCursor(this.context.uid, {
-            x: 0,
-            y: 0,
-            type: "main",
-        });
-        this.store.updateCursorState(this.context.uid, CursorState.Leave);
-    }
-
-    private setNormalCursorState() {
-        const cursorState = this.store.getCursorState(this.context.uid);
-        if (cursorState !== CursorState.Normal) {
-            this.store.updateCursorState(this.context.uid, CursorState.Normal);
-        }
-    }
-
     private mouseLeaveListener = () => {
-        this.hideCursor(this.context.uid);
-        this.store.updateCursorState(this.context.uid, CursorState.Leave);
+        this.hideCursor(this.manager.uid);
     };
 
     public updateContainerRect() {
@@ -191,16 +144,6 @@ export class CursorManager extends Base {
         this.wrapperRect = WindowManager.wrapper?.getBoundingClientRect();
     }
 
-    public setRoomMembers(members: readonly RoomMember[]) {
-        this.roomMembers = members;
-        this.cursorInstances.forEach(cursor => {
-            cursor.setMember();
-        });
-        if (WindowManager.wrapper) {
-            this.handleRoomMembersChange(WindowManager.wrapper);
-        }
-    }
-
     public deleteCursor(uid: string) {
         this.store.cleanCursor(uid);
         const cursor = this.cursorInstances.get(uid);
@@ -216,48 +159,6 @@ export class CursorManager extends Base {
         }
     }
 
-    public cleanMemberAttributes(members: readonly RoomMember[]) {
-        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(cursorId);
-            }
-        });
-        needDeleteIds.forEach(uid => {
-            this.deleteCursor(uid);
-        });
-    }
-
-    public onReconnect() {
-        if (this.cursorInstances.size) {
-            this.cursorInstances.forEach(cursor => cursor.destroy());
-            this.cursorInstances.clear();
-        }
-        this.roomMembers = this.appManager.room?.state.roomMembers;
-        if (WindowManager.wrapper) {
-            this.handleRoomMembersChange(WindowManager.wrapper);
-        }
-    }
-
-    public addCursorChangeListener = (
-        uid: string,
-        callback: (position: Position, state: CursorState) => void
-    ) => {
-        this.manager.refresher?.add(uid, () => {
-            const disposer = autorun(() => {
-                const position = get(this.cursors, [uid, Fields.Position]);
-                const state = get(this.cursors, [uid, Fields.CursorState]);
-                if (position) {
-                    callback(position, state);
-                }
-            });
-            return disposer;
-        });
-    };
-
     public destroy() {
         this.sideEffectManager.flushAll();
         if (this.cursorInstances.size) {
@@ -266,6 +167,5 @@ export class CursorManager extends Base {
             });
             this.cursorInstances.clear();
         }
-        this.manager.refresher?.remove("cursors");
     }
 }

package/src/Helper.ts

@@ -0,0 +1,30 @@
+import { WindowManager } from "./index";
+
+export const setupWrapper = (
+    root: HTMLElement
+): {
+    playground: HTMLDivElement;
+    wrapper: HTMLDivElement;
+    sizer: HTMLDivElement;
+    mainViewElement: HTMLDivElement;
+} => {
+    const playground = document.createElement("div");
+    playground.className = "netless-window-manager-playground";
+
+    const sizer = document.createElement("div");
+    sizer.className = "netless-window-manager-sizer";
+
+    const wrapper = document.createElement("div");
+    wrapper.className = "netless-window-manager-wrapper";
+
+    const mainViewElement = document.createElement("div");
+    mainViewElement.className = "netless-window-manager-main-view";
+
+    playground.appendChild(sizer);
+    sizer.appendChild(wrapper);
+    wrapper.appendChild(mainViewElement);
+    root.appendChild(playground);
+    WindowManager.wrapper = wrapper;
+
+    return { playground, wrapper, sizer, mainViewElement };
+};

package/src/ReconnectRefresher.ts

@@ -1,5 +1,4 @@
 import { debounce, isFunction } from "lodash";
-import { emitter } from "./index";
 import { log } from "./Utils/log";
 import { RoomPhase } from "white-web-sdk";
 import type { Room } from "white-web-sdk";
@@ -85,7 +84,3 @@ export class ReconnectRefresher {
         this.releaseDisposers();
     }
 }
-
-export const reconnectRefresher = new ReconnectRefresher({
-    emitter: emitter,
-});

package/src/Register/index.ts

@@ -10,34 +10,39 @@ class AppRegister {
 
     public async register(params: RegisterParams): Promise<void> {
         this.registered.set(params.kind, params);
-        
-        const srcOrAppOrFunction = params.src
-        let downloadApp: () => Promise<NetlessApp>
-        
+
+        const srcOrAppOrFunction = params.src;
+        let downloadApp: () => Promise<NetlessApp>;
+
         if (typeof srcOrAppOrFunction === "string") {
             downloadApp = async () => {
-                const appClass = await loadApp(srcOrAppOrFunction, params.kind);
+                let appClass = (await loadApp(srcOrAppOrFunction, params.kind)) as any;
                 if (appClass) {
-                    return appClass
+                    if (appClass.__esModule) {
+                        appClass = appClass.default;
+                    }
+                    return appClass;
                 } else {
-                    throw new Error(`[WindowManager]: load remote script failed, ${srcOrAppOrFunction}`);
+                    throw new Error(
+                        `[WindowManager]: load remote script failed, ${srcOrAppOrFunction}`
+                    );
                 }
-            }
+            };
         } else if (typeof srcOrAppOrFunction === "function") {
-            downloadApp = srcOrAppOrFunction
+            downloadApp = srcOrAppOrFunction;
         } else {
-            downloadApp = async () => srcOrAppOrFunction
+            downloadApp = async () => srcOrAppOrFunction;
         }
 
         this.appClasses.set(params.kind, async () => {
-            let app = this.appClassesCache.get(params.kind)
+            let app = this.appClassesCache.get(params.kind);
             if (!app) {
-                app = downloadApp()
-                this.appClassesCache.set(params.kind, app)
+                app = downloadApp();
+                this.appClassesCache.set(params.kind, app);
             }
-            return app
+            return app;
         });
-        
+
         if (params.addHooks) {
             const emitter = this.createKindEmitter(params.kind);
             if (emitter) {
@@ -46,7 +51,11 @@ class AppRegister {
         }
     }
 
-    public async notifyApp<T extends keyof RegisterEvents>(kind: string, event: T, payload: RegisterEvents[T]) {
+    public async notifyApp<T extends keyof RegisterEvents>(
+        kind: string,
+        event: T,
+        payload: RegisterEvents[T]
+    ) {
         const emitter = this.kindEmitters.get(kind);
         await emitter?.emit(event, payload);
     }

package/src/Register/loader.ts

@@ -8,7 +8,7 @@ const TIMEOUT = 10000; // 10 秒超时
 export const getScript = async (url: string): Promise<string> => {
     const item = await getItem(url);
     if (item) {
-        return item;
+        return item.sourceCode;
     } else {
         const result = await fetchWithTimeout(url, { timeout: TIMEOUT });
         const text = await result.text();
@@ -18,7 +18,7 @@ export const getScript = async (url: string): Promise<string> => {
 };
 
 export const executeScript = (text: string, appName: string): NetlessApp => {
-    let result = Function(text + `;return ${appName}`)();
+    let result = Function(text + `\n;return ${appName}`)();
     if (typeof result === "undefined") {
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore

package/src/Register/storage.ts

@@ -3,6 +3,11 @@ const DatabaseName = "__WindowManagerAppCache";
 let db: IDBDatabase;
 let store: IDBObjectStore;
 
+export type Item = {
+    kind: string;
+    sourceCode: string;
+}
+
 export const initDb = async () => {
     db = await createDb();
 }
@@ -12,7 +17,7 @@ export const setItem = (key: string, val: any) => {
     return addRecord(db, { kind: key, sourceCode: val })
 };
 
-export const getItem = async (key: string): Promise<string | null> => {
+export const getItem = async (key: string): Promise<Item | null> => {
     if (!db) return null;
     return await query(db, key);
 };

package/src/Utils/Common.ts

@@ -1,7 +1,8 @@
-import { appRegister } from '../Register';
-import { debounce } from 'lodash';
-import { emitter } from '../index';
-import { v4 } from 'uuid';
+import { appRegister } from "../Register";
+import { debounce } from "lodash";
+import { emitter } from "../index";
+import { ScenePathType } from "white-web-sdk";
+import { v4 } from "uuid";
 import type { PublicEvent } from "../index";
 import type { Displayer, ViewVisionMode, Room, View } from "white-web-sdk";
 import type Emittery from "emittery";
@@ -17,6 +18,14 @@ export const genAppId = async (kind: string) => {
 export const setViewFocusScenePath = (view: View, focusScenePath: string) => {
     if (view.focusScenePath !== focusScenePath) {
         view.focusScenePath = focusScenePath;
+        return view;
+    }
+};
+
+export const setViewSceneIndex = (view: View, index: number) => {
+    if (view.focusSceneIndex !== index) {
+        view.focusSceneIndex = index;
+        return view;
     }
 };
 
@@ -26,7 +35,30 @@ export const setScenePath = (room: Room | undefined, scenePath: string) => {
             room.setScenePath(scenePath);
         }
     }
-}
+};
+
+export const getScenePath = (
+    room: Room | undefined,
+    dir: string | undefined,
+    index: number
+): string | undefined => {
+    if (room && dir) {
+        const scenes = entireScenes(room);
+        const scene = scenes[dir]?.[index];
+        if (scene) {
+            return `${dir}/${scene.name}`;
+        }
+    }
+};
+
+export const removeScenes = (room: Room | undefined, scenePath: string) => {
+    if (room) {
+        const type = room.scenePathType(scenePath);
+        if (type !== ScenePathType.None) {
+            room.removeScenes(scenePath);
+        }
+    }
+};
 
 export const setViewMode = (view: View, mode: ViewVisionMode) => {
     if (!(view as any).didRelease && view.mode !== mode) {
@@ -44,7 +76,7 @@ export const emitError = (error: Error) => {
 
 export const addEmitterOnceListener = (event: any, listener: any) => {
     emitter.once(event).then(listener);
-}
+};
 
 export const notifyMainViewModeChange = debounce(
     (callbacks: Emittery<PublicEvent>, mode: ViewVisionMode) => {
@@ -53,9 +85,12 @@ export const notifyMainViewModeChange = debounce(
     200
 );
 
-export const makeValidScenePath = (displayer: Displayer, scenePath: string) => {
-    const scenes = displayer.entireScenes()[scenePath];
-    const firstSceneName = scenes[0].name;
+export const makeValidScenePath = (displayer: Displayer, scenePath: string, index = 0) => {
+    const scenes = entireScenes(displayer)[scenePath];
+    if (!scenes) return;
+    const scene = scenes[index];
+    if (!scene) return;
+    const firstSceneName = scene.name;
     if (scenePath === "/") {
         return `/${firstSceneName}`;
     } else {
@@ -63,9 +98,24 @@ export const makeValidScenePath = (displayer: Displayer, scenePath: string) => {
     }
 };
 
+export const entireScenes = (displayer: Displayer) => {
+    return displayer.entireScenes();
+};
+
 export const isValidScenePath = (scenePath: string) => {
     return scenePath.startsWith("/");
-}
+};
+
+export const parseSceneDir = (scenePath: string) => {
+    const sceneList = scenePath.split("/");
+    sceneList.pop();
+    let sceneDir = sceneList.join("/");
+    // "/page1" 的 dir 为 "/"
+    if (sceneDir === "") {
+        sceneDir = "/";
+    }
+    return sceneDir;
+};
 
 export const ensureValidScenePath = (scenePath: string) => {
     if (scenePath.endsWith("/")) {
@@ -73,11 +123,14 @@ export const ensureValidScenePath = (scenePath: string) => {
     } else {
         return scenePath;
     }
-}
+};
 
 export const getVersionNumber = (version: string) => {
-    const versionString = version.split(".").map(s => s.padStart(2, "0")).join("");
+    const versionString = version
+        .split(".")
+        .map(s => s.padStart(2, "0"))
+        .join("");
     return parseInt(versionString);
 };
 
-export const wait = (time: number) => new Promise((resolve) => setTimeout(resolve, time));
+export const wait = (time: number) => new Promise(resolve => setTimeout(resolve, time));

package/src/Utils/Reactive.ts

@@ -1,5 +1,6 @@
 import { listenUpdated, unlistenUpdated, reaction, UpdateEventKind } from "white-web-sdk";
 import type { AkkoObjectUpdatedProperty , AkkoObjectUpdatedListener } from "white-web-sdk";
+import { isObject } from "lodash";
 
 // 兼容 13 和 14 版本 SDK
 export const onObjectByEvent = (event: UpdateEventKind) => {
@@ -30,7 +31,8 @@ export const onObjectByEvent = (event: UpdateEventKind) => {
 
 export const safeListenPropsUpdated = <T>(
     getProps: () => T,
-    callback: AkkoObjectUpdatedListener<T>
+    callback: AkkoObjectUpdatedListener<T>,
+    onDestroyed?: (props: unknown) => void
   ) => {
     let disposeListenUpdated: (() => void) | null = null;
     const disposeReaction = reaction(
@@ -41,8 +43,12 @@ export const safeListenPropsUpdated = <T>(
           disposeListenUpdated = null;
         }
         const props = getProps();
-        disposeListenUpdated = () => unlistenUpdated(props, callback);
-        listenUpdated(props, callback);
+        if (isObject(props)) {
+          disposeListenUpdated = () => unlistenUpdated(props, callback);
+          listenUpdated(props, callback);
+        } else {
+          onDestroyed?.(props);
+        }
       },
       { fireImmediately: true }
     );

package/src/Utils/RoomHacker.ts

@@ -1,22 +1,13 @@
 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 { WindowManager } from "../index";
+import type { Camera, Room, Player, PlayerSeekingResult } from "white-web-sdk";
 
 // 修改多窗口状态下一些失效的方法实现到 manager 的 mainview 上, 降低迁移成本
 export const replaceRoomFunction = (room: Room, manager: WindowManager) => {
     if (isPlayer(room)) {
         const player = room as unknown as Player;
-        const originSeek = player.seekToProgressTime;
-        // eslint-disable-next-line no-inner-declarations
-        async function newSeek(time: number): Promise<PlayerSeekingResult> {
-            const seekResult = await originSeek.call(player, time);
-            if (seekResult === "success") {
-                emitter.emit("seek", time);
-            }
-            return seekResult;
-        }
-        player.seekToProgressTime = newSeek;
+        delegateSeekToProgressTime(player);
     } else {
         const descriptor = Object.getOwnPropertyDescriptor(room, "disableCameraTransform");
         if (descriptor) return;
@@ -29,6 +20,18 @@ export const replaceRoomFunction = (room: Room, manager: WindowManager) => {
             },
         });
 
+        Object.defineProperty(room, "canUndoSteps", {
+            get() {
+                return manager.mainView.canUndoSteps;
+            },
+        });
+
+        Object.defineProperty(room, "canRedoSteps", {
+            get() {
+                return manager.mainView.canRedoSteps;
+            },
+        });
+
         room.moveCamera = (camera: Camera) => manager.mainView.moveCamera(camera);
         room.moveCameraToContain = (...args) => manager.moveCameraToContain(...args);
         room.convertToPointInWorld = (...args) => manager.mainView.convertToPointInWorld(...args);
@@ -36,6 +39,32 @@ export const replaceRoomFunction = (room: Room, manager: WindowManager) => {
         room.scenePreview = (...args) => manager.mainView.scenePreview(...args);
         room.fillSceneSnapshot = (...args) => manager.mainView.fillSceneSnapshot(...args);
         room.generateScreenshot = (...args) => manager.mainView.generateScreenshot(...args);
+        room.setMemberState = (...args) => manager.mainView.setMemberState(...args);
+        room.redo = () => manager.mainView.redo();
+        room.undo = () => manager.mainView.undo();
+        room.cleanCurrentScene = () => manager.mainView.cleanCurrentScene();
+        delegateRemoveScenes(room);
     }
+};
 
-};
+const delegateRemoveScenes = (room: Room) => {
+    const originRemoveScenes = room.removeScenes;
+    room.removeScenes = (scenePath: string) => {
+        const result = originRemoveScenes.call(room, scenePath);
+        emitter.emit("removeScenes", scenePath);
+        return result;
+    };
+};
+
+const delegateSeekToProgressTime = (player: Player) => {
+    const originSeek = player.seekToProgressTime;
+    // eslint-disable-next-line no-inner-declarations
+    async function newSeek(time: number): Promise<PlayerSeekingResult> {
+        const seekResult = await originSeek.call(player, time);
+        if (seekResult === "success") {
+            emitter.emit("seek", time);
+        }
+        return seekResult;
+    }
+    player.seekToProgressTime = newSeek;
+};