@module-federation/data-prefetch 0.0.0-next-20240617071542

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+@module-federation/data-prefetch
+
+## 0.0.0-next-20240617071542
+
+### Patch Changes
+
+- Updated dependencies [103cd07]
+- Updated dependencies [364f2bc]
+  - @module-federation/runtime@0.0.0-next-20240617071542
+  - @module-federation/sdk@0.0.0-next-20240617071542

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson) Zhou Shaw (zhouxiao)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+Vmok Interface Prefetch
+https://vmok.bytedance.net/guide/performance/prefetch.html

package/dist/cli/babel.d.ts

@@ -0,0 +1,39 @@
+import { moduleFederationPlugin } from '@module-federation/sdk';
+
+interface BabelPluginOptions {
+    hook_id: string;
+    import_pkg: string;
+    attribute: string;
+    mf_name: string;
+    exposes: moduleFederationPlugin.ModuleFederationPluginOptions['exposes'];
+}
+declare const _default: (babel: {
+    types: any;
+}, options: BabelPluginOptions) => {
+    visitor?: undefined;
+} | {
+    visitor: {
+        ImportDeclaration(nodePath: {
+            node: {
+                source: {
+                    value: any;
+                };
+                specifiers: any;
+            };
+        }, state: {
+            file: {
+                opts: {
+                    filename: any;
+                };
+            };
+        }): void;
+        CallExpression(nodePath: {
+            node: {
+                callee: any;
+                arguments: string | any[];
+            };
+        }): void;
+    };
+};
+
+export { _default as default };

