@umijs/bundler-webpack 4.0.0-beta.9 → 4.0.0-canary-20240513.3

package/dist/config/progressPlugin.js

@@ -1,27 +1,53 @@
-"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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addProgressPlugin = void 0;
-const ProgressPlugin_1 = __importDefault(require("../plugins/ProgressPlugin"));
-function addProgressPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, name } = opts;
-        config.plugin('progress-plugin').use(ProgressPlugin_1.default, [
-            {
-                name,
-            },
-        ]);
-    });
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/progressPlugin.ts
+var progressPlugin_exports = {};
+__export(progressPlugin_exports, {
+  addProgressPlugin: () => addProgressPlugin
+});
+module.exports = __toCommonJS(progressPlugin_exports);
+var import_ProgressPlugin = __toESM(require("../plugins/ProgressPlugin"));
+var import_webpackbar = __toESM(require("../../compiled/webpackbar"));
+var import_types = require("../types");
+async function addProgressPlugin(opts) {
+  const { config, name, env } = opts;
+  if (env === import_types.Env.production) {
+    config.plugin("progress-plugin").use(import_webpackbar.default, [
+      {
+        name: name || "webpack"
+      }
+    ]);
+  } else {
+    config.plugin("progress-plugin-dev").use(import_ProgressPlugin.default);
+  }
 }
-exports.addProgressPlugin = addProgressPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addProgressPlugin
+});

package/dist/config/purgecssWebpackPlugin.js

@@ -1,32 +1,43 @@
-"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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPurgeCSSWebpackPlugin = void 0;
-const types_1 = require("../types");
-function applyPurgeCSSWebpackPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig, cwd, env } = opts;
-        config;
-        userConfig;
-        cwd;
-        env;
-        if (userConfig.purgeCSS && env === types_1.Env.production) {
-            config
-                .plugin('purgecss-webpack-plugin')
-                .use(require('@umijs/bundler-webpack/compiled/purgecss-webpack-plugin'), [
-                {
-                    paths: [],
-                },
-            ]);
-        }
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/purgecssWebpackPlugin.ts
+var purgecssWebpackPlugin_exports = {};
+__export(purgecssWebpackPlugin_exports, {
+  applyPurgeCSSWebpackPlugin: () => applyPurgeCSSWebpackPlugin
+});
+module.exports = __toCommonJS(purgecssWebpackPlugin_exports);
+var import_types = require("../types");
+async function applyPurgeCSSWebpackPlugin(opts) {
+  const { config, userConfig, cwd, env } = opts;
+  config;
+  userConfig;
+  cwd;
+  env;
+  if (userConfig.purgeCSS && env === import_types.Env.production) {
+    config.plugin("purgecss-webpack-plugin").use(require("@umijs/bundler-webpack/compiled/purgecss-webpack-plugin"), [
+      {
+        paths: []
+      }
+    ]);
+  }
 }
-exports.applyPurgeCSSWebpackPlugin = applyPurgeCSSWebpackPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyPurgeCSSWebpackPlugin
+});

package/dist/config/speedMeasureWebpackPlugin.js

