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

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,55 @@
+// 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 { mf_name: 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,137 @@
+import {
+  getPrefetchId
+} from "../chunk-EWCGK4XA.js";
+
+// src/cli/index.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import {
+  encodeName,
+  MFPrefetchCommon
+} from "@module-federation/sdk";
+
+// 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 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__['${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}']['${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 = 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;
+        }
+      }
+    });
+    const { runtimePlugins } = this.options;
+    if (!Array.isArray(runtimePlugins)) {
+      this.options.runtimePlugins = [];
+    }
+    this.options.runtimePlugins.push(
+      path2.resolve(__dirname, "../esm/plugin.js")
+    );
+    if (!this._reWriteExports) {
+      return;
+    }
+    const encodedName = encodeName(name);
+    const asyncEntryPath = path2.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`
+    );
+    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);
+    const prefetchEntry = path2.resolve(
+      compiler.options.context,
+      `node_modules/${TEMP_DIR}/${encodedName}/${MFPrefetchCommon.fileName}`
+    );
+    fs2.writeFileSync(prefetchEntry, addTemplate(name));
+    this.options.runtimePlugins.push(prefetchEntry);
+  }
+};
+export {
+  PrefetchPlugin
+};

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import {
+  prefetchPlugin
+} from "./chunk-BN3GGCE5.js";
+import "./chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "./chunk-JEPJP5O3.js";
+import "./chunk-EWCGK4XA.js";
+export {
+  MFDataPrefetch,
+  prefetchPlugin
+};

package/dist/esm/plugin.js

@@ -0,0 +1,11 @@
+import {
+  plugin_default,
+  prefetchPlugin
+} from "./chunk-BN3GGCE5.js";
+import "./chunk-TTJJJ2WZ.js";
+import "./chunk-JEPJP5O3.js";
+import "./chunk-EWCGK4XA.js";
+export {
+  plugin_default as default,
+  prefetchPlugin
+};

package/dist/esm/react/index.js

@@ -0,0 +1,93 @@
+import {
+  prefetch
+} from "../chunk-QHQN3BPZ.js";
+import {
+  logger_default
+} from "../chunk-TTJJJ2WZ.js";
+import {
+  MFDataPrefetch
+} from "../chunk-JEPJP5O3.js";
+import {
+  getScope
+} from "../chunk-EWCGK4XA.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} - ${startTiming}`
+    );
+  }
+  const { id, functionId, deferId } = options;
+  const prefetchInfo = {
+    id,
+    functionId
+  };
+  const mfScope = getScope(id);
+  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} - ${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/universal/index.js

@@ -0,0 +1,8 @@
+import {
+  prefetch
+} from "../chunk-QHQN3BPZ.js";
+import "../chunk-JEPJP5O3.js";
+import "../chunk-EWCGK4XA.js";
+export {
+  prefetch
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,324 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MFDataPrefetch: () => MFDataPrefetch,
+  prefetchPlugin: () => prefetchPlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/prefetch.ts
+var import_runtime = require("@module-federation/runtime");
+var import_sdk2 = require("@module-federation/sdk");
+
+// src/common/runtime-utils.ts
+var import_sdk = require("@module-federation/sdk");
+var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.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;
+};
+
+// src/prefetch.ts
+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] = (0, import_sdk2.loadScript)(entry, {});
+      }
+      return this.global.entryLoading[uniqueKey];
+    } else {
+      const remoteInfo = (0, import_runtime.getRemoteInfo)(remote);
+      const module2 = origin.moduleCache.get(remoteInfo.name);
+      return (0, import_runtime.getRemoteEntry)({
+        remoteInfo,
+        remoteEntryExports: module2 ? module2.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;
+    }
+  }
+};
+
+// src/plugin.ts
+var import_sdk4 = require("@module-federation/sdk");
+
+// src/logger/index.ts
+var import_sdk3 = require("@module-federation/sdk");
+var logger_default = new import_sdk3.Logger("[Module Federation Data Prefetch]");
+
+// src/plugin.ts
+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 = (0, import_sdk4.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 _a2;
+    const { remote, id } = options;
+    const { name } = remote;
+    const promise = (_a2 = loadingArray.find((loading) => loading.id === id)) == null ? void 0 : _a2.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 = (0, import_sdk4.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;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MFDataPrefetch,
+  prefetchPlugin
+});

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+import { FederationRuntimePlugin } from '@module-federation/runtime/types';
+
+declare const prefetchPlugin: () => FederationRuntimePlugin;
+
+export { prefetchPlugin as default, prefetchPlugin };