resource-preloader 2.0.4 → 2.0.5

package/src/loader.js

@@ -9,137 +9,137 @@ const loaderMap = new Map();
  * @returns {Promise<LoadResult>} 加载结果Promise
  */
 export function wrapLoadPromise(url, type, timeout) {
-    return new Promise(function (resolve, reject) {
-        // 获取加载器处理函数
-        const handler = getLoader(type);
-        // 超时处理
-        const timeoutTimer = setTimeout(() => {
-            reject(new Error(`Resource ${url} load timeout (${timeout}ms)`));
-        }, timeout);
+  return new Promise(function (resolve, reject) {
+    // 获取加载器处理函数
+    const handler = getLoader(type);
+    // 超时处理
+    const timeoutTimer = setTimeout(() => {
+      reject(new Error(`Resource ${url} load timeout (${timeout}ms)`));
+    }, timeout);
 
-        // 执行具体加载逻辑
-        handler(url)
-            .then(function (result) {
-                clearTimeout(timeoutTimer);
-                resolve({
-                    url,
-                    success: true,
-                    data: result,
-                    error: null,
-                });
-            })
-            .catch(function (error) {
-                clearTimeout(timeoutTimer);
-                reject({
-                    url,
-                    success: false,
-                    data: null,
-                    error,
-                });
-            });
-    });
+    // 执行具体加载逻辑
+    handler(url)
+      .then(function (result) {
+        clearTimeout(timeoutTimer);
+        resolve({
+          url,
+          success: true,
+          data: result,
+          error: null,
+        });
+      })
+      .catch(function (error) {
+        clearTimeout(timeoutTimer);
+        reject({
+          url,
+          success: false,
+          data: null,
+          error,
+        });
+      });
+  });
 }
 
 /** 初始化内置加载器 **/
 // --------------- 内置JS加载器 ---------------
 loaderMap.set(
-    'js',
-    /**
-     * JS加载器
-     * @param {string} url
-     * @returns {Promise<HTMLScriptElement|void>}
-     */
-    function (url) {
-        const script = document.createElement('script');
-        return new Promise(function (resolve, reject) {
-            script.type = 'text/javascript';
-            script.src = url;
-            script.async = false; // 保持加载顺序（不开启异步）
-            script.dataset.flag = 'resource-preloader';
+  "js",
+  /**
+   * JS加载器
+   * @param {string} url
+   * @returns {Promise<HTMLScriptElement|void>}
+   */
+  function (url) {
+    const script = document.createElement("script");
+    return new Promise(function (resolve, reject) {
+      script.type = "text/javascript";
+      script.src = url;
+      script.async = false; // 保持加载顺序（不开启异步）
+      script.dataset.flag = "resource-preloader";
 
-            script.addEventListener('load', function (e) {
-                resolve(script);
-            });
-            script.addEventListener('error', function () {
-                reject(new Error(`JS resource ${url} load failed`));
-            });
+      script.addEventListener("load", function (e) {
+        resolve(script);
+      });
+      script.addEventListener("error", function () {
+        reject(new Error(`JS resource ${url} load failed`));
+      });
 
-            document.head.appendChild(script);
-        }).finally(function () {
-            // 加载完成后移除标签，避免污染DOM
-            document.head.removeChild(script);
-        });
-    }
+      document.head.appendChild(script);
+    }).finally(function () {
+      // 加载完成后移除标签，避免污染DOM
+      document.head.removeChild(script);
+    });
+  },
 );
 // --------------- 内置CSS加载器 ---------------
 loaderMap.set(
-    'css',
-    /**
-     * CSS加载器
-     * @param {string} url
-     * @returns {Promise<HTMLLinkElement>}
-     */
-    function (url) {
-        return new Promise(function (resolve, reject) {
-            const link = document.createElement('link');
-            link.rel = 'stylesheet';
-            link.href = url;
-            link.dataset.flag = 'resource-preloader';
+  "css",
+  /**
+   * CSS加载器
+   * @param {string} url
+   * @returns {Promise<HTMLLinkElement>}
+   */
+  function (url) {
+    return new Promise(function (resolve, reject) {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = url;
+      link.dataset.flag = "resource-preloader";
 
-            link.addEventListener('load', function () {
-                resolve(link);
-            });
-            link.addEventListener('error', function () {
-                reject(new Error(`CSS resource ${url} load failed`));
-                document.head.removeChild(link);
-            });
-            document.head.appendChild(link);
-        });
-    }
+      link.addEventListener("load", function () {
+        resolve(link);
+      });
+      link.addEventListener("error", function () {
+        reject(new Error(`CSS resource ${url} load failed`));
+        document.head.removeChild(link);
+      });
+      document.head.appendChild(link);
+    });
+  },
 );
 // --------------- 内置IMG加载器 ---------------
 loaderMap.set(
-    'img',
-    /**
-     * 图片加载器
-     * @param url
-     * @returns {Promise<HTMLImageElement>}
-     */
-    function (url) {
-        const img = new Image();
-        img.dataset.flag = 'resource-preloader';
-        return new Promise(function (resolve, reject) {
-            img.addEventListener('load', function () {
-                resolve(img);
-            });
-            img.addEventListener('error', function () {
-                reject(new Error(`IMG resource ${url} load failed`));
-            });
-            // img 标签不需要添加到DOM树
-            img.src = url;
-        });
-    }
+  "img",
+  /**
+   * 图片加载器
+   * @param url
+   * @returns {Promise<HTMLImageElement>}
+   */
+  function (url) {
+    const img = new Image();
+    img.dataset.flag = "resource-preloader";
+    return new Promise(function (resolve, reject) {
+      img.addEventListener("load", function () {
+        resolve(img);
+      });
+      img.addEventListener("error", function () {
+        reject(new Error(`IMG resource ${url} load failed`));
+      });
+      // img 标签不需要添加到DOM树
+      img.src = url;
+    });
+  },
 );
 // --------------- 内置JSON加载器 ---------------
 loaderMap.set(
-    'json',
-    /**
-     * JSON加载器
-     * @param {string} url
-     * @returns {Promise<Object|Array|null|undefined>}
-     */
-    function (url) {
-        return fetch(url)
-            .then(function (res) {
-                if (!res.ok) {
-                    throw new Error(`JSON resource ${url} load failed`);
-                }
-                return res.json();
-            })
-            .catch(function (error) {
-                throw new Error(`JSON resource ${url} load failed: ${error.message}`);
-            });
-    }
+  "json",
+  /**
+   * JSON加载器
+   * @param {string} url
+   * @returns {Promise<Object|Array|null|undefined>}
+   */
+  function (url) {
+    return fetch(url)
+      .then(function (res) {
+        if (!res.ok) {
+          throw new Error(`JSON resource ${url} load failed`);
+        }
+        return res.json();
+      })
+      .catch(function (error) {
+        throw new Error(`JSON resource ${url} load failed: ${error.message}`);
+      });
+  },
 );
 
 /**
@@ -148,17 +148,17 @@ loaderMap.set(
  * @param {LoaderHandler} handler - 加载处理函数，接收url参数，返回Promise
  */
 export function registerLoader(type, handler) {
-    if (typeof type !== 'string' || type.trim() === '') {
-        throw new Error('资源类型必须是非空字符串');
-    }
-    const _ = Object.prototype.toString.call(type).slice(8, -1);
-    if (['Function', 'AsyncFunction'].includes(_)) {
-        throw new Error('加载器必须是一个函数返回Promise对象或一个异步函数');
-    }
-    if (loaderMap.has(type)) {
-        console.warn(`类型为${type}的加载器已存在，将被覆盖`);
-    }
-    loaderMap.set(type, handler);
+  if (typeof type !== "string" || type.trim() === "") {
+    throw new Error("资源类型必须是非空字符串");
+  }
+  const _ = Object.prototype.toString.call(type).slice(8, -1);
+  if (["Function", "AsyncFunction"].includes(_)) {
+    throw new Error("加载器必须是一个函数返回Promise对象或一个异步函数");
+  }
+  if (loaderMap.has(type)) {
+    console.warn(`类型为${type}的加载器已存在，将被覆盖`);
+  }
+  loaderMap.set(type, handler);
 }
 
 /**
@@ -167,8 +167,8 @@ export function registerLoader(type, handler) {
  * @returns {Function} 加载器处理函数
  */
 function getLoader(type) {
-    if (!loaderMap.has(type)) {
-        throw new Error(`未找到${type}类型的加载器，请先注册自定义加载器`);
-    }
-    return loaderMap.get(type);
+  if (!loaderMap.has(type)) {
+    throw new Error(`未找到${type}类型的加载器，请先注册自定义加载器`);
+  }
+  return loaderMap.get(type);
 }

