@umijs/bundler-webpack 3.5.20 → 4.0.0-beta.12

package/dist/client/client.js

@@ -0,0 +1,239 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strip_ansi_1 = __importDefault(require("@umijs/utils/compiled/strip-ansi"));
+// @ts-ignore
+const ErrorOverlay = __importStar(require("react-error-overlay"));
+const constants_1 = require("../constants");
+const formatWebpackMessages_1 = require("../utils/formatWebpackMessages");
+console.log('[webpack] connecting...');
+let pingTimer = null;
+const host = location.host;
+const wsUrl = `ws://${host}`;
+let isFirstCompilation = true;
+let mostRecentCompilationHash = null;
+let hasCompileErrors = false;
+let hadRuntimeError = false;
+const socket = new WebSocket(wsUrl, 'webpack-hmr');
+socket.addEventListener('message', ({ data }) => __awaiter(void 0, void 0, void 0, function* () {
+    data = JSON.parse(data);
+    if (data.type === 'connected') {
+        console.log(`[webpack] connected.`);
+        // proxy(nginx, docker) hmr ws maybe caused timeout,
+        // so send ping package let ws keep alive.
+        pingTimer = setInterval(() => socket.send('ping'), 30000);
+    }
+    else {
+        handleMessage(data).catch(console.error);
+    }
+}));
+function waitForSuccessfulPing(ms = 1000) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                yield fetch(`/__umi_ping`);
+                break;
+            }
+            catch (e) {
+                yield new Promise((resolve) => setTimeout(resolve, ms));
+            }
+        }
+    });
+}
+socket.addEventListener('close', () => __awaiter(void 0, void 0, void 0, function* () {
+    if (pingTimer)
+        clearInterval(pingTimer);
+    console.info('[webpack] Dev server disconnected. Polling for restart...');
+    yield waitForSuccessfulPing();
+    location.reload();
+}));
+ErrorOverlay.startReportingRuntimeErrors({
+    onError: function () {
+        hadRuntimeError = true;
+    },
+    filename: '/static/js/bundle.js',
+});
+// @ts-ignore
+if (module.hot && typeof module.hot.dispose === 'function') {
+    // @ts-ignore
+    module.hot.dispose(function () {
+        // TODO: why do we need this?
+        ErrorOverlay.stopReportingRuntimeErrors();
+    });
+}
+// There is a newer version of the code available.
+function handleAvailableHash(hash) {
+    // Update last known compilation hash.
+    mostRecentCompilationHash = hash;
+}
+function handleSuccess() {
+    const isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    // Attempt to apply hot updates or reload.
+    if (isHotUpdate) {
+        tryApplyUpdates(function onHotUpdateSuccess() {
+            // Only dismiss it when we're sure it's a hot update.
+            // Otherwise it would flicker right before the reload.
+            tryDismissErrorOverlay();
+        });
+    }
+}
+function handleWarnings(warnings) {
+    const isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    const formatted = (0, formatWebpackMessages_1.formatWebpackMessages)({
+        warnings,
+        errors: [],
+    });
+    // print warnings
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        for (let i = 0; i < formatted.warnings.length; i++) {
+            if (i === 5) {
+                console.warn('There were more warnings in other files.\n' +
+                    'You can find a complete log in the terminal.');
+                break;
+            }
+            console.warn((0, strip_ansi_1.default)(formatted.warnings[i]));
+        }
+    }
+    // Attempt to apply hot updates or reload.
+    if (isHotUpdate) {
+        tryApplyUpdates(function onSuccessfulHotUpdate() {
+            // Only dismiss it when we're sure it's a hot update.
+            // Otherwise it would flicker right before the reload.
+            tryDismissErrorOverlay();
+        });
+    }
+}
+function handleErrors(errors) {
+    isFirstCompilation = false;
+    hasCompileErrors = true;
+    const formatted = (0, formatWebpackMessages_1.formatWebpackMessages)({
+        warnings: [],
+        errors,
+    });
+    // Only show the first error.
+    ErrorOverlay.reportBuildError(formatted.errors[0]);
+    // Also log them to the console.
+    if (typeof console !== 'undefined' && typeof console.error === 'function') {
+        for (let i = 0; i < formatted.errors.length; i++) {
+            console.error((0, strip_ansi_1.default)(formatted.errors[i]));
+        }
+    }
+}
+function tryDismissErrorOverlay() {
+    if (!hasCompileErrors) {
+        ErrorOverlay.dismissBuildError();
+    }
+}
+// Is there a newer version of this code available?
+function isUpdateAvailable() {
+    // @ts-ignore
+    return mostRecentCompilationHash !== __webpack_hash__;
+}
+function canApplyUpdates() {
+    // @ts-ignore
+    return module.hot.status() === 'idle';
+}
+function canAcceptErrors() {
+    // NOTE: This var is injected by Webpack's DefinePlugin, and is a boolean instead of string.
+    const hasReactRefresh = process.env.FAST_REFRESH;
+    // @ts-ignore
+    const status = module.hot.status();
+    // React refresh can handle hot-reloading over errors.
+    // However, when hot-reload status is abort or fail,
+    // it indicates the current update cannot be applied safely,
+    // and thus we should bail out to a forced reload for consistency.
+    return hasReactRefresh && ['abort', 'fail'].indexOf(status) === -1;
+}
+function tryApplyUpdates(onHotUpdateSuccess) {
+    // @ts-ignore
+    if (!module.hot) {
+        window.location.reload();
+        return;
+    }
+    if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+    }
+    function handleApplyUpdates(err, updatedModules) {
+        const haveErrors = err || hadRuntimeError;
+        // When there is no error but updatedModules is unavailable,
+        // it indicates a critical failure in hot-reloading,
+        // e.g. server is not ready to serve new bundle,
+        // and hence we need to do a forced reload.
+        const needsForcedReload = !err && !updatedModules;
+        if ((haveErrors && !canAcceptErrors()) || needsForcedReload) {
+            window.location.reload();
+        }
+        if (onHotUpdateSuccess)
+            onHotUpdateSuccess();
+        // While we were updating, there was a new update! Do it again.
+        if (isUpdateAvailable()) {
+            tryApplyUpdates();
+        }
+    }
+    // @ts-ignore
+    module.hot
+        .check(/* autoApply */ true)
+        .then((updatedModules) => {
+        handleApplyUpdates(null, updatedModules);
+    })
+        .catch((err) => {
+        handleApplyUpdates(err, null);
+    });
+}
+function handleMessage(payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // console.log('[payload]', payload);
+        switch (payload.type) {
+            case constants_1.MESSAGE_TYPE.hash:
+                handleAvailableHash(payload.data);
+                break;
+            case constants_1.MESSAGE_TYPE.stillOk:
+            case constants_1.MESSAGE_TYPE.ok:
+                handleSuccess();
+                break;
+            case constants_1.MESSAGE_TYPE.errors:
+                handleErrors(payload.data);
+                break;
+            case constants_1.MESSAGE_TYPE.warnings:
+                handleWarnings(payload.data);
+                break;
+            default:
+            // Do nothing
+        }
+    });
+}

