@umijs/mfsu 4.0.0-canary.20220429.3 → 4.0.0-canary.20220506.2

package/dist/dep/getExposeFromContent.d.ts

@@ -0,0 +1,6 @@
+import { Dep } from './dep';
+export declare function getExposeFromContent(opts: {
+    dep: Dep;
+    filePath: string;
+    content: string;
+}): Promise<string>;

package/dist/dep/getExposeFromContent.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExposeFromContent = void 0;
+const assert_1 = __importDefault(require("assert"));
+const path_1 = require("path");
+const getModuleExports_1 = require("./getModuleExports");
+async function getExposeFromContent(opts) {
+    // Support CSS
+    if (opts.filePath &&
+        /\.(css|less|scss|sass|stylus|styl)$/.test(opts.filePath)) {
+        return `import '${opts.dep.file}';`;
+    }
+    // Support Assets Files
+    if (opts.filePath &&
+        /\.(json|svg|png|jpe?g|avif|gif|webp|ico|eot|woff|woff2|ttf|txt|text|mdx?)$/.test(opts.filePath)) {
+        return `
+import _ from '${opts.dep.file}';
+export default _;`.trim();
+    }
+    (0, assert_1.default)(/(js|jsx|mjs|ts|tsx)$/.test(opts.filePath), `file type not supported for ${(0, path_1.basename)(opts.filePath)}.`);
+    const { exports, isCJS } = await (0, getModuleExports_1.getModuleExports)({
+        content: opts.content,
+        filePath: opts.filePath,
+    });
+    // cjs
+    if (isCJS) {
+        return [
+            `import _ from '${opts.dep.file}';`,
+            `export default _;`,
+            `export * from '${opts.dep.file}';`,
+        ].join('\n');
+    }
+    // esm
+    else {
+        const ret = [];
+        let hasExports = false;
+        if (exports.includes('default')) {
+            ret.push(`import _ from '${opts.dep.file}';`);
+            ret.push(`export default _;`);
+            hasExports = true;
+        }
+        if (hasNonDefaultExports(exports) ||
+            // export * from 不会有 exports，只会有 imports
+            /export\s+\*\s+from/.test(opts.content)) {
+            ret.push(`export * from '${opts.dep.file}';`);
+            hasExports = true;
+        }
+        if (!hasExports) {
+            // 只有 __esModule 的全量导出
+            if (exports.includes('__esModule')) {
+                ret.push(`import _ from '${opts.dep.file}';`);
+                ret.push(`export default _;`);
+                ret.push(`export * from '${opts.dep.file}';`);
+            }
+            else {
+                ret.push(`import '${opts.dep.file}';`);
+            }
+        }
+        return ret.join('\n');
+    }
+}
+exports.getExposeFromContent = getExposeFromContent;
+function hasNonDefaultExports(exports) {
+    return (exports.filter((exp) => !['__esModule', 'default'].includes(exp))
+        .length > 0);
+}

package/dist/dep/getModuleExports.d.ts

@@ -0,0 +1,7 @@
+export declare function getModuleExports({ content, filePath, }: {
+    filePath: string;
+    content: string;
+}): Promise<{
+    exports: readonly string[];
+    isCJS: boolean;
+}>;

package/dist/dep/getModuleExports.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleExports = void 0;
+const es_module_lexer_1 = require("@umijs/bundler-utils/compiled/es-module-lexer");
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+const path_1 = require("path");
+const getCJSExports_1 = require("./getCJSExports");
+async function getModuleExports({ content, filePath, }) {
+    // Support tsx and jsx
+    if (filePath && /\.(tsx|jsx)$/.test(filePath)) {
+        content = (await (0, esbuild_1.transform)(content, {
+            sourcemap: false,
+            sourcefile: filePath,
+            format: 'esm',
+            target: 'es6',
+            loader: (0, path_1.extname)(filePath).slice(1),
+        })).code;
+    }
+    await es_module_lexer_1.init;
+    const [imports, exports] = (0, es_module_lexer_1.parse)(content);
+    let isCJS = !imports.length && !exports.length;
+    let cjsEsmExports = null;
+    if (isCJS) {
+        cjsEsmExports = (0, getCJSExports_1.getCJSExports)({ content });
+        if (cjsEsmExports.includes('__esModule')) {
+            isCJS = false;
+        }
+    }
+    return {
+        exports: cjsEsmExports || exports,
+        isCJS,
+    };
+}
+exports.getModuleExports = getModuleExports;

