@antglobal/create-sdk-loader 1.0.0 → 1.0.1

package/lib/main.d.ts

@@ -1,10 +1,20 @@
-type Code = 'NO_REMOTE_CLASS' | 'LOAD_ERROR' | 'INIT_ERROR';
+type Code = 'NO_REMOTE_CLASS' | 'LOAD_ERROR' | 'INIT_ERROR' | 'LOAD_TIMEOUT';
 declare class LoaderError extends Error {
     code: Code;
     constructor(code: Code, message: string);
 }
+interface InitType<ClassType> {
+    init: () => Promise<ClassType>;
+}
 interface LoaderConfig<Config, ClassType> {
+    /**
+     * @description sdk cdn url
+     */
     sdkURL: string;
+    /**
+     * @description the unit is ms, default 20000
+     */
+    timeout?: number;
     globalName: string | (() => new (config: Config) => ClassType);
     /**
      * @description when load error occurs, you can use this callback to monitoring report
@@ -19,12 +29,13 @@ interface LoaderConfig<Config, ClassType> {
      * @description you can use this callback to monitoring report
      * @param fromCache whether the SDK is loaded from cache
      */
-    onLoadComplete?: (fromCache: boolean) => void;
+    onLoadComplete?: () => void;
     /**
      * @description when the SDK is initialized successfully, you can use this callback to monitoring report
      */
     onInitialized?: (instance: ClassType, url: string) => void;
 }
-export declare function createLoader<Config, ClassType>(loadConfig: LoaderConfig<Config, ClassType>): (config: Config) => Promise<ClassType>;
-export declare function loadScript<T = any>(url: string): Promise<T>;
+export declare function createInstance<Config, ClassType extends InitType<ClassType>>(ClassConstructor: new (config: Config) => ClassType, config: Config): Promise<ClassType>;
+export declare function createLoader<Config, ClassType extends InitType<ClassType>>(loadConfig: LoaderConfig<Config, ClassType>): (config: Config) => Promise<ClassType>;
+export declare function loadScript<ClassType extends InitType<ClassType>, Params = any, SDKConstructor = new (config: Params) => ClassType>(url: string, globalName: string | (() => SDKConstructor)): Promise<SDKConstructor>;
 export {};

package/lib/main.js

@@ -6,32 +6,23 @@ class LoaderError extends Error {
         this.code = code;
     }
 }
+export function createInstance(ClassConstructor, config) {
+    const instance = new ClassConstructor(config);
+    return instance.init();
+}
 export function createLoader(loadConfig) {
-    const { sdkURL, globalName, onLoadComplete, onError, onLoadStart, onInitialized } = loadConfig;
-    const getRemoteClass = () => {
-        if (typeof globalName === 'function') {
-            return globalName();
-        }
-        else {
-            return window[globalName];
-        }
-    };
+    const { sdkURL, globalName, timeout = 20000, onLoadComplete, onError, onLoadStart, onInitialized } = loadConfig;
     return (config) => {
         onLoadStart?.();
-        let RemoteClass = getRemoteClass();
-        if (RemoteClass) {
-            onLoadComplete?.(true);
-            return Promise.resolve(new RemoteClass(config));
-        }
-        return loadScript(sdkURL)
-            .then(() => {
-            onLoadComplete?.(false);
-            const RemoteClass = getRemoteClass();
+        const _loadScript = createTimeout(() => loadScript(sdkURL, globalName), timeout);
+        return _loadScript()
+            .then(async (RemoteClass) => {
+            onLoadComplete?.();
             if (!RemoteClass) {
                 throw new LoaderError('NO_REMOTE_CLASS', `No variables ${globalName} were found. Cannot be initialized the Class ${globalName}`);
             }
             try {
-                const instance = new RemoteClass(config);
+                const instance = await createInstance(RemoteClass, config);
                 onInitialized?.(instance, window.location.href);
                 return instance;
             }
@@ -45,14 +36,28 @@ export function createLoader(loadConfig) {
         });
     };
 }
-export function loadScript(url) {
+export function loadScript(url, globalName) {
     return new Promise((resolve, reject) => {
+        const getRemoteClass = () => {
+            if (typeof globalName === 'function') {
+                return globalName();
+            }
+            else {
+                const className = window[globalName];
+                return className?.default || className;
+            }
+        };
+        const RemoteClass = getRemoteClass();
+        if (RemoteClass) {
+            return resolve(RemoteClass);
+        }
         const existedScript = document.querySelector(`script[src="${url}"]`);
         const script = existedScript || document.createElement('script');
         script.src = url;
         script.async = true;
         script.addEventListener('load', () => {
-            resolve(true);
+            // There is must use getRemoteClass
+            resolve(getRemoteClass());
         });
         script.addEventListener('error', (e) => {
             reject(new LoaderError('LOAD_ERROR', `Load script ${url} failed: ${e.message}`));
@@ -62,3 +67,15 @@ export function loadScript(url) {
         }
     });
 }
+function createTimeout(fn, t) {
+    return (..._args) => {
+        return Promise.race([
+            new Promise((_r, reject) => {
+                setTimeout(() => {
+                    reject(new LoaderError('LOAD_TIMEOUT', `Load timeout: ${t}`));
+                }, t);
+            }),
+            fn(..._args)
+        ]);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antglobal/create-sdk-loader",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "./lib/main.js",
   "module": "./lib/main.js",
   "types": "./lib/main.d.ts",
@@ -10,9 +10,7 @@
   ],
   "scripts": {
     "dev": "vite",
-    "build": "tsc",
-    "preview": "vite preview",
-    "postpublish": "node scripts/restorePkg.mjs"
+    "build": "tsc"
   },
   "devDependencies": {
     "typescript": "~5.9.3",