package/dist/config/_sampleFeature.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addSampleFeature(opts: IOpts): Promise<void>;
+export {};

package/dist/config/_sampleFeature.js

@@ -0,0 +1,22 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSampleFeature = void 0;
+function addSampleFeature(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, cwd, env } = opts;
+        config;
+        userConfig;
+        cwd;
+        env;
+    });
+}
+exports.addSampleFeature = addSampleFeature;

package/dist/config/assetRules.d.ts

@@ -0,0 +1,11 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    staticPathPrefix: string;
+}
+export declare function addAssetRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/assetRules.js

@@ -0,0 +1,57 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAssetRules = void 0;
+function addAssetRules(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig } = opts;
+        const inlineLimit = parseInt(userConfig.inlineLimit || '10000', 10);
+        const rule = config.module.rule('asset');
+        rule
+            .oneOf('avif')
+            .test(/\.avif$/)
+            .type('asset')
+            .mimetype('image/avif')
+            .parser({
+            dataUrlCondition: {
+                maxSize: inlineLimit,
+            },
+        })
+            .generator({
+            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
+        });
+        rule
+            .oneOf('image')
+            .test(/\.(bmp|gif|jpg|jpeg|png)$/)
+            .type('asset')
+            .parser({
+            dataUrlCondition: {
+                maxSize: inlineLimit,
+            },
+        })
+            .generator({
+            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
+        });
+        rule
+            .oneOf('fallback')
+            .exclude.add(/^$/) /* handle data: resources */
+            .add(/\.(js|mjs|jsx|ts|tsx)$/)
+            .add(/\.(css|less|sass|scss|stylus)$/)
+            .add(/\.html$/)
+            .add(/\.json$/)
+            .end()
+            .type('asset/resource')
+            .generator({
+            filename: `${opts.staticPathPrefix}[name].[hash:8].[ext]`,
+        });
+    });
+}
+exports.addAssetRules = addAssetRules;

