@umijs/bundler-webpack 3.5.18 → 4.0.0-beta.2

package/dist/config/config.js

@@ -0,0 +1,171 @@
+"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 || '/')
+            .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,
+        });
+        // 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,
+        });
+        return webpackConfig;
+    });
+}
+exports.getConfig = getConfig;

package/dist/config/copyPlugin.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 addCopyPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/copyPlugin.js

@@ -0,0 +1,49 @@
+"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.addCopyPlugin = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function addCopyPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, cwd } = opts;
+        const copyPatterns = [
+            (0, fs_1.existsSync)((0, path_1.join)(cwd, 'public')) && {
+                from: (0, path_1.join)(cwd, 'public'),
+            },
+            ...(userConfig.copy
+                ? userConfig.copy.map((item) => {
+                    if (typeof item === 'string') {
+                        return {
+                            from: (0, path_1.join)(cwd, item),
+                            to: item,
+                        };
+                    }
+                    return {
+                        // 相对于 process.cwd，所以这里需要使用绝对路径
+                        from: (0, path_1.join)(cwd, item.from),
+                        to: item.to,
+                    };
+                })
+                : []),
+        ].filter(Boolean);
+        if (copyPatterns.length) {
+            config
+                .plugin('copy')
+                .use(require('@umijs/bundler-webpack/compiled/copy-webpack-plugin'), [
+                {
+                    patterns: copyPatterns,
+                },
+            ]);
+        }
+    });
+}
+exports.addCopyPlugin = addCopyPlugin;

package/dist/config/cssRules.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;
+    browsers: any;
+}
+export declare function addCSSRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/cssRules.js

@@ -0,0 +1,98 @@
+"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.addCSSRules = void 0;
+function addCSSRules(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig } = opts;
+        const rulesConfig = [
+            { name: 'css', test: /\.css(\?.*)?$/ },
+            {
+                name: 'less',
+                test: /\.less(\?.*)?$/,
+                loader: require.resolve('@umijs/bundler-webpack/compiled/less-loader'),
+                loaderOptions: {
+                    implementation: require.resolve('@umijs/bundler-webpack/compiled/less'),
+                    lessOptions: Object.assign({ modifyVars: userConfig.theme, javascriptEnabled: true }, userConfig.lessLoader),
+                },
+            },
+            {
+                name: 'sass',
+                test: /\.(sass|scss)(\?.*)?$/,
+                loader: require.resolve('@umijs/bundler-webpack/compiled/sass-loader'),
+                loaderOptions: userConfig.sassLoader || {},
+            },
+        ];
+        for (const { name, test, loader, loaderOptions } of rulesConfig) {
+            const rule = config.module.rule(name);
+            const nestRulesConfig = [
+                userConfig.autoCSSModules && {
+                    rule: rule
+                        .test(test)
+                        .oneOf('css-modules')
+                        .resourceQuery(/modules/),
+                    isCSSModules: true,
+                },
+                {
+                    rule: rule.test(test).oneOf('css').sideEffects(true),
+                    isCSSModules: false,
+                },
+            ].filter(Boolean);
+            // @ts-ignore
+            for (const { rule, isCSSModules } of nestRulesConfig) {
+                if (userConfig.styleLoader) {
+                    rule
+                        .use('style-loader')
+                        .loader(require.resolve('@umijs/bundler-webpack/compiled/style-loader'))
+                        .options(Object.assign({ base: 0, esModule: true }, userConfig.styleLoader));
+                }
+                else {
+                    rule
+                        .use('mini-css-extract-plugin-loader')
+                        .loader(require.resolve('@umijs/bundler-webpack/compiled/mini-css-extract-plugin/loader'))
+                        .options({
+                        publicPath: './',
+                        emit: true,
+                        esModule: true,
+                    });
+                }
+                rule
+                    .use('css-loader')
+                    .loader(require.resolve('css-loader'))
+                    .options(Object.assign(Object.assign({ importLoaders: 1, esModule: true, url: true, import: true }, (isCSSModules
+                    ? {
+                        modules: Object.assign({ localIdentName: '[local]___[hash:base64:5]' }, userConfig.cssLoaderModules),
+                    }
+                    : {})), userConfig.cssLoader));
+                rule
+                    .use('postcss-loader')
+                    .loader(require.resolve('@umijs/bundler-webpack/compiled/postcss-loader'))
+                    .options({
+                    postcssOptions: Object.assign({ ident: 'postcss', plugins: [
+                            require('@umijs/bundler-webpack/compiled/postcss-flexbugs-fixes'),
+                            require('postcss-preset-env')({
+                                browsers: opts.browsers,
+                                autoprefixer: Object.assign({ flexbox: 'no-2009' }, userConfig.autoprefixer),
+                                stage: 3,
+                            }),
+                        ].concat(userConfig.extraPostCSSPlugins || []) }, userConfig.postcssLoader),
+                });
+                if (loader) {
+                    rule
+                        .use(loader)
+                        .loader(typeof loader === 'string' ? require.resolve(loader) : loader)
+                        .options(loaderOptions || {});
+                }
+            }
+        }
+    });
+}
+exports.addCSSRules = addCSSRules;

