@umijs/bundler-webpack 4.0.5 → 4.0.8

package/dist/schema.js

@@ -1,98 +1,122 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemas = void 0;
-const types_1 = require("./types");
-const options = [
-    'cheap-source-map',
-    'cheap-module-source-map',
-    'eval',
-    'eval-source-map',
-    'eval-cheap-source-map',
-    'eval-cheap-module-source-map',
-    'eval-nosources-cheap-source-map',
-    'eval-nosources-cheap-module-source-map',
-    'eval-nosources-source-map',
-    'source-map',
-    'hidden-source-map',
-    'hidden-nosources-cheap-source-map',
-    'hidden-nosources-cheap-module-source-map',
-    'hidden-nosources-source-map',
-    'hidden-cheap-source-map',
-    'hidden-cheap-module-source-map',
-    'inline-source-map',
-    'inline-cheap-source-map',
-    'inline-cheap-module-source-map',
-    'inline-nosources-cheap-source-map',
-    'inline-nosources-cheap-module-source-map',
-    'inline-nosources-source-map',
-    'nosources-source-map',
-    'nosources-cheap-source-map',
-    'nosources-cheap-module-source-map',
+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);
+
+// schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  getSchemas: () => getSchemas
+});
+module.exports = __toCommonJS(schema_exports);
+var import_types = require("./types");
+var options = [
+  "cheap-source-map",
+  "cheap-module-source-map",
+  "eval",
+  "eval-source-map",
+  "eval-cheap-source-map",
+  "eval-cheap-module-source-map",
+  "eval-nosources-cheap-source-map",
+  "eval-nosources-cheap-module-source-map",
+  "eval-nosources-source-map",
+  "source-map",
+  "hidden-source-map",
+  "hidden-nosources-cheap-source-map",
+  "hidden-nosources-cheap-module-source-map",
+  "hidden-nosources-source-map",
+  "hidden-cheap-source-map",
+  "hidden-cheap-module-source-map",
+  "inline-source-map",
+  "inline-cheap-source-map",
+  "inline-cheap-module-source-map",
+  "inline-nosources-cheap-source-map",
+  "inline-nosources-cheap-module-source-map",
+  "inline-nosources-source-map",
+  "nosources-source-map",
+  "nosources-cheap-source-map",
+  "nosources-cheap-module-source-map"
 ];
