@netless/window-manager 0.4.6 → 0.4.8

package/src/RedoUndo.ts

@@ -0,0 +1,87 @@
+import { callbacks, emitter } from "./index";
+import type { View } from "white-web-sdk";
+import type { AppProxy } from "./AppProxy";
+
+export type RedoUndoContext = {
+    mainView: () => View;
+    focus: () => string | undefined;
+    getAppProxy: (id: string) => AppProxy | undefined;
+};
+
+export class RedoUndo {
+    constructor(private context: RedoUndoContext) {
+        emitter.on("focusedChange", changed => {
+            this.disposePrevFocusViewRedoUndoListeners(changed.prev);
+            setTimeout(() => {
+                this.addRedoUndoListeners(changed.focused);
+            }, 0);
+        });
+        emitter.on("rootDirRemoved", () => {
+            this.disposePrevFocusViewRedoUndoListeners(context.focus());
+            this.addRedoUndoListeners(context.focus());
+        });
+        this.addRedoUndoListeners(context.focus());
+    }
+
+    private addRedoUndoListeners = (focused: string | undefined) => {
+        if (focused === undefined) {
+            this.addViewCallbacks(
+                this.context.mainView(),
+                this.onCanRedoStepsUpdate,
+                this.onCanUndoStepsUpdate
+            );
+        } else {
+            const focusApp = this.context.getAppProxy(focused);
+            if (focusApp && focusApp.view) {
+                this.addViewCallbacks(
+                    focusApp.view,
+                    this.onCanRedoStepsUpdate,
+                    this.onCanUndoStepsUpdate
+                );
+            }
+        }
+    };
+
+    private addViewCallbacks = (
+        view: View,
+        redoListener: (steps: number) => void,
+        undoListener: (steps: number) => void
+    ) => {
+        redoListener(view.canRedoSteps);
+        undoListener(view.canUndoSteps);
+        view.callbacks.on("onCanRedoStepsUpdate", redoListener);
+        view.callbacks.on("onCanUndoStepsUpdate", undoListener);
+    };
+
+    private disposeViewCallbacks = (view: View) => {
+        view.callbacks.off("onCanRedoStepsUpdate", this.onCanRedoStepsUpdate);
+        view.callbacks.off("onCanUndoStepsUpdate", this.onCanUndoStepsUpdate);
+    };
+
+    private onCanRedoStepsUpdate = (steps: number) => {
+        callbacks.emit("canRedoStepsChange", steps);
+    };
+
+    private onCanUndoStepsUpdate = (steps: number) => {
+        callbacks.emit("canUndoStepsChange", steps);
+    };
+
+    private disposePrevFocusViewRedoUndoListeners = (prevFocused: string | undefined) => {
+        let view: View | undefined = undefined;
+        if (prevFocused === undefined) {
+            view = this.context.mainView();
+        } else {
+            const appProxy = this.context.getAppProxy(prevFocused);
+            if (appProxy && appProxy.view) {
+                view = appProxy.view;
+            }
+        }
+        if (view) {
+            this.disposeViewCallbacks(view);
+        }
+    };
+
+    public destroy() {
+        this.disposePrevFocusViewRedoUndoListeners(this.context.focus());
+    }
+}

package/src/Register/index.ts

@@ -15,6 +15,7 @@ class AppRegister {
     public appClasses: Map<string, () => Promise<NetlessApp>> = new Map();
 
     public async register(params: RegisterParams): Promise<void> {
+        this.appClassesCache.delete(params.kind);
         this.registered.set(params.kind, params);
 
         const srcOrAppOrFunction = params.src;

package/src/View/MainView.ts

@@ -110,6 +110,17 @@ export class MainViewProxy {
         }
     }
 
+    public rebind(): void {
+        const divElement = this.mainView.divElement;
+        const disableCameraTransform = this.mainView.disableCameraTransform;
+        this.stop();
+        this.mainView.release();
+        this.mainView = this.createMainView();
+        this.mainView.disableCameraTransform = disableCameraTransform;
+        this.mainView.divElement = divElement;
+        this.start();
+    }
+
     private onCameraUpdatedByDevice = (camera: Camera) => {
         this.store.setMainViewCamera({ ...camera, id: this.manager.uid });
         if (!isEqual(this.mainViewSize, { ...this.mainView.size, id: this.manager.uid })) {

package/src/index.ts

@@ -138,6 +138,9 @@ export type EmitterEvent = {
     onReconnected: void;
     removeScenes: string;
     cursorMove: CursorMovePayload;
+    updateManagerRect: undefined;
+    focusedChange: { focused: string | undefined, prev: string | undefined };
+    rootDirRemoved: undefined;
 };
 
 export type EmitterType = Emittery<EmitterEvent>;
@@ -180,7 +183,7 @@ export const callbacks: CallbacksType = new Emittery();
 export const reconnectRefresher = new ReconnectRefresher({ emitter });
 
 export type AddPageParams = {
-    index?: number;
+    after?: boolean;
     scene?: SceneDefinition;
 }
 
@@ -374,7 +377,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> {
                 }
             }
         }
-        this.boxManager?.updateManagerRect();
+        emitter.emit("updateManagerRect");
         this.appManager?.refresh();
         this.appManager?.resetMaximized();
         this.appManager?.resetMinimized();
@@ -519,11 +522,13 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> {
 
     public async addPage(params?: AddPageParams): Promise<void> {
         if (this.appManager) {
-            const index = params?.index;
-            if (Number.isSafeInteger(index)) {
-                this.room.putScenes(ROOT_DIR, [params?.scene || {}], index);
+            const after = params?.after;
+            const scene = params?.scene;
+            if (after) {
+                const nextIndex = this.mainViewSceneIndex + 1;
+                this.room.putScenes(ROOT_DIR, [scene || {}], nextIndex);
             } else {
-                this.room.putScenes(ROOT_DIR, [params?.scene || {}]);
+                this.room.putScenes(ROOT_DIR, [scene || {}]);
             }
         }
     }