@module-federation/bridge-react 0.24.1 → 2.0.1

package/dist/prefetch-CFRpPfZQ.js

@@ -0,0 +1,632 @@
+"use strict";
+const lazyUtils = require("./utils-TDonIHDD.js");
+const index_esm = require("./index.esm-CYiGJfQW.js");
+const dataFetchFunction = async function(options) {
+  var _a, _b;
+  const [id, data, downgrade] = options;
+  lazyUtils.logger.debug("==========call data fetch function!");
+  if (data) {
+    if (!id) {
+      throw new Error("id is required!");
+    }
+    if (!lazyUtils.getDataFetchMap()) {
+      lazyUtils.initDataFetchMap();
+    }
+    const dataFetchItem = lazyUtils.getDataFetchItem(id);
+    if (dataFetchItem) {
+      (_b = (_a = dataFetchItem[1]) == null ? void 0 : _a[1]) == null ? void 0 : _b.call(_a, data);
+      dataFetchItem[2] = lazyUtils.MF_DATA_FETCH_STATUS.LOADED;
+      return;
+    }
+    if (!dataFetchItem) {
+      const dataFetchMap = lazyUtils.getDataFetchMap();
+      let res;
+      let rej;
+      const p = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      dataFetchMap[id] = [
+        [
+          async () => async () => {
+            return "";
+          },
+          lazyUtils.MF_DATA_FETCH_TYPE.FETCH_SERVER
+        ],
+        [p, res, rej],
+        lazyUtils.MF_DATA_FETCH_STATUS.LOADED
+      ];
+      res && res(data);
+      return;
+    }
+  }
+  if (downgrade) {
+    const mfDowngrade2 = lazyUtils.getDowngradeTag();
+    if (!mfDowngrade2) {
+      globalThis[lazyUtils.DOWNGRADE_KEY] = id ? [id] : true;
+    } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+      mfDowngrade2.push(id);
+    }
+  }
+  const mfDowngrade = lazyUtils.getDowngradeTag();
+  if (typeof mfDowngrade === "boolean") {
+    return lazyUtils.callAllDowngrade();
+  }
+  if (Array.isArray(mfDowngrade)) {
+    if (!id) {
+      globalThis[lazyUtils.DOWNGRADE_KEY] = true;
+      return lazyUtils.callAllDowngrade();
+    }
+    if (!mfDowngrade.includes(id)) {
+      mfDowngrade.push(id);
+    }
+    return lazyUtils.callDowngrade(id);
+  }
+};
+function injectDataFetch() {
+  var _a;
+  globalThis[_a = lazyUtils.DATA_FETCH_FUNCTION] || (globalThis[_a] = []);
+  const dataFetch = globalThis[lazyUtils.DATA_FETCH_FUNCTION];
+  if (dataFetch.push === dataFetchFunction) {
+    return;
+  }
+  if (typeof window === "undefined") {
+    return;
+  }
+  globalThis[lazyUtils.FS_HREF] = window.location.href;
+  dataFetch.push = dataFetchFunction;
+}
+const RUNTIME_001 = "RUNTIME-001";
+const RUNTIME_002 = "RUNTIME-002";
+const RUNTIME_003 = "RUNTIME-003";
+const RUNTIME_004 = "RUNTIME-004";
+const RUNTIME_005 = "RUNTIME-005";
+const RUNTIME_006 = "RUNTIME-006";
+const RUNTIME_007 = "RUNTIME-007";
+const RUNTIME_008 = "RUNTIME-008";
+const RUNTIME_009 = "RUNTIME-009";
+const getDocsUrl = (errorCode) => {
+  const type = errorCode.split("-")[0].toLowerCase();
+  return `View the docs to see how to solve: https://module-federation.io/guide/troubleshooting/${type}#${errorCode.toLowerCase()}`;
+};
+const getShortErrorMsg = (errorCode, errorDescMap, args, originalErrorMsg) => {
+  const msg = [`${[errorDescMap[errorCode]]} #${errorCode}`];
+  args && msg.push(`args: ${JSON.stringify(args)}`);
+  msg.push(getDocsUrl(errorCode));
+  return msg.join("\n");
+};
+const runtimeDescMap = {
+  [RUNTIME_001]: "Failed to get remoteEntry exports.",
+  [RUNTIME_002]: 'The remote entry interface does not contain "init"',
+  [RUNTIME_003]: "Failed to get manifest.",
+  [RUNTIME_004]: "Failed to locate remote.",
+  [RUNTIME_005]: "Invalid loadShareSync function call from bundler runtime",
+  [RUNTIME_006]: "Invalid loadShareSync function call from runtime",
+  [RUNTIME_007]: "Failed to get remote snapshot.",
+  [RUNTIME_008]: "Failed to load script resources.",
+  [RUNTIME_009]: "Please call createInstance first."
+};
+({
+  ...runtimeDescMap
+});
+const LOG_CATEGORY = "[ Federation Runtime ]";
+function assert(condition, msg) {
+  if (!condition) {
+    error(msg);
+  }
+}
+function error(msg) {
+  if (msg instanceof Error) {
+    if (!msg.message.startsWith(LOG_CATEGORY)) {
+      msg.message = `${LOG_CATEGORY}: ${msg.message}`;
+    }
+    throw msg;
+  }
+  throw new Error(`${LOG_CATEGORY}: ${msg}`);
+}
+const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
+const nativeGlobal = (() => {
+  try {
+    return document.defaultView;
+  } catch {
+    return CurrentGlobal;
+  }
+})();
+function definePropertyGlobalVal(target, key, val) {
+  Object.defineProperty(target, key, {
+    value: val,
+    configurable: false,
+    writable: true
+  });
+}
+function includeOwnProperty(target, key) {
+  return Object.hasOwnProperty.call(target, key);
+}
+if (!includeOwnProperty(CurrentGlobal, "__GLOBAL_LOADING_REMOTE_ENTRY__")) {
+  definePropertyGlobalVal(CurrentGlobal, "__GLOBAL_LOADING_REMOTE_ENTRY__", {});
+}
+const globalLoading = CurrentGlobal.__GLOBAL_LOADING_REMOTE_ENTRY__;
+function setGlobalDefaultVal(target) {
+  var _a, _b, _c, _d, _e, _f;
+  if (includeOwnProperty(target, "__VMOK__") && !includeOwnProperty(target, "__FEDERATION__")) {
+    definePropertyGlobalVal(target, "__FEDERATION__", target.__VMOK__);
+  }
+  if (!includeOwnProperty(target, "__FEDERATION__")) {
+    definePropertyGlobalVal(target, "__FEDERATION__", {
+      __GLOBAL_PLUGIN__: [],
+      __INSTANCES__: [],
+      moduleInfo: {},
+      __SHARE__: {},
+      __MANIFEST_LOADING__: {},
+      __PRELOADED_MAP__: /* @__PURE__ */ new Map()
+    });
+    definePropertyGlobalVal(target, "__VMOK__", target.__FEDERATION__);
+  }
+  (_a = target.__FEDERATION__).__GLOBAL_PLUGIN__ ?? (_a.__GLOBAL_PLUGIN__ = []);
+  (_b = target.__FEDERATION__).__INSTANCES__ ?? (_b.__INSTANCES__ = []);
+  (_c = target.__FEDERATION__).moduleInfo ?? (_c.moduleInfo = {});
+  (_d = target.__FEDERATION__).__SHARE__ ?? (_d.__SHARE__ = {});
+  (_e = target.__FEDERATION__).__MANIFEST_LOADING__ ?? (_e.__MANIFEST_LOADING__ = {});
+  (_f = target.__FEDERATION__).__PRELOADED_MAP__ ?? (_f.__PRELOADED_MAP__ = /* @__PURE__ */ new Map());
+}
+setGlobalDefaultVal(CurrentGlobal);
+setGlobalDefaultVal(nativeGlobal);
+const getRemoteEntryExports = (name, globalName) => {
+  const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
+  const entryExports = CurrentGlobal[remoteEntryKey];
+  return {
+    remoteEntryKey,
+    entryExports
+  };
+};
+const DEFAULT_SCOPE = "default";
+const DEFAULT_REMOTE_TYPE = "global";
+function matchRemoteWithNameAndExpose(remotes, id) {
+  for (const remote of remotes) {
+    const isNameMatched = id.startsWith(remote.name);
+    let expose = id.replace(remote.name, "");
+    if (isNameMatched) {
+      if (expose.startsWith("/")) {
+        const pkgNameOrAlias = remote.name;
+        expose = `.${expose}`;
+        return {
+          pkgNameOrAlias,
+          expose,
+          remote
+        };
+      } else if (expose === "") {
+        return {
+          pkgNameOrAlias: remote.name,
+          expose: ".",
+          remote
+        };
+      }
+    }
+    const isAliasMatched = remote.alias && id.startsWith(remote.alias);
+    let exposeWithAlias = remote.alias && id.replace(remote.alias, "");
+    if (remote.alias && isAliasMatched) {
+      if (exposeWithAlias && exposeWithAlias.startsWith("/")) {
+        const pkgNameOrAlias = remote.alias;
+        exposeWithAlias = `.${exposeWithAlias}`;
+        return {
+          pkgNameOrAlias,
+          expose: exposeWithAlias,
+          remote
+        };
+      } else if (exposeWithAlias === "") {
+        return {
+          pkgNameOrAlias: remote.alias,
+          expose: ".",
+          remote
+        };
+      }
+    }
+  }
+  return;
+}
+const importCallback = ".then(callbacks[0]).catch(callbacks[1])";
+async function loadEsmEntry({ entry, remoteEntryExports }) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!remoteEntryExports) {
+        if (typeof FEDERATION_ALLOW_NEW_FUNCTION !== "undefined") {
+          new Function("callbacks", `import("${entry}")${importCallback}`)([
+            resolve,
+            reject
+          ]);
+        } else {
+          import(
+            /* webpackIgnore: true */
+            /* @vite-ignore */
+            entry
+          ).then(resolve).catch(reject);
+        }
+      } else {
+        resolve(remoteEntryExports);
+      }
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+async function loadSystemJsEntry({ entry, remoteEntryExports }) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!remoteEntryExports) {
+        if (typeof __system_context__ === "undefined") {
+          System.import(entry).then(resolve).catch(reject);
+        } else {
+          new Function("callbacks", `System.import("${entry}")${importCallback}`)([resolve, reject]);
+        }
+      } else {
+        resolve(remoteEntryExports);
+      }
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function handleRemoteEntryLoaded(name, globalName, entry) {
+  const { remoteEntryKey, entryExports } = getRemoteEntryExports(name, globalName);
+  assert(entryExports, getShortErrorMsg(RUNTIME_001, runtimeDescMap, {
+    remoteName: name,
+    remoteEntryUrl: entry,
+    remoteEntryKey
+  }));
+  return entryExports;
+}
+async function loadEntryScript({ name, globalName, entry, loaderHook, getEntryUrl }) {
+  const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
+  if (remoteEntryExports) {
+    return remoteEntryExports;
+  }
+  const url = getEntryUrl ? getEntryUrl(entry) : entry;
+  return index_esm.loadScript(url, {
+    attrs: {},
+    createScriptHook: (url2, attrs) => {
+      const res = loaderHook.lifecycle.createScript.emit({ url: url2, attrs });
+      if (!res)
+        return;
+      if (res instanceof HTMLScriptElement) {
+        return res;
+      }
+      if ("script" in res || "timeout" in res) {
+        return res;
+      }
+      return;
+    }
+  }).then(() => {
+    return handleRemoteEntryLoaded(name, globalName, entry);
+  }).catch((e) => {
+    assert(void 0, getShortErrorMsg(RUNTIME_008, runtimeDescMap, {
+      remoteName: name,
+      resourceUrl: entry
+    }));
+    throw e;
+  });
+}
+async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl }) {
+  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,
+        loaderHook,
+        getEntryUrl
+      });
+  }
+}
+async function loadEntryNode({ remoteInfo, loaderHook }) {
+  const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
+  const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
+  if (remoteEntryExports) {
+    return remoteEntryExports;
+  }
+  return index_esm.loadScriptNode(entry, {
+    attrs: { name, globalName, type },
+    loaderHook: {
+      createScriptHook: (url, attrs = {}) => {
+        const res = loaderHook.lifecycle.createScript.emit({ url, attrs });
+        if (!res)
+          return;
+        if ("url" in res) {
+          return res;
+        }
+        return;
+      }
+    }
+  }).then(() => {
+    return handleRemoteEntryLoaded(name, globalName, entry);
+  }).catch((e) => {
+    throw e;
+  });
+}
+function getRemoteEntryUniqueKey(remoteInfo) {
+  const { entry, name } = remoteInfo;
+  return index_esm.composeKeyWithSeparator(name, entry);
+}
+async function getRemoteEntry(params) {
+  const { origin, remoteEntryExports, remoteInfo, getEntryUrl, _inErrorHandling = false } = params;
+  const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+  if (remoteEntryExports) {
+    return remoteEntryExports;
+  }
+  if (!globalLoading[uniqueKey]) {
+    const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
+    const loaderHook = origin.loaderHook;
+    globalLoading[uniqueKey] = loadEntryHook.emit({
+      loaderHook,
+      remoteInfo,
+      remoteEntryExports
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      const isWebEnvironment = typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : index_esm.isBrowserEnv();
+      return isWebEnvironment ? loadEntryDom({
+        remoteInfo,
+        remoteEntryExports,
+        loaderHook,
+        getEntryUrl
+      }) : loadEntryNode({ remoteInfo, loaderHook });
+    }).catch(async (err) => {
+      const uniqueKey2 = getRemoteEntryUniqueKey(remoteInfo);
+      const isScriptLoadError = err instanceof Error && err.message.includes(RUNTIME_008);
+      if (isScriptLoadError && !_inErrorHandling) {
+        const wrappedGetRemoteEntry = (params2) => {
+          return getRemoteEntry({ ...params2, _inErrorHandling: true });
+        };
+        const RemoteEntryExports = await origin.loaderHook.lifecycle.loadEntryError.emit({
+          getRemoteEntry: wrappedGetRemoteEntry,
+          origin,
+          remoteInfo,
+          remoteEntryExports,
+          globalLoading,
+          uniqueKey: uniqueKey2
+        });
+        if (RemoteEntryExports) {
+          return RemoteEntryExports;
+        }
+      }
+      throw err;
+    });
+  }
+  return globalLoading[uniqueKey];
+}
+function getRemoteInfo(remote) {
+  return {
+    ...remote,
+    entry: "entry" in remote ? remote.entry : "",
+    type: remote.type || DEFAULT_REMOTE_TYPE,
+    entryGlobalName: remote.entryGlobalName || remote.name,
+    shareScope: remote.shareScope || DEFAULT_SCOPE
+  };
+}
+function preloadAssets(remoteInfo, host, assets, useLinkPreload = true) {
+  const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+  if (host.options.inBrowser) {
+    entryAssets.forEach((asset) => {
+      const { moduleInfo } = asset;
+      const module2 = host.moduleCache.get(remoteInfo.name);
+      if (module2) {
+        getRemoteEntry({
+          origin: host,
+          remoteInfo: moduleInfo,
+          remoteEntryExports: module2.remoteEntryExports
+        });
+      } else {
+        getRemoteEntry({
+          origin: host,
+          remoteInfo: moduleInfo,
+          remoteEntryExports: void 0
+        });
+      }
+    });
+    if (useLinkPreload) {
+      const defaultAttrs = {
+        rel: "preload",
+        as: "style"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const { link: cssEl, needAttach } = index_esm.createLink({
+          url: cssUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) {
+              return res;
+            }
+            return;
+          }
+        });
+        needAttach && document.head.appendChild(cssEl);
+      });
+    } else {
+      const defaultAttrs = {
+        rel: "stylesheet",
+        type: "text/css"
+      };
+      cssAssets.forEach((cssUrl) => {
+        const { link: cssEl, needAttach } = index_esm.createLink({
+          url: cssUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) {
+              return res;
+            }
+            return;
+          },
+          needDeleteLink: false
+        });
+        needAttach && document.head.appendChild(cssEl);
+      });
+    }
+    if (useLinkPreload) {
+      const defaultAttrs = {
+        rel: "preload",
+        as: "script"
+      };
+      jsAssetsWithoutEntry.forEach((jsUrl) => {
+        const { link: linkEl, needAttach } = index_esm.createLink({
+          url: jsUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createLinkHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createLink.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLLinkElement) {
+              return res;
+            }
+            return;
+          }
+        });
+        needAttach && document.head.appendChild(linkEl);
+      });
+    } else {
+      const defaultAttrs = {
+        fetchpriority: "high",
+        type: (remoteInfo == null ? void 0 : remoteInfo.type) === "module" ? "module" : "text/javascript"
+      };
+      jsAssetsWithoutEntry.forEach((jsUrl) => {
+        const { script: scriptEl, needAttach } = index_esm.createScript({
+          url: jsUrl,
+          cb: () => {
+          },
+          attrs: defaultAttrs,
+          createScriptHook: (url, attrs) => {
+            const res = host.loaderHook.lifecycle.createScript.emit({
+              url,
+              attrs
+            });
+            if (res instanceof HTMLScriptElement) {
+              return res;
+            }
+            return;
+          },
+          needDeleteScript: true
+        });
+        needAttach && document.head.appendChild(scriptEl);
+      });
+    }
+  }
+}
+var helpers = {
+  utils: {
+    matchRemoteWithNameAndExpose,
+    preloadAssets,
+    getRemoteInfo
+  }
+};
+typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+const utils = helpers.utils;
+const runtimeHelpers = {
+  utils
+};
+async function prefetch(options) {
+  const { instance, id, dataFetchParams, preloadComponentResource } = options;
+  if (!id) {
+    lazyUtils.logger.error("id is required for prefetch!");
+    return;
+  }
+  if (!instance) {
+    lazyUtils.logger.error("instance is required for prefetch!");
+    return;
+  }
+  const matchedRemoteInfo = runtimeHelpers.utils.matchRemoteWithNameAndExpose(
+    instance.options.remotes,
+    id
+  );
+  if (!matchedRemoteInfo) {
+    lazyUtils.logger.error(`Can not found '${id}' in instance.options.remotes!`);
+    return;
+  }
+  const { remote, expose } = matchedRemoteInfo;
+  const { remoteSnapshot, globalSnapshot } = await instance.snapshotHandler.loadRemoteSnapshotInfo({
+    moduleInfo: remote,
+    id,
+    expose
+  });
+  if (preloadComponentResource) {
+    const remoteInfo = runtimeHelpers.utils.getRemoteInfo(remote);
+    Promise.resolve(
+      instance.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+        origin: instance,
+        preloadOptions: {
+          remote,
+          preloadConfig: {
+            nameOrAlias: remote.name,
+            exposes: [expose]
+          }
+        },
+        remote,
+        remoteInfo,
+        globalSnapshot,
+        remoteSnapshot
+      })
+    ).then((assets) => {
+      if (assets) {
+        runtimeHelpers.utils.preloadAssets(remoteInfo, instance, assets);
+      }
+    });
+  }
+  const dataFetchMap = lazyUtils.getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  const dataFetchInfo = lazyUtils.getDataFetchInfo({
+    name: remote.name,
+    alias: remote.alias,
+    id,
+    remoteSnapshot
+  });
+  const dataFetchMapKey = lazyUtils.getDataFetchMapKey(dataFetchInfo, {
+    name: instance.name,
+    version: instance.options.version
+  });
+  if (!dataFetchMapKey) {
+    return;
+  }
+  const dataFetchItem = dataFetchMap[dataFetchMapKey];
+  if (!dataFetchItem) {
+    return;
+  }
+  const [getDataFetchGetter, _type, getDataFetchPromise] = dataFetchItem[0];
+  let _getDataFetchPromise = getDataFetchPromise;
+  if (!getDataFetchPromise) {
+    if (!getDataFetchGetter) {
+      return;
+    }
+    _getDataFetchPromise = getDataFetchGetter();
+  }
+  _getDataFetchPromise.then((dataFetchFn) => {
+    return dataFetchFn({
+      ...dataFetchParams,
+      _id: dataFetchMapKey,
+      isDowngrade: false
+    });
+  });
+}
+exports.dataFetchFunction = dataFetchFunction;
+exports.injectDataFetch = injectDataFetch;
+exports.prefetch = prefetch;