@module-federation/data-prefetch 1.0.16 → 2.0.1

package/__tests__/prefetch.spec.ts

@@ -1,138 +0,0 @@
-// Import the necessary modules and functions
-import { MFDataPrefetch } from '../src/prefetch';
-import {
-  loadScript,
-  MFPrefetchCommon,
-  encodeName,
-} from '@module-federation/sdk';
-
-// Mock loadScript function from SDK
-jest.mock('@module-federation/sdk', () => {
-  const originalModule = jest.requireActual('@module-federation/sdk');
-  return {
-    ...originalModule,
-    loadScript: jest.fn(() => Promise.resolve()),
-  };
-});
-
-describe('MF Data Prefetch', () => {
-  let prefetch: MFDataPrefetch;
-
-  const options = {
-    name: '@mf/test',
-    remoteSnapshot: {
-      buildVersion: '1.0.0',
-      globalName: 'TestGlobalName',
-    },
-  };
-  const exposeId = `${options.name}/button/${MFPrefetchCommon.identifier}`;
-
-  beforeEach(() => {
-    globalThis.__FEDERATION__.__PREFETCH__ = {
-      entryLoading: {},
-      instance: new Map(),
-      __PREFETCH_EXPORTS__: {},
-    };
-    // @ts-ignore
-    prefetch = new MFDataPrefetch(options);
-  });
-  afterAll(() => {
-    // @ts-ignore
-    delete globalThis.__FEDERATION__;
-  });
-
-  // Instance gets added to global memory on creation
-  it('adds itself to global instances on creation', () => {
-    expect(prefetch.global.instance.get(options.name)).toBe(prefetch);
-  });
-
-  // Loads entry script using loadScript from sdk
-  it('loads entry script using loadScript from sdk', async () => {
-    const url = 'testUrl'; // Url of the script to be loaded
-
-    await prefetch.loadEntry(url); // Call `loadEntry` function
-
-    // Expect that the loadScript function is called with the correct url
-    expect(loadScript).toHaveBeenCalledWith(url, expect.any(Object));
-  });
-
-  // Retrieves project exports
-  it('gets project exports', async () => {
-    const exposeExport = {
-      nyPrefetch: () => {},
-    };
-    const projectExport = {
-      [encodeName(exposeId)]: exposeExport,
-    };
-    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[options.name] =
-      Promise.resolve(projectExport);
-
-    await prefetch.getProjectExports();
-    expect(prefetch.getExposeExports(`${options.name}/button`)).toEqual(
-      exposeExport,
-    );
-  });
-  // Prefetching with memory and executing prefetch function
-  it('executes prefetch using prefetch function with and without memory', async () => {
-    const id = options.name;
-    const functionId = 'nyPrefetch';
-    const refetchParams = 'testParams';
-    const prefetchOptions = { id: `${id}/button`, functionId, refetchParams };
-
-    // Creating a mock prefetch function
-    const executePrefetch = jest.fn(() => 'Expected Result');
-    const prefetchExports = { [functionId]: executePrefetch };
-
-    // Mock Project Exports
-    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[id] =
-      Promise.resolve({
-        [encodeName(exposeId)]: prefetchExports,
-      });
-
-    await prefetch.getProjectExports();
-    // Call the prefetch function first time
-    let result = await prefetch.prefetch(prefetchOptions);
-
-    // Verify that executePrefetch function is correctly executed
-    expect(executePrefetch).toHaveBeenCalled();
-
-    // Clear mock function calls data
-    executePrefetch.mockClear();
-
-    // Call the prefetch function again
-    result = await prefetch.prefetch(prefetchOptions);
-
-    // Verify that executePrefetch function is NOT called this time (since the result should come from memory)
-    expect(executePrefetch).not.toHaveBeenCalled();
-
-    // Clear mock function calls data
-    executePrefetch.mockClear();
-
-    prefetch.markOutdate(prefetchOptions, true);
-
-    // Call the prefetch function first time
-    result = await prefetch.prefetch(prefetchOptions);
-
-    // Verify that executePrefetch function is correctly executed
-    expect(executePrefetch).toHaveBeenCalled();
-  });
-
-  // Checking outdate marking
-  it('checks outdate marking', () => {
-    const markOptions = { id: 'testId', functionId: 'testFunction' };
-
-    // Mark the function as outdated
-    prefetch.markOutdate(markOptions, true);
-
-    // Verify that the function is marked as outdated
-    let isOutdated = prefetch.checkOutdate(markOptions);
-    expect(isOutdated).toBe(true);
-
-    // Mark the function as up-to-date
-    prefetch.markOutdate(markOptions, false);
-
-    // Verify that the function is marked as up-to-date
-    isOutdated = prefetch.checkOutdate(markOptions);
-    expect(isOutdated).toBe(false);
-  });
-});

package/__tests__/react.spec.ts

