@module-federation/data-prefetch 0.6.6 → 0.6.8

package/.swcrc

@@ -0,0 +1,29 @@
+{
+  "jsc": {
+    "target": "es2017",
+    "parser": {
+      "syntax": "typescript",
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "decoratorMetadata": true,
+      "legacyDecorator": true
+    },
+    "keepClassNames": true,
+    "externalHelpers": true,
+    "loose": true
+  },
+  "module": {
+    "type": "es6"
+  },
+  "sourceMaps": true,
+  "exclude": [
+    "jest.config.ts",
+    ".*\\.spec.tsx?$",
+    ".*\\.test.tsx?$",
+    "./src/jest-setup.ts$",
+    "./**/jest-setup.ts$",
+    ".*.js$"
+  ]
+}

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @module-federation/data-prefetch
 
+## 0.6.8
+
+### Patch Changes
+
+- Updated dependencies [32db0ac]
+- Updated dependencies [32db0ac]
+- Updated dependencies [6c5f444]
+- Updated dependencies [fac6ecf]
+  - @module-federation/sdk@0.6.8
+  - @module-federation/runtime@0.6.8
+
+## 0.6.7
+
+### Patch Changes
+
+- 9e32644: Refactored the way prefetch entries are imported for improved dynamic loading handling.
+
+  - Changed the import of prefetch entries to use a function wrapper for more dynamic control.
+  - Updated data types to ensure consistency with the new function-based import approach.
+  - Modified the `injectPrefetch` function structure to incorporate the new import method.
+  - Modified the `MFDataPrefetch` class to handle the new import function when resolving exports.
+
+- Updated dependencies [9e32644]
+- Updated dependencies [9e32644]
+- Updated dependencies [9e32644]
+  - @module-federation/runtime@0.6.7
+  - @module-federation/sdk@0.6.7
+
 ## 0.6.6
 
 ### Patch Changes

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson) Zhou Shaw (zhouxiao)
+Copyright (c) 2024-present nieyan(nyqykk)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/__tests__/prefetch.spec.ts

@@ -65,13 +65,14 @@ describe('MF Data Prefetch', () => {
       [encodeName(exposeId)]: exposeExport,
     };
     globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[options.name] =
-      Promise.resolve(projectExport);
+      () => 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;
@@ -84,7 +85,7 @@ describe('MF Data Prefetch', () => {
     const prefetchExports = { [functionId]: executePrefetch };
 
     // Mock Project Exports
-    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[id] =
+    globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[id] = () =>
       Promise.resolve({
         [encodeName(exposeId)]: prefetchExports,
       });

package/__tests__/react.spec.ts

@@ -71,7 +71,7 @@ describe('usePrefetch', () => {
       [ModuleFederationSDK.encodeName(exposeId)]: exposeExport,
     };
     globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__[options.name] =
-      Promise.resolve(projectExport);
+      () => Promise.resolve(projectExport);
   });
 
   afterEach(() => {

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present nieyan(nyqykk)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/babel.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/cli/babel";
+export { default } from "./src/cli/babel";

package/dist/babel.cjs.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var path = require('path');
+
+// no used now
+const attribute = 'id';
+const hookId = 'usePrefetch';
+const importPackage = '@module-federation/data-prefetch/react';
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+var babel = ((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(// @ts-ignore
+            typeof exposes[expose] === 'string' ? exposes[expose] : exposes[expose].import)
+        }));
+    return {
+        visitor: {
+            ImportDeclaration (nodePath, // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            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(// biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+                        (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)));
+                    }
+                }
+            }
+        }
+    };
+});
+
+module.exports = babel;

package/dist/babel.esm.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/cli/babel";
+export { default } from "./src/cli/babel";

package/dist/babel.esm.js