@@ -1,34 +1,59 @@
-"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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSpeedMeasureWebpackPlugin = void 0;
-// @ts-ignore
-const speed_measure_webpack_plugin_1 = __importDefault(require("@umijs/bundler-webpack/compiled/speed-measure-webpack-plugin"));
-const path_1 = require("path");
-function addSpeedMeasureWebpackPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webpackConfig = opts.webpackConfig;
-        if (process.env.SPEED_MEASURE) {
-            const smpOption = process.env.SPEED_MEASURE === 'JSON'
-                ? {
-                    outputFormat: 'json',
-                    outputTarget: (0, path_1.join)(process.cwd(), 'SPEED_MEASURE.json'),
-                }
-                : { outputFormat: 'human', outputTarget: console.log };
-            webpackConfig = new speed_measure_webpack_plugin_1.default(smpOption).wrap(webpackConfig);
-        }
-        return webpackConfig;
-    });
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/speedMeasureWebpackPlugin.ts
+var speedMeasureWebpackPlugin_exports = {};
+__export(speedMeasureWebpackPlugin_exports, {
+  addSpeedMeasureWebpackPlugin: () => addSpeedMeasureWebpackPlugin
+});
+module.exports = __toCommonJS(speedMeasureWebpackPlugin_exports);
+var import_speed_measure_webpack_plugin = __toESM(require("@umijs/bundler-webpack/compiled/speed-measure-webpack-plugin"));
+var import_path = require("path");
+async function addSpeedMeasureWebpackPlugin(opts) {
+  var _a, _b;
+  let webpackConfig = opts.webpackConfig;
+  if (process.env.SPEED_MEASURE) {
+    const miniCssExtractPluginIdx = (_a = webpackConfig.plugins) == null ? void 0 : _a.findIndex(
+      (plugin) => plugin.constructor.name === "MiniCssExtractPlugin"
+    );
+    const miniCssExtractPlugin = (_b = webpackConfig.plugins) == null ? void 0 : _b[miniCssExtractPluginIdx];
+    const smpOption = process.env.SPEED_MEASURE === "JSON" ? {
+      outputFormat: "json",
+      outputTarget: (0, import_path.join)(process.cwd(), "SPEED_MEASURE.json")
+    } : { outputFormat: "human", outputTarget: console.log };
+    webpackConfig = new import_speed_measure_webpack_plugin.default(smpOption).wrap(webpackConfig);
+    if (miniCssExtractPlugin) {
+      webpackConfig.plugins[miniCssExtractPluginIdx] = miniCssExtractPlugin;
+    }
+  }
+  return webpackConfig;
 }
-exports.addSpeedMeasureWebpackPlugin = addSpeedMeasureWebpackPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSpeedMeasureWebpackPlugin
+});

package/dist/config/ssrPlugin.d.ts

@@ -0,0 +1,11 @@
+import Config from '../../compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    name?: string;
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export default function addSSRPlugin(opts: IOpts): void;
+export {};

package/dist/config/ssrPlugin.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/ssrPlugin.ts
+var ssrPlugin_exports = {};
+__export(ssrPlugin_exports, {
+  default: () => addSSRPlugin
+});
+module.exports = __toCommonJS(ssrPlugin_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../constants");
+var PLUGIN_NAME = "SSR_PLUGIN";
+var SSRPlugin = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.manifest = /* @__PURE__ */ new Map();
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(PLUGIN_NAME, () => {
+        const publicPath = compiler.options.output.publicPath || "/";
+        const assets = compilation.getAssets().filter((asset) => {
+          if (asset.info.hotModuleReplacement) {
+            return false;
+          }
+          return true;
+        });
+        assets.forEach((asset) => {
+          if (asset.info.sourceFilename) {
+            this.manifest.set(
+              asset.info.sourceFilename,
+              publicPath + asset.name
+            );
+          }
+        });
+        const stats = compilation.getStats().toJson({
+          all: false,
+          assets: true,
+          cachedAssets: true,
+          cachedModules: true
+        });
+        const { assetsByChunkName } = stats;
+        Object.keys(assetsByChunkName).forEach((chunkName) => {
+          assetsByChunkName[chunkName].forEach((filename) => {
+            const ext = (0, import_path.extname)(filename.split(/[?#]/)[0]);
+            if (!filename.includes(".hot-update.")) {
+              this.manifest.set(chunkName + ext, publicPath + filename);
+            }
+          });
+        });
+        const assetsSource = JSON.stringify(
+          {
+            assets: Object.fromEntries(this.manifest)
+          },
+          null,
+          2
+        );
+        if (process.env.NODE_ENV === "production" || this.opts.userConfig.writeToDisk) {
+          compilation.emitAsset(
+            "build-manifest.json",
+            new import_webpack.sources.RawSource(assetsSource, false)
+          );
+        } else {
+          const outputPath = compiler.options.output.path;
+          import_utils.fsExtra.mkdirpSync(outputPath);
+          (0, import_fs.writeFileSync)(
+            (0, import_path.join)(outputPath, "build-manifest.json"),
+            assetsSource,
+            "utf-8"
+          );
+        }
+      });
+    });
+  }
+};
+function addSSRPlugin(opts) {
+  if (opts.userConfig.ssr && opts.name !== import_constants.MFSU_NAME) {
+    opts.config.plugin("ssr-plugin").use(SSRPlugin, [opts]);
+  }
+}