package/dist/cli/babel.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/babel.ts
+var babel_exports = {};
+__export(babel_exports, {
+  default: () => babel_default
+});
+module.exports = __toCommonJS(babel_exports);
+var import_path = __toESM(require("path"));
+var attribute = "id";
+var hookId = "usePrefetch";
+var importPackage = "@module-federation/data-prefetch/react";
+var babel_default = (babel, options) => {
+  const t = babel.types;
+  let shouldHandle = false;
+  let scope = "";
+  const { mf_name: name, exposes } = options;
+  if (!exposes) {
+    return {};
+  }
+  const exposesKey = Object.keys(exposes);
+  const processedExposes = exposesKey.map((expose) => ({
+    key: expose.replace(".", ""),
+    value: import_path.default.resolve(
+      typeof exposes[expose] === "string" ? exposes[expose] : exposes[expose].import
+    )
+  }));
+  return {
+    visitor: {
+      ImportDeclaration(nodePath, state) {
+        const source = nodePath.node.source.value;
+        const { specifiers } = nodePath.node;
+        const { filename } = state.file.opts;
+        if (source === importPackage) {
+          shouldHandle = specifiers.some(
+            (specifier) => specifier.imported && specifier.imported.name === hookId && processedExposes.find(
+              (expose) => expose.value === filename && (scope = expose.key)
+            )
+          );
+        }
+      },
+      CallExpression(nodePath) {
+        if (shouldHandle && t.isIdentifier(nodePath.node.callee, { name: hookId }) && nodePath.node.arguments.length > 0) {
+          const objectExpression = nodePath.node.arguments[0];
+          if (objectExpression && t.isObjectExpression(objectExpression) && !objectExpression.properties.find(
+            (p) => p.key.name === attribute
+          )) {
+            objectExpression.properties.push(
+              t.objectProperty(
+                t.identifier(attribute),
+                t.stringLiteral(name + scope)
+              )
+            );
+          }
+        }
+      }
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/cli/index.d.ts

@@ -0,0 +1,11 @@
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import { WebpackPluginInstance, Compiler } from 'webpack';
+
+declare class PrefetchPlugin implements WebpackPluginInstance {
+    options: moduleFederationPlugin.ModuleFederationPluginOptions;
+    private _reWriteExports;
+    constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
+    apply(compiler: Compiler): void;
+}
+
+export { PrefetchPlugin };

package/dist/cli/index.js

@@ -0,0 +1,165 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/index.ts
+var cli_exports = {};
+__export(cli_exports, {
+  PrefetchPlugin: () => PrefetchPlugin
+});
+module.exports = __toCommonJS(cli_exports);
+var import_path2 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_sdk2 = require("@module-federation/sdk");
+
+// src/common/constant.ts
+var TEMP_DIR = ".mf";
+
+// src/common/node-utils.ts
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var fileExistsWithCaseSync = (filepath) => {
+  const dir = import_path.default.dirname(filepath);
+  if (filepath === "/" || filepath === ".") {
+    return true;
+  }
+  const filenames = import_fs_extra.default.readdirSync(dir);
+  if (filenames.indexOf(import_path.default.basename(filepath)) === -1) {
+    return false;
+  }
+  return fileExistsWithCaseSync(dir);
+};
+var fixPrefetchPath = (exposePath) => {
+  const pathExt = [".js", ".ts"];
+  const extReg = /\.(ts|js|tsx|jsx)$/;
+  if (extReg.test(exposePath)) {
+    return pathExt.map((ext) => exposePath.replace(extReg, `.prefetch${ext}`));
+  } else {
+    return pathExt.map((ext) => exposePath + `.prefetch${ext}`);
+  }
+};
+
+// src/common/runtime-utils.ts
+var import_sdk = require("@module-federation/sdk");
+var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
+
+// src/cli/index.ts
+var addTemplate = (name) => `
+export default function () {
+  let hasInit = false;
+  return {
+    name: 'data-prefetch-init-plugin',
+    beforeInit(args) {
+      if (!hasInit) {
+        hasInit = true;
+        globalThis.__FEDERATION__ = globalThis.__FEDERATION__ || {};
+        globalThis.__FEDERATION__['${import_sdk2.MFPrefetchCommon.globalKey}'] = globalThis.__FEDERATION__['${import_sdk2.MFPrefetchCommon.globalKey}'] || {
+          entryLoading: {},
+          instance: new Map(),
+          __PREFETCH_EXPORTS__: {},
+        };
+        globalThis.__FEDERATION__['${import_sdk2.MFPrefetchCommon.globalKey}']['${import_sdk2.MFPrefetchCommon.exportsKey}'] = globalThis.__FEDERATION__['${import_sdk2.MFPrefetchCommon.globalKey}']['${import_sdk2.MFPrefetchCommon.exportsKey}'] || {};
+        globalThis.__FEDERATION__['${import_sdk2.MFPrefetchCommon.globalKey}']['${import_sdk2.MFPrefetchCommon.exportsKey}']['${name}'] = import('./bootstrap');
+      }
+      return args;
+    }
+  }
+}
+`;
+var PrefetchPlugin = class {
+  constructor(options) {
+    this.options = options;
+    this._reWriteExports = "";
+  }
+  apply(compiler) {
+    const { name, exposes } = this.options;
+    if (!exposes) {
+      return;
+    }
+    if (!compiler.options.context) {
+      throw new Error("compiler.options.context is not defined");
+    }
+    const prefetchs = [];
+    const exposeAlias = Object.keys(exposes);
+    exposeAlias.forEach((alias) => {
+      let exposePath;
+      const exposeValue = exposes[alias];
+      if (typeof exposeValue === "string") {
+        exposePath = exposeValue;
+      } else {
+        exposePath = exposeValue.import;
+      }
+      const targetPaths = fixPrefetchPath(exposePath);
+      for (const pathItem of targetPaths) {
+        const absolutePath = import_path2.default.resolve(compiler.options.context, pathItem);
+        if (fileExistsWithCaseSync(absolutePath)) {
+          prefetchs.push(pathItem);
+          const absoluteAlias = alias.replace(".", "");
+          this._reWriteExports += `export * as ${getPrefetchId(
+            `${name}${absoluteAlias}`
+          )} from '${absolutePath}';
+`;
+          break;
+        }
+      }
+    });
+    const { runtimePlugins } = this.options;
+    if (!Array.isArray(runtimePlugins)) {
+      this.options.runtimePlugins = [];
+    }
+    this.options.runtimePlugins.push(
+      import_path2.default.resolve(__dirname, "../esm/plugin.js")
+    );
+    if (!this._reWriteExports) {
+      return;
+    }
+    const encodedName = (0, import_sdk2.encodeName)(name);
+    const asyncEntryPath = import_path2.default.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`
+    );
+    const tempDirRealPath = import_path2.default.resolve(
+      compiler.options.context,
+      "node_modules",
+      TEMP_DIR
+    );
+    if (!import_fs_extra2.default.existsSync(tempDirRealPath)) {
+      import_fs_extra2.default.mkdirSync(tempDirRealPath);
+    }
+    if (!import_fs_extra2.default.existsSync(`${tempDirRealPath}/${encodedName}`)) {
+      import_fs_extra2.default.mkdirSync(`${tempDirRealPath}/${encodedName}`);
+    }
+    import_fs_extra2.default.writeFileSync(asyncEntryPath, this._reWriteExports);
+    const prefetchEntry = import_path2.default.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/${import_sdk2.MFPrefetchCommon.fileName}`
+    );
+    import_fs_extra2.default.writeFileSync(prefetchEntry, addTemplate(name));
+    this.options.runtimePlugins.push(prefetchEntry);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrefetchPlugin
+});

package/dist/esm/chunk-BN3GGCE5.js

@@ -0,0 +1,136 @@
+import {
+  logger_default
+} from "./chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "./chunk-JEPJP5O3.js";
+import {
+  getSignalFromManifest
+} from "./chunk-EWCGK4XA.js";
+
+// src/plugin.ts
+import { getResourceUrl } from "@module-federation/sdk";
+var loadingArray = [];
+var prefetchPlugin = () => ({
+  name: "data-prefetch-runtime-plugin",
+  afterResolve(options) {
+    const { remoteSnapshot, remoteInfo, id, origin } = options;
+    const snapshot = remoteSnapshot;
+    const { name } = remoteInfo;
+    const prefetchOptions = {
+      name,
+      remote: remoteInfo,
+      origin,
+      remoteSnapshot: snapshot
+    };
+    const signal = getSignalFromManifest(snapshot);
+    if (!signal) {
+      return options;
+    }
+    const instance = MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
+    let prefetchUrl;
+    if (snapshot.prefetchEntry) {
+      prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry);
+    }
+    const exist = loadingArray.find((loading) => loading.id === id);
+    if (exist) {
+      return options;
+    }
+    const promise = instance.loadEntry(prefetchUrl).then(async () => {
+      const projectExports = instance.getProjectExports();
+      if (projectExports instanceof Promise) {
+        await projectExports;
+      }
+      const exports = instance.getExposeExports(id);
+      logger_default.info(`1. Start Prefetch: ${id} - ${performance.now()}`);
+      const result = Object.keys(exports).map((k) => {
+        const value = instance.prefetch({
+          id,
+          functionId: k
+        });
+        const functionId = k;
+        return {
+          value,
+          functionId
+        };
+      });
+      return result;
+    });
+    loadingArray.push({
+      id,
+      promise
+    });
+    return options;
+  },
+  async onLoad(options) {
+    var _a;
+    const { remote, id } = options;
+    const { name } = remote;
+    const promise = (_a = loadingArray.find((loading) => loading.id === id)) == null ? void 0 : _a.promise;
+    if (promise) {
+      const prefetch = await promise;
+      const prefetchValue = prefetch.map((result) => result.value);
+      await Promise.all(prefetchValue);
+      const instance = MFDataPrefetch.getInstance(name);
+      prefetch.forEach((result) => {
+        const { value, functionId } = result;
+        instance.memorize(id + functionId, value);
+      });
+    }
+    return options;
+  },
+  handlePreloadModule(options) {
+    const { remoteSnapshot, name, id, preloadConfig, origin, remote } = options;
+    const snapshot = remoteSnapshot;
+    const signal = getSignalFromManifest(snapshot);
+    if (!signal) {
+      return options;
+    }
+    const prefetchOptions = {
+      name,
+      origin,
+      remote,
+      remoteSnapshot: snapshot
+    };
+    const instance = MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
+    let prefetchUrl;
+    if (snapshot.prefetchEntry) {
+      prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry);
+    }
+    if (!preloadConfig.prefetchInterface) {
+      instance.loadEntry(prefetchUrl);
+      return options;
+    }
+    const promise = instance.loadEntry(prefetchUrl).then(async () => {
+      const projectExports = instance.getProjectExports();
+      if (projectExports instanceof Promise) {
+        await projectExports;
+      }
+      const exports = instance.getExposeExports(id);
+      logger_default.info(`1. Start Prefetch: ${id} - ${performance.now()}`);
+      const result = Object.keys(exports).map((k) => {
+        const value = instance.prefetch({
+          id,
+          functionId: k
+        });
+        const functionId = k;
+        return {
+          value,
+          functionId
+        };
+      });
+      return result;
+    });
+    loadingArray.push({
+      id,
+      promise
+    });
+    return options;
+  }
+});
+var plugin_default = prefetchPlugin;
+
+export {
+  prefetchPlugin,
+  plugin_default
+};

