@netless/app-slide 0.2.104 → 0.2.105-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netless/app-slide",
-  "version": "0.2.104",
+  "version": "0.2.105-beta.1",
   "main": "dist/main.cjs.js",
   "module": "dist/main.es.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -37,6 +37,8 @@ export const usePlugin: (plugin: any) => any = /* @__PURE__ */ Slide.usePlugin.b
 
 export const version = __APP_VERSION__;
 
+const DEFAULT_SLIDE_SETUP_READY_TIMEOUT = 5_000;
+
 export { DefaultUrl, apps, FreezerLength, addHooks, useFreezer, log, logger };
 
 export { setFreezerLength, getFreezerLength, onCreated, onDestroyed } from "./utils/freezer";
@@ -87,6 +89,11 @@ export interface AppOptions
   enableScale?: boolean;
   resourceMaxRetries?: number;
   onResourceMaxRetries: (url: string, error: Error) => void;
+  /**
+   * Max time (ms) `setup()` waits for the first `renderEnd` before resolving
+   * anyway (the slide keeps loading in background). Default: 5_000.
+   */
+  setupReadyTimeout?: number;
 }
 
 export interface ILogger {
@@ -113,7 +120,9 @@ export interface AppResult {
   translateView: (offsetX: number, offsetY: number) => void;
 }
 
-const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
+const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> & {
+  teardown(context: import("@netless/window-manager").AppContext): void;
+} = {
   kind: "Slide",
   setup(context) {
     console.log("[Slide] setup @ " + version);
@@ -144,6 +153,10 @@ const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
     const baseScenePath = context.getInitScenePath() as string;
 
     let docsViewer: SlideDocsViewer | null = null;
+    // Serial setup queue support: capture the controller so setup() can await
+    // its first render before WindowManager starts the next app's setup.
+    let slideControllerRef: SlideController | null | undefined;
+    let firstRenderFailed = false;
 
     const onPageChanged = (page: number) => {
       const room = context.getRoom();
@@ -172,10 +185,16 @@ const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
         ...options,
         onPageChanged,
         onNavigate: options.onNavigate,
-        onRenderError: appOptions.onRenderError,
+        // Wrap the user callback: a render failure before the first
+        // renderEnd also fails the setup wait (serial setup queue).
+        onRenderError: (error, pageIndex) => {
+          firstRenderFailed = true;
+          appOptions.onRenderError?.(error, pageIndex);
+        },
         showRenderError: appOptions.showRenderError,
         invisibleBehavior: appOptions.invisibleBehavior,
       });
+      slideControllerRef = slideController;
       if (useFreezer) apps.set(context.appId, slideController, box);
       logger.setAppController(context.appId, slideController);
       if (import.meta.env.DEV) {
@@ -247,7 +266,14 @@ const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
       });
     }
 
-    context.emitter.on("destroy", () => {
+    let disposed = false;
+    let offDestroy: (() => void) | undefined;
+    const teardown = () => {
+      if (disposed) return;
+      disposed = true;
+      const removeDestroy = offDestroy;
+      offDestroy = undefined;
+      removeDestroy?.();
       log("[Slide] destroy", context.appId);
       if (useFreezer) apps.delete(context.appId);
       sideEffect.flushAll();
@@ -255,11 +281,41 @@ const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
         docsViewer.destroy();
         docsViewer = null;
       }
-    });
+    };
+    offDestroy = context.emitter.on("destroy", teardown);
 
     docsViewer.mount();
 
-    return {
+    (SlideApp as any).__teardownByContext ||= new WeakMap<object, () => void>();
+    (SlideApp as any).__teardownByContext.set(context, teardown);
+
+    // Resolve once the SlideController finished its first render (renderEnd).
+    // `false` means timeout or teardown; the slide then keeps loading in the
+    // background without blocking WindowManager's serial setup queue.
+    const waitForFirstRender = (timeoutMs: number): Promise<boolean> =>
+      new Promise<boolean>(resolve => {
+        let settled = false;
+        let pollTimer: number | undefined;
+        const settle = (loaded: boolean) => {
+          if (settled) return;
+          settled = true;
+          window.clearTimeout(timeoutTimer);
+          if (pollTimer !== undefined) window.clearInterval(pollTimer);
+          resolve(loaded);
+        };
+        const timeoutTimer = window.setTimeout(() => settle(false), timeoutMs);
+        // Success path resolves straight from readyPromise (no polling lag);
+        // the poll only catches teardown and pre-ready render failures.
+        slideControllerRef?.readyPromise.then(
+          () => settle(!firstRenderFailed),
+          () => settle(false),
+        );
+        pollTimer = window.setInterval(() => {
+          if (disposed || firstRenderFailed) settle(false);
+        }, 100);
+      });
+
+    const appResult: AppResult = {
       onScaleChanged: (cb: (scale: number) => void) => {
         if (!docsViewer) {
           return () => void 0;
@@ -383,6 +439,22 @@ const SlideApp: NetlessApp<Attributes, MagixEvents, AppOptions, AppResult> = {
         return false;
       },
     };
+
+    const setupReadyTimeout =
+      appOptions?.setupReadyTimeout ?? DEFAULT_SLIDE_SETUP_READY_TIMEOUT;
+    return waitForFirstRender(setupReadyTimeout).then(() => {
+      if (firstRenderFailed) {
+        throw new Error("[Slide] first render failed before ready");
+      }
+      if (!disposed && !slideControllerRef?.ready) {
+        log("[Slide] setup ready wait timed out, slide keeps loading in background");
+      }
+      return appResult;
+    }) as unknown as AppResult;
+  },
+  teardown(context) {
+    (SlideApp as any).__teardownByContext?.get(context)?.();
+    (SlideApp as any).__teardownByContext?.delete(context);
   },
 };