package/dist/config/definePlugin.d.ts

@@ -0,0 +1,15 @@
+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 resolveDefine(opts: {
+    define: any;
+}): {
+    'process.env': Record<string, any>;
+};
+export declare function addDefinePlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/definePlugin.js

@@ -0,0 +1,45 @@
+"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.addDefinePlugin = exports.resolveDefine = void 0;
+const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
+const prefixRE = /^UMI_APP_/;
+const ENV_SHOULD_PASS = ['NODE_ENV', 'HMR', 'SOCKET_SERVER', 'ERROR_OVERLAY'];
+function resolveDefine(opts) {
+    const env = {};
+    Object.keys(process.env).forEach((key) => {
+        if (prefixRE.test(key) || ENV_SHOULD_PASS.includes(key)) {
+            env[key] = process.env[key];
+        }
+    });
+    for (const key in env) {
+        env[key] = JSON.stringify(env[key]);
+    }
+    const define = {};
+    if (opts.define) {
+        for (const key in opts.define) {
+            define[key] = JSON.stringify(opts.define[key]);
+        }
+    }
+    return Object.assign({ 'process.env': env }, define);
+}
+exports.resolveDefine = resolveDefine;
+function addDefinePlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig } = opts;
+        config.plugin('define').use(webpack_1.DefinePlugin, [
+            resolveDefine({
+                define: userConfig.define || {},
+            }),
+        ]);
+    });
+}
+exports.addDefinePlugin = addDefinePlugin;

package/dist/config/fastRefreshPlugin.d.ts

@@ -0,0 +1,12 @@
+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;
+    browsers: any;
+    name?: string;
+}
+export declare function addFastRefreshPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/fastRefreshPlugin.js

@@ -0,0 +1,34 @@
+"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.addFastRefreshPlugin = void 0;
+// @ts-ignore
+const lib_1 = __importDefault(require("@pmmmwh/react-refresh-webpack-plugin/lib"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+function addFastRefreshPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, name } = opts;
+        const isDev = opts.env === types_1.Env.development;
+        const useFastRefresh = isDev && userConfig.fastRefresh !== false && name !== constants_1.MFSU_NAME;
+        // TODO: Should only run in react csr
+        if (useFastRefresh) {
+            config
+                .plugin('fastRefresh')
+                .after('hmr')
+                .use(lib_1.default, [{ overlay: false }]);
+        }
+    });
+}
+exports.addFastRefreshPlugin = addFastRefreshPlugin;

package/dist/config/ignorePlugin.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 addIgnorePlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/ignorePlugin.js

@@ -0,0 +1,27 @@
+"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.addIgnorePlugin = void 0;
+const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
+function addIgnorePlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig } = opts;
+        if (userConfig.ignoreMomentLocale) {
+            config.plugin('ignore-moment-locale').use(webpack_1.IgnorePlugin, [
+                {
+                    resourceRegExp: /^\.\/locale$/,
+                    contextRegExp: /moment$/,
+                },
+            ]);
+        }
+    });
+}
+exports.addIgnorePlugin = addIgnorePlugin;

package/dist/config/javaScriptRules.d.ts

@@ -0,0 +1,14 @@
+import Config from '../../compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    extraBabelPlugins: any[];
+    extraBabelPresets: any[];
+    babelPreset: any;
+    name?: string;
+}
+export declare function addJavaScriptRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/javaScriptRules.js

