@netless/app-slide 0.0.26 → 0.0.30

package/dist/utils/bgcolor.d.ts

@@ -0,0 +1,3 @@
+export declare function guessBgColor(el: HTMLElement): string;
+export declare function toHex(color: string): string;
+export declare function cachedGetBgColor(el: HTMLElement): string;

package/dist/utils/freezer.d.ts

@@ -0,0 +1,21 @@
+import type { RegisterParams } from "@netless/window-manager";
+export interface FreezableSlide {
+    freeze: () => void;
+    unfreeze: () => void;
+}
+export declare const FreezerLength = 2;
+export declare const apps: {
+    map: Map<string, FreezableSlide>;
+    queue: string[];
+    validateQueue(): void;
+    set(appId: string, slide: FreezableSlide): void;
+    delete(appId: string): void;
+    focus(appId: string): void;
+};
+export declare type AddHooks = NonNullable<RegisterParams["addHooks"]>;
+/**
+ * Put this function in your register code:
+ * `WindowManager.register({ addHooks })`
+ * So that it will automatically freeze the app when it is not in focus.
+ */
+export declare const addHooks: AddHooks;

package/dist/utils/logger.d.ts

@@ -0,0 +1,20 @@
+import type { SlideController } from "../SlideController";
+declare class Logger {
+    enable: boolean;
+    apps: Record<string, {
+        context?: any;
+        controller?: SlideController;
+    }>;
+    level: "debug" | "verbose";
+    constructor(enable: boolean);
+    log(...args: Parameters<Console["log"]>): void;
+    verbose(...args: Parameters<Console["log"]>): void;
+    dispose(appId: string): void;
+    _onMessage: (ev: MessageEvent<{
+        slide: boolean | "__instance";
+    }>) => void;
+}
+export declare const logger: Logger;
+export declare const log: (...args: Parameters<Console["log"]>) => void;
+export declare const verbose: (...args: Parameters<Console["log"]>) => void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netless/app-slide",
-  "version": "0.0.26",
+  "version": "0.0.30",
   "main": "dist/main.cjs.js",
   "module": "dist/main.es.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,9 @@
   ],
   "devDependencies": {
     "@netless/app-shared": "^0.1.1",
-    "@netless/slide": "^0.1.32",
+    "@netless/slide": "^0.1.35",
+    "@types/color-string": "^1.5.1",
+    "color-string": "^1.7.4",
     "side-effect-manager": "^0.1.5",
     "vanilla-lazyload": "^17.5.0"
   },

package/src/SlideController/index.ts

@@ -16,6 +16,8 @@ import type { Attributes, MagixPayload, SlideState } from "../typings";
 import { SideEffectManager } from "side-effect-manager";
 import { Slide, SLIDE_EVENTS } from "@netless/slide";
 import { clamp, deepClone, isObj } from "../utils/helpers";
+import { cachedGetBgColor } from "../utils/bgcolor";
+import { logger, log, verbose } from "../utils/logger";
 export { syncSceneWithSlide, createDocsViewerPages } from "./helpers";
 
 export const DefaultUrl = "https://convertcdn.netless.link/dynamicConvert";