package/dist/depBuilder/depBuilder.d.ts

@@ -0,0 +1,30 @@
+import { Dep } from '../dep/dep';
+import { MFSU } from '../mfsu';
+interface IOpts {
+    mfsu: MFSU;
+}
+export declare class DepBuilder {
+    opts: IOpts;
+    completeFns: Function[];
+    isBuilding: boolean;
+    constructor(opts: IOpts);
+    buildWithWebpack(opts: {
+        onBuildComplete: Function;
+        deps: Dep[];
+    }): Promise<unknown>;
+    buildWithESBuild(opts: {
+        onBuildComplete: Function;
+        deps: Dep[];
+    }): Promise<void>;
+    build(opts: {
+        deps: Dep[];
+    }): Promise<void>;
+    onBuildComplete(fn: Function): void;
+    writeMFFiles(opts: {
+        deps: Dep[];
+    }): Promise<void>;
+    getWebpackConfig(opts: {
+        deps: Dep[];
+    }): import("webpack").Configuration;
+}
+export {};

package/dist/depBuilder/depBuilder.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepBuilder = void 0;
+const bundler_esbuild_1 = require("@umijs/bundler-esbuild");
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const depChunkIdPrefixPlugin_1 = require("../webpackPlugins/depChunkIdPrefixPlugin");
+const stripSourceMapUrlPlugin_1 = require("../webpackPlugins/stripSourceMapUrlPlugin");
+const getESBuildEntry_1 = require("./getESBuildEntry");
+class DepBuilder {
+    constructor(opts) {
+        this.completeFns = [];
+        this.isBuilding = false;
+        this.opts = opts;
+    }
+    async buildWithWebpack(opts) {
+        const config = this.getWebpackConfig({ deps: opts.deps });
+        return new Promise((resolve, reject) => {
+            const compiler = this.opts.mfsu.opts.implementor(config);
+            compiler.run((err, stats) => {
+                opts.onBuildComplete();
+                if (err || (stats === null || stats === void 0 ? void 0 : stats.hasErrors())) {
+                    if (err) {
+                        reject(err);
+                    }
+                    if (stats) {
+                        const errorMsg = stats.toString('errors-only');
+                        // console.error(errorMsg);
+                        reject(new Error(errorMsg));
+                    }
+                }
+                else {
+                    resolve(stats);
+                }
+                compiler.close(() => { });
+            });
+        });
+    }
+    // TODO: support watch and rebuild
+    async buildWithESBuild(opts) {
+        const entryContent = (0, getESBuildEntry_1.getESBuildEntry)({ deps: opts.deps });
+        const ENTRY_FILE = 'esbuild-entry.js';
+        const tmpDir = this.opts.mfsu.opts.tmpBase;
+        const entryPath = (0, path_1.join)(tmpDir, ENTRY_FILE);
+        (0, fs_1.writeFileSync)(entryPath, entryContent, 'utf-8');
+        const date = new Date().getTime();
+        await (0, bundler_esbuild_1.build)({
+            cwd: this.opts.mfsu.opts.cwd,
+            entry: {
+                [`${constants_1.MF_VA_PREFIX}remoteEntry`]: entryPath,
+            },
+            config: {
+                ...this.opts.mfsu.opts.depBuildConfig,
+                outputPath: tmpDir,
+                alias: this.opts.mfsu.alias,
+                externals: this.opts.mfsu.externals,
+            },
+            inlineStyle: true,
+        });
+        utils_1.logger.event(`[mfsu] compiled with esbuild successfully in ${+new Date() - date} ms`);
+        opts.onBuildComplete();
+    }
+    async build(opts) {
+        this.isBuilding = true;
+        const onBuildComplete = () => {
+            this.isBuilding = false;
+            this.completeFns.forEach((fn) => fn());
+            this.completeFns = [];
+        };
+        try {
+            await this.writeMFFiles({ deps: opts.deps });
+            const newOpts = {
+                ...opts,
+                onBuildComplete,
+            };
+            if (this.opts.mfsu.opts.buildDepWithESBuild) {
+                await this.buildWithESBuild(newOpts);
+            }
+            else {
+                await this.buildWithWebpack(newOpts);
+            }
+        }
+        catch (e) {
+            onBuildComplete();
+            throw e;
+        }
+    }
+    onBuildComplete(fn) {
+        if (this.isBuilding) {
+            this.completeFns.push(fn);
+        }
+        else {
+            fn();
+        }
+    }
+    async writeMFFiles(opts) {
+        const tmpBase = this.opts.mfsu.opts.tmpBase;
+        utils_1.fsExtra.mkdirpSync(tmpBase);
+        // expose files
+        for (const dep of opts.deps) {
+            const content = await dep.buildExposeContent();
+            (0, fs_1.writeFileSync)((0, path_1.join)(tmpBase, dep.filePath), content, 'utf-8');
+        }
+        // index file
+        (0, fs_1.writeFileSync)((0, path_1.join)(tmpBase, 'index.js'), '"😛"', 'utf-8');
+    }
+    getWebpackConfig(opts) {
+        var _a, _b;
+        const mfName = this.opts.mfsu.opts.mfName;
+        const depConfig = utils_1.lodash.cloneDeep(this.opts.mfsu.depConfig);
+        // depConfig.stats = 'none';
+        depConfig.entry = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'index.js');
+        depConfig.output.path = this.opts.mfsu.opts.tmpBase;
+        // disable devtool
+        depConfig.devtool = false;
+        // disable library
+        // library 会影响 external 的语法，导致报错
+        // ref: https://github.com/umijs/plugins/blob/6d3fc2d/packages/plugin-qiankun/src/slave/index.ts#L83
+        if ((_a = depConfig.output) === null || _a === void 0 ? void 0 : _a.library)
+            delete depConfig.output.library;
+        if ((_b = depConfig.output) === null || _b === void 0 ? void 0 : _b.libraryTarget)
+            delete depConfig.output.libraryTarget;
+        // merge all deps to vendor
+        depConfig.optimization || (depConfig.optimization = {});
+        depConfig.optimization.splitChunks = {
+            chunks: 'all',
+            maxInitialRequests: Infinity,
+            minSize: 0,
+            cacheGroups: {
+                vendor: {
+                    test: /.+/,
+                    name(_module, _chunks, cacheGroupKey) {
+                        return `${constants_1.MF_DEP_PREFIX}___${cacheGroupKey}`;
+                    },
+                },
+            },
+        };
+        depConfig.plugins = depConfig.plugins || [];
+        depConfig.plugins.push(new depChunkIdPrefixPlugin_1.DepChunkIdPrefixPlugin());
+        depConfig.plugins.push(new stripSourceMapUrlPlugin_1.StripSourceMapUrlPlugin({
+            webpack: this.opts.mfsu.opts.implementor,
+        }));
+        depConfig.plugins.push(new this.opts.mfsu.opts.implementor.ProgressPlugin((percent, msg) => {
+            this.opts.mfsu.onProgress({ percent, status: msg });
+        }));
+        const exposes = opts.deps.reduce((memo, dep) => {
+            memo[`./${dep.file}`] = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, dep.filePath);
+            return memo;
+        }, {});
+        depConfig.plugins.push(new this.opts.mfsu.opts.implementor.container.ModuleFederationPlugin({
+            library: {
+                type: 'global',
+                name: mfName,
+            },
+            name: mfName,
+            filename: constants_1.REMOTE_FILE_FULL,
+            exposes,
+        }));
+        return depConfig;
+    }
+}
+exports.DepBuilder = DepBuilder;

