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

package/CHANGELOG.md

@@ -1,10 +1,11 @@
 @module-federation/data-prefetch
 
-## 0.0.0-next-20240617071542
+## 0.0.0-next-20240702090143
 
 ### Patch Changes
 
-- Updated dependencies [103cd07]
-- Updated dependencies [364f2bc]
-  - @module-federation/runtime@0.0.0-next-20240617071542
-  - @module-federation/sdk@0.0.0-next-20240617071542
+- 3ddab21: feat(@module-federation/data-prefetch): support data prefetch in Module Federation
+- Updated dependencies [09b792d]
+- Updated dependencies [09b792d]
+  - @module-federation/sdk@0.0.0-next-20240702090143
+  - @module-federation/runtime@0.0.0-next-20240702090143

package/README.md

@@ -1,2 +1 @@
-Vmok Interface Prefetch
-https://vmok.bytedance.net/guide/performance/prefetch.html
+Module Federation Data Prefetch

package/__tests__/babel.spec.ts

@@ -0,0 +1,75 @@
+/// <reference types="jest" />
+
+import path from 'path';
+import fs from 'fs';
+import { BabelFileResult, transformFileSync } from '@babel/core';
+// @ts-ignore no use
+import type from '@types/jest';
+
+import babelPlugin from '../src/cli/babel';
+
+const emptyRegexp = /\s+/g;
+describe('Babel Plugin Test', () => {
+  const options = {
+    name: '@mf/test',
+    exposes: { './expose': path.resolve(__dirname, 'test') },
+  };
+
+  const testFilePath = path.join(__dirname, './test');
+
+  beforeEach(() => {
+    fs.mkdirSync(path.dirname(testFilePath), { recursive: true });
+    fs.closeSync(fs.openSync(testFilePath, 'w'));
+  });
+
+  afterEach(() => {
+    fs.unlinkSync(testFilePath);
+  });
+
+  // Check if the plugin will add the id parameter when it is not present
+  test('it adds id argument to usePrefetch call when it is absent', () => {
+    const input = `
+      import { usePrefetch } from "@module-federation/data-prefetch/react";
+      usePrefetch({});
+    `;
+
+    const expected = `
+      import { usePrefetch } from "@module-federation/data-prefetch/react";
+      usePrefetch({ id: "@mf/test/expose" });
+    `;
+
+    fs.writeFileSync(testFilePath, input);
+    const { code } = transformFileSync(testFilePath, {
+      plugins: [[babelPlugin, options]],
+      configFile: false,
+    }) as BabelFileResult;
+
+    expect(code?.replace(emptyRegexp, '')).toBe(
+      expected.replace(emptyRegexp, ''),
+    );
+  });
+
+  // The plugin should retain the existing id parameter in the usePrefetch call
+  test('it does not overwrite existing id argument in usePrefetch call', () => {
+    const input = `
+      import { usePrefetch } from "@module-federation/data-prefetch/react";
+      usePrefetch({ id: "existingId" });
+    `;
+
+    const expected = `
+      import { usePrefetch } from "@module-federation/data-prefetch/react";
+      usePrefetch({ id: "existingId" });
+    `;
+
+    fs.writeFileSync(testFilePath, input);
+    const { code } = transformFileSync(testFilePath, {
+      plugins: [[babelPlugin, options]],
+      configFile: false,
+      babelrc: false,
+    }) as BabelFileResult;
+
+    expect(code?.replace(emptyRegexp, '')).toBe(
+      expected.replace(emptyRegexp, ''),
+    );
+  });
+});

package/__tests__/prefetch.spec.ts