package/dist/config/bundleAnalyzerPlugin.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addBundleAnalyzerPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/bundleAnalyzerPlugin.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBundleAnalyzerPlugin = void 0;
+// @ts-ignore
+const webpack_bundle_analyzer_1 = require("@umijs/bundler-webpack/compiled/webpack-bundle-analyzer");
+function addBundleAnalyzerPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config } = opts;
+        config.plugin('webpack-bundle-analyzer').use(webpack_bundle_analyzer_1.BundleAnalyzerPlugin, [
+            // https://github.com/webpack-contrib/webpack-bundle-analyzer
+            {
+                analyzerMode: 'server',
+                analyzerPort: process.env.ANALYZE_PORT || 8888,
+                openAnalyzer: false,
+                logLevel: 'info',
+                defaultSizes: 'parsed',
+            },
+        ]);
+    });
+}
+exports.addBundleAnalyzerPlugin = addBundleAnalyzerPlugin;

package/dist/config/compressPlugin.d.ts

@@ -0,0 +1,10 @@
+import Config from '../../compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addCompressPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/compressPlugin.js

@@ -0,0 +1,77 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCompressPlugin = void 0;
+// @ts-ignore
+const css_minimizer_webpack_plugin_1 = __importDefault(require("@umijs/bundler-webpack/compiled/css-minimizer-webpack-plugin"));
+const terser_webpack_plugin_1 = __importDefault(require("../../compiled/terser-webpack-plugin"));
+const ESBuildCSSMinifyPlugin_1 = __importDefault(require("../plugins/ESBuildCSSMinifyPlugin"));
+const types_1 = require("../types");
+function addCompressPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, env } = opts;
+        const jsMinifier = userConfig.jsMinifier || types_1.JSMinifier.esbuild;
+        const cssMinifier = userConfig.cssMinifier || types_1.CSSMinifier.esbuild;
+        if (env === types_1.Env.development ||
+            process.env.COMPRESS === 'none' ||
+            (jsMinifier === types_1.JSMinifier.none && cssMinifier === types_1.CSSMinifier.none)) {
+            config.optimization.minimize(false);
+            return;
+        }
+        config.optimization.minimize(true);
+        let minify;
+        if (jsMinifier === types_1.JSMinifier.esbuild) {
+            minify = terser_webpack_plugin_1.default.esbuildMinify;
+        }
+        else if (jsMinifier === types_1.JSMinifier.terser) {
+            minify = terser_webpack_plugin_1.default.terserMinify;
+        }
+        else if (jsMinifier === types_1.JSMinifier.swc) {
+            minify = terser_webpack_plugin_1.default.swcMinify;
+        }
+        else if (jsMinifier === types_1.JSMinifier.uglifyJs) {
+            minify = terser_webpack_plugin_1.default.uglifyJsMinify;
+        }
+        else if (jsMinifier !== types_1.JSMinifier.none) {
+            throw new Error(`Unsupported jsMinifier ${userConfig.jsMinifier}.`);
+        }
+        if (jsMinifier !== types_1.JSMinifier.none) {
+            config.optimization.minimizer(`js-${jsMinifier}`).use(terser_webpack_plugin_1.default, [
+                {
+                    minify,
+                    terserOptions: userConfig.jsMinifierOptions,
+                },
+            ]);
+        }
+        if (cssMinifier === types_1.CSSMinifier.esbuild) {
+            config.optimization
+                .minimizer(`css-${cssMinifier}`)
+                .use(ESBuildCSSMinifyPlugin_1.default, [userConfig.cssMinifierOptions]);
+        }
+        else if (cssMinifier === types_1.CSSMinifier.cssnano) {
+            config.optimization
+                .minimizer(`css-${cssMinifier}`)
+                .use(css_minimizer_webpack_plugin_1.default, [
+                {
+                    minimizerOptions: userConfig.cssMinifierOptions,
+                    parallel: true,
+                },
+            ]);
+        }
+        else if (cssMinifier !== types_1.CSSMinifier.none) {
+            throw new Error(`Unsupported cssMinifier ${userConfig.cssMinifier}.`);
+        }
+    });
+}
+exports.addCompressPlugin = addCompressPlugin;