package/src/other.js

@@ -1,8 +1,8 @@
-import {resourcePreloader} from "./scheduler.js";
-import {registerLoader} from "./loader.js";
-import {setGlobalConfig} from "./config.js";
+import { resourcePreloader } from "./scheduler.js";
+import { registerLoader } from "./loader.js";
+import { setGlobalConfig } from "./config.js";
 
 resourcePreloader.registerLoader = registerLoader;
 resourcePreloader.setGlobalConfig = setGlobalConfig;
 
-export default resourcePreloader;
+export default resourcePreloader;

package/src/scheduler.js

@@ -1,51 +1,6 @@
-import {getGlobalConfig} from './config.js';
-import {wrapLoadPromise} from './loader.js';
-
-/**
- * 检测循环依赖（深度优先遍历，配置字段改为dependencies）
- * @param {Array} configList - 完整配置数组
- * @param {number} currentId - 当前资源ID
- * @param {Set} visited - 已访问的资源ID集合
- * @param {Set} visiting - 正在访问的资源ID集合（用于检测环）
- */
-function detectCycle(configList, currentId, visited, visiting) {
-    const currentConfig = configList.find(item => item.name === currentId);
-    if (!currentConfig) {
-        throw new Error(`未找到ID为${currentId}的资源配置`);
-    }
-
-    // 若正在访问中，说明存在循环依赖
-    if (visiting.has(currentId)) {
-        throw new Error(`检测到循环依赖：${Array.from(visiting).join(' -> ')} -> ${currentId}`);
-    }
-
-    // 若已访问过，直接返回（无需重复检测）
-    if (visited.has(currentId)) {
-        return;
-    }
-
-    // 标记为正在访问
-    visiting.add(currentId);
-    // 递归检测依赖项（改为dependencies）
-    const dependencies = currentConfig.dependencies || [];
-    for (const depId of dependencies) {
-        detectCycle(configList, depId, visited, visiting);
-    }
-    // 标记为已访问，移出正在访问集合
-    visiting.delete(currentId);
-    visited.add(currentId);
-}
-
-/**
- * 预检测所有资源的循环依赖（配置字段改为dependencies）
- * @param {Array} configList - 完整配置数组
- */
-function checkAllCycles(configList) {
-    const visited = new Set();
-    for (const config of configList) {
-        detectCycle(configList, config.name, visited, new Set());
-    }
-}
+import { getGlobalConfig } from "./config.js";
+import { wrapLoadPromise } from "./loader.js";
+import checkDependencies from "./checker.js";
 
 /**
  * 递归加载单个资源及其所有依赖（保证依赖先加载，配置字段改为dependencies）
@@ -56,72 +11,80 @@ function checkAllCycles(configList) {
  * @returns {Promise<ResourceLoadResult>} 加载结果
  */
 async function loadResourceWithDeps(name, configList, timeout, loadedMap) {
-    // 若已加载，直接返回缓存结果
-    if (loadedMap.has(name)) {
-        return loadedMap.get(name);
-    }
-
-    const currentConfig = configList.find(item => item.name === name);
-    if (!currentConfig) {
-        throw new Error(`未找到name为${name}的资源配置`);
-    }
-
-    // 1. 先加载所有依赖（改为dependencies）
-    const dependencies = currentConfig.dependencies || [];
-    for (const _ of dependencies) {
-        await loadResourceWithDeps(_, configList, timeout, loadedMap);
-    }
-
-    // 2. 再加载当前资源的urls（顺序加载，一个成功即可）
-    const {urls, type} = currentConfig;
-    let loadResult = null;
-    let status = 'success';
-    let error = null;
-
-    try {
-        loadResult = await loadUrlsInOrder(urls, type, timeout);
-    } catch (err) {
-        status = 'failed';
-        error = err;
-    }
-
-    // 3. 缓存加载结果
-    const result = {
-        name,
-        config: currentConfig,
-        result:loadResult,
-        status,
-        error,
-    };
-    loadedMap.set(name, result);
-    return result;
+  // 若已加载，直接返回缓存结果
+  if (loadedMap.has(name)) {
+    return loadedMap.get(name);
+  }
+
+  const currentConfig = configList.find((item) => item.name === name);
+  if (!currentConfig) {
+    throw new Error(`未找到name为${name}的资源配置`);
+  }
+
+  // 1. 先加载所有依赖（改为dependencies）
+  const dependencies = currentConfig.dependencies || [];
+  for (const _ of dependencies) {
+    await loadResourceWithDeps(_, configList, timeout, loadedMap);
+  }
+
+  // 2. 再加载当前资源的urls（顺序加载，一个成功即可）
+  const { urls, type } = currentConfig;
+  let loadResult = null;
+  let status = "success";
+  let error = null;
+
+  try {
+    loadResult = await loadUrlsInOrder(name, urls, type, timeout);
+  } catch (err) {
+    status = "failed";
+    error = err;
+  }
+
+  // 3. 缓存加载结果
+  const result = {
+    name,
+    config: currentConfig,
+    result: loadResult,
+    status,
+    error,
+  };
+  loadedMap.set(name, result);
+  return result;
 }
 
 /**
  * 按顺序加载urls，只需要一个成功即可
- * @param {Array} urls - 资源地址数组
+ * @param {string} name - 资源名
+ * @param {Array<string>} urls - 资源地址数组
  * @param {string} type - 资源类型
  * @param {number} timeout - 超时时间
  * @returns {Promise<LoadResult>} 成功的加载结果
  */