@@ -1,119 +0,0 @@
-import { FederationHost, init } from '@module-federation/runtime';
-import { renderHook, act } from '@testing-library/react-hooks';
-import * as ModuleFederationSDK from '@module-federation/sdk';
-import { usePrefetch } from '../src/react';
-import { MFDataPrefetch } from '../src/prefetch';
-
-const mockLoadScript = jest.spyOn(ModuleFederationSDK, 'loadScript');
-mockLoadScript.mockImplementation(() => Promise.resolve());
-
-describe('usePrefetch', () => {
-  // Mock prefetch function
-  global.fetch = jest.fn(() =>
-    Promise.resolve({
-      ok: true,
-      status: 200,
-      statusText: 'OK',
-      redirected: false,
-      type: 'basic',
-      url: '',
-      clone: jest.fn(),
-      headers: new Headers(),
-      body: null,
-      bodyUsed: false,
-      text: () => Promise.resolve(JSON.stringify({ data: 'testData' })),
-      json: () => Promise.resolve({ data: 'testData' }),
-      formData: () => Promise.resolve(new FormData()),
-      arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-      blob: () => Promise.resolve(new Blob()),
-    }),
-  );
-
-  let prefetch: MFDataPrefetch;
-
-  const options = {
-    // Options that will be passed to the `MFDataPrefetch` constructor
-    name: '@mf/test',
-    remoteSnapshot: {
-      buildVersion: '1.0.0',
-      globalName: 'TestGlobalName',
-    },
-  };
-  const testData = 'testData';
-  const newTestData = 'newTestData';
-  const functionId = 'testPrefetch';
-  const executePrefetch = jest.fn((params: string) =>
-    Promise.resolve(params ? params : testData),
-  );
-
-  new FederationHost({
-    name: options.name,
-    remotes: [],
-  });
-  init({
-    name: options.name,
-    remotes: [],
-  });
-  beforeEach(() => {
-    globalThis.__FEDERATION__.__PREFETCH__ = {
-      entryLoading: {},
-      instance: new Map(),
-      __PREFETCH_EXPORTS__: {},
-    };
-    // @ts-ignore
-    prefetch = new MFDataPrefetch(options); // Create a new instance of `MFDataPrefetch` class before each test
-
-    const exposeExport = {
-      [functionId]: executePrefetch,
-    };
-    const exposeId = `${options.name}/button/${ModuleFederationSDK.MFPrefetchCommon.identifier}`;
-    const projectExport = {
-      [ModuleFederationSDK.encodeName(exposeId)]: exposeExport,
-    };
-    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[options.name] =
-      Promise.resolve(projectExport);
-  });
-
-  afterEach(() => {
-    executePrefetch.mockClear();
-    mockLoadScript.mockRestore();
-  });
-
-  afterAll(() => {
-    // @ts-ignore
-    delete globalThis.__FEDERATION__;
-  });
-
-  it('should prefetch data on first mount', async () => {
-    const { result } = renderHook(() =>
-      usePrefetch({ id: `${options.name}/button`, functionId }),
-    );
-    await result.current[0];
-    expect(executePrefetch).toHaveBeenCalled();
-    // Verify the prefechState
-    expect(result.current[0]).resolves.toEqual(testData);
-  });
-
-  it('should refetch data when refreshExecutor is called', async () => {
-    const { result } = renderHook(() =>
-      usePrefetch({ id: `${options.name}/button`, functionId }),
-    );
-
-    await result.current[0];
-    expect(executePrefetch).toHaveBeenCalled();
-    executePrefetch.mockClear();
-    const { result: newCallResult } = renderHook(() =>
-      usePrefetch({ id: `${options.name}/button`, functionId }),
-    );
-    await newCallResult.current[0];
-    expect(executePrefetch).not.toHaveBeenCalled();
-    // Call refreshExecutor
-    act(() => {
-      result.current[1](newTestData);
-    });
-
-    expect(executePrefetch).toHaveBeenCalled();
-    // // Verify the prefetchState after refetch
-    expect(result.current[0]).resolves.toEqual(newTestData);
-  });
-});

package/dist/esm/chunk-AJPO2B2T.js

@@ -1,30 +0,0 @@
-// 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-EZUCZHGV.js

@@ -1,11 +0,0 @@
-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
-};

package/dist/esm/chunk-ISLXMAIA.js

@@ -1,155 +0,0 @@
-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 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 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-KI4QGPIS.js

@@ -1,32 +0,0 @@
-import {
-  MFDataPrefetch
-} from "./chunk-ISLXMAIA.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

@@ -1,7 +0,0 @@
-// 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/chunk-VVZ6XIM6.js

@@ -1,166 +0,0 @@
-import {
-  logger_default
-} from "./chunk-TTJJJ2WZ.js";
-import {
-  MFDataPrefetch
-} from "./chunk-ISLXMAIA.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
-};