package/dist/depBuilder/getESBuildEntry.d.ts

@@ -0,0 +1,4 @@
+import { Dep } from '../dep/dep';
+export declare function getESBuildEntry(opts: {
+    deps: Dep[];
+}): string;

package/dist/depBuilder/getESBuildEntry.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getESBuildEntry = void 0;
+const constants_1 = require("../constants");
+// from typescript `esModuleInterop`
+const ES_INTEROP_FUNC = `__exportStar`;
+const ES_INTEROP_HELPER = `
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+}));
+var ${ES_INTEROP_FUNC} = (this && this.__exportStar) || function(m, exports) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+`;
+function getESBuildEntry(opts) {
+    return `
+(function() {
+/******/   "use strict";
+/******/   var __webpack_modules__ = ({});
+/************************************************************************/
+/******/   // The module cache
+/******/   var __webpack_module_cache__ = {};
+/******/
+/******/   // The require function
+/******/   function __webpack_require__(moduleId) {
+/******/     // Check if module is in cache
+/******/     var cachedModule = __webpack_module_cache__[moduleId];
+/******/     if (cachedModule !== undefined) {
+/******/       return cachedModule.exports;
+/******/     }
+/******/     // Create a new module (and put it into the cache)
+/******/     var module = __webpack_module_cache__[moduleId] = {
+/******/       id: moduleId,
+/******/       loaded: false,
+/******/       exports: {}
+/******/     };
+/******/
+/******/     // Execute the module function
+/******/     __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/
+/******/     // Flag the module as loaded
+/******/     module.loaded = true;
+/******/
+/******/     // Return the exports of the module
+/******/     return module.exports;
+/******/   }
+/******/
+/******/   // expose the modules object (__webpack_modules__)
+/******/   __webpack_require__.m = __webpack_modules__;
+/******/
+/************************************************************************/
+/******/   /* webpack/runtime/compat get default export */
+/******/   !function() {
+/******/     // getDefaultExport function for compatibility with non-harmony modules
+/******/     __webpack_require__.n = function(module) {
+/******/       var getter = module && module.__esModule ?
+/******/         function() { return module['default']; } :
+/******/         function() { return module; };
+/******/       __webpack_require__.d(getter, { a: getter });
+/******/       return getter;
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/define property getters */
+/******/   !function() {
+/******/     // define getter functions for harmony exports
+/******/     __webpack_require__.d = function(exports, definition) {
+/******/       for(var key in definition) {
+/******/         if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/           Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/         }
+/******/       }
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/ensure chunk */
+/******/   !function() {
+/******/     __webpack_require__.f = {};
+/******/     // This file contains only the entry chunk.
+/******/     // The chunk loading function for additional chunks
+/******/     __webpack_require__.e = function(chunkId) {
+/******/       return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
+/******/         __webpack_require__.f[key](chunkId, promises);
+/******/         return promises;
+/******/       }, []));
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/get javascript chunk filename */
+/******/   !function() {
+/******/     // This function allow to reference async chunks
+/******/     __webpack_require__.u = function(chunkId) {
+/******/       // return url for filenames based on template
+/******/       return "" + "mf-dep____vendor" + "." + "8b5e340b" + ".js";
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/get mini-css chunk filename */
+/******/   !function() {
+/******/     // This function allow to reference all chunks
+/******/     __webpack_require__.miniCssF = function(chunkId) {
+/******/       // return url for filenames based on template
+/******/       return undefined;
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/hasOwnProperty shorthand */
+/******/   !function() {
+/******/     __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/   }();
+/******/
+/******/   /* webpack/runtime/load script */
+/******/   !function() {
+/******/     var inProgress = {};
+/******/     // data-webpack is not used as build has no uniqueName
+/******/     // loadScript function to load a script via script tag
+/******/     __webpack_require__.l = function(url, done, key, chunkId) {
+/******/       if(inProgress[url]) { inProgress[url].push(done); return; }
+/******/       var script, needAttach;
+/******/       if(key !== undefined) {
+/******/         var scripts = document.getElementsByTagName("script");
+/******/         for(var i = 0; i < scripts.length; i++) {
+/******/           var s = scripts[i];
+/******/           if(s.getAttribute("src") == url) { script = s; break; }
+/******/         }
+/******/       }
+/******/       if(!script) {
+/******/         needAttach = true;
+/******/         script = document.createElement('script');
+/******/
+/******/         script.charset = 'utf-8';
+/******/         script.timeout = 120;
+/******/         if (__webpack_require__.nc) {
+/******/           script.setAttribute("nonce", __webpack_require__.nc);
+/******/         }
+/******/
+/******/         script.src = url;
+/******/       }
+/******/       inProgress[url] = [done];
+/******/       var onScriptComplete = function(prev, event) {
+/******/         // avoid mem leaks in IE.
+/******/         script.onerror = script.onload = null;
+/******/         clearTimeout(timeout);
+/******/         var doneFns = inProgress[url];
+/******/         delete inProgress[url];
+/******/         script.parentNode && script.parentNode.removeChild(script);
+/******/         doneFns && doneFns.forEach(function(fn) { return fn(event); });
+/******/         if(prev) return prev(event);
+/******/       }
+/******/       ;
+/******/       var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
+/******/       script.onerror = onScriptComplete.bind(null, script.onerror);
+/******/       script.onload = onScriptComplete.bind(null, script.onload);
+/******/       needAttach && document.head.appendChild(script);
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/make namespace object */
+/******/   !function() {
+/******/     // define __esModule on exports
+/******/     __webpack_require__.r = function(exports) {
+/******/       if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/         Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/       }
+/******/       Object.defineProperty(exports, '__esModule', { value: true });
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/node module decorator */
+/******/   !function() {
+/******/     __webpack_require__.nmd = function(module) {
+/******/       module.paths = [];
+/******/       if (!module.children) module.children = [];
+/******/       return module;
+/******/     };
+/******/   }();
+/******/
+/******/   /* webpack/runtime/publicPath */
+/******/   !function() {
+/******/     __webpack_require__.p = "/";
+/******/   }();
+/******/
+/******/   /* webpack/runtime/jsonp chunk loading */
+/******/   !function() {
+/******/     // no baseURI
+/******/
+/******/     // object to store loaded and loading chunks
+/******/     // undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/     // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/     var installedChunks = {
+/******/       "mf-dep_mf": 0
+/******/     };
+/******/
+/******/     __webpack_require__.f.j = function(chunkId, promises) {
+/******/         // JSONP chunk loading for javascript
+/******/         var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
+/******/         if(installedChunkData !== 0) { // 0 means "already installed".
+/******/
+/******/           // a Promise means "currently loading".
+/******/           if(installedChunkData) {
+/******/             promises.push(installedChunkData[2]);
+/******/           } else {
+/******/             if(true) { // all chunks have JS
+/******/               // setup Promise in chunk cache
+/******/               var promise = new Promise(function(resolve, reject) { installedChunkData = installedChunks[chunkId] = [resolve, reject]; });
+/******/               promises.push(installedChunkData[2] = promise);
+/******/
+/******/               // start chunk loading
+/******/               var url = __webpack_require__.p + __webpack_require__.u(chunkId);
+/******/               // create error before stack unwound to get useful stacktrace later
+/******/               var error = new Error();
+/******/               var loadingEnded = function(event) {
+/******/                 if(__webpack_require__.o(installedChunks, chunkId)) {
+/******/                   installedChunkData = installedChunks[chunkId];
+/******/                   if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
+/******/                   if(installedChunkData) {
+/******/                     var errorType = event && (event.type === 'load' ? 'missing' : event.type);
+/******/                     var realSrc = event && event.target && event.target.src;
+/******/                     error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';
+/******/                     error.name = 'ChunkLoadError';
+/******/                     error.type = errorType;
+/******/                     error.request = realSrc;
+/******/                     installedChunkData[1](error);
+/******/                   }
+/******/                 }
+/******/               };
+/******/               __webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
+/******/             } else installedChunks[chunkId] = 0;
+/******/           }
+/******/         }
+/******/     };
+/******/
+/******/     // no prefetching
+/******/
+/******/     // no preloaded
+/******/
+/******/     // no HMR
+/******/
+/******/     // no HMR manifest
+/******/
+/******/     // no on chunks loaded
+/******/
+/******/     // install a JSONP callback for chunk loading
+/******/     var webpackJsonpCallback = function(parentChunkLoadingFunction, data) {
+/******/       var chunkIds = data[0];
+/******/       var moreModules = data[1];
+/******/       var runtime = data[2];
+/******/       // add "moreModules" to the modules object,
+/******/       // then flag all "chunkIds" as loaded and fire callback
+/******/       var moduleId, chunkId, i = 0;
+/******/       if(chunkIds.some(function(id) { return installedChunks[id] !== 0; })) {
+/******/         for(moduleId in moreModules) {
+/******/           if(__webpack_require__.o(moreModules, moduleId)) {
+/******/             __webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/           }
+/******/         }
+/******/         if(runtime) var result = runtime(__webpack_require__);
+/******/       }
+/******/       if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+/******/       for(;i < chunkIds.length; i++) {
+/******/         chunkId = chunkIds[i];
+/******/         if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+/******/           installedChunks[chunkId][0]();
+/******/         }
+/******/         installedChunks[chunkIds[i]] = 0;
+/******/       }
+/******/
+/******/     }
+/******/
+/******/     var chunkLoadingGlobal = self["webpackChunk"] = self["webpackChunk"] || [];
+/******/     chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
+/******/     chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
+/******/   }();
+/******/
+/************************************************************************/
+var __webpack_exports__ = {};
+(function() {
+  var exports = __webpack_exports__;
+${ES_INTEROP_HELPER}
+  var moduleMap = {
+${opts.deps.map(getDepModuleStr).join(',\n')}
+  };
+  var get = function(module, getScope) {
+    __webpack_require__.R = getScope;
+    getScope = (
+      __webpack_require__.o(moduleMap, module)
+        ? moduleMap[module]()
+        : Promise.resolve().then(function() {
+          throw new Error('Module "' + module + '" does not exist in container.');
+        })
+    );
+    __webpack_require__.R = undefined;
+    return getScope;
+  };
+  var init = function(shareScope, initScope) {
+    if (!__webpack_require__.S) return;
+    var oldScope = __webpack_require__.S["default"];
+    var name = "default"
+    if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");
+    __webpack_require__.S[name] = shareScope;
+    return __webpack_require__.I(name, initScope);
+  };
+  __webpack_require__.d(exports, {
+    get: function() { return get; },
+    init: function() { return init; }
+  });
+  self.mf = __webpack_exports__;
+})();
+})();
+  `;
+}
+exports.getESBuildEntry = getESBuildEntry;
+function getDepModuleStr(dep) {
+    return `
+"./${dep.file}": function() {
+  return new Promise(resolve => {
+    import('./${constants_1.MF_VA_PREFIX}${dep.normalizedFile}.js').then(module => {
+      module.default && ${ES_INTEROP_FUNC}(module, module.default);
+      resolve(() => module.default || module);
+    });
+  })
+}
+  `.trim();
+}

package/dist/depInfo.d.ts

@@ -0,0 +1,17 @@
+import { MFSU } from './mfsu';
+import { ModuleGraph } from './moduleGraph';
+interface IOpts {
+    mfsu: MFSU;
+}
+export declare class DepInfo {
+    private opts;
+    cacheFilePath: string;
+    moduleGraph: ModuleGraph;
+    cacheDependency: object;
+    constructor(opts: IOpts);
+    shouldBuild(): false | "cacheDependency has changed" | "moduleGraph has changed";
+    snapshot(): void;
+    loadCache(): void;
+    writeCache(): void;
+}
+export {};