@netless/window-manager 0.4.38 → 0.4.39

package/dist/typings.d.ts

@@ -62,7 +62,9 @@ export declare type RegisterEvents<SetupResult = any> = {
 };
 export declare type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any> = {
     kind: string;
-    src: NetlessApp<Attributes, SetupResult> | string | (() => Promise<NetlessApp<Attributes, SetupResult>>);
+    src: NetlessApp<Attributes, SetupResult> | string | (() => Promise<NetlessApp<Attributes, SetupResult>>) | (() => Promise<{
+        default: NetlessApp<Attributes, SetupResult>;
+    }>);
     appOptions?: AppOptions | (() => AppOptions);
     addHooks?: (emitter: Emittery<RegisterEvents<SetupResult>>) => void;
     /** dynamic load app package name */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netless/window-manager",
-  "version": "0.4.38",
+  "version": "0.4.39",
   "description": "",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Register/index.ts

@@ -31,12 +31,19 @@ class AppRegister {
         this.appClassesCache.delete(params.kind);
         this.registered.set(params.kind, params);
 
-        const srcOrAppOrFunction = params.src;
+        const paramSrc = params.src;
+        let srcOrAppOrFunction: () => Promise<NetlessApp>;
         let downloadApp: () => Promise<NetlessApp>;
 
-        if (typeof srcOrAppOrFunction === "string") {
+        if (typeof paramSrc === "string") {
+            srcOrAppOrFunction = () => loadApp(paramSrc, params.kind, params.name);
+            if (this.syncRegisterApp) {
+                this.syncRegisterApp({ kind: params.kind, src: paramSrc, name: params.name });
+            }
+        }
+        if (typeof paramSrc === "function") {
             downloadApp = async () => {
-                let appClass = (await loadApp(srcOrAppOrFunction, params.kind, params.name)) as any;
+                let appClass = await srcOrAppOrFunction() as any;
                 if (appClass) {
                     if (appClass.__esModule) {
                         appClass = appClass.default;
@@ -48,15 +55,10 @@ class AppRegister {
                     );
                 }
             };
-            if (this.syncRegisterApp) {
-                this.syncRegisterApp({ kind: params.kind, src: srcOrAppOrFunction, name: params.name });
-            }
-        } else if (typeof srcOrAppOrFunction === "function") {
-            downloadApp = srcOrAppOrFunction;
-        } else {
-            downloadApp = async () => srcOrAppOrFunction;
         }
-
+        if (typeof paramSrc === "object") {
+            downloadApp = async () => paramSrc;
+        }
         this.appClasses.set(params.kind, async () => {
             let app = this.appClassesCache.get(params.kind);
             if (!app) {

package/src/Register/loader.ts

@@ -28,41 +28,45 @@ export const executeScript = (text: string, appName: string): NetlessApp => {
     return result;
 };
 
-export const loadApp = async (
-    url: string,
-    key: string,
-    name?: string
-): Promise<NetlessApp | undefined> => {
+export const loadApp = async (url: string, key: string, name?: string): Promise<NetlessApp> => {
     const appName = name || Prefix + key;
     callbacks.emit("loadApp", { kind: key, status: "start" });
+
+    let text: string;
     try {
-        const text = await getScript(url);
+        text = await getScript(url);
         if (!text || text.length === 0) {
             callbacks.emit("loadApp", { kind: key, status: "failed", reason: "script is empty." });
-            return;
+            throw new Error("[WindowManager]: script is empty.");
         }
-        try {
+    } catch (error) {
+        callbacks.emit("loadApp", { kind: key, status: "failed", reason: error.message });
+        throw error;
+    }
+    return getResult(text, appName, key);
+};
+
+const getResult = (text: string, appName: string, key: string): NetlessApp => {
+    try {
+        const result = executeScript(text, appName);
+        callbacks.emit("loadApp", { kind: key, status: "success" });
+        return result;
+    } catch (error: any) {
+        if (error.message.includes("Can only have one anonymous define call per script file")) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const define = window.define;
+            if ("function" == typeof define && define.amd) {
+                delete define.amd;
+            }
             const result = executeScript(text, appName);
             callbacks.emit("loadApp", { kind: key, status: "success" });
             return result;
-        } catch (error: any) {
-            if (error.message.includes("Can only have one anonymous define call per script file")) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                const define = window.define;
-                if ("function" == typeof define && define.amd) {
-                    delete define.amd;
-                }
-                const result = executeScript(text, appName);
-                callbacks.emit("loadApp", { kind: key, status: "success" });
-                return result;
-            }
-            callbacks.emit("loadApp", { kind: key, status: "failed", reason: error.message });
         }
-    } catch (error: any) {
         callbacks.emit("loadApp", { kind: key, status: "failed", reason: error.message });
+        throw error;
     }
-};
+}
 
 async function fetchWithTimeout(resource: string, options: RequestInit & { timeout: number }) {
     const { timeout = 10000 } = options;

package/src/typings.ts

@@ -67,7 +67,11 @@ export type RegisterEvents<SetupResult = any> = {
 
 export type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any> = {
     kind: string;
-    src: NetlessApp<Attributes, SetupResult> | string | (() => Promise<NetlessApp<Attributes, SetupResult>>);
+    src:
+        | NetlessApp<Attributes, SetupResult>
+        | string
+        | (() => Promise<NetlessApp<Attributes, SetupResult>>)
+        | (() => Promise<{ default: NetlessApp<Attributes, SetupResult> }>);
     appOptions?: AppOptions | (() => AppOptions);
     addHooks?: (emitter: Emittery<RegisterEvents<SetupResult>>) => void;
     /** dynamic load app package name */