@module-federation/data-prefetch 0.0.0-next-20241010063233 → 0.0.0-next-20241010084324

package/dist/esm/chunk-ISF7VMBW.js

@@ -0,0 +1,156 @@
+import {
+  compatGetPrefetchId,
+  getPrefetchId
+} from "./chunk-AJPO2B2T.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({
+        origin,
+        remoteInfo,
+        remoteEntryExports: module ? module.remoteEntryExports : void 0
+      });
+    }
+  }
+  getProjectExports() {
+    var _a2;
+    if (Object.keys(this._exports).length > 0) {
+      return this._exports;
+    }
+    const { name } = this._options;
+    const exportsPromiseFn = (_a2 = globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__) == null ? void 0 : _a2[name];
+    const exportsPromise = typeof exportsPromiseFn === "function" ? exportsPromiseFn() : Promise.resolve({});
+    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 compatId = compatGetPrefetchId(id);
+    const prefetchExports = this._exports[prefetchId] || this._exports[compatId];
+    return prefetchExports || {};
+  }
+  prefetch(prefetchOptions) {
+    const { id, functionId = "default", refetchParams } = prefetchOptions;
+    let prefetchResult;
+    const prefetchId = getPrefetchId(id);
+    const compatId = compatGetPrefetchId(id);
+    const memorizeId = id + functionId;
+    const memory = this.prefetchMemory.get(memorizeId);
+    if (!this.checkOutdate(prefetchOptions) && memory) {
+      return memory;
+    }
+    const prefetchExports = this._exports[prefetchId] || this._exports[compatId];
+    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-OCDMSRMZ.js

@@ -0,0 +1,32 @@
+import {
+  MFDataPrefetch
+} from "./chunk-ISF7VMBW.js";
+import {
+  getScope
+} from "./chunk-AJPO2B2T.js";
+
+// src/universal/index.ts
+function prefetch(options) {
+  const { id, functionId = "default" } = options;
+  const mfScope = getScope();
+  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
+};

package/dist/esm/chunk-TTJJJ2WZ.js

@@ -0,0 +1,7 @@
+// src/logger/index.ts
+import { Logger } from "@module-federation/sdk";
+var logger_default = new Logger("[Module Federation Data Prefetch]");
+
+export {
+  logger_default
+};

package/dist/esm/cli/babel.js

@@ -0,0 +1,57 @@
+import "../chunk-EZUCZHGV.js";
+
+// src/cli/babel.ts
+import path from "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: path.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)
+              )
+            );
+          }
+        }
+      }
+    }
+  };
+};
+export {
+  babel_default as default
+};

package/dist/esm/cli/index.js

