@module-federation/bridge-react 2.6.0 → 2.8.0

package/dist/{prefetch-DzO9_QQ-.mjs → prefetch-CTZuFBqh.mjs}

@@ -1,4 +1,4 @@
-import { B as warn, y as DATA_FETCH_FUNCTION, F as FS_HREF, l as logger, e as getDataFetchMap, i as initDataFetchMap, o as getDataFetchItem, M as MF_DATA_FETCH_STATUS, q as MF_DATA_FETCH_TYPE, G as DOWNGRADE_KEY, H as callAllDowngrade, I as callDowngrade, J as getDowngradeTag, K as composeKeyWithSeparator, m as getDataFetchInfo, n as getDataFetchMapKey } from "./utils-DGS4pYp8.mjs";
+import { B as warn, y as DATA_FETCH_FUNCTION, F as FS_HREF, l as logger, e as getDataFetchMap, i as initDataFetchMap, o as getDataFetchItem, M as MF_DATA_FETCH_STATUS, q as MF_DATA_FETCH_TYPE, G as DOWNGRADE_KEY, H as callAllDowngrade, I as callDowngrade, J as getDowngradeTag, K as composeKeyWithSeparator, N as safeToString, m as getDataFetchInfo, n as getDataFetchMapKey } from "./utils-BBP3hEeV.mjs";
 import { i as isBrowserEnvValue } from "./logger-DwWkXsWl.mjs";
 async function safeWrapper(callback, disableWarn) {
   try {
@@ -215,16 +215,12 @@ function importNodeModule(name) {
   sdkImportCache.set(name, promise);
   return promise;
 }
-const loadNodeFetch = async () => {
-  const fetchModule = await importNodeModule("node-fetch");
-  return fetchModule.default || fetchModule;
-};
 const lazyLoaderHookFetch = async (input, init, loaderHook) => {
   const hook = (url, init2) => {
     return loaderHook.lifecycle.fetch.emit(url, init2);
   };
   const res = await hook(input, init || {});
-  if (!res || !(res instanceof Response)) return (typeof fetch === "undefined" ? await loadNodeFetch() : fetch)(input, init || {});
+  if (!res || !(res instanceof Response)) return fetch(input, init || {});
   return res;
 };
 const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url, cb, attrs, loaderHook) => {
@@ -242,7 +238,7 @@ const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "we
   }
   const getFetch = async () => {
     if (loaderHook == null ? void 0 : loaderHook.fetch) return (input, init) => lazyLoaderHookFetch(input, init, loaderHook);
-    return typeof fetch === "undefined" ? loadNodeFetch() : fetch;
+    return fetch;
   };
   const handleScriptFetch = async (f, urlObj2) => {
     var _a;
@@ -306,20 +302,82 @@ const loadScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web"
   throw new Error("loadScriptNode is disabled in non-Node.js environment");
 };
 const esmModuleCache = /* @__PURE__ */ new Map();
+const isFetchableRemoteModuleUrl = (url) => url.startsWith("http:") || url.startsWith("https:");
+const isBareModuleSpecifier = (specifier) => !specifier.startsWith("./") && !specifier.startsWith("../") && !specifier.startsWith("/") && !specifier.includes(":");
+function encodeRemoteModulePath(url) {
+  const remoteUrl = new URL(url);
+  const encodedProtocol = encodeURIComponent(remoteUrl.protocol.slice(0, -1));
+  const encodedHost = encodeURIComponent(remoteUrl.host);
+  const encodedPathname = remoteUrl.pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  const encodedSearchHash = encodeURIComponent(`${remoteUrl.search}${remoteUrl.hash}`);
+  return `/${encodedProtocol}/${encodedHost}${encodedPathname}${encodedSearchHash ? `/${encodedSearchHash}` : ""}`;
+}
+function createImportMetaUrl(url, baseFileUrl) {
+  const baseUrl = baseFileUrl.endsWith("/") ? baseFileUrl : `${baseFileUrl}/`;
+  return new URL(`__module_federation_remote__${encodeRemoteModulePath(url)}`, baseUrl).href;
+}
+async function isNodeBuiltinSpecifier(specifier) {
+  if (specifier.startsWith("node:")) return true;
+  if (!isBareModuleSpecifier(specifier)) return false;
+  return (await importNodeModule("node:module")).builtinModules.includes(specifier);
+}
+function getSyntheticModuleExports(moduleExports) {
+  const namespaceObject = moduleExports && (typeof moduleExports === "object" || typeof moduleExports === "function") ? moduleExports : { default: moduleExports };
+  const effectiveExports = { ...namespaceObject };
+  if (!Object.prototype.hasOwnProperty.call(effectiveExports, "default")) effectiveExports.default = namespaceObject;
+  return effectiveExports;
+}
+async function createSyntheticModuleFromExports(identifier, moduleExports, vm) {
+  if (typeof vm.SyntheticModule !== "function") throw new Error("vm.SyntheticModule is required to load Node.js built-in modules in ESM remote entries.");
+  const effectiveExports = getSyntheticModuleExports(moduleExports);
+  const exportNames = Object.keys(effectiveExports);
+  const syntheticModule = new vm.SyntheticModule(exportNames, function setSyntheticModuleExports() {
+    for (const name of exportNames) this.setExport(name, effectiveExports[name]);
+  }, { identifier });
+  esmModuleCache.set(identifier, syntheticModule);
+  await syntheticModule.link(async () => {
+    throw new Error(`Node.js built-in module "${identifier}" should not request child modules.`);
+  });
+  await syntheticModule.evaluate();
+  return syntheticModule;
+}
+async function loadNodeBuiltinModule(specifier, vm) {
+  const cacheKey = `node-builtin:${specifier}`;
+  if (esmModuleCache.has(cacheKey)) return esmModuleCache.get(cacheKey);
+  return createSyntheticModuleFromExports(cacheKey, await importNodeModule(specifier), vm);
+}
+async function loadResolvedModule(specifier, parentUrl, options) {
+  if (await isNodeBuiltinSpecifier(specifier)) return loadNodeBuiltinModule(specifier, options.vm);
+  if (isBareModuleSpecifier(specifier)) throw new Error(`Unsupported ESM module specifier "${specifier}". Only relative or absolute http(s) remote modules and Node.js built-in modules are supported.`);
+  const resolvedUrl = new URL(specifier, parentUrl).href;
+  if (!isFetchableRemoteModuleUrl(resolvedUrl)) throw new Error(`Unsupported ESM module specifier "${specifier}" resolved to "${resolvedUrl}". Only http(s) remote modules and Node.js built-in modules are supported.`);
+  return loadModule(resolvedUrl, options);
+}
+async function evaluateDynamicModule(module) {
+  if (module.status === "linked") await module.evaluate();
+  if (module.status === "errored") throw module.error;
+  return module;
+}
 async function loadModule(url, options) {
   if (esmModuleCache.has(url)) return esmModuleCache.get(url);
   const { fetch: fetch2, vm } = options;
+  if (!isFetchableRemoteModuleUrl(url)) throw new Error(`Unsupported ESM module URL "${url}". Only http(s) remote modules and Node.js built-in modules are supported.`);
   const code = await (await fetch2(url)).text();
-  const module = new vm.SourceTextModule(code, { importModuleDynamically: async (specifier, script) => {
-    const resolvedUrl = new URL(specifier, url).href;
-    return loadModule(resolvedUrl, options);
-  } });
-  esmModuleCache.set(url, module);
-  await module.link(async (specifier) => {
-    const resolvedUrl = new URL(specifier, url).href;
-    return await loadModule(resolvedUrl, options);
+  const cwdFileUrl = (await importNodeModule("node:url")).pathToFileURL(process.cwd()).href;
+  const sourceTextModule = new vm.SourceTextModule(code, {
+    identifier: url,
+    initializeImportMeta: (meta) => {
+      meta.url = createImportMetaUrl(url, cwdFileUrl);
+    },
+    importModuleDynamically: async (specifier) => {
+      return evaluateDynamicModule(await loadResolvedModule(specifier, url, options));
+    }
   });
-  return module;
+  esmModuleCache.set(url, sourceTextModule);
+  await sourceTextModule.link(async (specifier) => {
+    return loadResolvedModule(specifier, url, options);
+  });
+  return sourceTextModule;
 }
 const dataFetchFunction = async function(options) {
   var _a, _b;
@@ -411,6 +469,9 @@ function logAndReport(code, descMap, args, logger2, originalErrorMsg, context) {
   return logger2(getShortErrorMsg(code, descMap, args, originalErrorMsg));
 }
 const LOG_CATEGORY = "[ Federation Runtime ]";
+function assert(condition, msgOrCode, descMap, args, context) {
+  if (!condition) error(msgOrCode);
+}
 function error(msgOrCode, descMap, args, originalErrorMsg, context) {
   if (descMap !== void 0) return logAndReport(msgOrCode, descMap, args ?? {}, (msg2) => {
     throw new Error(`${LOG_CATEGORY}: ${msg2}`);
@@ -422,6 +483,14 @@ function error(msgOrCode, descMap, args, originalErrorMsg, context) {
   }
   throw new Error(`${LOG_CATEGORY}: ${msg}`);
 }
+const processModuleAlias = (name, subPath) => {
+  let moduleName;
+  if (name.endsWith("/")) moduleName = name.slice(0, -1);
+  else moduleName = name;
+  if (subPath.startsWith(".")) subPath = subPath.slice(1);
+  moduleName = moduleName + subPath;
+  return moduleName;
+};
 const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
 const nativeGlobal = (() => {
   try {
@@ -474,6 +543,10 @@ const getRemoteEntryExports = (name, globalName) => {
 };
 const DEFAULT_SCOPE = "default";
 const DEFAULT_REMOTE_TYPE = "global";
+function composeRemoteRequestId(remoteName, expose) {
+  if (!expose || expose === ".") return remoteName;
+  return `${remoteName}/${expose.replace(/^\.\//, "")}`;
+}
 function matchRemoteWithNameAndExpose(remotes, id) {
   for (const remote of remotes) {
     const isNameMatched = id.startsWith(remote.name);
@@ -751,6 +824,42 @@ function getRemoteInfo(remote) {
     shareScope: remote.shareScope || DEFAULT_SCOPE
   };
 }
+function remoteToEntry(r) {
+  return {
+    name: r.name,
+    alias: r.alias,
+    entry: "entry" in r ? r.entry : void 0,
+    version: "version" in r ? r.version : void 0,
+    type: r.type,
+    entryGlobalName: r.entryGlobalName,
+    shareScope: r.shareScope
+  };
+}
+function optionsToMFContext(options) {
+  var _a, _b, _c, _d, _e, _f;
+  const shared = {};
+  for (const [pkgName, versions] of Object.entries(options.shared)) {
+    const first = versions[0];
+    if (first) shared[pkgName] = {
+      version: first.version,
+      singleton: (_a = first.shareConfig) == null ? void 0 : _a.singleton,
+      requiredVersion: ((_b = first.shareConfig) == null ? void 0 : _b.requiredVersion) === false ? false : (_c = first.shareConfig) == null ? void 0 : _c.requiredVersion,
+      eager: first.eager,
+      strictVersion: (_d = first.shareConfig) == null ? void 0 : _d.strictVersion
+    };
+  }
+  return {
+    project: {
+      name: options.name,
+      mfRole: ((_e = options.remotes) == null ? void 0 : _e.length) > 0 ? "host" : "unknown"
+    },
+    mfConfig: {
+      name: options.name,
+      remotes: ((_f = options.remotes) == null ? void 0 : _f.map(remoteToEntry)) ?? [],
+      shared
+    }
+  };
+}
 function isTimeoutError(error2) {
   if (!(error2 instanceof Error)) return false;
   return error2.message.includes("timed out") || error2.name.includes("Timeout");
@@ -928,8 +1037,270 @@ var helpers_default = {
     getRemoteInfo
   }
 };
+function getAvailableExposeNames(remoteSnapshot) {
+  if (!remoteSnapshot || !("modules" in remoteSnapshot) || !Array.isArray(remoteSnapshot.modules)) return;
+  const exposes = remoteSnapshot.modules.map((module) => module.moduleName).filter(Boolean);
+  return exposes.length ? exposes.join(",") : void 0;
+}
+function createRemoteEntryInitOptions(remoteInfo, hostShareScopeMap, rawInitScope) {
+  const localShareScopeMap = hostShareScopeMap;
+  const shareScopeKeys = Array.isArray(remoteInfo.shareScope) ? remoteInfo.shareScope : [remoteInfo.shareScope];
+  if (!shareScopeKeys.length) shareScopeKeys.push("default");
+  shareScopeKeys.forEach((shareScopeKey) => {
+    if (!localShareScopeMap[shareScopeKey]) localShareScopeMap[shareScopeKey] = {};
+  });
+  const remoteEntryInitOptions = {
+    version: remoteInfo.version || "",
+    shareScopeKeys: Array.isArray(remoteInfo.shareScope) ? shareScopeKeys : remoteInfo.shareScope || "default"
+  };
+  Object.defineProperty(remoteEntryInitOptions, "shareScopeMap", {
+    value: localShareScopeMap,
+    enumerable: false
+  });
+  return {
+    remoteEntryInitOptions,
+    shareScope: localShareScopeMap[shareScopeKeys[0]],
+    initScope: rawInitScope ?? []
+  };
+}
+var Module$1 = class {
+  constructor({ remoteInfo, host }) {
+    this.inited = false;
+    this.initing = false;
+    this.lib = void 0;
+    this.remoteInfo = remoteInfo;
+    this.host = host;
+  }
+  async getEntry(expose) {
+    if (this.remoteEntryExports) return this.remoteEntryExports;
+    const remoteEntryExports = await getRemoteEntry({
+      origin: this.host,
+      remoteInfo: this.remoteInfo,
+      remoteEntryExports: this.remoteEntryExports,
+      resourceContext: {
+        initiator: "loadRemote",
+        id: composeRemoteRequestId(this.remoteInfo.name, expose),
+        resourceType: "remoteEntry"
+      }
+    });
+    assert(remoteEntryExports, `remoteEntryExports is undefined 
+ ${safeToString(this.remoteInfo)}`);
+    this.remoteEntryExports = remoteEntryExports;
+    return this.remoteEntryExports;
+  }
+  async init(id, remoteSnapshot, rawInitScope, expose) {
+    const remoteEntryExports = await this.getEntry(expose);
+    if (this.inited) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        cached: true,
+        origin: this.host
+      });
+      return remoteEntryExports;
+    }
+    if (this.initPromise) {
+      try {
+        await this.initPromise;
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          cached: true,
+          origin: this.host
+        });
+      } catch (initError) {
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          error: initError,
+          cached: true,
+          origin: this.host
+        });
+        throw initError;
+      }
+      return remoteEntryExports;
+    }
+    this.initing = true;
+    this.initPromise = (async () => {
+      await this.host.loaderHook.lifecycle.beforeInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        origin: this.host
+      });
+      const { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap, rawInitScope);
+      const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
+        shareScope,
+        remoteEntryInitOptions,
+        initScope,
+        remoteInfo: this.remoteInfo,
+        origin: this.host
+      });
+      if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === "undefined") error(RUNTIME_002, runtimeDescMap, {
+        hostName: this.host.name,
+        remoteName: this.remoteInfo.name,
+        remoteEntryUrl: this.remoteInfo.entry,
+        remoteEntryKey: this.remoteInfo.entryGlobalName
+      }, void 0, optionsToMFContext(this.host.options));
+      try {
+        await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
+      } catch (initError) {
+        error(RUNTIME_015, runtimeDescMap, {
+          hostName: this.host.name,
+          remoteName: this.remoteInfo.name,
+          remoteEntryUrl: this.remoteInfo.entry,
+          remoteEntryKey: this.remoteInfo.entryGlobalName,
+          shareScope: this.remoteInfo.shareScope
+        }, `${initError}`, optionsToMFContext(this.host.options));
+      }
+      await this.host.hooks.lifecycle.initContainer.emit({
+        ...initContainerOptions,
+        id,
+        remoteSnapshot,
+        remoteEntryExports
+      });
+      this.inited = true;
+    })();
+    try {
+      await this.initPromise;
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        origin: this.host
+      });
+    } catch (initError) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        error: initError,
+        origin: this.host
+      });
+      throw initError;
+    } finally {
+      this.initing = false;
+      this.initPromise = void 0;
+    }
+    return remoteEntryExports;
+  }
+  async get(id, expose, options, remoteSnapshot) {
+    const { loadFactory = true } = options || { loadFactory: true };
+    const remoteEntryExports = await this.init(id, remoteSnapshot, void 0, expose);
+    this.lib = remoteEntryExports;
+    await this.host.loaderHook.lifecycle.beforeGetExpose.emit({
+      id,
+      expose,
+      moduleInfo: this.remoteInfo,
+      remoteEntryExports,
+      origin: this.host
+    });
+    let moduleFactory;
+    try {
+      const hookModuleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+        remoteEntryExports,
+        expose,
+        moduleInfo: this.remoteInfo
+      });
+      moduleFactory = typeof hookModuleFactory === "function" ? hookModuleFactory : void 0;
+      if (!moduleFactory) moduleFactory = await remoteEntryExports.get(expose);
+      if (!moduleFactory) error(RUNTIME_014, runtimeDescMap, {
+        hostName: this.host.name,
+        remoteName: this.remoteInfo.name,
+        remoteEntryUrl: this.remoteInfo.entry,
+        expose,
+        requestId: id,
+        availableExposes: getAvailableExposeNames(remoteSnapshot)
+      }, void 0, optionsToMFContext(this.host.options));
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        moduleFactory,
+        origin: this.host
+      });
+    } catch (getExposeError) {
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        error: getExposeError,
+        origin: this.host
+      });
+      throw getExposeError;
+    }
+    const symbolName = processModuleAlias(this.remoteInfo.name, expose);
+    const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
+    if (!loadFactory) return wrapModuleFactory;
+    await this.host.loaderHook.lifecycle.beforeExecuteFactory.emit({
+      id,
+      expose,
+      moduleInfo: this.remoteInfo,
+      loadFactory,
+      origin: this.host
+    });
+    try {
+      const exposeContent = await wrapModuleFactory();
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        exposeModule: exposeContent,
+        origin: this.host
+      });
+      return exposeContent;
+    } catch (executeFactoryError) {
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        error: executeFactoryError,
+        origin: this.host
+      });
+      throw executeFactoryError;
+    }
+  }
+  wraperFactory(moduleFactory, id) {
+    function defineModuleId(res, id2) {
+      if (res && typeof res === "object" && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for("mf_module_id"))) Object.defineProperty(res, Symbol.for("mf_module_id"), {
+        value: id2,
+        enumerable: false
+      });
+    }
+    return () => {
+      const res = moduleFactory();
+      if (res instanceof Promise) return res.then((asyncRes) => {
+        defineModuleId(asyncRes, id);
+        return asyncRes;
+      });
+      defineModuleId(res, id);
+      return res;
+    };
+  }
+};
+const REMOTE_DISABLED_MESSAGE = "Remote loading is disabled by experiments.optimization.disableRemote.";
+var UnavailableRemoteModule = class {
+  constructor() {
+    throw new Error(REMOTE_DISABLED_MESSAGE);
+  }
+};
 typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" ? !FEDERATION_OPTIMIZE_NO_REMOTE : true;
+typeof FEDERATION_OPTIMIZE_NO_SHARED === "boolean" ? !FEDERATION_OPTIMIZE_NO_SHARED : true;
 const helpers = helpers_default;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" && FEDERATION_OPTIMIZE_NO_REMOTE ? UnavailableRemoteModule : Module$1;
 const utils = helpers.utils;
 const runtimeHelpers = {
   utils