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

package/dist/{src/prefetch.d.ts → prefetch-c08be471.d.ts}

@@ -1,6 +1,7 @@
 import { FederationHost } from '@module-federation/runtime';
 import { ModuleInfo } from '@module-federation/sdk';
 import { Remote } from '@module-federation/runtime/types';
+
 declare module '@module-federation/runtime' {
     interface Federation {
         __PREFETCH__: {
@@ -11,19 +12,19 @@ declare module '@module-federation/runtime' {
     }
 }
 type PrefetchExports = Record<string, any>;
-export interface DataPrefetchOptions {
+interface DataPrefetchOptions {
     name: string;
     remote?: Remote;
     origin?: FederationHost;
     remoteSnapshot?: ModuleInfo;
 }
-export interface prefetchOptions {
+interface prefetchOptions {
     id: string;
     functionId?: string;
     cacheStrategy?: () => boolean;
     refetchParams?: any;
 }
-export declare class MFDataPrefetch {
+declare class MFDataPrefetch {
     prefetchMemory: Map<string, Promise<any>>;
     recordOutdate: Record<string, Record<string, boolean>>;
     private _exports;
@@ -40,4 +41,5 @@ export declare class MFDataPrefetch {
     markOutdate(markOptions: Omit<prefetchOptions, 'cacheStrategy'>, isOutdate: boolean): void;
     checkOutdate(outdateOptions: prefetchOptions): boolean;
 }
-export {};
+
+export { DataPrefetchOptions as D, MFDataPrefetch as M, prefetchOptions as p };

package/dist/react/index.d.ts

@@ -0,0 +1,16 @@
+import { p as prefetchOptions } from '../prefetch-c08be471.js';
+import '@module-federation/runtime';
+import '@module-federation/sdk';
+import '@module-federation/runtime/types';
+
+type refetchParams = any;
+type prefetchReturnType<T> = [
+    Promise<T>,
+    (refetchParams?: refetchParams) => void
+];
+type UsePrefetchOptions = prefetchOptions & {
+    deferId?: string;
+};
+declare const usePrefetch: <T>(options: UsePrefetchOptions) => prefetchReturnType<T>;
+
+export { usePrefetch };

package/dist/react/index.js

@@ -0,0 +1,287 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  usePrefetch: () => usePrefetch
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/hooks.ts
+var import_react2 = require("react");
+
+// src/logger/index.ts
+var import_sdk = require("@module-federation/sdk");
+var logger_default = new import_sdk.Logger("[Module Federation Data Prefetch]");
+
+// src/prefetch.ts
+var import_runtime2 = require("@module-federation/runtime");
+var import_sdk3 = require("@module-federation/sdk");
+
+// src/common/runtime-utils.ts
+var import_runtime = require("@module-federation/runtime");
+var import_sdk2 = require("@module-federation/sdk");
+var getScope = () => {
+  return (0, import_runtime.getInstance)().options.name;
+};
+var getPrefetchId = (id) => (0, import_sdk2.encodeName)(`${id}/${import_sdk2.MFPrefetchCommon.identifier}`);
+var compatGetPrefetchId = (id) => (0, import_sdk2.encodeName)(`${id}/VmokPrefetch`);
+
+// 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_sdk3.loadScript)(entry, {});
+      }
+      return this.global.entryLoading[uniqueKey];
+    } else {
+      const remoteInfo = (0, import_runtime2.getRemoteInfo)(remote);
+      const module2 = origin.moduleCache.get(remoteInfo.name);
+      return (0, import_runtime2.getRemoteEntry)({
+        origin,
+        remoteInfo,
+        remoteEntryExports: module2 ? module2.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;
+    }
+  }
+};
+
+// 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;
+  }
+}
+
+// src/react/utils.ts
+var import_react = require("react");
+var useFirstMounted = () => {
+  const ref = (0, import_react.useRef)(true);
+  (0, import_react.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] = (0, import_react2.useState)(
+    state
+  );
+  const prefetchInstance = MFDataPrefetch.getInstance(mfScope);
+  (0, import_react2.useEffect)(() => {
+    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];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePrefetch
+});

package/dist/shared/index.d.ts

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

package/dist/shared/index.js

@@ -0,0 +1,48 @@
+"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/shared/index.ts
+var shared_exports = {};
+__export(shared_exports, {
+  default: () => shared_default
+});
+module.exports = __toCommonJS(shared_exports);
+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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/universal/index.d.ts

@@ -0,0 +1,8 @@
+import { p as prefetchOptions } from '../prefetch-c08be471.js';
+import '@module-federation/runtime';
+import '@module-federation/sdk';
+import '@module-federation/runtime/types';
+
+declare function prefetch(options: prefetchOptions): Promise<any>;
+
+export { prefetch };

package/dist/universal/index.js

@@ -0,0 +1,205 @@
+"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/universal/index.ts
+var universal_exports = {};
+__export(universal_exports, {
+  prefetch: () => prefetch
+});
+module.exports = __toCommonJS(universal_exports);
+
+// src/prefetch.ts
+var import_runtime2 = require("@module-federation/runtime");
+var import_sdk2 = require("@module-federation/sdk");
+
+// src/common/runtime-utils.ts
+var import_runtime = require("@module-federation/runtime");
+var import_sdk = require("@module-federation/sdk");
+var getScope = () => {
+  return (0, import_runtime.getInstance)().options.name;
+};
+var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
+var compatGetPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/VmokPrefetch`);
+
+// 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_runtime2.getRemoteInfo)(remote);
+      const module2 = origin.moduleCache.get(remoteInfo.name);
+      return (0, import_runtime2.getRemoteEntry)({
+        origin,
+        remoteInfo,
+        remoteEntryExports: module2 ? module2.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;
+    }
+  }
+};
+
+// 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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prefetch
+});