@umijs/bundler-webpack 4.0.0-canary.20220429.3 → 4.0.0-canary.20220506.2

package/dist/config/config.js

@@ -0,0 +1,218 @@
+"use strict";
+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 RuntimePublicPathPlugin_1 = require("../plugins/RuntimePublicPathPlugin");
+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 detectDeadCodePlugin_1 = require("./detectDeadCodePlugin");
+const fastRefreshPlugin_1 = require("./fastRefreshPlugin");
+const forkTSCheckerPlugin_1 = require("./forkTSCheckerPlugin");
+const harmonyLinkingErrorPlugin_1 = require("./harmonyLinkingErrorPlugin");
+const ignorePlugin_1 = require("./ignorePlugin");
+const javaScriptRules_1 = require("./javaScriptRules");
+const manifestPlugin_1 = require("./manifestPlugin");
+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");
+async function getConfig(opts) {
+    const { userConfig } = opts;
+    const isDev = opts.env === types_1.Env.development;
+    const config = new webpack_5_chain_1.default();
+    userConfig.targets || (userConfig.targets = constants_1.DEFAULT_BROWSER_TARGETS);
+    const useHash = !!(opts.hash || (userConfig.hash && !isDev));
+    const applyOpts = {
+        name: opts.name,
+        config,
+        userConfig,
+        cwd: opts.cwd,
+        env: opts.env,
+        babelPreset: opts.babelPreset,
+        extraBabelPlugins: opts.extraBabelPlugins || [],
+        extraBabelPresets: opts.extraBabelPresets || [],
+        extraBabelIncludes: opts.extraBabelIncludes || [],
+        extraEsbuildLoaderHandler: opts.extraEsbuildLoaderHandler || [],
+        browsers: (0, browsersList_1.getBrowsersList)({
+            targets: userConfig.targets,
+        }),
+        useHash,
+        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);
+        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 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
+    await (0, nodePolyfill_1.addNodePolyfill)(applyOpts);
+    // rules
+    await (0, javaScriptRules_1.addJavaScriptRules)(applyOpts);
+    await (0, cssRules_1.addCSSRules)(applyOpts);
+    await (0, assetRules_1.addAssetRules)(applyOpts);
+    await (0, svgRules_1.addSVGRules)(applyOpts);
+    // plugins
+    // mini-css-extract-plugin
+    await (0, miniCSSExtractPlugin_1.addMiniCSSExtractPlugin)(applyOpts);
+    // ignoreMomentLocale
+    await (0, ignorePlugin_1.addIgnorePlugin)(applyOpts);
+    // define
+    await (0, definePlugin_1.addDefinePlugin)(applyOpts);
+    // fast refresh
+    await (0, fastRefreshPlugin_1.addFastRefreshPlugin)(applyOpts);
+    // progress
+    await (0, progressPlugin_1.addProgressPlugin)(applyOpts);
+    // detect-dead-code-plugin
+    await (0, detectDeadCodePlugin_1.addDetectDeadCodePlugin)(applyOpts);
+    // fork-ts-checker
+    await (0, forkTSCheckerPlugin_1.addForkTSCheckerPlugin)(applyOpts);
+    // copy
+    await (0, copyPlugin_1.addCopyPlugin)(applyOpts);
+    // manifest
+    await (0, manifestPlugin_1.addManifestPlugin)(applyOpts);
+    // hmr
+    if (isDev && opts.hmr) {
+        config.plugin('hmr').use(webpack_1.default.HotModuleReplacementPlugin);
+    }
+    // compress
+    await (0, compressPlugin_1.addCompressPlugin)(applyOpts);
+    // purgecss
+    // await applyPurgeCSSWebpackPlugin(applyOpts);
+    // handle HarmonyLinkingError
+    await (0, harmonyLinkingErrorPlugin_1.addHarmonyLinkingErrorPlugin)(applyOpts);
+    // remove node: prefix
+    // disable for performance
+    // await addNodePrefixPlugin(applyOpts);
+    // runtimePublicPath
+    if (userConfig.runtimePublicPath) {
+        config.plugin('runtimePublicPath').use(RuntimePublicPathPlugin_1.RuntimePublicPathPlugin);
+    }
+    // cache
+    if (opts.cache) {
+        config.cache({
+            type: 'filesystem',
+            version: require('../../package.json').version,
+            buildDependencies: {
+                config: opts.cache.buildDependencies || [],
+            },
+            cacheDirectory: opts.cache.cacheDirectory ||
+                // 使用 rootDir 是在有 APP_ROOT 时，把 cache 目录放在根目录下
+                (0, path_1.join)(opts.rootDir || opts.cwd, 'node_modules', '.cache', 'bundler-webpack'),
+        });
+        // tnpm 安装依赖的情况 webpack 默认的 managedPaths 不生效
+        // 使用 immutablePaths 避免 node_modules 的内容被写入缓存
+        // tnpm 安装的依赖路径中同时包含包名和版本号，满足 immutablePaths 使用的条件
+        // ref: smallfish
+        if ( /*isTnpm*/require('@umijs/utils/package').__npminstall_done) {
+            config.snapshot({
+                immutablePaths: [
+                    opts.cache.absNodeModulesPath ||
+                        (0, path_1.join)(opts.rootDir || opts.cwd, 'node_modules'),
+                ],
+            });
+        }
+        config.infrastructureLogging({
+            level: 'error',
+            ...(process.env.WEBPACK_FS_CACHE_DEBUG
+                ? {
+                    debug: /webpack\.cache/,
+                }
+                : {}),
+        });
+    }
+    // analyzer
+    if (opts.analyze) {
+        await (0, bundleAnalyzerPlugin_1.addBundleAnalyzerPlugin)(applyOpts);
+    }
+    // chain webpack
+    if (opts.chainWebpack) {
+        await opts.chainWebpack(config, {
+            env: opts.env,
+            webpack: webpack_1.default,
+        });
+    }
+    if (userConfig.chainWebpack) {
+        await userConfig.chainWebpack(config, {
+            env: opts.env,
+            webpack: webpack_1.default,
+        });
+    }
+    let webpackConfig = config.toConfig();
+    // speed measure
+    // TODO: mini-css-extract-plugin 报错
+    webpackConfig = await (0, speedMeasureWebpackPlugin_1.addSpeedMeasureWebpackPlugin)({
+        webpackConfig,
+    });
+    if (opts.modifyWebpackConfig) {
+        webpackConfig = await opts.modifyWebpackConfig(webpackConfig, {
+            env: opts.env,
+            webpack: webpack_1.default,
+        });
+    }
+    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,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCopyPlugin = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function addCopyPlugin(opts) {
+    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,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCSSRules = void 0;
+async function addCSSRules(opts) {
+    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-utils/compiled/less'),
+                lessOptions: {
+                    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({ base: 0, esModule: true, ...userConfig.styleLoader });
+            }
+            else {
+                rule
+                    .use('mini-css-extract-plugin')
+                    .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({
+                importLoaders: 1,
+                esModule: true,
+                url: true,
+                import: true,
+                ...(isCSSModules
+                    ? {
+                        modules: {
+                            localIdentName: '[local]___[hash:base64:5]',
+                            ...userConfig.cssLoaderModules,
+                        },
+                    }
+                    : {}),
+                ...userConfig.cssLoader,
+            });
+            rule
+                .use('postcss-loader')
+                .loader(require.resolve('@umijs/bundler-webpack/compiled/postcss-loader'))
+                .options({
+                postcssOptions: {
+                    ident: 'postcss',
+                    plugins: [
+                        require('@umijs/bundler-webpack/compiled/postcss-flexbugs-fixes'),
+                        require('postcss-preset-env')({
+                            browsers: opts.browsers,
+                            autoprefixer: {
+                                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,37 @@
+"use strict";
+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 {
+        'process.env': env,
+        ...define,
+    };
+}
+exports.resolveDefine = resolveDefine;
+async function addDefinePlugin(opts) {
+    const { config, userConfig } = opts;
+    config.plugin('define').use(webpack_1.DefinePlugin, [
+        resolveDefine({
+            define: userConfig.define || {},
+        }),
+    ]);
+}
+exports.addDefinePlugin = addDefinePlugin;

package/dist/config/detectDeadCode.d.ts

@@ -0,0 +1,12 @@
+import { Compilation } from '@umijs/bundler-webpack/compiled/webpack';
+import { DeadCodeParams } from '../types';
+export interface Options extends DeadCodeParams {
+    patterns: string[];
+    exclude: string[];
+    failOnHint: boolean;
+    detectUnusedFiles: boolean;
+    detectUnusedExport: boolean;
+}
+export declare const disabledFolders: string[];
+declare const detectDeadCode: (compilation: Compilation, options: Options) => void;
+export default detectDeadCode;

package/dist/config/detectDeadCode.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disabledFolders = void 0;
+const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
+const utils_1 = require("@umijs/utils");
+const path_1 = __importDefault(require("path"));
+exports.disabledFolders = [
+    'node_modules',
+    '.umi',
+    '.umi-production',
+    'dist',
+];
+const detectDeadCode = (compilation, options) => {
+    const assets = getWebpackAssets(compilation);
+    const compiledFilesDictionary = convertFilesToDict(assets);
+    const includedFiles = getPattern(options)
+        .map((pattern) => utils_1.glob.sync(pattern))
+        .flat();
+    const unusedFiles = options.detectUnusedFiles
+        ? includedFiles.filter((file) => !compiledFilesDictionary[file])
+        : [];
+    const unusedExportMap = options.detectUnusedExport
+        ? getUnusedExportMap(convertFilesToDict(includedFiles), compilation)
+        : {};
+    logUnusedFiles(unusedFiles);
+    logUnusedExportMap(unusedExportMap);
+    const hasUnusedThings = unusedFiles.length || Object.keys(unusedExportMap).length;
+    if (hasUnusedThings && options.failOnHint) {
+        process.exit(2);
+    }
+};
+const getPattern = (options) => {
+    return options.patterns
+        .map((pattern) => path_1.default.resolve(options.context || '', pattern))
+        .concat(options.exclude.map((pattern) => path_1.default.resolve(options.context || '', `!${pattern}`)))
+        .map(convertToUnixPath);
+};
+const getUnusedExportMap = (includedFileMap, compilation) => {
+    const unusedExportMap = {};
+    compilation.chunks.forEach((chunk) => {
+        compilation.chunkGraph.getChunkModules(chunk).forEach((module) => {
+            outputUnusedExportMap(compilation, chunk, module, includedFileMap, unusedExportMap);
+        });
+    });
+    return unusedExportMap;
+};
+const outputUnusedExportMap = (compilation, chunk, module, includedFileMap, unusedExportMap) => {
+    if (!(module instanceof webpack_1.NormalModule) || !module.resource) {
+        return;
+    }
+    const path = convertToUnixPath(module.resource);
+    if (!/^((?!(node_modules)).)*$/.test(path))
+        return;
+    const providedExports = compilation.chunkGraph.moduleGraph.getProvidedExports(module);
+    const usedExports = compilation.chunkGraph.moduleGraph.getUsedExports(module, chunk.runtime);
+    if (usedExports !== true &&
+        providedExports !== true &&
+        includedFileMap[path]) {
+        if (usedExports === false) {
+            if (providedExports === null || providedExports === void 0 ? void 0 : providedExports.length) {
+                unusedExportMap[path] = providedExports;
+            }
+        }
+        else if (providedExports instanceof Array) {
+            const unusedExports = providedExports.filter((item) => usedExports && !usedExports.has(item));
+            if (unusedExports.length) {
+                unusedExportMap[path] = unusedExports;
+            }
+        }
+    }
+};
+const logUnusedExportMap = (unusedExportMap) => {
+    if (!Object.keys(unusedExportMap).length) {
+        return;
+    }
+    let numberOfUnusedExport = 0;
+    let logStr = '';
+    Object.keys(unusedExportMap).forEach((filePath, fileIndex) => {
+        const unusedExports = unusedExportMap[filePath];
+        logStr += [
+            `\n${fileIndex + 1}. `,
+            utils_1.chalk.yellow(`${filePath}\n`),
+            '    >>>  ',
+            utils_1.chalk.yellow(`${unusedExports.join(',  ')}`),
+        ].join('');
+        numberOfUnusedExport += unusedExports.length;
+    });
+    console.log(utils_1.chalk.yellow.bold('\nWarning:'), utils_1.chalk.yellow(`There are ${numberOfUnusedExport} unused exports in ${Object.keys(unusedExportMap).length} files:`), logStr, utils_1.chalk.red.bold('\nPlease be careful if you want to remove them (¬º-°)¬.\n'));
+};
+const getWebpackAssets = (compilation) => {
+    const outputPath = compilation.getPath(compilation.compiler.outputPath);
+    const assets = [
+        ...Array.from(compilation.fileDependencies),
+        ...compilation
+            .getAssets()
+            .map((asset) => path_1.default.join(outputPath, asset.name)),
+    ];
+    return assets;
+};
+const convertFilesToDict = (assets) => {
+    return assets
+        .filter((file) => Boolean(file) &&
+        exports.disabledFolders.every((disabledPath) => !file.includes(disabledPath)))
+        .reduce((fileDictionary, file) => {
+        const unixFile = convertToUnixPath(file);
+        fileDictionary[unixFile] = true;
+        return fileDictionary;
+    }, {});
+};
+const logUnusedFiles = (unusedFiles) => {
+    if (!(unusedFiles === null || unusedFiles === void 0 ? void 0 : unusedFiles.length)) {
+        return;
+    }
+    console.log(utils_1.chalk.yellow.bold('\nWarning:'), utils_1.chalk.yellow(`There are ${unusedFiles.length} unused files:`), ...unusedFiles.map((file, index) => `\n${index + 1}. ${utils_1.chalk.yellow(file)}`), utils_1.chalk.red.bold('\nPlease be careful if you want to remove them (¬º-°)¬.\n'));
+};
+const convertToUnixPath = (path) => path.replace(/\\+/g, '/');
+exports.default = detectDeadCode;

package/dist/config/detectDeadCodePlugin.d.ts

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

package/dist/config/detectDeadCodePlugin.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDetectDeadCodePlugin = void 0;
+const types_1 = require("../types");
+const detectDeadCode_1 = __importStar(require("./detectDeadCode"));
+const defaultOptions = {
+    patterns: [`!(${detectDeadCode_1.disabledFolders.join('|')})/**/*.*`],
+    exclude: [],
+    failOnHint: false,
+    detectUnusedFiles: true,
+    detectUnusedExport: true,
+};
+class DetectDeadCodePlugin {
+    constructor(options) {
+        this.options = defaultOptions;
+        this.handleAfterEmit = (compilation, callback) => {
+            (0, detectDeadCode_1.default)(compilation, this.options);
+            callback();
+        };
+        if (!options) {
+            return;
+        }
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+    }
+    apply(compiler) {
+        if (!this.options.context) {
+            this.options = {
+                ...this.options,
+                context: compiler.context,
+            };
+        }
+        compiler.hooks.afterEmit.tapAsync('DetectDeadCodePlugin', this.handleAfterEmit);
+    }
+}
+async function addDetectDeadCodePlugin(opts) {
+    const { config, userConfig } = opts;
+    const isDev = opts.env === types_1.Env.development;
+    if (userConfig.deadCode && !isDev) {
+        config
+            .plugin('detect-dead-code-plugin')
+            .use(DetectDeadCodePlugin, [userConfig.deadCode]);
+    }
+}
+exports.addDetectDeadCodePlugin = addDetectDeadCodePlugin;

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