@@ -38,7 +40,6 @@ export interface SlideControllerOptions {
 export class SlideController {
   public readonly context: SlideControllerOptions["context"];
   public readonly slide: Slide;
-  public readonly debug: boolean;
 
   private readonly channel: string;
   private readonly room?: Room;
@@ -68,13 +69,22 @@ export class SlideController {
     this.channel = `channel-${context.appId}`;
     this.room = context.getRoom();
     this.player = this.room ? undefined : (context.getDisplayer() as Player);
-    this.debug = import.meta.env.DEV || !!context.getAppOptions()?.debug;
     this.slide = this.createSlide(anchor);
     // the adder does not need to sync state
     this.syncStateOnceFlag = !this.context.isAddApp;
     this.initialize();
   }
 
+  public ready = false;
+  private resolveReady!: () => void;
+  public readonly readyPromise = new Promise<void>(resolve => {
+    this.resolveReady = () =>
+      setTimeout(() => {
+        this.ready = true;
+        resolve();
+      }, 1000);
+  });
+
   public jumpToPage(page: number) {
     if (this.ready) {
       page = clamp(page, 1, this.pageCount);
@@ -93,16 +103,12 @@ export class SlideController {
     slide.setResource(taskId, url || DefaultUrl);
     if (state) {
       // if we already have state, try restore from it
-      if (this.debug) {
-        console.log("[Slide] init with state", deepClone(state));
-      }
+      log("[Slide] init with state", deepClone(state));
       this.syncStateOnceFlag = false;
       slide.setSlideState(deepClone(state));
     } else if (context.isAddApp) {
       // otherwise, maybe this slide is just added, let the adder kick start first render
-      if (this.debug) {
-        console.log("[Slide] init by renderSlide", 1);
-      }
+      log("[Slide] init by renderSlide", 1);
       slide.renderSlide(1);
     }
     // there's still some risk that the adder is left and no first render
@@ -131,6 +137,11 @@ export class SlideController {
       return disposer;
     });
 
+    this.sideEffect.add(() => {
+      context.emitter.on("seek", this.onSeeked);
+      return () => context.emitter.off("seek", this.onSeeked);
+    });
+
     this.sideEffect.add(() => {
       const displayer = context.getDisplayer();
       displayer.addMagixEventListener(this.channel, this.magixEventListener, {
@@ -149,6 +160,8 @@ export class SlideController {
     slide.on(SLIDE_EVENTS.renderError, this.onError);
     slide.on(SLIDE_EVENTS.stateChange, this.onStateChange);
     slide.on(SLIDE_EVENTS.syncDispatch, this.onSyncDispatch);
+
+    slide.on(SLIDE_EVENTS.renderEnd, this.resolveReady);
   }
 
   private onSyncDispatch = (event: SyncEvent) => {
@@ -157,9 +170,7 @@ export class SlideController {
         type: SLIDE_EVENTS.syncDispatch,
         payload: event,
       };
-      if (this.debug) {
-        console.log("[Slide] dispatch", event);
-      }
+      log("[Slide] dispatch", event);
       this.room.dispatchMagixEvent(this.channel, payload);
     }
   };
@@ -169,9 +180,7 @@ export class SlideController {
       const { type, payload } = ev.payload as MagixPayload;
       if (type === SLIDE_EVENTS.syncDispatch) {
         this.syncStateOnce();
-        if (this.debug) {
-          console.log("[Slide] receive", payload);
-        }
+        log("[Slide] receive", payload);
         // only emit the event if the slide state is sync-ed
         if (!this.syncStateOnceFlag) {
           this.slide.emit(SLIDE_EVENTS.syncReceive, payload);
@@ -185,9 +194,7 @@ export class SlideController {
     if (this.syncStateOnceFlag) {
       const { state } = { ...EmptyAttributes, ...this.context.getAttributes() };
       if (state) {
-        if (this.debug) {
-          console.log("[Slide] sync with state (once)", deepClone(state));
-        }
+        log("[Slide] sync with state (once)", deepClone(state));
         this.slide.setSlideState(deepClone(state));
         this.syncStateOnceFlag = false;
       }
@@ -196,40 +203,44 @@ export class SlideController {
 
   private onStateChange = (state: SlideState) => {
     if (this.context.getIsWritable()) {
-      if (import.meta.env.DEV) {
-        console.log("[Slide] state change", JSON.stringify(state, null, 2));
-      }
+      verbose("[Slide] state change", JSON.stringify(state, null, 2));
       this.context.updateAttributes(["state"], state);
     }
   };
 
-  private resolveReady!: () => void;
-  public readonly readyPromise = new Promise<void>(resolve => {
-    this.resolveReady = resolve;
-  });
+  private onSeeked = () => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const state = this.context.getAttributes()!.state;
+    if (state) {
+      this.slide.setSlideState(deepClone(state));
+    }
+  };
 
   private pollCount = 0;
   private pollReadyState = () => {
     if (this.ready) {
-      this.resolveReady();
+      if (this._toFreeze === 1) {
+        this.freeze();
+      } else if (this._toFreeze === -1) {
+        this.unfreeze();
+      }
     } else if (this.pollCount < MaxPollCount) {
       this.pollCount++;
       setTimeout(this.pollReadyState, 500);
     } else {
       this.pollCount = 0;
-      if (this.debug) {
-        console.log("[Slide] renderSlide (retry after timeout)", 1);
-      }
+      log("[Slide] renderSlide (retry after timeout)", 1);
       this.slide.renderSlide(1);
     }
   };
 
-  public get ready() {
-    return this.slide.slideCount > 0;
-  }
-
+  // cache `slideCount`, because once the slide is frozen,
+  // the `slideCount` will be 0
+  private _pageCount = 0;
   public get pageCount() {
-    return this.slide.slideCount;
+    if (this._pageCount > 0) return this._pageCount;
+    this._pageCount = this.slide.slideCount;
+    return this._pageCount;
   }
 
   public get page() {
@@ -242,18 +253,18 @@ export class SlideController {
       interactive: true,
       mode: "interactive",
       resize: true,
-      controller: this.debug,
+      controller: logger.enable,
       renderOptions: {
         minFPS: 25,
         maxFPS: 30,
         autoFPS: true,
         autoResolution: true,
         resolution: this.context.getAppOptions()?.resolution,
-        transactionBgColor: this.context.getAppOptions()?.bgColor || "#f9f9fc",
+        transactionBgColor: this.context.getAppOptions()?.bgColor || cachedGetBgColor(anchor),
       },
       timestamp: this.timestamp,
     });
-    if (this.debug) {
+    if (import.meta.env.DEV) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (window as any).slide = slide;
     }
@@ -265,9 +276,7 @@ export class SlideController {
   public destroy() {
     this.sideEffect.flushAll();
     if (!this.destroyed) {
-      if (this.debug) {
-        console.log("[Slide] destroy slide (once)");
-      }
+      log("[Slide] destroy slide (once)");
       this.slide.destroy();
       this.destroyed = true;
     }
@@ -282,4 +291,52 @@ export class SlideController {
       return Date.now();
     }
   };
+
+  public isFrozen = false;
+  private _toFreeze: -1 | 0 | 1 = 0; // -1: unfreeze, 0: no change, 1: freeze
+  private freezePromise: Promise<void> | null = null;
+
+  private afterFreeze(from: -1 | 1) {
+    if (from === 1) {
+      this.isFrozen = true;
+      this.freezePromise = null;
+      if (this._toFreeze === -1) {
+        this.unfreeze();
+      }
+    } else if (from === -1) {
+      this.isFrozen = false;
+      this.freezePromise = null;
+      if (this._toFreeze === 1) {
+        this.freeze();
+      }
+    }
+  }
+
+  public freeze = () => {
+    if (this.ready) {
+      log("[Slide] freeze", this.context.appId);
+      if (this.freezePromise) {
+        this._toFreeze = 1;
+      } else if (!this.isFrozen) {
+        this._toFreeze = 0;
+        this.freezePromise = this.slide.frozen().then(this.afterFreeze.bind(this, 1));
+      }
+    } else {
+      this._toFreeze = 1;
+    }
+  };
+
+  public unfreeze = async () => {
+    if (this.ready) {
+      log("[Slide] unfreeze", this.context.appId);
+      if (this.freezePromise) {
+        this._toFreeze = -1;
+      } else if (this.isFrozen) {
+        this._toFreeze = 0;
+        this.freezePromise = this.slide.release().then(this.afterFreeze.bind(this, -1));
+      }
+    } else {
+      this._toFreeze = -1;
+    }
+  };
 }

package/src/SlideDocsViewer/index.ts

@@ -5,7 +5,7 @@ import { SideEffectManager } from "side-effect-manager";
 import { createDocsViewerPages } from "../SlideController";
 import { DocsViewer } from "../DocsViewer";
 
-export const ClickThroughAppliances = new Set(["clicker", "selector"]);
+export const ClickThroughAppliances = new Set(["clicker"]);
 
 export type MountSlideOptions = Omit<SlideControllerOptions, "context" | "onPageChanged"> & {
   onReady: () => void;
@@ -26,6 +26,7 @@ export class SlideDocsViewer {
   protected readonly whiteboardView: SlideDocsViewerConfig["view"];
   protected readonly mountSlideController: SlideDocsViewerConfig["mountSlideController"];
   protected readonly mountWhiteboard: SlideDocsViewerConfig["mountWhiteboard"];
+  private isViewMounted = false;
 
   public constructor({ box, view, mountSlideController, mountWhiteboard }: SlideDocsViewerConfig) {
     this.box = box;
@@ -92,7 +93,6 @@ export class SlideDocsViewer {
     if (!this.$whiteboardView) {
       this.$whiteboardView = document.createElement("div");
       this.$whiteboardView.className = this.wrapClassName("wb-view");
-      this.mountWhiteboard(this.$whiteboardView);
     }
     return this.$whiteboardView;
   }
@@ -161,13 +161,20 @@ export class SlideDocsViewer {
   protected scaleDocsToFit = () => {
     if (this.slideController) {
       const { width, height } = this.slideController.slide;
-      this.whiteboardView.moveCameraToContain({
-        originX: -width / 2,
-        originY: -height / 2,
-        width,
-        height,
-        animationMode: "immediately" as AnimationMode.Immediately,
-      });
+      if (width && height) {
+        this.whiteboardView.moveCameraToContain({
+          originX: -width / 2,
+          originY: -height / 2,
+          width,
+          height,
+          animationMode: "immediately" as AnimationMode.Immediately,
+        });
+        if (!this.isViewMounted) {
+          this.isViewMounted = true;
+          console.log("[Slide] mount whiteboard view");
+          this.mountWhiteboard(this.$whiteboardView);
+        }
+      }
     }
   };
 

package/src/index.ts

@@ -2,6 +2,7 @@ import type { NetlessApp } from "@netless/window-manager";
 import type { RoomState } from "white-web-sdk";
 import type { MountSlideOptions } from "./SlideDocsViewer";
 import type { Attributes } from "./typings";
+import type { AddHooks, FreezableSlide } from "./utils/freezer";
 
 import { SideEffectManager } from "side-effect-manager";
 import { ensureAttributes } from "@netless/app-shared";
@@ -12,11 +13,13 @@ import {
   SlideController,
 } from "./SlideController";
 import { SlideDocsViewer } from "./SlideDocsViewer";
+import { apps, FreezerLength, addHooks } from "./utils/freezer";
+import { log, logger } from "./utils/logger";
 import styles from "./style.scss?inline";
 
-export type { Attributes };
+export type { Attributes, AddHooks, FreezableSlide };
 
-export { DefaultUrl };
+export { DefaultUrl, apps, FreezerLength, addHooks };
 
 const SlideApp: NetlessApp<Attributes> = {
   kind: "Slide",
@@ -46,8 +49,13 @@ const SlideApp: NetlessApp<Attributes> = {
 
     const onPageChanged = (page: number) => {
       const room = context.getRoom();
-      if (docsViewer && docsViewer.slideController && room && context.getIsWritable()) {
-        syncSceneWithSlide(room, context, docsViewer.slideController.slide, baseScenePath);
+      if (docsViewer && docsViewer.slideController) {
+        let synced = false;
+        if (room && context.getIsWritable()) {
+          syncSceneWithSlide(room, context, docsViewer.slideController.slide, baseScenePath);
+          synced = true;
+        }
+        log("[Slide] page to", page, synced);
         docsViewer.viewer.setPageIndex(page - 1);
       }
     };
@@ -58,6 +66,8 @@ const SlideApp: NetlessApp<Attributes> = {
         ...options,
         onPageChanged,
       });
+      apps.set(context.appId, slideController);
+      (logger.apps[context.appId] ||= {}).controller = slideController;
       if (import.meta.env.DEV) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (window as any).slideController = slideController;
@@ -80,6 +90,14 @@ const SlideApp: NetlessApp<Attributes> = {
 
     const room = context.getRoom();
     const sideEffect = new SideEffectManager();
+
+    sideEffect.add(() => {
+      (logger.apps[context.appId] ||= {}).context = context;
+      logger.enable = context.getAppOptions()?.debug || import.meta.env.DEV;
+      logger.level = import.meta.env.DEV ? "verbose" : "debug";
+      return () => logger.dispose(context.appId);
+    });
+
     if (room) {
       docsViewer.toggleClickThrough(room.state.memberState.currentApplianceName);
       sideEffect.add(() => {
@@ -94,7 +112,8 @@ const SlideApp: NetlessApp<Attributes> = {
     }
 
     context.emitter.on("destroy", () => {
-      console.log("[Slide]: destroy");
+      log("[Slide]: destroy");
+      apps.delete(context.appId);
       sideEffect.flushAll();
       if (docsViewer) {
         docsViewer.destroy();

package/src/utils/bgcolor.ts

@@ -0,0 +1,45 @@
+import ColorString from "color-string";
+import { log } from "./logger";
+
+export function guessBgColor(el: HTMLElement): string {
+  try {
+    const bg = window.getComputedStyle(el).backgroundColor;
+    if (bg !== "rgba(0, 0, 0, 0)" && bg !== "transparent") {
+      return bg;
+    }
+    if (el.parentElement) {
+      return guessBgColor(el.parentElement);
+    }
+  } catch {
+    // ignore any error
+  }
+  return "#ffffff";
+}
+
+export function toHex(color: string): string {
+  const result = ColorString.get(color);
+  if (result && result.model === "rgb") {
+    const args = result.value;
+
+    // https://github.com/Qix-/color-convert/blob/8dfdbbc6b46fa6a305bf394d942cc1b08e23fca5/conversions.js#L616
+    const integer =
+      ((Math.round(args[0]) & 0xff) << 16) +
+      ((Math.round(args[1]) & 0xff) << 8) +
+      (Math.round(args[2]) & 0xff);
+
+    const string = integer.toString(16);
+    return "#" + "000000".substring(string.length) + string;
+  } else {
+    return color;
+  }
+}
+
+let cachedBgColor = "";
+
+export function cachedGetBgColor(el: HTMLElement): string {
+  if (!cachedBgColor) {
+    cachedBgColor = toHex(guessBgColor(el));
+    log("[Slide] guess bg color", cachedBgColor);
+  }
+  return cachedBgColor;
+}

package/src/utils/freezer.ts

@@ -0,0 +1,69 @@
+import type { RegisterParams } from "@netless/window-manager";
+import { log } from "./logger";
+
+export interface FreezableSlide {
+  freeze: () => void;
+  unfreeze: () => void;
+}
+
+export const FreezerLength = 2;
+
+export const apps = {
+  map: new Map<string, FreezableSlide>(),
+  queue: [] as string[],
+  validateQueue() {
+    log("[Slide] freezer: validate", this.queue);
+    while (this.queue.length > FreezerLength) {
+      const appId = this.queue.pop() as string;
+      const slide = this.map.get(appId);
+      if (slide) {
+        log("[Slide] freezer: validate-freeze", appId, this.queue);
+        slide.freeze();
+      }
+    }
+  },
+  set(appId: string, slide: FreezableSlide) {
+    log("[Slide] freezer: add", appId, this.queue);
+    this.map.set(appId, slide);
+    if (!this.queue.includes(appId)) {
+      this.queue.unshift(appId);
+    }
+    this.validateQueue();
+  },
+  delete(appId: string) {
+    log("[Slide] freezer: delete", appId, this.queue);
+    this.map.delete(appId);
+    this.queue = this.queue.filter(id => id !== appId);
+  },
+  focus(appId: string) {
+    const slide = this.map.get(appId);
+    const index = this.queue.indexOf(appId);
+    if (index > -1) {
+      this.queue.splice(index, 1);
+    }
+    this.queue.unshift(appId);
+    this.validateQueue();
+    log("[Slide] freezer: focus", appId, this.queue);
+    if (slide) {
+      slide.unfreeze();
+    }
+  },
+};
+
+if (import.meta.env.DEV) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (window as any).freezer = apps;
+}
+
+export type AddHooks = NonNullable<RegisterParams["addHooks"]>;
+
+/**
+ * Put this function in your register code:
+ * `WindowManager.register({ addHooks })`
+ * So that it will automatically freeze the app when it is not in focus.
+ */
+export const addHooks: AddHooks = emitter => {
+  emitter.on("focus", ({ appId }) => {
+    apps.focus(appId);
+  });
+};

package/src/utils/logger.ts

@@ -0,0 +1,39 @@
+import type { SlideController } from "../SlideController";
+import { isObj } from "./helpers";
+
+class Logger {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public apps: Record<string, { context?: any; controller?: SlideController }> = {};
+  public level: "debug" | "verbose" = import.meta.env.DEV ? "verbose" : "debug";
+  constructor(public enable: boolean) {
+    window.addEventListener("message", this._onMessage);
+  }
+  log(...args: Parameters<Console["log"]>) {
+    if (this.enable) {
+      console.log(...args);
+    }
+  }
+  verbose(...args: Parameters<Console["log"]>) {
+    if (this.enable && this.level === "verbose") {
+      console.log(...args);
+    }
+  }
+  dispose(appId: string) {
+    this.enable = false;
+    delete this.apps[appId];
+    window.removeEventListener("message", this._onMessage);
+  }
+  _onMessage = (ev: MessageEvent<{ slide: boolean | "__instance" }>) => {
+    if (isObj(ev.data)) {
+      if (typeof ev.data.slide === "boolean") {
+        this.enable = ev.data.slide;
+      } else if (ev.data.slide === "__instance") {
+        console.log(this);
+      }
+    }
+  };
+}
+
+export const logger = new Logger(import.meta.env.DEV);
+export const log = logger.log.bind(logger);
+export const verbose = logger.verbose.bind(logger);