@module-federation/bridge-react 0.15.0 → 0.17.0

package/dist/index.es.js

@@ -1,9 +1,13 @@
-import { c as createBaseBridgeComponent, E as ErrorBoundary } from "./bridge-base-P6pEjY1q.js";
+import { c as createBaseBridgeComponent, E as ErrorBoundary } from "./bridge-base-BoshEggF.mjs";
 import ReactDOM from "react-dom";
 import React__default, { forwardRef, useRef, useState, useEffect, useContext } from "react";
-import { L as LoggerInstance, g as getRootDomDefaultClassName, p as pathJoin } from "./index-D4yt7Udv.js";
+import { L as LoggerInstance, g as getRootDomDefaultClassName, p as pathJoin } from "./index-CqxytsLY.mjs";
 import * as ReactRouterDOM from "react-router-dom";
 import { federationRuntime } from "./plugin.es.js";
+import { b, a, c, l } from "./lazy-load-component-plugin-PERjiaFJ.mjs";
+import { C, b as b2, E, e, h, c as c2, d, r, s } from "./utils-Cy-amYU5.mjs";
+import { callDataFetch } from "./data-fetch-utils.es.js";
+import { p } from "./prefetch-Dux8GUpr.mjs";
 function createReact16Or17Root(container) {
   return {
     render(children) {
@@ -34,7 +38,7 @@ function createBridgeComponent(bridgeInfo) {
   };
   return createBaseBridgeComponent(fullBridgeInfo);
 }
-function e() {
+function e2() {
   const t = new PopStateEvent("popstate", { state: window.history.state });
   window.dispatchEvent(t);
 }
@@ -64,7 +68,7 @@ const RemoteAppWrapper = forwardRef(function(props, ref) {
       var _a, _b, _c, _d, _e, _f, _g, _h;
       if ((_a = providerInfoRef.current) == null ? void 0 : _a.destroy) {
         LoggerInstance.debug(
-          `createRemoteComponent LazyComponent destroy >>>`,
+          `createRemoteAppComponent LazyComponent destroy >>>`,
           { moduleName, basename, dom: renderDom.current }
         );
         (_d = (_c = (_b = instance == null ? void 0 : instance.bridgeHook) == null ? void 0 : _b.lifecycle) == null ? void 0 : _c.beforeBridgeDestroy) == null ? void 0 : _d.emit({
@@ -152,7 +156,7 @@ function withRouterData(WrappedComponent) {
         }
       }
     }
-    LoggerInstance.debug(`createRemoteComponent withRouterData >>>`, {
+    LoggerInstance.debug(`createRemoteAppComponent withRouterData >>>`, {
       ...props,
       basename,
       routerContextVal,
@@ -164,13 +168,13 @@ function withRouterData(WrappedComponent) {
       useEffect(() => {
         if (pathname !== "" && pathname !== location.pathname) {
           LoggerInstance.debug(
-            `createRemoteComponent dispatchPopstateEnv >>>`,
+            `createRemoteAppComponent dispatchPopstateEnv >>>`,
             {
               name: props.name,
               pathname: location.pathname
             }
           );
-          e();
+          e2();
         }
         setPathname(location.pathname);
       }, [location]);
@@ -185,7 +189,7 @@ const RemoteApp = withRouterData(RemoteAppWrapper);
 function createLazyRemoteComponent(info) {
   const exportName = (info == null ? void 0 : info.export) || "default";
   return React__default.lazy(async () => {
-    LoggerInstance.debug(`createRemoteComponent LazyComponent create >>>`, {
+    LoggerInstance.debug(`createRemoteAppComponent LazyComponent create >>>`, {
       lazyComponent: info.loader,
       exportName
     });
@@ -193,7 +197,7 @@ function createLazyRemoteComponent(info) {
       const m = await info.loader();
       const moduleName = m && m[Symbol.for("mf_module_id")];
       LoggerInstance.debug(
-        `createRemoteComponent LazyComponent loadRemote info >>>`,
+        `createRemoteAppComponent LazyComponent loadRemote info >>>`,
         { name: moduleName, module: m, exportName }
       );
       const exportFn = m[exportName];
@@ -216,7 +220,7 @@ function createLazyRemoteComponent(info) {
         };
       } else {
         LoggerInstance.debug(
-          `createRemoteComponent LazyComponent module not found >>>`,
+          `createRemoteAppComponent LazyComponent module not found >>>`,
           { name: moduleName, module: m, exportName }
         );
         throw Error(
@@ -230,7 +234,7 @@ function createLazyRemoteComponent(info) {
     }
   });
 }
-function createRemoteComponent(info) {
+function createRemoteAppComponent(info) {
   const LazyComponent = createLazyRemoteComponent(info);
   return forwardRef((props, ref) => {
     return /* @__PURE__ */ React__default.createElement(
@@ -242,7 +246,29 @@ function createRemoteComponent(info) {
     );
   });
 }
+function createRemoteComponent(info) {
+  LoggerInstance.warn(
+    `createRemoteAppComponent is deprecated, please use createRemoteAppComponent instead!`
+  );
+  return createRemoteAppComponent(info);
+}
 export {
+  C as CacheSize,
+  b2 as CacheTime,
+  E as ERROR_TYPE,
+  b as autoFetchDataPlugin,
+  e as cache,
+  callDataFetch,
+  h as clearStore,
+  a as collectSSRAssets,
+  c2 as configureCache,
   createBridgeComponent,
-  createRemoteComponent
+  c as createLazyComponent,
+  createRemoteAppComponent,
+  createRemoteComponent,
+  d as generateKey,
+  l as lazyLoadComponentPlugin,
+  p as prefetch,
+  r as revalidateTag,
+  s as setSSREnv
 };

package/dist/index.esm-BCeUd-x9.mjs

@@ -0,0 +1,418 @@
+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 (module) => {
+        await module.evaluate();
+        cb(void 0, module.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 module = new vm2.SourceTextModule(code, {
+    // @ts-ignore
+    importModuleDynamically: async (specifier, script2) => {
+      const resolvedUrl = new URL(specifier, url2).href;
+      return loadModule(resolvedUrl, options);
+    }
+  });
+  await module.link(async (specifier) => {
+    const resolvedUrl = new URL(specifier, url2).href;
+    const module2 = await loadModule(resolvedUrl, options);
+    return module2;
+  });
+  return module;
+}
+export {
+  MANIFEST_EXT as M,
+  SEPARATOR as S,
+  composeKeyWithSeparator as a,
+  isDebugMode as b,
+  createLogger as c,
+  createLink as d,
+  createScript as e,
+  loadScript as f,
+  isBrowserEnv as i,
+  loadScriptNode as l
+};