package/dist/config/config.d.ts

@@ -0,0 +1,20 @@
+import { Configuration } from '../../compiled/webpack';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    cwd: string;
+    env: Env;
+    entry: Record<string, string>;
+    extraBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    babelPreset?: any;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    hash?: boolean;
+    hmr?: boolean;
+    staticPathPrefix?: string;
+    userConfig: IConfig;
+    analyze?: any;
+    name?: string;
+}
+export declare function getConfig(opts: IOpts): Promise<Configuration>;
+export {};

package/dist/config/config.js

@@ -0,0 +1,178 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const path_1 = require("path");
+const webpack_1 = __importDefault(require("../../compiled/webpack"));
+const webpack_5_chain_1 = __importDefault(require("../../compiled/webpack-5-chain"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const browsersList_1 = require("../utils/browsersList");
+const assetRules_1 = require("./assetRules");
+const bundleAnalyzerPlugin_1 = require("./bundleAnalyzerPlugin");
+const compressPlugin_1 = require("./compressPlugin");
+const copyPlugin_1 = require("./copyPlugin");
+const cssRules_1 = require("./cssRules");
+const definePlugin_1 = require("./definePlugin");
+const fastRefreshPlugin_1 = require("./fastRefreshPlugin");
+const ignorePlugin_1 = require("./ignorePlugin");
+const javaScriptRules_1 = require("./javaScriptRules");
+const miniCSSExtractPlugin_1 = require("./miniCSSExtractPlugin");
+const nodePolyfill_1 = require("./nodePolyfill");
+const progressPlugin_1 = require("./progressPlugin");
+const speedMeasureWebpackPlugin_1 = require("./speedMeasureWebpackPlugin");
+const svgRules_1 = require("./svgRules");
+function getConfig(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { userConfig } = opts;
+        const isDev = opts.env === types_1.Env.development;
+        const config = new webpack_5_chain_1.default();
+        userConfig.targets = userConfig.targets || {
+            chrome: 80,
+        };
+        const applyOpts = {
+            name: opts.name,
+            config,
+            userConfig,
+            cwd: opts.cwd,
+            env: opts.env,
+            babelPreset: opts.babelPreset,
+            extraBabelPlugins: opts.extraBabelPlugins || [],
+            extraBabelPresets: opts.extraBabelPresets || [],
+            browsers: (0, browsersList_1.getBrowsersList)({
+                targets: userConfig.targets,
+            }),
+            staticPathPrefix: opts.staticPathPrefix !== undefined ? opts.staticPathPrefix : 'static/',
+        };
+        // mode
+        config.mode(opts.env);
+        config.stats('none');
+        // entry
+        Object.keys(opts.entry).forEach((key) => {
+            const entry = config.entry(key);
+            // TODO: runtimePublicPath
+            if (isDev && opts.hmr) {
+                entry.add(require.resolve('../../client/client/client'));
+            }
+            entry.add(opts.entry[key]);
+        });
+        // devtool
+        config.devtool(isDev
+            ? userConfig.devtool === false
+                ? false
+                : userConfig.devtool || constants_1.DEFAULT_DEVTOOL
+            : userConfig.devtool);
+        // output
+        const absOutputPath = (0, path_1.join)(opts.cwd, userConfig.outputPath || constants_1.DEFAULT_OUTPUT_PATH);
+        const useHash = opts.hash || (userConfig.hash && !isDev);
+        const disableCompress = process.env.COMPRESS === 'none';
+        config.output
+            .path(absOutputPath)
+            .filename(useHash ? `[name].[contenthash:8].js` : `[name].js`)
+            .chunkFilename(useHash ? `[name].[contenthash:8].async.js` : `[name].js`)
+            .publicPath(userConfig.publicPath || 'auto')
+            .pathinfo(isDev || disableCompress);
+        // resolve
+        // prettier-ignore
+        config.resolve
+            .set('symlinks', true)
+            .modules
+            .add('node_modules')
+            .end()
+            .alias
+            .merge(userConfig.alias || {})
+            .end()
+            .extensions
+            .merge([
+            '.wasm',
+            '.mjs',
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+            '.json'
+        ])
+            .end();
+        // externals
+        config.externals(userConfig.externals || []);
+        // target
+        config.target(['web', 'es5']);
+        // experiments
+        config.experiments({
+            topLevelAwait: true,
+            outputModule: !!userConfig.esm,
+        });
+        // node polyfill
+        yield (0, nodePolyfill_1.addNodePolyfill)(applyOpts);
+        // rules
+        yield (0, javaScriptRules_1.addJavaScriptRules)(applyOpts);
+        yield (0, cssRules_1.addCSSRules)(applyOpts);
+        yield (0, assetRules_1.addAssetRules)(applyOpts);
+        yield (0, svgRules_1.addSVGRules)(applyOpts);
+        // plugins
+        // mini-css-extract-plugin
+        yield (0, miniCSSExtractPlugin_1.addMiniCSSExtractPlugin)(applyOpts);
+        // ignoreMomentLocale
+        yield (0, ignorePlugin_1.addIgnorePlugin)(applyOpts);
+        // define
+        yield (0, definePlugin_1.addDefinePlugin)(applyOpts);
+        // fast refresh
+        yield (0, fastRefreshPlugin_1.addFastRefreshPlugin)(applyOpts);
+        // progress
+        yield (0, progressPlugin_1.addProgressPlugin)(applyOpts);
+        // copy
+        yield (0, copyPlugin_1.addCopyPlugin)(applyOpts);
+        // TODO: friendly-error
+        // TODO: manifest
+        // hmr
+        if (isDev && opts.hmr) {
+            config.plugin('hmr').use(webpack_1.default.HotModuleReplacementPlugin);
+        }
+        // compress
+        yield (0, compressPlugin_1.addCompressPlugin)(applyOpts);
+        // purgecss
+        // await applyPurgeCSSWebpackPlugin(applyOpts);
+        // analyzer
+        if (opts.analyze) {
+            yield (0, bundleAnalyzerPlugin_1.addBundleAnalyzerPlugin)(applyOpts);
+        }
+        // chain webpack
+        if (opts.chainWebpack) {
+            yield opts.chainWebpack(config, {
+                env: opts.env,
+                webpack: webpack_1.default,
+            });
+        }
+        if (userConfig.chainWebpack) {
+            yield userConfig.chainWebpack(config, {
+                env: opts.env,
+                webpack: webpack_1.default,
+            });
+        }
+        let webpackConfig = config.toConfig();
+        // speed measure
+        // TODO: mini-css-extract-plugin 报错
+        webpackConfig = yield (0, speedMeasureWebpackPlugin_1.addSpeedMeasureWebpackPlugin)({
+            webpackConfig,
+        });
+        if (opts.modifyWebpackConfig) {
+            webpackConfig = yield opts.modifyWebpackConfig(webpackConfig, {
+                env: opts.env,
+                webpack: webpack_1.default,
+            });
+        }
+        return webpackConfig;
+    });
+}
+exports.getConfig = getConfig;