@@ -0,0 +1,180 @@
+import {
+  getPrefetchId
+} from "../chunk-AJPO2B2T.js";
+import {
+  __require
+} from "../chunk-EZUCZHGV.js";
+
+// src/cli/index.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import {
+  encodeName,
+  MFPrefetchCommon
+} from "@module-federation/sdk";
+import { normalizeWebpackPath } from "@module-federation/sdk/normalize-webpack-path";
+
+// src/common/constant.ts
+var TEMP_DIR = ".mf";
+
+// src/common/node-utils.ts
+import path from "path";
+import fs from "fs-extra";
+var fileExistsWithCaseSync = (filepath) => {
+  const dir = path.dirname(filepath);
+  if (filepath === "/" || filepath === ".") {
+    return true;
+  }
+  const filenames = fs.readdirSync(dir);
+  if (filenames.indexOf(path.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/cli/index.ts
+var { RuntimeGlobals, Template } = __require(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 = path2.resolve(__dirname, "../esm/plugin.js");
+    const sharedPath = path2.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 = encodeName(name);
+    const asyncEntryPath = path2.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`
+    );
+    if (fs2.existsSync(asyncEntryPath)) {
+      fs2.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 = path2.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 = path2.resolve(
+      compiler.options.context,
+      "node_modules",
+      TEMP_DIR
+    );
+    if (!fs2.existsSync(tempDirRealPath)) {
+      fs2.mkdirSync(tempDirRealPath);
+    }
+    if (!fs2.existsSync(`${tempDirRealPath}/${encodedName}`)) {
+      fs2.mkdirSync(`${tempDirRealPath}/${encodedName}`);
+    }
+    fs2.writeFileSync(asyncEntryPath, this._reWriteExports);
+    new compiler.webpack.DefinePlugin({
+      FederationDataPrefetch: JSON.stringify(asyncEntryPath)
+    }).apply(compiler);
+  }
+  static addRuntime(compiler, options) {
+    const encodedName = encodeName(options.name);
+    if (!compiler.options.context) {
+      throw new Error("compiler.options.context is not defined");
+    }
+    const prefetchEntry = path2.resolve(
+      compiler.options.context,
+      `node_modules/.mf/${encodedName}/bootstrap.js`
+    );
+    const federationGlobal = getFederationGlobalScope(
+      RuntimeGlobals || {}
+    );
+    return Template.asString([
+      fs2.existsSync(prefetchEntry) ? Template.indent([
+        "function injectPrefetch() {",
+        Template.indent([
+          `globalThis.__FEDERATION__ = globalThis.__FEDERATION__ || {};`,
+          `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] || {`,
+          `entryLoading: {},`,
+          `instance: new Map(),`,
+          `__PREFETCH_EXPORTS__: {},`,
+          `};`,
+          `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] || {};`,
+          `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${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;`]);
+  }
+};
+export {
+  PrefetchPlugin,
+  getFederationGlobalScope
+};

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+import {
+  prefetchPlugin
+} from "./chunk-BGNOVRH5.js";
+import "./chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "./chunk-ISF7VMBW.js";
+import "./chunk-AJPO2B2T.js";
+import "./chunk-EZUCZHGV.js";
+export {
+  MFDataPrefetch,
+  prefetchPlugin
+};

package/dist/esm/plugin.js

@@ -0,0 +1,12 @@
+import {
+  plugin_default,
+  prefetchPlugin
+} from "./chunk-BGNOVRH5.js";
+import "./chunk-TTJJJ2WZ.js";
+import "./chunk-ISF7VMBW.js";
+import "./chunk-AJPO2B2T.js";
+import "./chunk-EZUCZHGV.js";
+export {
+  plugin_default as default,
+  prefetchPlugin
+};

package/dist/esm/react/index.js

@@ -0,0 +1,94 @@
+import {
+  prefetch
+} from "../chunk-OCDMSRMZ.js";
+import {
+  logger_default
+} from "../chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "../chunk-ISF7VMBW.js";
+import {
+  getScope
+} from "../chunk-AJPO2B2T.js";
+import "../chunk-EZUCZHGV.js";
+
+// src/react/hooks.ts
+import { useEffect as useEffect2, useState } from "react";
+
+// src/react/utils.ts
+import { useEffect, useRef } from "react";
+var useFirstMounted = () => {
+  const ref = useRef(true);
+  useEffect(() => {
+    ref.current = false;
+  }, []);
+  return ref.current;
+};
+
+// src/react/hooks.ts
+var usePrefetch = (options) => {
+  const isFirstMounted = useFirstMounted();
+  if (isFirstMounted) {
+    const startTiming = performance.now();
+    logger_default.info(
+      `2. Start Get Prefetch Data: ${options.id} - ${options.functionId || "default"} - ${startTiming}`
+    );
+  }
+  const { id, functionId, deferId } = options;
+  const prefetchInfo = {
+    id,
+    functionId
+  };
+  const mfScope = getScope();
+  let state;
+  const prefetchResult = prefetch(options);
+  if (deferId) {
+    if (prefetchResult instanceof Promise) {
+      state = prefetchResult.then(
+        (deferredData) => deferredData.data[deferId]
+      );
+    } else {
+      state = prefetchResult.data[deferId];
+    }
+  } else {
+    state = prefetchResult;
+  }
+  const [prefetchState, setPrefetchState] = useState(
+    state
+  );
+  const prefetchInstance = MFDataPrefetch.getInstance(mfScope);
+  useEffect2(() => {
+    const useEffectTiming = performance.now();
+    logger_default.info(
+      `3. Start Execute UseEffect: ${options.id} - ${options.functionId || "default"} - ${useEffectTiming}`
+    );
+    return () => {
+      prefetchInstance == null ? void 0 : prefetchInstance.markOutdate(prefetchInfo, true);
+    };
+  }, []);
+  const refreshExecutor = (refetchParams) => {
+    const refetchOptions = {
+      ...options
+    };
+    if (refetchParams) {
+      refetchOptions.refetchParams = refetchParams;
+    }
+    prefetchInstance == null ? void 0 : prefetchInstance.markOutdate(prefetchInfo, true);
+    const newVal = prefetch(refetchOptions);
+    let newState;
+    if (deferId) {
+      if (newVal instanceof Promise) {
+        newState = newVal.then((deferredData) => deferredData.data[deferId]);
+      } else {
+        newState = newVal.data[deferId];
+      }
+    } else {
+      newState = newVal;
+    }
+    setPrefetchState(newState);
+  };
+  return [prefetchState, refreshExecutor];
+};
+export {
+  usePrefetch
+};

package/dist/esm/shared/index.js

@@ -0,0 +1,27 @@
+import "../chunk-EZUCZHGV.js";
+
+// src/shared/index.ts
+var sharedStrategy = () => ({
+  name: "shared-strategy",
+  beforeInit(args) {
+    const { userOptions } = args;
+    const shared = userOptions.shared;
+    if (shared) {
+      Object.keys(shared).forEach((sharedKey) => {
+        const sharedConfigs = shared[sharedKey];
+        const arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [sharedConfigs];
+        arraySharedConfigs.forEach((s) => {
+          s.strategy = "loaded-first";
+        });
+      });
+      console.warn(
+        `[Module Federation Data Prefetch]: Your shared strategy is set to 'loaded-first', this is a necessary condition for data prefetch`
+      );
+    }
+    return args;
+  }
+});
+var shared_default = sharedStrategy;
+export {
+  shared_default as default
+};

package/dist/esm/universal/index.js

@@ -0,0 +1,9 @@
+import {
+  prefetch
+} from "../chunk-OCDMSRMZ.js";
+import "../chunk-ISF7VMBW.js";
+import "../chunk-AJPO2B2T.js";
+import "../chunk-EZUCZHGV.js";
+export {
+  prefetch
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { D as DataPrefetchOptions, M as MFDataPrefetch, p as prefetchOptions } from './prefetch-c08be471.js';
+export { default as prefetchPlugin } from './plugin.js';
+import '@module-federation/runtime';
+import '@module-federation/sdk';
+import '@module-federation/runtime/types';