@module-federation/data-prefetch 0.0.0-next-20240927195332 → 0.0.0-next-20240930091801

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @module-federation/data-prefetch
 
-## 0.0.0-next-20240927195332
+## 0.0.0-next-20240930091801
 
 ### Patch Changes
 
@@ -14,8 +14,9 @@
 - Updated dependencies [9e32644]
 - Updated dependencies [9e32644]
 - Updated dependencies [9e32644]
-  - @module-federation/runtime@0.0.0-next-20240927195332
-  - @module-federation/sdk@0.0.0-next-20240927195332
+- Updated dependencies [3082116]
+  - @module-federation/runtime@0.0.0-next-20240930091801
+  - @module-federation/sdk@0.0.0-next-20240930091801
 
 ## 0.6.6
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-present nieyan(nyqykk)
+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

package/dist/{src/cli → cli}/babel.d.ts

@@ -1,4 +1,5 @@
-import type { moduleFederationPlugin } from '@module-federation/sdk';
+import { moduleFederationPlugin } from '@module-federation/sdk';
+
 interface BabelPluginOptions {
     hook_id: string;
     import_pkg: string;
@@ -34,4 +35,5 @@ declare const _default: (babel: {
         }): void;
     };
 };
-export default _default;
+
+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 { 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/{src/cli → cli}/index.d.ts

@@ -1,8 +1,10 @@
+import * as webpack from 'webpack';
+import { WebpackPluginInstance, Compiler } from 'webpack';
 import { moduleFederationPlugin } from '@module-federation/sdk';
-import type { Compiler, WebpackPluginInstance } from 'webpack';
-declare const RuntimeGlobals: typeof import("webpack").RuntimeGlobals;
-export declare function getFederationGlobalScope(runtimeGlobals: typeof RuntimeGlobals): string;
-export declare class PrefetchPlugin implements WebpackPluginInstance {
+
+declare const RuntimeGlobals: typeof webpack.RuntimeGlobals;
+declare function getFederationGlobalScope(runtimeGlobals: typeof RuntimeGlobals): string;
+declare class PrefetchPlugin implements WebpackPluginInstance {
     options: moduleFederationPlugin.ModuleFederationPluginOptions;
     private _reWriteExports;
     constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
@@ -13,4 +15,5 @@ export declare class PrefetchPlugin implements WebpackPluginInstance {
     static setRemoteIdentifier(): string;
     static removeRemoteIdentifier(): string;
 }
-export {};
+
+export { PrefetchPlugin, getFederationGlobalScope };

package/dist/cli/index.js

@@ -0,0 +1,207 @@
+"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,
+  getFederationGlobalScope: () => getFederationGlobalScope
+});
+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");
+var import_normalize_webpack_path = require("@module-federation/sdk/normalize-webpack-path");
+
+// 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_runtime = require("@module-federation/runtime");
+var import_sdk = require("@module-federation/sdk");
+var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
+
+// src/cli/index.ts
+var { RuntimeGlobals, Template } = require((0, import_normalize_webpack_path.normalizeWebpackPath)("webpack"));
+function getFederationGlobalScope(runtimeGlobals) {
+  return `${runtimeGlobals.require || "__webpack_require__"}.federation`;
+}
+var PrefetchPlugin = class {
+  constructor(options) {
+    this.options = options;
+    this._reWriteExports = "";
+  }
+  apply(compiler) {
+    var _a, _b;
+    const { name, exposes } = this.options;
+    if (!exposes) {
+      return;
+    }
+    if (!compiler.options.context) {
+      throw new Error("compiler.options.context is not defined");
+    }
+    const { runtimePlugins } = this.options;
+    if (!Array.isArray(runtimePlugins)) {
+      this.options.runtimePlugins = [];
+    }
+    const runtimePath = import_path2.default.resolve(__dirname, "../esm/plugin.js");
+    const sharedPath = import_path2.default.resolve(__dirname, "../esm/shared/index.js");
+    if (!((_a = this.options.runtimePlugins) == null ? void 0 : _a.includes(runtimePath))) {
+      this.options.runtimePlugins.push(runtimePath);
+    }
+    if (!((_b = this.options.runtimePlugins) == null ? void 0 : _b.includes(sharedPath))) {
+      this.options.runtimePlugins.push(sharedPath);
+    }
+    const encodedName = (0, import_sdk2.encodeName)(name);
+    const asyncEntryPath = import_path2.default.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`
+    );
+    if (import_fs_extra2.default.existsSync(asyncEntryPath)) {
+      import_fs_extra2.default.unlinkSync(asyncEntryPath);
+    }
+    if (!this.options.dataPrefetch) {
+      return;
+    }
+    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[0];
+      }
+      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;
+        }
+      }
+    });
+    if (!this._reWriteExports) {
+      return;
+    }
+    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);
+    new compiler.webpack.DefinePlugin({
+      FederationDataPrefetch: JSON.stringify(asyncEntryPath)
+    }).apply(compiler);
+  }
+  static addRuntime(compiler, options) {
+    const encodedName = (0, import_sdk2.encodeName)(options.name);
+    if (!compiler.options.context) {
+      throw new Error("compiler.options.context is not defined");
+    }
+    const prefetchEntry = import_path2.default.resolve(
+      compiler.options.context,
+      `node_modules/.mf/${encodedName}/bootstrap.js`
+    );
+    const federationGlobal = getFederationGlobalScope(
+      RuntimeGlobals || {}
+    );
+    return Template.asString([
+      import_fs_extra2.default.existsSync(prefetchEntry) ? Template.indent([
+        "function injectPrefetch() {",
+        Template.indent([
+          `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}']['${options.name}'] = function(){ return import('${prefetchEntry}');}`
+        ]),
+        "}",
+        `${federationGlobal}.prefetch = injectPrefetch`
+      ]) : "",
+      Template.indent([
+        `if(!${federationGlobal}.isMFRemote && ${federationGlobal}.prefetch){`,
+        `${federationGlobal}.prefetch()`,
+        "}"
+      ])
+    ]);
+  }
+  static setRemoteIdentifier() {
+    const federationGlobal = getFederationGlobalScope(
+      RuntimeGlobals || {}
+    );
+    return Template.indent([`${federationGlobal}.isMFRemote = true;`]);
+  }
+  static removeRemoteIdentifier() {
+    const federationGlobal = getFederationGlobalScope(
+      RuntimeGlobals || {}
+    );
+    return Template.indent([`${federationGlobal}.isMFRemote = false;`]);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrefetchPlugin,
+  getFederationGlobalScope
+});