-const DEVTOOL_REGEX = new RegExp('^' + // start of string
-    '(#@|@|#)?' + // maybe one of the pragmas
-    `(${options.join('$|')})`);
+var DEVTOOL_REGEX = new RegExp(`^(#@|@|#)?(${options.join("$|")})`);
 function getSchemas() {
-    return {
-        alias: (Joi) => Joi.object(),
-        autoCSSModules: (Joi) => Joi.boolean(),
-        autoprefixer: (Joi) => Joi.object(),
-        chainWebpack: (Joi) => Joi.function(),
-        copy: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.object({
-            from: Joi.string(),
-            to: Joi.string(),
-        }), Joi.string())),
-        cssLoader: (Joi) => Joi.object(),
-        cssLoaderModules: (Joi) => Joi.object(),
-        cssMinifier: (Joi) => Joi.string().valid(types_1.CSSMinifier.cssnano, types_1.CSSMinifier.esbuild, types_1.CSSMinifier.parcelCSS, types_1.CSSMinifier.none),
-        cssMinifierOptions: (Joi) => Joi.object(),
-        deadCode: (Joi) => Joi.object(),
-        define: (Joi) => Joi.object(),
-        depTranspiler: (Joi) => Joi.string().valid(types_1.Transpiler.babel, types_1.Transpiler.esbuild, types_1.Transpiler.swc, types_1.Transpiler.none),
-        devtool: (Joi) => Joi.alternatives().try(Joi.string().regex(DEVTOOL_REGEX), Joi.boolean()),
-        esm: (Joi) => Joi.object(),
-        externals: (Joi) => Joi.alternatives().try(Joi.object(), Joi.string(), Joi.func()),
-        extraBabelIncludes: (Joi) => Joi.array().items(Joi.string()),
-        extraBabelPlugins: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.array())),
-        extraBabelPresets: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.array())),
-        extraPostCSSPlugins: (Joi) => Joi.array(),
-        fastRefresh: (Joi) => Joi.boolean(),
-        forkTSChecker: (Joi) => Joi.object(),
-        hash: (Joi) => Joi.boolean(),
-        https: (Joi) => Joi.object(),
-        ignoreMomentLocale: (Joi) => Joi.boolean(),
-        inlineLimit: (Joi) => Joi.number(),
-        jsMinifier: (Joi) => Joi.string().valid(types_1.JSMinifier.esbuild, types_1.JSMinifier.swc, types_1.JSMinifier.terser, types_1.JSMinifier.uglifyJs, types_1.JSMinifier.none),
-        jsMinifierOptions: (Joi) => Joi.object(),
-        lessLoader: (Joi) => Joi.object(),
-        manifest: (Joi) => Joi.object(),
-        mdx: (Joi) => Joi.object({
-            loader: Joi.string(),
-            loaderOptions: Joi.object(),
-        }),
-        mfsu: (Joi) => Joi.alternatives(Joi.object({
-            cacheDirectory: Joi.string(),
-            chainWebpack: Joi.function(),
-            esbuild: Joi.boolean(),
-            include: Joi.array().items(Joi.string()),
-            mfName: Joi.string(),
-            runtimePublicPath: Joi.boolean(),
-            strategy: Joi.string().valid('eager', 'normal').default('normal'),
-        }), Joi.boolean()),
-        outputPath: (Joi) => Joi.string(),
-        postcssLoader: (Joi) => Joi.object(),
-        proxy: (Joi) => Joi.object(),
-        publicPath: (Joi) => Joi.string(),
-        purgeCSS: (Joi) => Joi.object(),
-        runtimePublicPath: (Joi) => Joi.object(),
-        sassLoader: (Joi) => Joi.object(),
-        srcTranspiler: (Joi) => Joi.string().valid(types_1.Transpiler.babel, types_1.Transpiler.esbuild, types_1.Transpiler.swc, types_1.Transpiler.none),
-        styleLoader: (Joi) => Joi.object(),
-        svgo: (Joi) => Joi.alternatives().try(Joi.object(), Joi.boolean()),
-        svgr: (Joi) => Joi.object(),
-        targets: (Joi) => Joi.object(),
-        theme: (Joi) => Joi.object(),
-        writeToDisk: (Joi) => Joi.boolean(),
-    };
+  return {
+    alias: (Joi) => Joi.object(),
+    autoCSSModules: (Joi) => Joi.boolean(),
+    autoprefixer: (Joi) => Joi.object(),
+    cacheDirectoryPath: (Joi) => Joi.string(),
+    chainWebpack: (Joi) => Joi.function(),
+    copy: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.object({
+      from: Joi.string(),
+      to: Joi.string()
+    }), Joi.string())),
+    cssLoader: (Joi) => Joi.object(),
+    cssLoaderModules: (Joi) => Joi.object(),
+    cssMinifier: (Joi) => Joi.string().valid(import_types.CSSMinifier.cssnano, import_types.CSSMinifier.esbuild, import_types.CSSMinifier.parcelCSS, import_types.CSSMinifier.none),
+    cssMinifierOptions: (Joi) => Joi.object(),
+    deadCode: (Joi) => Joi.object(),
+    define: (Joi) => Joi.object(),
+    depTranspiler: (Joi) => Joi.string().valid(import_types.Transpiler.babel, import_types.Transpiler.esbuild, import_types.Transpiler.swc, import_types.Transpiler.none),
+    devtool: (Joi) => Joi.alternatives().try(Joi.string().regex(DEVTOOL_REGEX), Joi.boolean()),
+    esm: (Joi) => Joi.object(),
+    externals: (Joi) => Joi.alternatives().try(Joi.object(), Joi.string(), Joi.func()),
+    extraBabelIncludes: (Joi) => Joi.array().items(Joi.string()),
+    extraBabelPlugins: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.array())),
+    extraBabelPresets: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.array())),
+    extraPostCSSPlugins: (Joi) => Joi.array(),
+    fastRefresh: (Joi) => Joi.boolean(),
+    forkTSChecker: (Joi) => Joi.object(),
+    hash: (Joi) => Joi.boolean(),
+    https: (Joi) => Joi.object(),
+    ignoreMomentLocale: (Joi) => Joi.boolean(),
+    inlineLimit: (Joi) => Joi.number(),
+    jsMinifier: (Joi) => Joi.string().valid(import_types.JSMinifier.esbuild, import_types.JSMinifier.swc, import_types.JSMinifier.terser, import_types.JSMinifier.uglifyJs, import_types.JSMinifier.none),
+    jsMinifierOptions: (Joi) => Joi.object(),
+    lessLoader: (Joi) => Joi.object(),
+    manifest: (Joi) => Joi.object(),
+    mdx: (Joi) => Joi.object({
+      loader: Joi.string(),
+      loaderOptions: Joi.object()
+    }),
+    mfsu: (Joi) => Joi.alternatives(Joi.object({
+      cacheDirectory: Joi.string(),
+      chainWebpack: Joi.function(),
+      esbuild: Joi.boolean(),
+      exclude: Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.object().regex())),
+      include: Joi.array().items(Joi.string()),
+      mfName: Joi.string(),
+      runtimePublicPath: Joi.boolean(),
+      strategy: Joi.string().valid("eager", "normal").default("normal")
+    }), Joi.boolean()),
+    outputPath: (Joi) => Joi.string(),
+    postcssLoader: (Joi) => Joi.object(),
+    proxy: (Joi) => Joi.alternatives().try(Joi.object(), Joi.array()),
+    publicPath: (Joi) => Joi.string(),
+    purgeCSS: (Joi) => Joi.object(),
+    runtimePublicPath: (Joi) => Joi.object(),
+    sassLoader: (Joi) => Joi.object(),
+    srcTranspiler: (Joi) => Joi.string().valid(import_types.Transpiler.babel, import_types.Transpiler.esbuild, import_types.Transpiler.swc, import_types.Transpiler.none),
+    styleLoader: (Joi) => Joi.object(),
+    svgo: (Joi) => Joi.alternatives().try(Joi.object(), Joi.boolean()),
+    svgr: (Joi) => Joi.object(),
+    targets: (Joi) => Joi.object(),
+    theme: (Joi) => Joi.object(),
+    writeToDisk: (Joi) => Joi.boolean()
+  };
 }