@@ -0,0 +1,48 @@
+import path from 'path';
+
+// no used now
+const attribute = 'id';
+const hookId = 'usePrefetch';
+const importPackage = '@module-federation/data-prefetch/react';
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+var babel = ((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(// @ts-ignore
+            typeof exposes[expose] === 'string' ? exposes[expose] : exposes[expose].import)
+        }));
+    return {
+        visitor: {
+            ImportDeclaration (nodePath, // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            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(// biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+                        (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 as default };

package/dist/cli.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/cli/index";

package/dist/cli.cjs.js

@@ -0,0 +1,155 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs-extra');
+var sdk = require('@module-federation/sdk');
+var normalizeWebpackPath = require('@module-federation/sdk/normalize-webpack-path');
+var runtimeUtils = require('./runtime-utils.cjs.js');
+require('@module-federation/runtime');
+
+const TEMP_DIR = '.mf';
+
+const 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);
+};
+const 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}`);
+    }
+};
+
+const { RuntimeGlobals, Template } = require(normalizeWebpackPath.normalizeWebpackPath('webpack'));
+function getFederationGlobalScope(runtimeGlobals) {
+    return `${runtimeGlobals.require || '__webpack_require__'}.federation`;
+}
+class PrefetchPlugin {
+    // eslint-disable-next-line max-lines-per-function
+    apply(compiler) {
+        var _this_options_runtimePlugins, _this_options_runtimePlugins1;
+        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 = path.resolve(__dirname, './plugin.esm.js');
+        const sharedPath = path.resolve(__dirname, './shared.esm.js');
+        if (!((_this_options_runtimePlugins = this.options.runtimePlugins) == null ? void 0 : _this_options_runtimePlugins.includes(runtimePath))) {
+            this.options.runtimePlugins.push(runtimePath);
+        }
+        if (!((_this_options_runtimePlugins1 = this.options.runtimePlugins) == null ? void 0 : _this_options_runtimePlugins1.includes(sharedPath))) {
+            this.options.runtimePlugins.push(sharedPath);
+        }
+        const encodedName = sdk.encodeName(name);
+        const asyncEntryPath = path.resolve(compiler.options.context, `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`);
+        if (fs.existsSync(asyncEntryPath)) {
+            fs.unlinkSync(asyncEntryPath);
+        }
+        if (!this.options.dataPrefetch) {
+            return;
+        }
+        const exposeAlias = Object.keys(exposes);
+        exposeAlias.forEach((alias)=>{
+            let exposePath;
+            // @ts-ignore
+            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 = path.resolve(compiler.options.context, pathItem);
+                if (fileExistsWithCaseSync(absolutePath)) {
+                    const absoluteAlias = alias.replace('.', '');
+                    this._reWriteExports += `export * as ${runtimeUtils.getPrefetchId(`${name}${absoluteAlias}`)} from '${absolutePath}';\n`;
+                    break;
+                }
+            }
+        });
+        if (!this._reWriteExports) {
+            return;
+        }
+        const tempDirRealPath = path.resolve(compiler.options.context, 'node_modules', TEMP_DIR);
+        if (!fs.existsSync(tempDirRealPath)) {
+            fs.mkdirSync(tempDirRealPath);
+        }
+        if (!fs.existsSync(`${tempDirRealPath}/${encodedName}`)) {
+            fs.mkdirSync(`${tempDirRealPath}/${encodedName}`);
+        }
+        fs.writeFileSync(asyncEntryPath, this._reWriteExports);
+        new compiler.webpack.DefinePlugin({
+            FederationDataPrefetch: JSON.stringify(asyncEntryPath)
+        }).apply(compiler);
+    }
+    static addRuntime(compiler, options) {
+        const encodedName = sdk.encodeName(options.name);
+        if (!compiler.options.context) {
+            throw new Error('compiler.options.context is not defined');
+        }
+        const prefetchEntry = path.resolve(compiler.options.context, `node_modules/.mf/${encodedName}/bootstrap.js`);
+        const federationGlobal = getFederationGlobalScope(RuntimeGlobals || {});
+        return Template.asString([
+            fs.existsSync(prefetchEntry) ? Template.indent([
+                'function injectPrefetch() {',
+                Template.indent([
+                    `globalThis.__FEDERATION__ = globalThis.__FEDERATION__ || {};`,
+                    `globalThis.__FEDERATION__['${sdk.MFPrefetchCommon.globalKey}'] = globalThis.__FEDERATION__['${sdk.MFPrefetchCommon.globalKey}'] || {`,
+                    `entryLoading: {},`,
+                    `instance: new Map(),`,
+                    `__PREFETCH_EXPORTS__: {},`,
+                    `};`,
+                    `globalThis.__FEDERATION__['${sdk.MFPrefetchCommon.globalKey}']['${sdk.MFPrefetchCommon.exportsKey}'] = globalThis.__FEDERATION__['${sdk.MFPrefetchCommon.globalKey}']['${sdk.MFPrefetchCommon.exportsKey}'] || {};`,
+                    `globalThis.__FEDERATION__['${sdk.MFPrefetchCommon.globalKey}']['${sdk.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;`
+        ]);
+    }
+    constructor(options){
+        this.options = options;
+        this._reWriteExports = '';
+    }
+}
+
+exports.PrefetchPlugin = PrefetchPlugin;
+exports.getFederationGlobalScope = getFederationGlobalScope;