-async function loadUrlsInOrder(urls, type, timeout) {
-    if (!Array.isArray(urls) || urls.length === 0) {
-        throw new Error('urls必须是非空数组');
-    }
+async function loadUrlsInOrder(name, urls, type, timeout) {
+  if (!Array.isArray(urls) || urls.length === 0) {
+    throw new Error("urls必须是非空数组");
+  }
 
-    let lastError;
+  let lastError;
+  const errors = [];
 
-    // 按顺序遍历urls，直到有一个加载成功
-    for (const url of urls) {
-        try {
-            return await wrapLoadPromise(url, type, timeout);
-        } catch (error) {
-            lastError = error; // 加载失败，继续下一个url
-        }
+  // 按顺序遍历urls，直到有一个加载成功
+  for (const url of urls) {
+    try {
+      const ret = await wrapLoadPromise(url, type, timeout);
+      if (errors.length) {
+        console.warn(`加载${name}资源时的一些错误信息：`, errors);
+      }
+      return ret;
+    } catch (error) {
+      errors.push({ url, error });
+      lastError = error; // 加载失败，继续下一个url
     }
+  }
 
-    // 所有url都加载失败，抛出最后一个错误
-    throw new Error(`所有${type}类型资源加载失败，最后一个错误：${lastError?.message || '未知错误'}`);
+  // 所有url都加载失败，抛出最后一个错误
+  console.warn(`所有${name}资源加载错误信息`, errors);
+  throw new Error(`所有${name}资源加载失败，错误内容看上面`);
 }
 
 /**
@@ -130,53 +93,64 @@ async function loadUrlsInOrder(urls, type, timeout) {
  * @returns {Promise<ResourceLoadResult[]>} 按配置定义顺序的加载结果数组
  */
 export async function resourcePreloader(configList) {
-    if (!Array.isArray(configList) || configList.length === 0) {
-        throw new Error('配置数组必须是非空数组');
-    }
-
-    // 将 string[] 形式处理成 { name, urls, type } 形式
-    configList = configList.map(item => {
-        if (typeof item === 'string') {
-            const url = new URL(item, window.location.href);
-            return {
-                name: url.pathname,
-                urls: [item],
-                type: url.pathname.split('.').pop() || 'js',
-            };
-        } else if (Array.isArray(item)) {
-            if (!item.length) {
-                return;
-            }
-            const url = new URL(item[0], window.location.href);
-            return {
-                name: url.pathname,
-                urls: item,
-                type: url.pathname.split('.').pop() || 'js',
-            };
-        } else {
-            return item;
+  if (!Array.isArray(configList) || configList.length === 0) {
+    throw new Error("配置数组必须是非空数组");
+  }
+
+  // 将 string[]|string 形式处理成 { name, urls, type } 形式 同时处理 urls:string 为 urls:[string]
+  /** @type {Array<FullResourceConfig>} */
+  const configs = configList
+    .map(function(item) {
+      if (typeof item === "string") {
+        const url = new URL(item, window.location.href);
+        return {
+          name: url.pathname,
+          urls: [item],
+          type: url.pathname.split(".").pop() || "js",
+        };
+      } else if (Array.isArray(item)) {
+        if (!item.length) {
+          return;
         }
-    }).filter(Boolean);
-
-    // 1. 获取全局配置
-    const {timeout: globalTimeout} = getGlobalConfig();
-
-    // 2. 预检测所有循环依赖（防止无限递归）
-    checkAllCycles(configList);
-
-    // 3. 初始化缓存（存储已加载资源结果，避免重复加载）
-    const loadedMap = new Map();
-
-    // 4. 按配置定义的顺序，并行加载同层级无依赖资源（保证依赖先加载，结果保留原始顺序）
-    const rawOrderPromises = configList.map(async function(config) {
-        return await loadResourceWithDeps(config.name, configList, globalTimeout, loadedMap);
-    });
-
-    // 5. 等待所有资源加载完成，返回原始配置顺序的结果
-    return Promise.all(rawOrderPromises).then(function (result) {
-        if (result.find(item => item.error)) {
-            return Promise.reject(result);
+        const url = new URL(item[0], window.location.href);
+        return {
+          name: url.pathname,
+          urls: item,
+          type: url.pathname.split(".").pop() || "js",
+        };
+      } else {
+        if (typeof item.urls === "string") {
+          item.urls = [item.urls];
         }
-        return result;
-    });
+        return item;
+      }
+    })
+    .filter(Boolean);
+
+  // 1. 获取全局配置
+  const { timeout: globalTimeout } = getGlobalConfig();
+
+  // 2. 预检测所有循环依赖（防止无限递归）
+  checkDependencies(configs);
+
+  // 3. 初始化缓存（存储已加载资源结果，避免重复加载）
+  const loadedMap = new Map();
+
+  // 4. 按配置定义的顺序，并行加载同层级无依赖资源（保证依赖先加载，结果保留原始顺序）
+  const rawOrderPromises = configs.map(async function (config) {
+    return await loadResourceWithDeps(
+      config.name,
+      configs,
+      globalTimeout,
+      loadedMap,
+    );
+  });
+
+  // 5. 等待所有资源加载完成，返回原始配置顺序的结果
+  return Promise.all(rawOrderPromises).then(function (result) {
+    if (result.find((item) => item.error)) {
+      return Promise.reject(result);
+    }
+    return result;
+  });
 }

package/types/index.d.ts

@@ -1,14 +1,24 @@
 // 资源配置类型
-export type ResourceConfig  = {
-  /** 资源名称/ID */
+export type ResourceConfig =
+  | {
+      /** 资源名称/ID */
+      name: string;
+      /** 资源类型 (js, css, 等) */
+      type: string;
+      /** 资源URL数组，按优先级顺序 */
+      urls: string | string[];
+      /** 依赖的其他资源ID数组 */
+      dependencies?: string[];
+    }
+  | string
+  | string[];
+
+export type FullResourceConfig = {
   name: string;
-  /** 资源类型 (js, css, 等) */
   type: string;
-  /** 资源URL数组，按优先级顺序 */
   urls: string[];
-  /** 依赖的其他资源ID数组 */
   dependencies?: string[];
-} | string| string[];
+};
 
 // 加载结果类型
 export interface LoadResult {
@@ -31,7 +41,7 @@ export interface ResourceLoadResult {
   /** 加载结果 */
   result: LoadResult;
   /** 加载状态 */
-  status: 'success' | 'failed';
+  status: "success" | "failed";
   /** 错误信息 */
   error: Error | null;
 }
@@ -54,7 +64,9 @@ export type LoaderHandler = (url: string) => Promise<any>;
  * @param configList - 资源配置数组
  * @returns 加载结果数组的Promise
  */
-export function resourcePreloader(configList: ResourceConfig[]): Promise<ResourceLoadResult[]>;
+export function resourcePreloader(
+  configList: ResourceConfig[],
+): Promise<ResourceLoadResult[]>;
 
 /**
  * 注册自定义加载器