package/dist/config/svgRules.d.ts

@@ -6,6 +6,7 @@ interface IOpts {
     cwd: string;
     env: Env;
     browsers: any;
+    staticPathPrefix: string;
 }
 export declare function addSVGRules(opts: IOpts): Promise<void>;
 export {};

package/dist/config/svgRules.js

@@ -1,43 +1,70 @@
-"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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSVGRules = void 0;
-function addSVGRules(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig } = opts;
-        const { svgr, svgo = {} } = userConfig;
-        if (svgr) {
-            const svgrRule = config.module.rule('svgr');
-            svgrRule
-                .test(/\.svg$/i)
-                .issuer(/\.[jt]sx?$/)
-                .use('svgr-loader')
-                .loader(require.resolve('@umijs/bundler-webpack/compiled/@svgr/webpack'))
-                .options(Object.assign(Object.assign({ svgoConfig: Object.assign({}, (svgo || {})) }, svgr), { svgo: !!svgo }));
-        }
-        if (svgo === false) {
-            const svgRule = config.module.rule('svg');
-            svgRule
-                .test(/\.svg$/)
-                .use('url-loader')
-                .loader(require.resolve('@umijs/bundler-webpack/compiled/url-loader'));
-            return;
-        }
-        const svgRule = config.module.rule('svg');
-        svgRule
-            .test(/\.svg$/)
-            .use('svgo-loader')
-            .loader(require.resolve('@umijs/bundler-webpack/compiled/svgo-loader'))
-            .options(Object.assign({ configFile: false }, svgo))
-            .end();
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/svgRules.ts
+var svgRules_exports = {};
+__export(svgRules_exports, {
+  addSVGRules: () => addSVGRules
+});
+module.exports = __toCommonJS(svgRules_exports);
+async function addSVGRules(opts) {
+  const { config, userConfig } = opts;
+  const { svgr, svgo = {} } = userConfig;
+  if (svgr) {
+    const svgrRule = config.module.rule("svgr");
+    svgrRule.test(/\.svg$/).issuer(/\.[jt]sx?$/).type("javascript/auto").use("svgr-loader").loader(require.resolve("../loader/svgr")).options({
+      svgoConfig: {
+        plugins: [
+          {
+            name: "preset-default",
+            params: {
+              overrides: {
+                removeTitle: false
+              }
+            }
+          },
+          "prefixIds"
+        ],
+        ...svgo
+      },
+      ...svgr,
+      svgo: !!svgo
+    }).end().use("url-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/url-loader")).options({
+      limit: userConfig.inlineLimit,
+      fallback: require.resolve("@umijs/bundler-webpack/compiled/file-loader")
+    }).end();
+  }
+  if (svgo !== false) {
+    const svgRule = config.module.rule("svg");
+    svgRule.test(/\.svg$/).use("svgo-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/svgo-loader")).options({ configFile: false, ...svgo }).end();
+  }
 }
-exports.addSVGRules = addSVGRules;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSVGRules
+});

package/dist/constants.d.ts

@@ -9,3 +9,7 @@ export declare enum MESSAGE_TYPE {
     stillOk = "still-ok",
     invalid = "invalid"
 }
+export declare const DEFAULT_BROWSER_TARGETS: {
+    chrome: number;
+};
+export declare const DEFAULT_ESBUILD_TARGET_KEYS: string[];

package/dist/constants.js

