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

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 {};

package/dist/depInfo.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepInfo = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const moduleGraph_1 = require("./moduleGraph");
+class DepInfo {
+    constructor(opts) {
+        this.moduleGraph = new moduleGraph_1.ModuleGraph();
+        this.cacheDependency = {};
+        this.opts = opts;
+        this.cacheFilePath = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'MFSU_CACHE.json');
+    }
+    shouldBuild() {
+        if (!utils_1.lodash.isEqual(this.cacheDependency, this.opts.mfsu.opts.getCacheDependency())) {
+            return 'cacheDependency has changed';
+        }
+        if (this.moduleGraph.hasDepChanged()) {
+            return 'moduleGraph has changed';
+        }
+        return false;
+    }
+    snapshot() {
+        this.cacheDependency = this.opts.mfsu.opts.getCacheDependency();
+        this.moduleGraph.snapshotDeps();
+    }
+    loadCache() {
+        if ((0, fs_1.existsSync)(this.cacheFilePath)) {
+            utils_1.logger.info('MFSU restore cache');
+            const { cacheDependency, moduleGraph } = JSON.parse((0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8'));
+            this.cacheDependency = cacheDependency;
+            this.moduleGraph.restore(moduleGraph);
+        }
+    }
+    writeCache() {
+        utils_1.fsExtra.mkdirpSync((0, path_1.dirname)(this.cacheFilePath));
+        const newContent = JSON.stringify({
+            cacheDependency: this.cacheDependency,
+            moduleGraph: this.moduleGraph.toJSON(),
+        }, null, 2);
+        if ((0, fs_1.existsSync)(this.cacheFilePath) &&
+            (0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8') === newContent) {
+            return;
+        }
+        utils_1.logger.info('MFSU write cache');
+        (0, fs_1.writeFileSync)(this.cacheFilePath, newContent, 'utf-8');
+    }
+}
+exports.DepInfo = DepInfo;

package/dist/esbuildHandlers/autoCssModules.d.ts

@@ -0,0 +1,2 @@
+import { IEsbuildLoaderHandlerParams } from '../types';
+export declare function autoCssModulesHandler(opts: IEsbuildLoaderHandlerParams): string;

package/dist/esbuildHandlers/autoCssModules.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoCssModulesHandler = void 0;
+const utils_1 = require("@umijs/utils");
+const CSS_MODULES_QUERY = '?modules';
+const QUERY_LENGTH = CSS_MODULES_QUERY.length;
+function autoCssModulesHandler(opts) {
+    let { code } = opts;
+    let offset = 0;
+    opts.imports.forEach((i) => {
+        if (i.d < 0 && (0, utils_1.isStyleFile)({ filename: i.n })) {
+            // import x from './index.less'
+            //   => import x from '
+            const importSegment = code.substring(i.ss + offset, i.s + offset);
+            // is css module
+            if (~importSegment.indexOf(' from')) {
+                code = `${code.substring(0, i.e + offset)}${CSS_MODULES_QUERY}${code.substring(i.e + offset)}`;
+                offset += QUERY_LENGTH;
+            }
+        }
+    });
+    return code;
+}
+exports.autoCssModulesHandler = autoCssModulesHandler;

package/dist/esbuildHandlers/awaitImport/index.d.ts

@@ -0,0 +1,12 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+interface IParams {
+    cache: Map<string, any>;
+    opts: any;
+}
+interface IOpts {
+    code: string;
+    imports: ImportSpecifier[];
+    filePath: string;
+}
+export default function getAwaitImportHandler(params: IParams): (opts: IOpts) => string;
+export {};

package/dist/esbuildHandlers/awaitImport/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const checkMatch_1 = require("../../babelPlugins/awaitImport/checkMatch");
+function getAwaitImportHandler(params) {
+    return function awaitImportHandler(opts) {
+        var _a, _b;
+        let offset = 0;
+        let { code } = opts;
+        const { filePath, imports } = opts;
+        imports.forEach((i) => {
+            if (!i.n)
+                return;
+            const isLazyImport = i.d > 0;
+            const from = i.n;
+            const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                cache: params.cache,
+                value: from,
+                opts: params.opts,
+                filename: filePath,
+            });
+            if (isMatch) {
+                // case: import x from './index.ts';
+                //       import('./index.ts');
+                // import x from '
+                // import(
+                const preSeg = code.substring(0, i.s + offset);
+                // ';
+                // );
+                const tailSeg = code.substring(i.e + offset);
+                const quote = isLazyImport ? '"' : '';
+                code = `${preSeg}${quote}${replaceValue}${quote}${tailSeg}`;
+                offset += replaceValue.length - from.length;
+            }
+        });
+        if (params.cache.has(filePath)) {
+            (_b = (_a = params.opts).onCollect) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                file: filePath,
+                data: params.cache.get(filePath),
+            });
+        }
+        return code;
+    };
+}
+exports.default = getAwaitImportHandler;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './esbuildHandlers/autoCssModules';
+export { esbuildLoader } from './loader/esbuild';
+export * from './mfsu';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esbuildLoader = void 0;
+__exportStar(require("./constants"), exports);
+__exportStar(require("./esbuildHandlers/autoCssModules"), exports);
+// for independent use `esbuild-loader`
+var esbuild_1 = require("./loader/esbuild");
+Object.defineProperty(exports, "esbuildLoader", { enumerable: true, get: function () { return esbuild_1.esbuildLoader; } });
+__exportStar(require("./mfsu"), exports);