package/dist/cli.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/cli/index";

package/dist/cli.esm.js

@@ -0,0 +1,152 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { encodeName, MFPrefetchCommon } from '@module-federation/sdk';
+import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
+import { b as getPrefetchId } from './runtime-utils.esm.js';
+import '@module-federation/runtime';
+
+const TEMP_DIR = '.mf';
+
+const 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);
+};
+const 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}`);
+    }
+};
+
+const { RuntimeGlobals, Template } = require(normalizeWebpackPath('webpack'));
+function getFederationGlobalScope(runtimeGlobals) {
+    return `${runtimeGlobals.require || '__webpack_require__'}.federation`;
+}
+class PrefetchPlugin {
+    // eslint-disable-next-line max-lines-per-function
+    apply(compiler) {
+        var _this_options_runtimePlugins, _this_options_runtimePlugins1;
+        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 = path.resolve(__dirname, './plugin.esm.js');
+        const sharedPath = path.resolve(__dirname, './shared.esm.js');
+        if (!((_this_options_runtimePlugins = this.options.runtimePlugins) == null ? void 0 : _this_options_runtimePlugins.includes(runtimePath))) {
+            this.options.runtimePlugins.push(runtimePath);
+        }
+        if (!((_this_options_runtimePlugins1 = this.options.runtimePlugins) == null ? void 0 : _this_options_runtimePlugins1.includes(sharedPath))) {
+            this.options.runtimePlugins.push(sharedPath);
+        }
+        const encodedName = encodeName(name);
+        const asyncEntryPath = path.resolve(compiler.options.context, `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`);
+        if (fs.existsSync(asyncEntryPath)) {
+            fs.unlinkSync(asyncEntryPath);
+        }
+        if (!this.options.dataPrefetch) {
+            return;
+        }
+        const exposeAlias = Object.keys(exposes);
+        exposeAlias.forEach((alias)=>{
+            let exposePath;
+            // @ts-ignore
+            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 = path.resolve(compiler.options.context, pathItem);
+                if (fileExistsWithCaseSync(absolutePath)) {
+                    const absoluteAlias = alias.replace('.', '');
+                    this._reWriteExports += `export * as ${getPrefetchId(`${name}${absoluteAlias}`)} from '${absolutePath}';\n`;
+                    break;
+                }
+            }
+        });
+        if (!this._reWriteExports) {
+            return;
+        }
+        const tempDirRealPath = path.resolve(compiler.options.context, 'node_modules', TEMP_DIR);
+        if (!fs.existsSync(tempDirRealPath)) {
+            fs.mkdirSync(tempDirRealPath);
+        }
+        if (!fs.existsSync(`${tempDirRealPath}/${encodedName}`)) {
+            fs.mkdirSync(`${tempDirRealPath}/${encodedName}`);
+        }
+        fs.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 = path.resolve(compiler.options.context, `node_modules/.mf/${encodedName}/bootstrap.js`);
+        const federationGlobal = getFederationGlobalScope(RuntimeGlobals || {});
+        return Template.asString([
+            fs.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;`
+        ]);
+    }
+    constructor(options){
+        this.options = options;
+        this._reWriteExports = '';
+    }
+}
+
+export { PrefetchPlugin, getFederationGlobalScope };

package/dist/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.cjs.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var prefetch = require('./prefetch.cjs.js');
+var plugin = require('./plugin.cjs.js');
+require('@module-federation/runtime');
+require('@module-federation/sdk');
+require('./runtime-utils.cjs.js');
+require('./index.cjs2.js');
+
+
+
+exports.MFDataPrefetch = prefetch.MFDataPrefetch;
+exports.prefetchPlugin = plugin.prefetchPlugin;

package/dist/index.cjs2.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var sdk = require('@module-federation/sdk');
+
+var logger = new sdk.Logger('[Module Federation Data Prefetch]');
+
+exports.logger = logger;

package/dist/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.esm.js

@@ -0,0 +1,6 @@
+export { M as MFDataPrefetch } from './prefetch.esm.js';
+export { prefetchPlugin } from './plugin.esm.js';
+import '@module-federation/runtime';
+import '@module-federation/sdk';
+import './runtime-utils.esm.js';
+import './index.esm2.js';

package/dist/index.esm2.js

@@ -0,0 +1,5 @@
+import { Logger } from '@module-federation/sdk';
+
+var logger = new Logger('[Module Federation Data Prefetch]');
+
+export { logger as l };