@@ -1,15 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGE_TYPE = exports.MFSU_NAME = exports.DEFAULT_OUTPUT_PATH = exports.DEFAULT_DEVTOOL = void 0;
-exports.DEFAULT_DEVTOOL = 'cheap-module-source-map';
-exports.DEFAULT_OUTPUT_PATH = 'dist';
-exports.MFSU_NAME = 'MFSU';
-var MESSAGE_TYPE;
-(function (MESSAGE_TYPE) {
-    MESSAGE_TYPE["ok"] = "ok";
-    MESSAGE_TYPE["warnings"] = "warnings";
-    MESSAGE_TYPE["errors"] = "errors";
-    MESSAGE_TYPE["hash"] = "hash";
-    MESSAGE_TYPE["stillOk"] = "still-ok";
-    MESSAGE_TYPE["invalid"] = "invalid";
-})(MESSAGE_TYPE = exports.MESSAGE_TYPE || (exports.MESSAGE_TYPE = {}));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_BROWSER_TARGETS: () => DEFAULT_BROWSER_TARGETS,
+  DEFAULT_DEVTOOL: () => DEFAULT_DEVTOOL,
+  DEFAULT_ESBUILD_TARGET_KEYS: () => DEFAULT_ESBUILD_TARGET_KEYS,
+  DEFAULT_OUTPUT_PATH: () => DEFAULT_OUTPUT_PATH,
+  MESSAGE_TYPE: () => MESSAGE_TYPE,
+  MFSU_NAME: () => MFSU_NAME
+});
+module.exports = __toCommonJS(constants_exports);
+var DEFAULT_DEVTOOL = "cheap-module-source-map";
+var DEFAULT_OUTPUT_PATH = "dist";
+var MFSU_NAME = "MFSU";
+var MESSAGE_TYPE = /* @__PURE__ */ ((MESSAGE_TYPE2) => {
+  MESSAGE_TYPE2["ok"] = "ok";
+  MESSAGE_TYPE2["warnings"] = "warnings";
+  MESSAGE_TYPE2["errors"] = "errors";
+  MESSAGE_TYPE2["hash"] = "hash";
+  MESSAGE_TYPE2["stillOk"] = "still-ok";
+  MESSAGE_TYPE2["invalid"] = "invalid";
+  return MESSAGE_TYPE2;
+})(MESSAGE_TYPE || {});
+var DEFAULT_BROWSER_TARGETS = {
+  chrome: 80
+};
+var DEFAULT_ESBUILD_TARGET_KEYS = [
+  "chrome",
+  "firefox",
+  "edge",
+  "safari"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BROWSER_TARGETS,
+  DEFAULT_DEVTOOL,
+  DEFAULT_ESBUILD_TARGET_KEYS,
+  DEFAULT_OUTPUT_PATH,
+  MESSAGE_TYPE,
+  MFSU_NAME
+});

package/dist/dev.d.ts

@@ -1,10 +1,19 @@
+/// <reference types="node" />
+import { MFSU } from '@umijs/mfsu';
+import type { Worker } from 'worker_threads';
+import webpack from '../compiled/webpack';
+import type { IOpts as IConfigOpts } from './config/config';
 import { IConfig } from './types';
-interface IOpts {
+declare type IOpts = {
     afterMiddlewares?: any[];
     beforeMiddlewares?: any[];
     onDevCompileDone?: Function;
+    onProgress?: Function;
+    onMFSUProgress?: Function;
     port?: number;
     host?: string;
+    ip?: string;
+    babelPreset?: any;
     chainWebpack?: Function;
     modifyWebpackConfig?: Function;
     beforeBabelPlugins?: any[];
@@ -12,8 +21,20 @@ interface IOpts {
     extraBabelPlugins?: any[];
     extraBabelPresets?: any[];
     cwd: string;
+    rootDir?: string;
     config: IConfig;
     entry: Record<string, string>;
-}
+    mfsuStrategy?: 'eager' | 'normal';
+    mfsuInclude?: string[];
+    srcCodeCache?: any;
+    startBuildWorker?: (deps: any[]) => Worker;
+    onBeforeMiddleware?: Function;
+    disableCopy?: boolean;
+} & Pick<IConfigOpts, 'cache' | 'pkg'>;
+export declare function ensureSerializableValue(obj: any): any;
 export declare function dev(opts: IOpts): Promise<void>;
+export declare function setup(opts: IOpts): Promise<{
+    mfsu: MFSU | null;
+    webpackConfig: webpack.Configuration;
+}>;
 export {};