@netless/app-slide 0.2.106-beta.2 → 0.2.106-beta.3

package/dist/main.es.js

@@ -41109,6 +41109,32 @@ function cachedGetBgColor(el) {
 const getRoomTracker = (displayer) => {
   return displayer.tracker;
 };
+function shouldSlideRuntimeBeActive(isFocused, isVisible, isMinimized) {
+  return isFocused && isVisible && !isMinimized;
+}
+function createFocusTransitionQueue(initialState, apply, onError) {
+  let acceptedState = initialState;
+  let revision = 0;
+  let queue = Promise.resolve();
+  let acceptedPromise = Promise.resolve();
+  return (isFocused, force = false) => {
+    if (!force && isFocused === acceptedState)
+      return acceptedPromise;
+    acceptedState = isFocused;
+    const transitionRevision = ++revision;
+    const transition = queue.then(() => apply(isFocused)).catch((error) => {
+      if (revision === transitionRevision) {
+        acceptedState = void 0;
+        acceptedPromise = Promise.resolve();
+      }
+      onError == null ? void 0 : onError(error);
+      throw error;
+    });
+    queue = transition.catch(() => void 0);
+    acceptedPromise = transition;
+    return transition;
+  };
+}
 function createDocsViewerPages(slide, previewUrls = []) {
   const { width, height, slideCount, slideState } = slide;
   const { taskId, url } = slideState;
@@ -41166,6 +41192,7 @@ const noop$1 = function noop2() {
 class SlideControllerBase {
   constructor(props) {
     this.sideEffect = new SideEffectManager();
+    this.focused = true;
     this.previewList = [];
     this.ready = false;
     this.readyPromise = new Promise((resolve) => {
@@ -41174,7 +41201,11 @@ class SlideControllerBase {
           log("[Slide] render end", slideIndex);
         } else {
           setTimeout(() => {
+            if (this.destroyed)
+              return;
             this.ready = true;
+            if (this.isLazySetupMode())
+              void this.reconcileActivity(true).catch(() => void 0);
             resolve();
           }, 1e3);
         }
@@ -41207,6 +41238,10 @@ class SlideControllerBase {
     this.pollCount = 0;
     this.pollReadyState = () => {
       if (this.ready) {
+        if (this.isLazySetupMode()) {
+          void this.reconcileActivity().catch(() => void 0);
+          return;
+        }
         if (this._toFreeze === 1) {
           this.freeze();
         } else if (this._toFreeze === -1) {
@@ -41232,48 +41267,108 @@ class SlideControllerBase {
       }
     };
     this.isFrozen = false;
+    this.resourceStateUnknown = false;
+    this.managedActivity = false;
     this._toFreeze = 0;
-    this.freeze = () => {
+    this.setFocusedState = (focused) => {
+      this.focused = focused;
+      return this.reconcileActivity();
+    };
+    this.resourceTransition = createFocusTransitionQueue(
+      void 0,
+      async (active) => {
+        if (this.destroyed)
+          return;
+        if (active && this.shouldBeActive())
+          await this.unfreeze();
+        else
+          await this.freeze();
+      },
+      (error) => logger.warn("[Slide] resource transition failed", this.context.appId, error)
+    );
+    this.shouldBeActive = () => {
+      var _a, _b, _c;
+      const wm = this.context.getWindowManager();
+      const host = (_b = (_a = this.context).getRuntimeActivity) == null ? void 0 : _b.call(_a);
+      const lazy = this.isLazySetupMode();
+      const minimized = lazy && host ? !host.active : (wm == null ? void 0 : wm.boxState) === "minimized" || ((_c = wm == null ? void 0 : wm.attributes) == null ? void 0 : _c.minimized) === true || this.context.getBoxStatus() === "minimized";
+      return shouldSlideRuntimeBeActive(
+        !lazy || this.focused,
+        document.visibilityState !== "hidden",
+        minimized
+      ) && (!lazy || (host == null ? void 0 : host.active) !== false);
+    };
+    this.reconcileActivity = (force = false) => {
+      if (this.destroyed)
+        return Promise.resolve();
+      if (this.isLazySetupMode())
+        this.managedActivity = true;
+      if (!this.managedActivity)
+        return Promise.resolve();
+      this.visible = document.visibilityState !== "hidden";
+      return this.resourceTransition(this.shouldBeActive(), force);
+    };
+    this.freeze = async () => {
+      const previousIsFrozen = this.isFrozen;
+      const previousToFreeze = this._toFreeze;
       this.isFrozen = true;
-      if (this.ready) {
-        log("[Slide] freeze", this.context.appId);
-        if (this.invisibleBehavior === "frozen") {
-          return Promise.resolve(this.slide.frozen());
+      try {
+        if (this.ready) {
+          log("[Slide] freeze", this.context.appId);
+          if (this.invisibleBehavior === "frozen") {
+            await this.slide.frozen();
+          } else {
+            this.slide.pause();
+          }
         } else {
-          this.slide.pause();
+          this._toFreeze = 1;
         }
-      } else {
-        this._toFreeze = 1;
+        this.resourceStateUnknown = false;
+      } catch (error) {
+        this.resourceStateUnknown = true;
+        this.isFrozen = previousIsFrozen;
+        this._toFreeze = previousToFreeze;
+        throw error;
       }
-      return Promise.resolve();
     };
     this.unfreeze = async () => {
       if (!this.visible)
         return;
-      if (!this.isFrozen && this.ready)
+      if (!this.isFrozen && this.ready && !this.resourceStateUnknown)
         return;
+      const previousIsFrozen = this.isFrozen;
+      const previousToFreeze = this._toFreeze;
       this.isFrozen = false;
-      if (this.ready) {
-        let isNeedSyncState = false;
-        log("[Slide] unfreeze", this.context.appId);
-        if (this.invisibleBehavior === "frozen") {
-          await this.slide.release(() => {
+      try {
+        if (this.ready) {
+          let isNeedSyncState = false;
+          log("[Slide] unfreeze", this.context.appId);
+          if (this.invisibleBehavior === "frozen") {
+            await this.slide.release(() => {
+              if (!this.isLazySetupMode() || this.shouldBeActive())
+                this.slide.notifyFrameResize();
+            });
+            isNeedSyncState = true;
+          } else {
+            this.slide.resume();
             this.slide.notifyFrameResize();
-          });
-          isNeedSyncState = true;
-        } else {
-          this.slide.resume();
-          this.slide.notifyFrameResize();
-        }
-        if (isNeedSyncState) {
-          const state = this.context.storage.state.state;
-          if (state) {
-            log("[Slide] sync storage", JSON.stringify(state));
-            this.slide.setSlideState(state);
           }
+          if (isNeedSyncState && (!this.isLazySetupMode() || this.shouldBeActive())) {
+            const state = this.context.storage.state.state;
+            if (state) {
+              log("[Slide] sync storage", JSON.stringify(state));
+              await this.slide.setSlideState(state);
+            }
+          }
+        } else {
+          this._toFreeze = -1;
         }
-      } else {
-        this._toFreeze = -1;
+        this.resourceStateUnknown = false;
+      } catch (error) {
+        this.resourceStateUnknown = true;
+        this.isFrozen = previousIsFrozen;
+        this._toFreeze = previousToFreeze;
+        throw error;
       }
     };
     this.bindAppStateChangeEvent = () => {
@@ -41297,6 +41392,10 @@ class SlideControllerBase {
       }
     };
     this.onAppStateChangeHandler = (state) => {
+      if (this.isLazySetupMode() || this.managedActivity) {
+        void this.reconcileActivity().catch(() => void 0);
+        return;
+      }
       if (state === "minimized") {
         log("[Slide] freeze because app state is minimized");
         this.freeze();
@@ -41304,6 +41403,10 @@ class SlideControllerBase {
     };
     this.onAppStatusChangeHandler = (payload) => {
       const { appId, status } = payload;
+      if (appId === this.context.appId && (this.isLazySetupMode() || this.managedActivity)) {
+        void this.reconcileActivity().catch(() => void 0);
+        return;
+      }
       if (appId === this.context.appId && status === "minimized") {
         log("[Slide] freeze because app status is minimized");
         this.freeze();
@@ -41322,21 +41425,35 @@ class SlideControllerBase {
         return void 0;
       }
     };
+    this.isLazySetupMode = () => {
+      var _a;
+      try {
+        return ((_a = this.context.getWindowManager()) == null ? void 0 : _a.lazySetupInMaximizedMode) === true;
+      } catch {
+        return false;
+      }
+    };
     this.onVisibilityChange = async () => {
+      this.visible = document.visibilityState === "visible";
+      if (this.isLazySetupMode() || this.managedActivity) {
+        await this.reconcileActivity().catch(() => void 0);
+        return;
+      }
       const appStatus = this.getAppStatus();
+      if (!this.visible) {
+        this.savedIsFrozen = this.isFrozen;
+        log("[Slide] freeze because tab becomes invisible");
+        if (!this.isFrozen)
+          await this.freeze();
+        return;
+      }
       if (appStatus === "minimized") {
         log("[Slide] do nothing because app state is minimized");
         return;
       }
-      if (!(this.visible = document.visibilityState === "visible")) {
-        this.savedIsFrozen = this.isFrozen;
-        log("[Slide] freeze because tab becomes invisible");
-        this.freeze();
-      } else {
-        if (!this.savedIsFrozen) {
-          log("[Slide] unfreeze because tab becomes visible", { savedIsFrozen: this.savedIsFrozen });
-          this.unfreeze();
-        }
+      if (!this.savedIsFrozen) {
+        log("[Slide] unfreeze because tab becomes visible", { savedIsFrozen: this.savedIsFrozen });
+        await this.unfreeze();
       }
     };
     const {
@@ -44265,7 +44382,7 @@ class SlidePreviewer {
   }
 }
 const usePlugin = /* @__PURE__ */ Slide.Slide.usePlugin.bind(Slide.Slide);
-const version = "0.2.106-beta.2";
+const version = "0.2.106-beta.3";
 const DEFAULT_SLIDE_SETUP_READY_TIMEOUT = 5e3;
 const SlideApp = {
   kind: "Slide",
@@ -44392,36 +44509,19 @@ const SlideApp = {
         return () => room.callbacks.off("onRoomStateChanged", onRoomStateChanged);
       });
     }
-    const isBlurFreezeAllowed = () => {
-      var _a2;
-      const boxStatus = context.getBoxStatus();
-      if (boxStatus)
-        return boxStatus !== "normal";
-      const boxState = (_a2 = context.getWindowManager()) == null ? void 0 : _a2.boxState;
-      return boxState != null && boxState !== "normal";
-    };
     sideEffect.add(
-      () => context.emitter.on("focus", async (isFocused) => {
+      () => context.emitter.on("focus", (isFocused) => {
         if (disposed)
           return;
-        if (!isLazySetupMode())
-          return;
         const controller = docsViewer == null ? void 0 : docsViewer.slideController;
-        if (!controller)
-          return;
-        if (!isFocused) {
-          if (!isBlurFreezeAllowed())
-            return;
-          if (!controller.isFrozen) {
-            log("[Slide] blur freeze", context.appId);
-            await controller.freeze();
-          }
-          return;
-        }
-        if (controller.isFrozen) {
-          log("[Slide] focus unfreeze", context.appId);
-          await controller.unfreeze();
-        }
+        return controller == null ? void 0 : controller.setFocusedState(isFocused);
+      })
+    );
+    sideEffect.add(
+      () => context.emitter.on("runtimeActivity", () => {
+        var _a2;
+        if (!disposed)
+          return (_a2 = docsViewer == null ? void 0 : docsViewer.slideController) == null ? void 0 : _a2.reconcileActivity();
       })
     );
     let disposed = false;
@@ -44453,6 +44553,7 @@ const SlideApp = {
     SlideApp.__teardownByContext.set(context, teardown);
     const waitForFirstRender = (timeoutMs) => new Promise((resolve) => {
       let settled = false;
+      let timedOut = false;
       const settle = (loaded) => {
         if (settled)
           return;
@@ -44461,7 +44562,12 @@ const SlideApp = {
         window.clearInterval(pollTimer);
         resolve(loaded);
       };
-      const timeoutTimer = window.setTimeout(() => settle(false), timeoutMs);
+      const timeoutTimer = window.setTimeout(() => {
+        timedOut = true;
+        logger.warn("[Slide] first render still pending", context.appId, timeoutMs);
+        if (!context.waitForActualSetupReady)
+          settle(false);
+      }, timeoutMs);
       slideControllerRef == null ? void 0 : slideControllerRef.readyPromise.then(
         () => settle(!firstRenderFailed),
         () => settle(false)
@@ -44469,6 +44575,8 @@ const SlideApp = {
       const pollTimer = window.setInterval(() => {
         if (disposed || firstRenderFailed)
           settle(false);
+        else if (timedOut && !context.waitForActualSetupReady)
+          settle(false);
       }, 100);
     });
     const appResult = {
@@ -44605,6 +44713,8 @@ const SlideApp = {
     };
     const setupReadyTimeout = (_g = appOptions == null ? void 0 : appOptions.setupReadyTimeout) != null ? _g : DEFAULT_SLIDE_SETUP_READY_TIMEOUT;
     return waitForFirstRender(setupReadyTimeout).then(() => {
+      if (disposed)
+        throw new Error("[Slide] disposed before first render");
       if (firstRenderFailed) {
         throw new Error("[Slide] first render failed before ready");
       }