package/dist/esm/chunk-EWCGK4XA.js

@@ -0,0 +1,32 @@
+// src/common/runtime-utils.ts
+import {
+  encodeName,
+  MFPrefetchCommon
+} from "@module-federation/sdk";
+var getScope = (id) => {
+  const idArray = id.split("/");
+  if (idArray.length >= 2) {
+    idArray.pop();
+  }
+  const name = idArray.join("/");
+  return name;
+};
+var getPrefetchId = (id) => encodeName(`${id}/${MFPrefetchCommon.identifier}`);
+var getSignalFromManifest = (remoteSnapshot) => {
+  if (!remoteSnapshot) {
+    return false;
+  }
+  if (!("prefetchEntry" in remoteSnapshot) && !("prefetchInterface" in remoteSnapshot)) {
+    return false;
+  }
+  if (!remoteSnapshot.prefetchEntry && !remoteSnapshot.prefetchInterface) {
+    return false;
+  }
+  return true;
+};
+
+export {
+  getScope,
+  getPrefetchId,
+  getSignalFromManifest
+};

package/dist/esm/chunk-JEPJP5O3.js

@@ -0,0 +1,160 @@
+import {
+  getPrefetchId
+} from "./chunk-EWCGK4XA.js";
+
+// src/prefetch.ts
+import {
+  getRemoteEntry,
+  getRemoteInfo
+} from "@module-federation/runtime";
+import {
+  loadScript
+} from "@module-federation/sdk";
+globalThis.__FEDERATION__ ?? (globalThis.__FEDERATION__ = {});
+var _a;
+(_a = globalThis.__FEDERATION__).__PREFETCH__ ?? (_a.__PREFETCH__ = {
+  entryLoading: {},
+  instance: /* @__PURE__ */ new Map(),
+  __PREFETCH_EXPORTS__: {}
+});
+var MFDataPrefetch = class {
+  constructor(options) {
+    this.prefetchMemory = /* @__PURE__ */ new Map();
+    this.recordOutdate = {};
+    this._exports = {};
+    this._options = options;
+    this.global.instance.set(options.name, this);
+  }
+  get global() {
+    return globalThis.__FEDERATION__.__PREFETCH__;
+  }
+  static getInstance(id) {
+    return globalThis.__FEDERATION__.__PREFETCH__.instance.get(id);
+  }
+  async loadEntry(entry) {
+    const { name, remoteSnapshot, remote, origin } = this._options;
+    if (entry) {
+      const { buildVersion, globalName } = remoteSnapshot;
+      const uniqueKey = globalName || `${name}:${buildVersion}`;
+      if (!this.global.entryLoading[uniqueKey]) {
+        this.global.entryLoading[uniqueKey] = loadScript(entry, {});
+      }
+      return this.global.entryLoading[uniqueKey];
+    } else {
+      const remoteInfo = getRemoteInfo(remote);
+      const module = origin.moduleCache.get(remoteInfo.name);
+      return getRemoteEntry({
+        remoteInfo,
+        remoteEntryExports: module ? module.remoteEntryExports : void 0,
+        createScriptHook: (url) => {
+          const res = origin.loaderHook.lifecycle.createScript.emit({
+            url
+          });
+          if (res instanceof HTMLScriptElement) {
+            return res;
+          }
+          return;
+        }
+      });
+    }
+  }
+  getProjectExports() {
+    var _a2;
+    if (Object.keys(this._exports).length > 0) {
+      return this._exports;
+    }
+    const { name } = this._options;
+    const exportsPromise = (_a2 = globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__) == null ? void 0 : _a2[name];
+    const resolve = exportsPromise.then(
+      (exports = {}) => {
+        const memory = {};
+        Object.keys(exports).forEach((key) => {
+          memory[key] = {};
+          const exportVal = exports[key];
+          Object.keys(exportVal).reduce(
+            (memo, current) => {
+              if (current.toLocaleLowerCase().endsWith("prefetch") || current.toLocaleLowerCase() === "default") {
+                memo[current] = exportVal[current];
+              }
+              return memo;
+            },
+            memory[key]
+          );
+        });
+        this.memorizeExports(memory);
+      }
+    );
+    return resolve;
+  }
+  memorizeExports(exports) {
+    this._exports = exports;
+  }
+  getExposeExports(id) {
+    const prefetchId = getPrefetchId(id);
+    const prefetchExports = this._exports[prefetchId];
+    return prefetchExports || {};
+  }
+  prefetch(prefetchOptions) {
+    const { id, functionId = "default", refetchParams } = prefetchOptions;
+    let prefetchResult;
+    const prefetchId = getPrefetchId(id);
+    const memorizeId = id + functionId;
+    const memory = this.prefetchMemory.get(memorizeId);
+    if (!this.checkOutdate(prefetchOptions) && memory) {
+      return memory;
+    }
+    const prefetchExports = this._exports[prefetchId];
+    if (!prefetchExports) {
+      return;
+    }
+    const executePrefetch = prefetchExports[functionId];
+    if (typeof executePrefetch === "function") {
+      if (refetchParams) {
+        prefetchResult = executePrefetch(refetchParams);
+      } else {
+        prefetchResult = executePrefetch();
+      }
+    } else {
+      throw new Error(
+        `[Module Federation Data Prefetch]: No prefetch function called ${functionId} export in prefetch file`
+      );
+    }
+    this.memorize(memorizeId, prefetchResult);
+    return prefetchResult;
+  }
+  memorize(id, value) {
+    this.prefetchMemory.set(id, value);
+  }
+  markOutdate(markOptions, isOutdate) {
+    const { id, functionId = "default" } = markOptions;
+    if (!this.recordOutdate[id]) {
+      this.recordOutdate[id] = {};
+    }
+    this.recordOutdate[id][functionId] = isOutdate;
+  }
+  checkOutdate(outdateOptions) {
+    const { id, functionId = "default", cacheStrategy } = outdateOptions;
+    if (typeof cacheStrategy === "function") {
+      return cacheStrategy();
+    }
+    if (!this.recordOutdate[id]) {
+      this.recordOutdate[id] = {};
+    }
+    if (this.recordOutdate[id][functionId]) {
+      this.markOutdate(
+        {
+          id,
+          functionId
+        },
+        false
+      );
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+export {
+  MFDataPrefetch
+};

package/dist/esm/chunk-QHQN3BPZ.js

@@ -0,0 +1,32 @@
+import {
+  MFDataPrefetch
+} from "./chunk-JEPJP5O3.js";
+import {
+  getScope
+} from "./chunk-EWCGK4XA.js";
+
+// src/universal/index.ts
+function prefetch(options) {
+  const { id, functionId } = options;
+  const mfScope = getScope(id);
+  const prefetchInstance = MFDataPrefetch.getInstance(mfScope) || new MFDataPrefetch({
+    name: mfScope
+  });
+  const res = prefetchInstance.getProjectExports();
+  if (res instanceof Promise) {
+    const promise = res.then(() => {
+      const result = prefetchInstance.prefetch(options);
+      prefetchInstance.memorize(id + functionId, result);
+      return result;
+    });
+    return promise;
+  } else {
+    const result = prefetchInstance.prefetch(options);
+    prefetchInstance.memorize(id + functionId, result);
+    return result;
+  }
+}
+
+export {
+  prefetch
+};