package/dist/esm/chunk-AJPO2B2T.js

@@ -0,0 +1,30 @@
+// src/common/runtime-utils.ts
+import { getInstance } from "@module-federation/runtime";
+import {
+  encodeName,
+  MFPrefetchCommon
+} from "@module-federation/sdk";
+var getScope = () => {
+  return getInstance().options.name;
+};
+var getPrefetchId = (id) => encodeName(`${id}/${MFPrefetchCommon.identifier}`);
+var compatGetPrefetchId = (id) => encodeName(`${id}/VmokPrefetch`);
+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,
+  compatGetPrefetchId,
+  getSignalFromManifest
+};

package/dist/esm/chunk-BGNOVRH5.js

@@ -0,0 +1,166 @@
+import {
+  logger_default
+} from "./chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "./chunk-ISF7VMBW.js";
+import {
+  getSignalFromManifest
+} from "./chunk-AJPO2B2T.js";
+
+// src/plugin.ts
+import { getResourceUrl } from "@module-federation/sdk";
+var loadingArray = [];
+var strategy = "loaded-first";
+var sharedFlag = strategy;
+var prefetchPlugin = () => ({
+  name: "data-prefetch-runtime-plugin",
+  initContainer(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;
+    }
+    if (sharedFlag !== strategy) {
+      throw new Error(
+        `[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`
+      );
+    }
+    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;
+      }
+      return Promise.resolve().then(() => {
+        const exports = instance.getExposeExports(id);
+        logger_default.info(
+          `1. Start Prefetch initContainer: ${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;
+  },
+  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 inited = loadingArray.some((info) => info.id === id);
+    if (!inited) {
+      return options;
+    }
+    if (sharedFlag !== strategy) {
+      throw new Error(
+        `[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`
+      );
+    }
+    const instance = MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
+    let prefetchUrl;
+    if (snapshot.prefetchEntry) {
+      prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry);
+    }
+    const index = loadingArray.findIndex((loading) => loading.id === id);
+    if (index !== -1) {
+      loadingArray.splice(index, 1);
+    }
+    const promise = instance.loadEntry(prefetchUrl).then(async () => {
+      const projectExports = instance.getProjectExports();
+      if (projectExports instanceof Promise) {
+        await projectExports;
+      }
+      return Promise.resolve().then(() => {
+        const exports = instance.getExposeExports(id);
+        logger_default.info(
+          `1. Start Prefetch afterResolve: ${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;
+  },
+  beforeLoadShare(options) {
+    const shareInfo = options.shareInfo;
+    sharedFlag = (shareInfo == null ? void 0 : shareInfo.strategy) || sharedFlag;
+    return options;
+  }
+});
+var plugin_default = prefetchPlugin;
+
+export {
+  prefetchPlugin,
+  plugin_default
+};

package/dist/esm/chunk-EZUCZHGV.js

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};