@module-federation/bridge-react 0.16.0 → 0.17.0

package/dist/index.esm-j_1sIRzg.js

@@ -0,0 +1,417 @@
+"use strict";
+function _extends() {
+  _extends = Object.assign || function assign(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+const MANIFEST_EXT = ".json";
+const BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+const SEPARATOR = ":";
+function isBrowserEnv() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isBrowserDebug() {
+  try {
+    if (isBrowserEnv() && window.localStorage) {
+      return Boolean(localStorage.getItem(BROWSER_LOG_KEY));
+    }
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+function isDebugMode() {
+  if (typeof process !== "undefined" && process.env && process.env["FEDERATION_DEBUG"]) {
+    return Boolean(process.env["FEDERATION_DEBUG"]);
+  }
+  if (typeof FEDERATION_DEBUG !== "undefined" && Boolean(FEDERATION_DEBUG)) {
+    return true;
+  }
+  return isBrowserDebug();
+}
+const LOG_CATEGORY = "[ Federation Runtime ]";
+const composeKeyWithSeparator = function(...args) {
+  if (!args.length) {
+    return "";
+  }
+  return args.reduce((sum, cur) => {
+    if (!cur) {
+      return sum;
+    }
+    if (!sum) {
+      return cur;
+    }
+    return `${sum}${SEPARATOR}${cur}`;
+  }, "");
+};
+const warn = (msg) => {
+  console.warn(`${LOG_CATEGORY}: ${msg}`);
+};
+let Logger = class Logger2 {
+  setPrefix(prefix) {
+    this.prefix = prefix;
+  }
+  log(...args) {
+    console.log(this.prefix, ...args);
+  }
+  warn(...args) {
+    console.log(this.prefix, ...args);
+  }
+  error(...args) {
+    console.log(this.prefix, ...args);
+  }
+  success(...args) {
+    console.log(this.prefix, ...args);
+  }
+  info(...args) {
+    console.log(this.prefix, ...args);
+  }
+  ready(...args) {
+    console.log(this.prefix, ...args);
+  }
+  debug(...args) {
+    if (isDebugMode()) {
+      console.log(this.prefix, ...args);
+    }
+  }
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+};
+function createLogger(prefix) {
+  return new Logger(prefix);
+}
+async function safeWrapper(callback, disableWarn) {
+  try {
+    const res2 = await callback();
+    return res2;
+  } catch (e) {
+    warn(e);
+    return;
+  }
+}
+function isStaticResourcesEqual(url1, url2) {
+  const REG_EXP = /^(https?:)?\/\//i;
+  const relativeUrl1 = url1.replace(REG_EXP, "").replace(/\/$/, "");
+  const relativeUrl2 = url2.replace(REG_EXP, "").replace(/\/$/, "");
+  return relativeUrl1 === relativeUrl2;
+}
+function createScript(info) {
+  let script2 = null;
+  let needAttach = true;
+  let timeout = 2e4;
+  let timeoutId;
+  const scripts = document.getElementsByTagName("script");
+  for (let i = 0; i < scripts.length; i++) {
+    const s = scripts[i];
+    const scriptSrc = s.getAttribute("src");
+    if (scriptSrc && isStaticResourcesEqual(scriptSrc, info.url)) {
+      script2 = s;
+      needAttach = false;
+      break;
+    }
+  }
+  if (!script2) {
+    const attrs2 = info.attrs;
+    script2 = document.createElement("script");
+    script2.type = (attrs2 == null ? void 0 : attrs2["type"]) === "module" ? "module" : "text/javascript";
+    let createScriptRes = void 0;
+    if (info.createScriptHook) {
+      createScriptRes = info.createScriptHook(info.url, info.attrs);
+      if (createScriptRes instanceof HTMLScriptElement) {
+        script2 = createScriptRes;
+      } else if (typeof createScriptRes === "object") {
+        if ("script" in createScriptRes && createScriptRes.script) {
+          script2 = createScriptRes.script;
+        }
+        if ("timeout" in createScriptRes && createScriptRes.timeout) {
+          timeout = createScriptRes.timeout;
+        }
+      }
+    }
+    if (!script2.src) {
+      script2.src = info.url;
+    }
+    if (attrs2 && !createScriptRes) {
+      Object.keys(attrs2).forEach((name) => {
+        if (script2) {
+          if (name === "async" || name === "defer") {
+            script2[name] = attrs2[name];
+          } else if (!script2.getAttribute(name)) {
+            script2.setAttribute(name, attrs2[name]);
+          }
+        }
+      });
+    }
+  }
+  const onScriptComplete = async (prev, event) => {
+    clearTimeout(timeoutId);
+    const onScriptCompleteCallback = () => {
+      if ((event == null ? void 0 : event.type) === "error") {
+        (info == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(event));
+      } else {
+        (info == null ? void 0 : info.cb) && (info == null ? void 0 : info.cb());
+      }
+    };
+    if (script2) {
+      script2.onerror = null;
+      script2.onload = null;
+      safeWrapper(() => {
+        const { needDeleteScript = true } = info;
+        if (needDeleteScript) {
+          (script2 == null ? void 0 : script2.parentNode) && script2.parentNode.removeChild(script2);
+        }
+      });
+      if (prev && typeof prev === "function") {
+        const result = prev(event);
+        if (result instanceof Promise) {
+          const res2 = await result;
+          onScriptCompleteCallback();
+          return res2;
+        }
+        onScriptCompleteCallback();
+        return result;
+      }
+    }
+    onScriptCompleteCallback();
+  };
+  script2.onerror = onScriptComplete.bind(null, script2.onerror);
+  script2.onload = onScriptComplete.bind(null, script2.onload);
+  timeoutId = setTimeout(() => {
+    onScriptComplete(null, new Error(`Remote script "${info.url}" time-outed.`));
+  }, timeout);
+  return {
+    script: script2,
+    needAttach
+  };
+}
+function createLink(info) {
+  let link = null;
+  let needAttach = true;
+  const links = document.getElementsByTagName("link");
+  for (let i = 0; i < links.length; i++) {
+    const l = links[i];
+    const linkHref = l.getAttribute("href");
+    const linkRel = l.getAttribute("rel");
+    if (linkHref && isStaticResourcesEqual(linkHref, info.url) && linkRel === info.attrs["rel"]) {
+      link = l;
+      needAttach = false;
+      break;
+    }
+  }
+  if (!link) {
+    link = document.createElement("link");
+    link.setAttribute("href", info.url);
+    let createLinkRes = void 0;
+    const attrs2 = info.attrs;
+    if (info.createLinkHook) {
+      createLinkRes = info.createLinkHook(info.url, attrs2);
+      if (createLinkRes instanceof HTMLLinkElement) {
+        link = createLinkRes;
+      }
+    }
+    if (attrs2 && !createLinkRes) {
+      Object.keys(attrs2).forEach((name) => {
+        if (link && !link.getAttribute(name)) {
+          link.setAttribute(name, attrs2[name]);
+        }
+      });
+    }
+  }
+  const onLinkComplete = (prev, event) => {
+    const onLinkCompleteCallback = () => {
+      if ((event == null ? void 0 : event.type) === "error") {
+        (info == null ? void 0 : info.onErrorCallback) && (info == null ? void 0 : info.onErrorCallback(event));
+      } else {
+        (info == null ? void 0 : info.cb) && (info == null ? void 0 : info.cb());
+      }
+    };
+    if (link) {
+      link.onerror = null;
+      link.onload = null;
+      safeWrapper(() => {
+        const { needDeleteLink = true } = info;
+        if (needDeleteLink) {
+          (link == null ? void 0 : link.parentNode) && link.parentNode.removeChild(link);
+        }
+      });
+      if (prev) {
+        const res2 = prev(event);
+        onLinkCompleteCallback();
+        return res2;
+      }
+    }
+    onLinkCompleteCallback();
+  };
+  link.onerror = onLinkComplete.bind(null, link.onerror);
+  link.onload = onLinkComplete.bind(null, link.onload);
+  return {
+    link,
+    needAttach
+  };
+}
+function loadScript(url2, info) {
+  const { attrs: attrs2 = {}, createScriptHook } = info;
+  return new Promise((resolve, reject) => {
+    const { script: script2, needAttach } = createScript({
+      url: url2,
+      cb: resolve,
+      onErrorCallback: reject,
+      attrs: _extends({
+        fetchpriority: "high"
+      }, attrs2),
+      createScriptHook,
+      needDeleteScript: true
+    });
+    needAttach && document.head.appendChild(script2);
+  });
+}
+function importNodeModule(name) {
+  if (!name) {
+    throw new Error("import specifier is required");
+  }
+  const importModule = new Function("name", `return import(name)`);
+  return importModule(name).then((res2) => res2).catch((error) => {
+    console.error(`Error importing module ${name}:`, error);
+    throw error;
+  });
+}
+const loadNodeFetch = async () => {
+  const fetchModule = await importNodeModule("node-fetch");
+  return fetchModule.default || fetchModule;
+};
+const lazyLoaderHookFetch = async (input, init, loaderHook2) => {
+  const hook = (url2, init2) => {
+    return loaderHook2.lifecycle.fetch.emit(url2, init2);
+  };
+  const res2 = await hook(input, init || {});
+  if (!res2 || !(res2 instanceof Response)) {
+    const fetchFunction = typeof fetch === "undefined" ? await loadNodeFetch() : fetch;
+    return fetchFunction(input, init || {});
+  }
+  return res2;
+};
+const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url, cb, attrs, loaderHook) => {
+  if (loaderHook == null ? void 0 : loaderHook.createScriptHook) {
+    const hookResult = loaderHook.createScriptHook(url);
+    if (hookResult && typeof hookResult === "object" && "url" in hookResult) {
+      url = hookResult.url;
+    }
+  }
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch (e) {
+    console.error("Error constructing URL:", e);
+    cb(new Error(`Invalid URL: ${e}`));
+    return;
+  }
+  const getFetch = async () => {
+    if (loaderHook == null ? void 0 : loaderHook.fetch) {
+      return (input, init) => lazyLoaderHookFetch(input, init, loaderHook);
+    }
+    return typeof fetch === "undefined" ? loadNodeFetch() : fetch;
+  };
+  const handleScriptFetch = async (f, urlObj) => {
+    try {
+      var _vm_constants;
+      const res = await f(urlObj.href);
+      const data = await res.text();
+      const [path, vm] = await Promise.all([
+        importNodeModule("path"),
+        importNodeModule("vm")
+      ]);
+      const scriptContext = {
+        exports: {},
+        module: {
+          exports: {}
+        }
+      };
+      const urlDirname = urlObj.pathname.split("/").slice(0, -1).join("/");
+      const filename = path.basename(urlObj.pathname);
+      var _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER;
+      const script = new vm.Script(`(function(exports, module, require, __dirname, __filename) {${data}
+})`, {
+        filename,
+        importModuleDynamically: (_vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER = (_vm_constants = vm.constants) == null ? void 0 : _vm_constants.USE_MAIN_CONTEXT_DEFAULT_LOADER) != null ? _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER : importNodeModule
+      });
+      script.runInThisContext()(scriptContext.exports, scriptContext.module, eval("require"), urlDirname, filename);
+      const exportedInterface = scriptContext.module.exports || scriptContext.exports;
+      if (attrs && exportedInterface && attrs["globalName"]) {
+        const container = exportedInterface[attrs["globalName"]] || exportedInterface;
+        cb(void 0, container);
+        return;
+      }
+      cb(void 0, exportedInterface);
+    } catch (e) {
+      cb(e instanceof Error ? e : new Error(`Script execution error: ${e}`));
+    }
+  };
+  getFetch().then(async (f2) => {
+    if ((attrs == null ? void 0 : attrs["type"]) === "esm" || (attrs == null ? void 0 : attrs["type"]) === "module") {
+      return loadModule(urlObj.href, {
+        fetch: f2,
+        vm: await importNodeModule("vm")
+      }).then(async (module2) => {
+        await module2.evaluate();
+        cb(void 0, module2.namespace);
+      }).catch((e) => {
+        cb(e instanceof Error ? e : new Error(`Script execution error: ${e}`));
+      });
+    }
+    handleScriptFetch(f2, urlObj);
+  }).catch((err) => {
+    cb(err);
+  });
+} : (url2, cb2, attrs2, loaderHook2) => {
+  cb2(new Error("createScriptNode is disabled in non-Node.js environment"));
+};
+const loadScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url2, info) => {
+  return new Promise((resolve, reject) => {
+    createScriptNode(url2, (error, scriptContext2) => {
+      if (error) {
+        reject(error);
+      } else {
+        var _info_attrs, _info_attrs1;
+        const remoteEntryKey = (info == null ? void 0 : (_info_attrs = info.attrs) == null ? void 0 : _info_attrs["globalName"]) || `__FEDERATION_${info == null ? void 0 : (_info_attrs1 = info.attrs) == null ? void 0 : _info_attrs1["name"]}:custom__`;
+        const entryExports = globalThis[remoteEntryKey] = scriptContext2;
+        resolve(entryExports);
+      }
+    }, info.attrs, info.loaderHook);
+  });
+} : (url2, info) => {
+  throw new Error("loadScriptNode is disabled in non-Node.js environment");
+};
+async function loadModule(url2, options) {
+  const { fetch: fetch1, vm: vm2 } = options;
+  const response = await fetch1(url2);
+  const code = await response.text();
+  const module2 = new vm2.SourceTextModule(code, {
+    // @ts-ignore
+    importModuleDynamically: async (specifier, script2) => {
+      const resolvedUrl = new URL(specifier, url2).href;
+      return loadModule(resolvedUrl, options);
+    }
+  });
+  await module2.link(async (specifier) => {
+    const resolvedUrl = new URL(specifier, url2).href;
+    const module3 = await loadModule(resolvedUrl, options);
+    return module3;
+  });
+  return module2;
+}
+exports.MANIFEST_EXT = MANIFEST_EXT;
+exports.SEPARATOR = SEPARATOR;
+exports.composeKeyWithSeparator = composeKeyWithSeparator;
+exports.createLink = createLink;
+exports.createLogger = createLogger;
+exports.createScript = createScript;
+exports.isBrowserEnv = isBrowserEnv;
+exports.isDebugMode = isDebugMode;
+exports.loadScript = loadScript;
+exports.loadScriptNode = loadScriptNode;