package/dist/loader/esbuild.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from 'webpack';
+import type { IEsbuildLoaderOpts } from '../types';
+declare function esbuildTranspiler(this: LoaderContext<IEsbuildLoaderOpts>, source: string): Promise<void>;
+export default esbuildTranspiler;
+export declare const esbuildLoader: string;

package/dist/loader/esbuild.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esbuildLoader = 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");
+function esbuildTranspiler(source) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const done = this.async();
+        const options = this.getOptions();
+        const { handler = [], implementation } = options, otherOptions = __rest(options, ["handler", "implementation"]);
+        const transform = (implementation === null || implementation === void 0 ? void 0 : implementation.transform) || esbuild_1.transform;
+        const filePath = this.resourcePath;
+        const ext = (0, path_1.extname)(filePath).slice(1);
+        const transformOptions = Object.assign(Object.assign({}, otherOptions), { target: (_a = options.target) !== null && _a !== void 0 ? _a : 'es2015', loader: ext !== null && ext !== void 0 ? ext : 'js', sourcemap: this.sourceMap, sourcefile: filePath });
+        try {
+            let { code, map } = yield transform(source, transformOptions);
+            if (handler.length) {
+                yield es_module_lexer_1.init;
+                handler.forEach((handle) => {
+                    const [imports, exports] = (0, es_module_lexer_1.parse)(code);
+                    code = handle({ code, imports, exports, filePath });
+                });
+            }
+            done(null, code, map && JSON.parse(map));
+        }
+        catch (error) {
+            done(error);
+        }
+    });
+}
+exports.default = esbuildTranspiler;
+exports.esbuildLoader = __filename;

package/dist/mfsu.d.ts

@@ -0,0 +1,63 @@
+import type { NextFunction, Request, Response } from '@umijs/bundler-utils/compiled/express';
+import webpack, { Configuration } from 'webpack';
+import awaitImport from './babelPlugins/awaitImport/awaitImport';
+import { DepBuilder } from './depBuilder/depBuilder';
+import { DepInfo } from './depInfo';
+import { Mode } from './types';
+interface IOpts {
+    cwd?: string;
+    excludeNodeNatives?: boolean;
+    exportAllMembers?: Record<string, string[]>;
+    getCacheDependency?: Function;
+    onMFSUProgress?: Function;
+    mfName?: string;
+    mode?: Mode;
+    tmpBase?: string;
+    unMatchLibs?: string[];
+    runtimePublicPath?: boolean | string;
+    implementor: typeof webpack;
+    buildDepWithESBuild?: boolean;
+    depBuildConfig: any;
+}
+export declare class MFSU {
+    opts: IOpts;
+    alias: Record<string, string>;
+    externals: (Record<string, string> | Function)[];
+    depInfo: DepInfo;
+    depBuilder: DepBuilder;
+    depConfig: Configuration | null;
+    buildDepsAgain: boolean;
+    progress: any;
+    onProgress: Function;
+    publicPath: string;
+    constructor(opts: IOpts);
+    asyncImport(content: string): string;
+    setWebpackConfig(opts: {
+        config: Configuration;
+        depConfig: Configuration;
+    }): Promise<void>;
+    buildDeps(): Promise<void>;
+    getMiddlewares(): ((req: Request, res: Response, next: NextFunction) => void)[];
+    private getAwaitImportCollectOpts;
+    getBabelPlugins(): ({
+        onTransformDeps: () => void;
+        onCollect: ({ file, data, }: {
+            file: string;
+            data: {
+                unMatched: Set<{
+                    sourceValue: string;
+                }>;
+                matched: Set<{
+                    sourceValue: string;
+                }>;
+            };
+        }) => void;
+        exportAllMembers: Record<string, string[]> | undefined;
+        unMatchLibs: string[] | undefined;
+        remoteName: string | undefined;
+        alias: Record<string, string>;
+        externals: (Function | Record<string, string>)[];
+    } | typeof awaitImport)[][];
+    getEsbuildLoaderHandler(): any[];
+}
+export {};