@module-federation/bridge-react 2.7.0 → 2.8.1

package/dist/{prefetch-BwRDb4SJ.mjs → prefetch-BzCq3MT3.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 {
@@ -469,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}`);
@@ -480,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 {
@@ -532,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);
@@ -606,6 +621,9 @@ const runtimeDescMap = {
   ...runtimeDescMap
 });
 const importCallback = ".then(callbacks[0]).catch(callbacks[1])";
+function isEsmRemoteType(type) {
+  return type === "esm" || type === "module";
+}
 async function loadEsmEntry({ entry, remoteEntryExports }) {
   return new Promise((resolve, reject) => {
     try {
@@ -673,29 +691,23 @@ async function loadEntryScript({ name, globalName, entry, remoteInfo, loaderHook
 }
 async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl, resourceContext }) {
   const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
-  switch (type) {
-    case "esm":
-    case "module":
-      return loadEsmEntry({
-        entry,
-        remoteEntryExports
-      });
-    case "system":
-      return loadSystemJsEntry({
-        entry,
-        remoteEntryExports
-      });
-    default:
-      return loadEntryScript({
-        entry,
-        globalName,
-        name,
-        remoteInfo,
-        loaderHook,
-        getEntryUrl,
-        resourceContext
-      });
-  }
+  if (isEsmRemoteType(type)) return loadEsmEntry({
+    entry,
+    remoteEntryExports
+  });
+  if (type === "system") return loadSystemJsEntry({
+    entry,
+    remoteEntryExports
+  });
+  return loadEntryScript({
+    entry,
+    globalName,
+    name,
+    remoteInfo,
+    loaderHook,
+    getEntryUrl,
+    resourceContext
+  });
 }
 async function loadEntryNode({ remoteInfo, loaderHook, resourceContext }) {
   const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
@@ -809,6 +821,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");
@@ -918,7 +966,7 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
       results.push(waitForRemoteEntryPreload(host, remoteInfo, entryRemoteInfo, createResourceContext(baseContext, "remoteEntry")));
     });
     if (useLinkPreload) {
-      const defaultAttrs = {
+      const defaultAttrs2 = {
         rel: "preload",
         as: "style"
       };
@@ -927,12 +975,12 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
           host,
           remoteInfo,
           url: cssUrl,
-          attrs: defaultAttrs,
+          attrs: defaultAttrs2,
           context: createResourceContext(baseContext, "css")
         }));
       });
     } else {
-      const defaultAttrs = {
+      const defaultAttrs2 = {
         rel: "stylesheet",
         type: "text/css"
       };
@@ -941,41 +989,39 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
           host,
           remoteInfo,
           url: cssUrl,
-          attrs: defaultAttrs,
+          attrs: defaultAttrs2,
           needDeleteLink: false,
           context: createResourceContext(baseContext, "css")
         }));
       });
     }
+    let preloadJsAsset = waitForScriptPreload;
+    let defaultAttrs = {
+      fetchpriority: "high",
+      type: "text/javascript"
+    };
     if (useLinkPreload) {
-      const defaultAttrs = {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
         rel: "preload",
         as: "script"
       };
-      jsAssetsWithoutEntry.forEach((jsUrl) => {
-        results.push(waitForLinkPreload({
-          host,
-          remoteInfo,
-          url: jsUrl,
-          attrs: defaultAttrs,
-          context: createResourceContext(baseContext, "js")
-        }));
-      });
-    } else {
-      const defaultAttrs = {
-        fetchpriority: "high",
-        type: (remoteInfo == null ? void 0 : remoteInfo.type) === "module" ? "module" : "text/javascript"
+    } else if (isEsmRemoteType(remoteInfo.type)) {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
+        rel: "modulepreload",
+        fetchpriority: "high"
       };
-      jsAssetsWithoutEntry.forEach((jsUrl) => {
-        results.push(waitForScriptPreload({
-          host,
-          remoteInfo,
-          url: jsUrl,
-          attrs: defaultAttrs,
-          context: createResourceContext(baseContext, "js")
-        }));
-      });
     }
+    jsAssetsWithoutEntry.forEach((jsUrl) => {
+      results.push(preloadJsAsset({
+        host,
+        remoteInfo,
+        url: jsUrl,
+        attrs: defaultAttrs,
+        context: createResourceContext(baseContext, "js")
+      }));
+    });
   }
   return Promise.all(results);
 }
@@ -986,8 +1032,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