-exports.getSchemas = getSchemas;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSchemas
+});

package/dist/server/server.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { Configuration } from '@umijs/bundler-webpack/compiled/webpack';
 import http from 'http';
 import { IConfig } from '../types';

package/dist/server/server.js

@@ -1,196 +1,226 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServer = void 0;
-const bundler_utils_1 = require("@umijs/bundler-utils");
-const express_1 = __importDefault(require("@umijs/bundler-utils/compiled/express"));
-const http_proxy_middleware_1 = require("@umijs/bundler-webpack/compiled/http-proxy-middleware");
-const webpack_1 = __importDefault(require("@umijs/bundler-webpack/compiled/webpack"));
-const utils_1 = require("@umijs/utils");
-const cors_1 = __importDefault(require("cors"));
-const fs_1 = require("fs");
-const http_1 = __importDefault(require("http"));
-const path_1 = require("path");
-const constants_1 = require("../constants");
-const ws_1 = require("./ws");
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_bundler_utils = require("@umijs/bundler-utils");
+var import_express = __toESM(require("@umijs/bundler-utils/compiled/express"));
+var import_http_proxy_middleware = require("@umijs/bundler-webpack/compiled/http-proxy-middleware");
+var import_webpack = __toESM(require("@umijs/bundler-webpack/compiled/webpack"));
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_cors = __toESM(require("cors"));
+var import_fs = require("fs");
+var import_http = __toESM(require("http"));
+var import_path = require("path");
+var import_constants = require("../constants");
+var import_ws = require("./ws");
 async function createServer(opts) {
-    const { webpackConfig, userConfig } = opts;
-    const { proxy } = userConfig;
-    const app = (0, express_1.default)();
-    // cros
-    app.use((0, cors_1.default)({
-        origin: true,
-        methods: ['GET', 'HEAD', 'PUT', 'POST', 'PATCH', 'DELETE', 'OPTIONS'],
-        credentials: true,
-    }));
-    // compression
-    app.use(require('@umijs/bundler-webpack/compiled/compression')());
-    // TODO: headers
-    // before middlewares
-    (opts.beforeMiddlewares || []).forEach((m) => app.use(m));
-    // TODO: add to before middleware
-    app.use((req, res, next) => {
-        const file = req.path;
-        const filePath = (0, path_1.join)(opts.cwd, file);
-        const ext = (0, path_1.extname)(filePath);
-        if (ext === '.js' && (0, fs_1.existsSync)(filePath)) {
-            res.sendFile(filePath);
-        }
-        else {
-            next();
-        }
-    });
-    // webpack dev middleware
-    const configs = Array.isArray(webpackConfig)
-        ? webpackConfig
-        : [webpackConfig];
-    const progresses = [];
-    if (opts.onProgress) {
-        configs.forEach((config) => {
-            const progress = {
-                percent: 0,
-                status: 'waiting',
-            };
-            progresses.push(progress);
-            config.plugins.push(new webpack_1.default.ProgressPlugin((percent, msg) => {
-                progress.percent = percent;
-                progress.status = msg;
-                opts.onProgress({ progresses });
-            }));
-        });
+  const { webpackConfig, userConfig } = opts;
+  const { proxy } = userConfig;
+  const app = (0, import_express.default)();
+  app.use((0, import_cors.default)({
+    origin: true,
+    methods: ["GET", "HEAD", "PUT", "POST", "PATCH", "DELETE", "OPTIONS"],
+    credentials: true
+  }));
+  app.use(require("@umijs/bundler-webpack/compiled/compression")());
+  app.use((req, res, next) => {
+    const file = req.path;
+    const filePath = (0, import_path.join)(opts.cwd, file);
+    const ext = (0, import_path.extname)(filePath);
+    if (ext === ".js" && (0, import_fs.existsSync)(filePath)) {
+      import_utils.logger.info("[dev]", `${file} is responded with ${filePath}, remove it to use original file`);
+      res.sendFile(filePath);
+    } else {
+      next();
     }
-    const compiler = (0, webpack_1.default)(configs);
-    const webpackDevMiddleware = require('@umijs/bundler-webpack/compiled/webpack-dev-middleware');
-    const compilerMiddleware = webpackDevMiddleware(compiler, {
-        publicPath: userConfig.publicPath || '/',
-        writeToDisk: userConfig.writeToDisk,
-        stats: 'none',
-        // watchOptions: { ignored }
+  });
+  (opts.beforeMiddlewares || []).forEach((m) => app.use(m));
+  const configs = Array.isArray(webpackConfig) ? webpackConfig : [webpackConfig];
+  const progresses = [];
+  if (opts.onProgress) {
+    configs.forEach((config) => {
+      const progress = {
+        percent: 0,
+        status: "waiting"
+      };
+      progresses.push(progress);
+      config.plugins.push(new import_webpack.default.ProgressPlugin((percent, msg) => {
+        progress.percent = percent;
+        progress.status = msg;
+        opts.onProgress({ progresses });
+      }));
     });
-    app.use(compilerMiddleware);
-    // hmr hooks
-    let stats;
-    let isFirstCompile = true;
-    compiler.compilers.forEach(addHooks);
-    function addHooks(compiler) {
-        compiler.hooks.invalid.tap('server', () => {
-            sendMessage(constants_1.MESSAGE_TYPE.invalid);
-        });
-        compiler.hooks.done.tap('server', (_stats) => {
-            var _a;
-            stats = _stats;
-            sendStats(getStats(stats));
-            (_a = opts.onDevCompileDone) === null || _a === void 0 ? void 0 : _a.call(opts, {
-                stats,
-                isFirstCompile,
-                time: stats.endTime - stats.startTime,
-            });
-            isFirstCompile = false;
-        });
-    }
-    function sendStats(stats, force, sender) {
-        const shouldEmit = !force &&
-            stats &&
-            (!stats.errors || stats.errors.length === 0) &&
-            (!stats.warnings || stats.warnings.length === 0) &&
-            stats.assets &&
-            stats.assets.every((asset) => !asset.emitted);
-        if (shouldEmit) {
-            sendMessage(constants_1.MESSAGE_TYPE.stillOk, null, sender);
-            return;
-        }
-        sendMessage(constants_1.MESSAGE_TYPE.hash, stats.hash, sender);
-        if ((stats.errors && stats.errors.length > 0) ||
-            (stats.warnings && stats.warnings.length > 0)) {
-            if (stats.warnings && stats.warnings.length > 0) {
-                sendMessage(constants_1.MESSAGE_TYPE.warnings, stats.warnings, sender);
-            }
-            if (stats.errors && stats.errors.length > 0) {
-                sendMessage(constants_1.MESSAGE_TYPE.errors, stats.errors, sender);
-            }
-        }
-        else {
-            sendMessage(constants_1.MESSAGE_TYPE.ok, null, sender);
-        }
-    }
-    function getStats(stats) {
-        return stats.toJson({
-            all: false,
-            hash: true,
-            assets: true,
-            warnings: true,
-            errors: true,
-            errorDetails: false,
-        });
-    }
-    function sendMessage(type, data, sender) {
-        (sender || ws).send(JSON.stringify({ type, data }));
+  }
+  const compiler = (0, import_webpack.default)(configs);
+  const webpackDevMiddleware = require("@umijs/bundler-webpack/compiled/webpack-dev-middleware");
+  const compilerMiddleware = webpackDevMiddleware(compiler, {
+    publicPath: userConfig.publicPath || "/",
+    writeToDisk: userConfig.writeToDisk,
+    stats: "none"
+  });
+  app.use(compilerMiddleware);
+  let stats;
+  let isFirstCompile = true;
+  compiler.compilers.forEach(addHooks);
+  function addHooks(compiler2) {
+    compiler2.hooks.invalid.tap("server", () => {
+      sendMessage(import_constants.MESSAGE_TYPE.invalid);
+    });
+    compiler2.hooks.done.tap("server", (_stats) => {
+      var _a;
+      stats = _stats;
+      sendStats(getStats(stats));
+      (_a = opts.onDevCompileDone) == null ? void 0 : _a.call(opts, {
+        stats,
+        isFirstCompile,
+        time: stats.endTime - stats.startTime
+      });
+      isFirstCompile = false;
+    });
+  }
+  function sendStats(stats2, force, sender) {
+    const shouldEmit = !force && stats2 && (!stats2.errors || stats2.errors.length === 0) && (!stats2.warnings || stats2.warnings.length === 0) && stats2.assets && stats2.assets.every((asset) => !asset.emitted);
+    if (shouldEmit) {
+      sendMessage(import_constants.MESSAGE_TYPE.stillOk, null, sender);
+      return;
     }
-    // mock
-    // proxy
-    if (proxy) {
-        Object.keys(proxy).forEach((key) => {
-            const proxyConfig = proxy[key];
-            const target = proxyConfig.target;
-            if (target) {
-                app.use(key, (0, http_proxy_middleware_1.createProxyMiddleware)(key, {
-                    ...proxy[key],
-                    // Add x-real-url in response header
-                    onProxyRes(proxyRes, req, res) {
-                        var _a, _b;
-                        proxyRes.headers['x-real-url'] =
-                            ((_a = new URL(req.url || '', target)) === null || _a === void 0 ? void 0 : _a.href) || '';
-                        (_b = proxyConfig.onProxyRes) === null || _b === void 0 ? void 0 : _b.call(proxyConfig, proxyRes, req, res);
-                    },
-                }));
-            }
-        });
+    sendMessage(import_constants.MESSAGE_TYPE.hash, stats2.hash, sender);
+    if (stats2.errors && stats2.errors.length > 0 || stats2.warnings && stats2.warnings.length > 0) {
+      if (stats2.warnings && stats2.warnings.length > 0) {
+        sendMessage(import_constants.MESSAGE_TYPE.warnings, stats2.warnings, sender);
+      }
+      if (stats2.errors && stats2.errors.length > 0) {
+        sendMessage(import_constants.MESSAGE_TYPE.errors, stats2.errors, sender);
+      }
+    } else {
+      sendMessage(import_constants.MESSAGE_TYPE.ok, null, sender);
     }
-    // after middlewares
-    (opts.afterMiddlewares || []).forEach((m) => {
-        // TODO: FIXME
-        app.use(m.toString().includes(`{ compiler }`) ? m({ compiler }) : m);
+  }
+  function getStats(stats2) {
+    return stats2.toJson({
+      all: false,
+      hash: true,
+      assets: true,
+      warnings: true,
+      errors: true,
+      errorDetails: false
     });
-    // history fallback
-    app.use(require('@umijs/bundler-webpack/compiled/connect-history-api-fallback')({
-        index: '/',
-    }));
-    // hmr reconnect ping
-    app.use('/__umi_ping', (_, res) => {
-        res.end('pong');
+  }
+  function sendMessage(type, data, sender) {
+    (sender || ws).send(JSON.stringify({ type, data }));
+  }
+  if (proxy) {
+    const proxyArr = Array.isArray(proxy) ? proxy : proxy.target ? [proxy] : Object.keys(proxy).map((key) => {
+      return __spreadProps(__spreadValues({}, proxy[key]), {
+        context: key
+      });
     });
-    // index.html
-    // TODO: remove me
-    app.get('/', (_req, res, next) => {
-        res.set('Content-Type', 'text/html');
-        const htmlPath = (0, path_1.join)(opts.cwd, 'index.html');
-        if ((0, fs_1.existsSync)(htmlPath)) {
-            (0, fs_1.createReadStream)(htmlPath).on('error', next).pipe(res);
-        }
-        else {
-            next();
+    proxyArr.forEach((proxy2) => {
+      let middleware;
+      if (proxy2.target) {
+        (0, import_assert.default)(typeof proxy2.target === "string", "proxy.target must be string");
+        (0, import_assert.default)(proxy2.context, "proxy.context must be supplied");
+        middleware = (0, import_http_proxy_middleware.createProxyMiddleware)(proxy2.context, __spreadProps(__spreadValues({}, proxy2), {
+          onProxyRes(proxyRes, req, res) {
+            var _a, _b;
+            proxyRes.headers["x-real-url"] = ((_a = new URL(req.url || "", proxy2.target)) == null ? void 0 : _a.href) || "";
+            (_b = proxy2.onProxyRes) == null ? void 0 : _b.call(proxy2, proxyRes, req, res);
+          }
+        }));
+      }
+      app.use((req, res, next) => {
+        const bypassUrl = typeof proxy2.bypass === "function" ? proxy2.bypass(req, res, proxy2) : null;
+        if (typeof bypassUrl === "string") {
+          req.url = bypassUrl;
+          return next();
+        } else if (bypassUrl === false) {
+          return res.end(404);
+        } else if ((bypassUrl === null || bypassUrl === void 0) && middleware) {
+          return middleware(req, res, next);
+        } else {
+          next();
         }
+      });
     });
-    const server = userConfig.https
-        ? await (0, bundler_utils_1.createHttpsServer)(app, userConfig.https)
-        : http_1.default.createServer(app);
-    if (!server) {
-        return null;
+  }
+  (opts.afterMiddlewares || []).forEach((m) => {
+    app.use(m.toString().includes(`{ compiler }`) ? m({ compiler }) : m);
+  });
+  app.use(require("@umijs/bundler-webpack/compiled/connect-history-api-fallback")({
+    index: "/"
+  }));
+  app.use("/__umi_ping", (_, res) => {
+    res.end("pong");
+  });
+  app.get("/", (_req, res, next) => {
+    res.set("Content-Type", "text/html");
+    const htmlPath = (0, import_path.join)(opts.cwd, "index.html");
+    if ((0, import_fs.existsSync)(htmlPath)) {
+      (0, import_fs.createReadStream)(htmlPath).on("error", next).pipe(res);
+    } else {
+      next();
     }
-    const ws = (0, ws_1.createWebSocketServer)(server);
-    ws.wss.on('connection', (socket) => {
-        if (stats) {
-            sendStats(getStats(stats), false, socket);
-        }
-    });
-    const protocol = userConfig.https ? 'https:' : 'http:';
-    const port = opts.port || 8000;
-    server.listen(port, () => {
-        const host = opts.host && opts.host !== '0.0.0.0' ? opts.host : '127.0.0.1';
-        utils_1.logger.ready(`App listening at ${utils_1.chalk.green(`${protocol}//${host}:${port}`)}`);
-    });
-    return server;
+  });
+  const server = userConfig.https ? await (0, import_bundler_utils.createHttpsServer)(app, userConfig.https) : import_http.default.createServer(app);
+  if (!server) {
+    return null;
+  }
+  const ws = (0, import_ws.createWebSocketServer)(server);
+  ws.wss.on("connection", (socket) => {
+    if (stats) {
+      sendStats(getStats(stats), false, socket);
+    }
+  });
+  const protocol = userConfig.https ? "https:" : "http:";
+  const port = opts.port || 8e3;
+  server.listen(port, () => {
+    const host = opts.host && opts.host !== "0.0.0.0" ? opts.host : "localhost";
+    import_utils.logger.ready(`App listening at ${import_utils.chalk.green(`${protocol}//${host}:${port}`)}`);
+  });
+  return server;
 }
-exports.createServer = createServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});