@@ -0,0 +1,150 @@
+"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.addJavaScriptRules = void 0;
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const depMatch_1 = require("../utils/depMatch");
+function addJavaScriptRules(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, cwd, env, name } = opts;
+        const isDev = opts.env === types_1.Env.development;
+        const useFastRefresh = isDev && userConfig.fastRefresh !== false && name === constants_1.MFSU_NAME;
+        const depPkgs = Object.assign({}, (0, depMatch_1.es5ImcompatibleVersionsToPkg)());
+        const srcRules = [
+            config.module
+                .rule('src')
+                .test(/\.(js|mjs)$/)
+                .include.add([
+                cwd,
+                // import module out of cwd using APP_ROOT
+                // issue: https://github.com/umijs/umi/issues/5594
+                ...(process.env.APP_ROOT ? [process.cwd()] : []),
+            ])
+                .end()
+                .exclude.add(/node_modules/)
+                .end(),
+            config.module.rule('jsx-ts-tsx').test(/\.(jsx|ts|tsx)$/),
+            config.module
+                .rule('extra-src')
+                .test(/\.(js|mjs)$/)
+                .include.add((path) => {
+                try {
+                    if (path.includes('client/client'))
+                        return true;
+                    return (0, depMatch_1.isMatch)({ path, pkgs: depPkgs });
+                }
+                catch (e) {
+                    console.error(utils_1.chalk.red(e));
+                    throw e;
+                }
+            })
+                .end(),
+        ];
+        const depRules = [
+            config.module
+                .rule('dep')
+                .test(/\.(js|mjs)$/)
+                .include.add(/node_modules/)
+                .end()
+                .exclude.add((path) => {
+                try {
+                    return (0, depMatch_1.isMatch)({ path, pkgs: depPkgs });
+                }
+                catch (e) {
+                    console.error(utils_1.chalk.red(e));
+                    throw e;
+                }
+            })
+                .end(),
+        ];
+        // const prefix = existsSync(join(cwd, 'src')) ? join(cwd, 'src') : cwd;
+        const srcTranspiler = userConfig.srcTranspiler || types_1.Transpiler.babel;
+        srcRules.forEach((rule) => {
+            if (srcTranspiler === types_1.Transpiler.babel) {
+                rule
+                    .use('babel-loader')
+                    .loader(require.resolve('../../compiled/babel-loader'))
+                    .options({
+                    // Tell babel to guess the type, instead assuming all files are modules
+                    // https://github.com/webpack/webpack/issues/4039#issuecomment-419284940
+                    sourceType: 'unambiguous',
+                    babelrc: false,
+                    cacheDirectory: false,
+                    // process.env.BABEL_CACHE !== 'none'
+                    //   ? join(cwd, `.umi/.cache/babel-loader`)
+                    //   : false,
+                    targets: userConfig.targets,
+                    presets: [
+                        opts.babelPreset || [
+                            require.resolve('@umijs/babel-preset-umi'),
+                            {
+                                presetEnv: {},
+                                presetReact: {},
+                                presetTypeScript: {},
+                                pluginTransformRuntime: {},
+                                pluginLockCoreJS: {},
+                                pluginDynamicImportNode: false,
+                                pluginAutoCSSModules: userConfig.autoCSSModules,
+                            },
+                        ],
+                        ...opts.extraBabelPresets,
+                        ...(userConfig.extraBabelPresets || []).filter(Boolean),
+                    ],
+                    plugins: [
+                        useFastRefresh && require.resolve('react-refresh/babel'),
+                        ...opts.extraBabelPlugins,
+                        ...(userConfig.extraBabelPlugins || []),
+                    ].filter(Boolean),
+                });
+            }
+            else if (srcTranspiler === types_1.Transpiler.swc) {
+                // TODO: support javascript
+                rule
+                    .use('swc-loader')
+                    .loader(require.resolve('../../compiled/swc-loader'))
+                    .options({
+                    jsc: {
+                        parser: {
+                            syntax: 'typescript',
+                            dynamicImport: true,
+                            tsx: true,
+                        },
+                        transform: {
+                            react: {
+                                runtime: 'automatic',
+                                pragma: 'React.createElement',
+                                pragmaFrag: 'React.Fragment',
+                                throwIfNamespace: true,
+                                development: env === types_1.Env.development,
+                                useBuiltins: true,
+                            },
+                        },
+                    },
+                });
+            }
+            else {
+                throw new Error(`Unsupported srcTranspiler ${srcTranspiler}.`);
+            }
+        });
+        const depTranspiler = userConfig.depTranspiler || types_1.Transpiler.none;
+        depRules.forEach((_rule) => {
+            if (depTranspiler === types_1.Transpiler.none) {
+                // noop
+            }
+            else {
+                throw new Error(`Unsupported depTranspiler ${depTranspiler}.`);
+            }
+        });
+    });
+}
+exports.addJavaScriptRules = addJavaScriptRules;

package/dist/config/miniCSSExtractPlugin.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 addMiniCSSExtractPlugin(opts: IOpts): Promise<void>;
+export {};