@@ -0,0 +1,127 @@
+// Import the necessary modules and functions
+import { MFDataPrefetch } from '../src/prefetch';
+import { loadScript } from '@module-federation/sdk';
+
+// Mock loadScript function from SDK
+jest.mock('@module-federation/sdk', () => ({
+  loadScript: jest.fn(() => Promise.resolve()),
+}));
+
+describe('MF Data Prefetch', () => {
+  let prefetch: MFDataPrefetch;
+
+  const options = {
+    name: '@mf/test',
+    remoteSnapshot: {
+      buildVersion: '1.0.0',
+      globalName: 'TestGlobalName',
+    },
+  };
+
+  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 = {
+      [options.name]: exposeExport,
+    };
+    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[options.name] =
+      Promise.resolve(projectExport);
+
+    await prefetch.getProjectExports();
+    expect(prefetch.getExposeExports(options.name)).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, 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({
+        [id]: 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

@@ -0,0 +1,109 @@
+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),
+  );
+
+  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 projectExport = {
+      [options.name]: 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, 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, functionId }),
+    );
+
+    await result.current[0];
+    expect(executePrefetch).toHaveBeenCalled();
+    executePrefetch.mockClear();
+    const { result: newCallResult } = renderHook(() =>
+      usePrefetch({ id: options.name, 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/cli/index.js

@@ -65,28 +65,6 @@ var import_sdk = require("@module-federation/sdk");
 var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
 
 // 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__['${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}']['${name}'] = import('./bootstrap');
-      }
-      return args;
-    }
-  }
-}
-`;
 var PrefetchPlugin = class {
   constructor(options) {
     this.options = options;
@@ -100,6 +78,19 @@ var PrefetchPlugin = class {
     if (!compiler.options.context) {
       throw new Error("compiler.options.context is not defined");
     }
+    const { runtimePlugins } = this.options;
+    if (!Array.isArray(runtimePlugins)) {
+      this.options.runtimePlugins = [];
+    }
+    this.options.runtimePlugins.push(
+      import_path2.default.resolve(__dirname, "../esm/plugin.js")
+    );
+    this.options.runtimePlugins.push(
+      import_path2.default.resolve(__dirname, "../esm/shared/index.js")
+    );
+    if (!this.options.dataPrefetch) {
+      return;
+    }
     const prefetchs = [];
     const exposeAlias = Object.keys(exposes);
     exposeAlias.forEach((alias) => {
@@ -108,7 +99,7 @@ var PrefetchPlugin = class {
       if (typeof exposeValue === "string") {
         exposePath = exposeValue;
       } else {
-        exposePath = exposeValue.import;
+        exposePath = exposeValue.import[0];
       }
       const targetPaths = fixPrefetchPath(exposePath);
       for (const pathItem of targetPaths) {
@@ -124,13 +115,6 @@ var PrefetchPlugin = class {
         }
       }
     });
-    const { runtimePlugins } = this.options;
-    if (!Array.isArray(runtimePlugins)) {
-      this.options.runtimePlugins = [];
-    }
-    this.options.runtimePlugins.push(
-      import_path2.default.resolve(__dirname, "../esm/plugin.js")
-    );
     if (!this._reWriteExports) {
       return;
     }
@@ -151,12 +135,9 @@ var PrefetchPlugin = class {
       import_fs_extra2.default.mkdirSync(`${tempDirRealPath}/${encodedName}`);
     }
     import_fs_extra2.default.writeFileSync(asyncEntryPath, this._reWriteExports);
-    const prefetchEntry = import_path2.default.resolve(
-      compiler.options.context,
-      `node_modules/${TEMP_DIR}/${encodedName}/${import_sdk2.MFPrefetchCommon.fileName}`
-    );
-    import_fs_extra2.default.writeFileSync(prefetchEntry, addTemplate(name));
-    this.options.runtimePlugins.push(prefetchEntry);
+    new compiler.webpack.DefinePlugin({
+      FederationDataPrefetch: JSON.stringify(asyncEntryPath)
+    }).apply(compiler);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/esm/{chunk-BN3GGCE5.js → chunk-WLE6YNDH.js}

@@ -9,11 +9,14 @@ import {
 } from "./chunk-EWCGK4XA.js";
 
 // src/plugin.ts
+import { Module } from "@module-federation/runtime";
 import { getResourceUrl } from "@module-federation/sdk";
 var loadingArray = [];
+var strategy = "loaded-first";
+var sharedFlag = strategy;
 var prefetchPlugin = () => ({
   name: "data-prefetch-runtime-plugin",
-  afterResolve(options) {
+  initContainer(options) {
     const { remoteSnapshot, remoteInfo, id, origin } = options;
     const snapshot = remoteSnapshot;
     const { name } = remoteInfo;
@@ -27,6 +30,11 @@ var prefetchPlugin = () => ({
     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) {
@@ -41,20 +49,22 @@ var prefetchPlugin = () => ({
       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
+      return Promise.resolve().then(() => {
+        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
+          };
         });
-        const functionId = k;
-        return {
-          value,
-          functionId
-        };
+        return result;
       });
-      return result;
     });
     loadingArray.push({
       id,
@@ -102,12 +112,29 @@ var prefetchPlugin = () => ({
       return options;
     }
     const promise = instance.loadEntry(prefetchUrl).then(async () => {
+      let module = origin.moduleCache.get(remote.name);
+      const moduleOptions = {
+        host: origin,
+        remoteInfo: remote
+      };
+      if (!module) {
+        module = new Module(moduleOptions);
+        origin.moduleCache.set(remote.name, module);
+      }
+      const idPart = id.split("/");
+      let expose = idPart[idPart.length - 1];
+      if (expose !== ".") {
+        expose = `./${expose}`;
+      }
+      await module.get(id, expose, {}, remoteSnapshot);
       const projectExports = instance.getProjectExports();
       if (projectExports instanceof Promise) {
         await projectExports;
       }
       const exports = instance.getExposeExports(id);
-      logger_default.info(`1. Start Prefetch: ${id} - ${performance.now()}`);
+      logger_default.info(
+        `1. PreloadRemote Start Prefetch: ${id} - ${performance.now()}`
+      );
       const result = Object.keys(exports).map((k) => {
         const value = instance.prefetch({
           id,
@@ -126,6 +153,11 @@ var prefetchPlugin = () => ({
       promise
     });
     return options;
+  },
+  beforeLoadShare(options) {
+    const shareInfo = options.shareInfo;
+    sharedFlag = (shareInfo == null ? void 0 : shareInfo.strategy) || sharedFlag;
+    return options;
   }
 });
 var plugin_default = prefetchPlugin;

package/dist/esm/cli/index.js

@@ -6,8 +6,7 @@ import {
 import path2 from "path";
 import fs2 from "fs-extra";
 import {
-  encodeName,
-  MFPrefetchCommon
+  encodeName
 } from "@module-federation/sdk";
 
 // src/common/constant.ts
@@ -38,28 +37,6 @@ var fixPrefetchPath = (exposePath) => {
 };
 
 // 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;
@@ -73,6 +50,19 @@ var PrefetchPlugin = class {
     if (!compiler.options.context) {
       throw new Error("compiler.options.context is not defined");
     }
+    const { runtimePlugins } = this.options;
+    if (!Array.isArray(runtimePlugins)) {
+      this.options.runtimePlugins = [];
+    }
+    this.options.runtimePlugins.push(
+      path2.resolve(__dirname, "../esm/plugin.js")
+    );
+    this.options.runtimePlugins.push(
+      path2.resolve(__dirname, "../esm/shared/index.js")
+    );
+    if (!this.options.dataPrefetch) {
+      return;
+    }
     const prefetchs = [];
     const exposeAlias = Object.keys(exposes);
     exposeAlias.forEach((alias) => {
@@ -81,7 +71,7 @@ var PrefetchPlugin = class {
       if (typeof exposeValue === "string") {
         exposePath = exposeValue;
       } else {
-        exposePath = exposeValue.import;
+        exposePath = exposeValue.import[0];
       }
       const targetPaths = fixPrefetchPath(exposePath);
       for (const pathItem of targetPaths) {
@@ -97,13 +87,6 @@ var PrefetchPlugin = class {
         }
       }
     });
-    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;
     }
@@ -124,12 +107,9 @@ var PrefetchPlugin = class {
       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);
+    new compiler.webpack.DefinePlugin({
+      FederationDataPrefetch: JSON.stringify(asyncEntryPath)
+    }).apply(compiler);
   }
 };
 export {

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 import {
   prefetchPlugin
-} from "./chunk-BN3GGCE5.js";
+} from "./chunk-WLE6YNDH.js";
 import "./chunk-TTJJJ2WZ.js";
 import {
   MFDataPrefetch

package/dist/esm/plugin.js

@@ -1,7 +1,7 @@
 import {
   plugin_default,
   prefetchPlugin
-} from "./chunk-BN3GGCE5.js";
+} from "./chunk-WLE6YNDH.js";
 import "./chunk-TTJJJ2WZ.js";
 import "./chunk-JEPJP5O3.js";
 import "./chunk-EWCGK4XA.js";

package/dist/esm/react/index.js

@@ -30,7 +30,7 @@ var usePrefetch = (options) => {
   if (isFirstMounted) {
     const startTiming = performance.now();
     logger_default.info(
-      `2. Start Get Prefetch Data: ${options.id} - ${options.functionId} - ${startTiming}`
+      `2. Start Get Prefetch Data: ${options.id} - ${options.functionId || "default"} - ${startTiming}`
     );
   }
   const { id, functionId, deferId } = options;
@@ -59,7 +59,7 @@ var usePrefetch = (options) => {
   useEffect2(() => {
     const useEffectTiming = performance.now();
     logger_default.info(
-      `3. Start Execute UseEffect: ${options.id} - ${options.functionId} - ${useEffectTiming}`
+      `3. Start Execute UseEffect: ${options.id} - ${options.functionId || "default"} - ${useEffectTiming}`
     );
     return () => {
       prefetchInstance == null ? void 0 : prefetchInstance.markOutdate(prefetchInfo, true);

package/dist/esm/shared/index.js

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