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

package/dist/config/purgecssWebpackPlugin.js

@@ -0,0 +1,32 @@
+"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.applyPurgeCSSWebpackPlugin = void 0;
+const types_1 = require("../types");
+function applyPurgeCSSWebpackPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig, cwd, env } = opts;
+        config;
+        userConfig;
+        cwd;
+        env;
+        if (userConfig.purgeCSS && env === types_1.Env.production) {
+            config
+                .plugin('purgecss-webpack-plugin')
+                .use(require('@umijs/bundler-webpack/compiled/purgecss-webpack-plugin'), [
+                {
+                    paths: [],
+                },
+            ]);
+        }
+    });
+}
+exports.applyPurgeCSSWebpackPlugin = applyPurgeCSSWebpackPlugin;

package/dist/config/speedMeasureWebpackPlugin.d.ts

@@ -0,0 +1,6 @@
+import { Configuration } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+    webpackConfig: Configuration;
+}
+export declare function addSpeedMeasureWebpackPlugin(opts: IOpts): Promise<Configuration>;
+export {};

package/dist/config/speedMeasureWebpackPlugin.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.addSpeedMeasureWebpackPlugin = void 0;
+// @ts-ignore
+const speed_measure_webpack_plugin_1 = __importDefault(require("@umijs/bundler-webpack/compiled/speed-measure-webpack-plugin"));
+const path_1 = require("path");
+function addSpeedMeasureWebpackPlugin(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let webpackConfig = opts.webpackConfig;
+        if (process.env.SPEED_MEASURE) {
+            const smpOption = process.env.SPEED_MEASURE === 'JSON'
+                ? {
+                    outputFormat: 'json',
+                    outputTarget: (0, path_1.join)(process.cwd(), 'SPEED_MEASURE.json'),
+                }
+                : { outputFormat: 'human', outputTarget: console.log };
+            webpackConfig = new speed_measure_webpack_plugin_1.default(smpOption).wrap(webpackConfig);
+        }
+        return webpackConfig;
+    });
+}
+exports.addSpeedMeasureWebpackPlugin = addSpeedMeasureWebpackPlugin;

package/dist/config/svgRules.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;
+    staticPathPrefix: string;
+}
+export declare function addSVGRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/svgRules.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.addSVGRules = void 0;
+function addSVGRules(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { config, userConfig } = opts;
+        const { svgr, svgo = {} } = userConfig;
+        if (svgr) {
+            const svgrRule = config.module.rule('svgr');
+            svgrRule
+                .test(/\.svg$/)
+                .issuer(/\.[jt]sx?$/)
+                .type('javascript/auto')
+                .use('svgr-loader')
+                .loader(require.resolve('../loader/svgr'))
+                .options(Object.assign(Object.assign({ svgoConfig: Object.assign({ plugins: [
+                        {
+                            name: 'preset-default',
+                            params: {
+                                overrides: {
+                                    removeTitle: false,
+                                },
+                            },
+                        },
+                    ] }, svgo) }, svgr), { svgo: !!svgo }))
+                .end()
+                .use('url-loader')
+                .loader(require.resolve('@umijs/bundler-webpack/compiled/url-loader'))
+                .end();
+        }
+        if (svgo === false) {
+            const svgRule = config.module.rule('svg');
+            svgRule
+                .test(/\.svg$/)
+                .use('url-loader')
+                .loader(require.resolve('@umijs/bundler-webpack/compiled/url-loader'));
+            return;
+        }
+        const svgRule = config.module.rule('svg');
+        svgRule
+            .test(/\.svg$/)
+            .use('svgo-loader')
+            .loader(require.resolve('@umijs/bundler-webpack/compiled/svgo-loader'))
+            .options(Object.assign({ configFile: false }, svgo))
+            .end();
+    });
+}
+exports.addSVGRules = addSVGRules;

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_DEVTOOL = "cheap-module-source-map";
+export declare const DEFAULT_OUTPUT_PATH = "dist";
+export declare const MFSU_NAME = "MFSU";
+export declare enum MESSAGE_TYPE {
+    ok = "ok",
+    warnings = "warnings",
+    errors = "errors",
+    hash = "hash",
+    stillOk = "still-ok",
+    invalid = "invalid"
+}

package/dist/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_TYPE = exports.MFSU_NAME = exports.DEFAULT_OUTPUT_PATH = exports.DEFAULT_DEVTOOL = void 0;
+exports.DEFAULT_DEVTOOL = 'cheap-module-source-map';
+exports.DEFAULT_OUTPUT_PATH = 'dist';
+exports.MFSU_NAME = 'MFSU';
+var MESSAGE_TYPE;
+(function (MESSAGE_TYPE) {
+    MESSAGE_TYPE["ok"] = "ok";
+    MESSAGE_TYPE["warnings"] = "warnings";
+    MESSAGE_TYPE["errors"] = "errors";
+    MESSAGE_TYPE["hash"] = "hash";
+    MESSAGE_TYPE["stillOk"] = "still-ok";
+    MESSAGE_TYPE["invalid"] = "invalid";
+})(MESSAGE_TYPE = exports.MESSAGE_TYPE || (exports.MESSAGE_TYPE = {}));

package/dist/dev.d.ts

@@ -0,0 +1,19 @@
+import { IConfig } from './types';
+interface IOpts {
+    afterMiddlewares?: any[];
+    beforeMiddlewares?: any[];
+    onDevCompileDone?: Function;
+    port?: number;
+    host?: string;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    beforeBabelPlugins?: any[];
+    beforeBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    extraBabelPresets?: any[];
+    cwd: string;
+    config: IConfig;
+    entry: Record<string, string>;
+}
+export declare function dev(opts: IOpts): Promise<void>;
+export {};

package/dist/dev.js

@@ -0,0 +1,87 @@
+"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.dev = void 0;
+const mfsu_1 = require("@umijs/mfsu");
+const webpack_1 = __importDefault(require("../compiled/webpack"));
+const config_1 = require("./config/config");
+const constants_1 = require("./constants");
+const server_1 = require("./server/server");
+const types_1 = require("./types");
+function dev(opts) {
+    var _a;
+    var _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const enableMFSU = opts.config.mfsu !== false;
+        let mfsu = null;
+        if (enableMFSU) {
+            mfsu = new mfsu_1.MFSU({
+                implementor: webpack_1.default,
+                buildDepWithESBuild: (_a = opts.config.mfsu) === null || _a === void 0 ? void 0 : _a.esbuild,
+            });
+        }
+        const webpackConfig = yield (0, config_1.getConfig)({
+            cwd: opts.cwd,
+            env: types_1.Env.development,
+            entry: opts.entry,
+            userConfig: opts.config,
+            extraBabelPlugins: [
+                ...(opts.beforeBabelPlugins || []),
+                ...((mfsu === null || mfsu === void 0 ? void 0 : mfsu.getBabelPlugins()) || []),
+                ...(opts.extraBabelPlugins || []),
+            ],
+            extraBabelPresets: [
+                ...(opts.beforeBabelPresets || []),
+                ...(opts.extraBabelPresets || []),
+            ],
+            chainWebpack: opts.chainWebpack,
+            modifyWebpackConfig: opts.modifyWebpackConfig,
+            hmr: true,
+            analyze: process.env.ANALYZE,
+        });
+        const depConfig = yield (0, config_1.getConfig)({
+            cwd: opts.cwd,
+            env: types_1.Env.development,
+            entry: opts.entry,
+            userConfig: opts.config,
+            hash: true,
+            staticPathPrefix: mfsu_1.MF_DEP_PREFIX,
+            name: constants_1.MFSU_NAME,
+        });
+        (_b = webpackConfig.resolve).alias || (_b.alias = {});
+        // TODO: REMOVE ME
+        ['@umijs/utils/compiled/strip-ansi', 'react-error-overlay'].forEach((dep) => {
+            // @ts-ignore
+            webpackConfig.resolve.alias[dep] = require.resolve(dep);
+        });
+        mfsu === null || mfsu === void 0 ? void 0 : mfsu.setWebpackConfig({
+            config: webpackConfig,
+            depConfig: depConfig,
+        });
+        yield (0, server_1.createServer)({
+            webpackConfig,
+            userConfig: opts.config,
+            cwd: opts.cwd,
+            beforeMiddlewares: [
+                ...((mfsu === null || mfsu === void 0 ? void 0 : mfsu.getMiddlewares()) || []),
+                ...(opts.beforeMiddlewares || []),
+            ],
+            port: opts.port,
+            host: opts.host,
+            afterMiddlewares: [...(opts.afterMiddlewares || [])],
+            onDevCompileDone: opts.onDevCompileDone,
+        });
+    });
+}
+exports.dev = dev;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { RequestHandler } from '../compiled/express';
+export * from './build';
+export * from './config/config';
+export * from './dev';
+export * from './schema';

package/dist/index.js

@@ -0,0 +1,16 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build"), exports);
+__exportStar(require("./config/config"), exports);
+__exportStar(require("./dev"), exports);
+__exportStar(require("./schema"), exports);

package/dist/loader/svgr.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '@svgr/core';
+import type { LoaderContext } from '../../compiled/webpack';
+declare function svgrLoader(this: LoaderContext<Config>, contents: string): void;
+export default svgrLoader;

package/dist/loader/svgr.js

@@ -0,0 +1,67 @@
+"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 });
+// MIT: https://github.com/gregberge/svgr/blob/main/packages/webpack/src/index.ts
+// TODO: prebuild @svgr/core @svgr/plugin-jsx @svgr/plugin-svgo
+const core_1 = require("@svgr/core");
+// @ts-ignore
+const plugin_jsx_1 = __importDefault(require("@svgr/plugin-jsx"));
+// @ts-ignore
+const plugin_svgo_1 = __importDefault(require("@svgr/plugin-svgo"));
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+const path_1 = require("path");
+const util_1 = require("util");
+const tranformSvg = (0, util_1.callbackify)((contents, options, state) => __awaiter(void 0, void 0, void 0, function* () {
+    const jsCode = yield (0, core_1.transform)(contents, options, state);
+    const result = yield (0, esbuild_1.transform)(jsCode, {
+        loader: 'tsx',
+        target: 'es2015',
+    });
+    if (!(result === null || result === void 0 ? void 0 : result.code)) {
+        throw new Error(`Error while transforming using Esbuild`);
+    }
+    return result.code;
+}));
+function svgrLoader(contents) {
+    this.cacheable && this.cacheable();
+    const callback = this.async();
+    const options = this.getOptions();
+    const previousExport = (() => {
+        if (contents.startsWith('export '))
+            return contents;
+        const exportMatches = contents.match(/^module.exports\s*=\s*(.*)/);
+        return exportMatches ? `export default ${exportMatches[1]}` : null;
+    })();
+    const state = {
+        caller: {
+            name: 'svgr-loader',
+            previousExport,
+            defaultPlugins: [plugin_svgo_1.default, plugin_jsx_1.default],
+        },
+        filePath: (0, path_1.normalize)(this.resourcePath),
+    };
+    if (!previousExport) {
+        tranformSvg(contents, options, state, callback);
+    }
+    else {
+        this.fs.readFile(this.resourcePath, (err, result) => {
+            if (err) {
+                callback(err);
+                return;
+            }
+            tranformSvg(String(result), options, state, callback);
+        });
+    }
+}
+exports.default = svgrLoader;

package/dist/plugins/ESBuildCSSMinifyPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Compilation, Compiler } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+    sourcemap?: any;
+}
+declare class ESBuildCSSMinifyPlugin {
+    options: IOpts;
+    constructor(options?: IOpts);
+    apply(compiler: Compiler): void;
+    transformAssets(compilation: Compilation): Promise<void>;
+}
+export default ESBuildCSSMinifyPlugin;

package/dist/plugins/ESBuildCSSMinifyPlugin.js

@@ -0,0 +1,65 @@
+"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 });
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+const webpack_sources_1 = require("@umijs/bundler-webpack/compiled/webpack-sources");
+const version = require('../../package.json');
+const PLUGIN_NAME = 'ESBuildCSSMinifyPlugin';
+const RE_CSS_FILE = /\.css(\?.*)?$/i;
+class ESBuildCSSMinifyPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (_, hash) => {
+                hash.update(JSON.stringify({
+                    version,
+                    options: this.options,
+                }));
+            });
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: 400,
+                additionalAssets: true,
+            }, () => __awaiter(this, void 0, void 0, function* () {
+                yield this.transformAssets(compilation);
+            }));
+        });
+    }
+    transformAssets(compilation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { options: { devtool }, } = compilation.compiler;
+            const sourcemap = this.options.sourcemap === undefined
+                ? devtool && devtool
+                : this.options.sourcemap;
+            const assets = compilation.getAssets().filter((asset) => {
+                return !asset.info.minimized && RE_CSS_FILE.test(asset.name);
+            });
+            yield Promise.all(assets.map((asset) => __awaiter(this, void 0, void 0, function* () {
+                const { source, map } = asset.source.sourceAndMap();
+                const sourceAsString = source.toString();
+                const result = yield (0, esbuild_1.transform)(sourceAsString, {
+                    loader: 'css',
+                    sourcemap,
+                    sourcefile: asset.name,
+                    minify: true,
+                });
+                compilation.updateAsset(asset.name, 
+                // @ts-ignore
+                sourcemap
+                    ? new webpack_sources_1.SourceMapSource(result.code, asset.name, result.map, sourceAsString, map, true)
+                    : new webpack_sources_1.RawSource(result.code), Object.assign(Object.assign({}, asset.info), { minimized: true }));
+            })));
+        });
+    }
+}
+exports.default = ESBuildCSSMinifyPlugin;

package/dist/plugins/ProgressPlugin.d.ts

@@ -0,0 +1,15 @@
+import { Compiler, ProgressPlugin } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+    name?: string;
+}
+declare class UmiProgressPlugin extends ProgressPlugin {
+    options: IOpts;
+    constructor(options?: IOpts);
+    apply(compiler: Compiler): void;
+    updateProgress(opts: {
+        percent: number;
+        message: string;
+        details: any[];
+    }): void;
+}
+export default UmiProgressPlugin;

package/dist/plugins/ProgressPlugin.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
+const utils_1 = require("@umijs/utils");
+const PLUGIN_NAME = 'ProgressPlugin';
+class UmiProgressPlugin extends webpack_1.ProgressPlugin {
+    constructor(options = {}) {
+        super({ activeModules: true });
+        this.options = options;
+        this.handler = (percent, message, ...details) => {
+            this.updateProgress({ percent, message, details });
+        };
+    }
+    apply(compiler) {
+        compiler.hooks.invalid.tap(PLUGIN_NAME, () => {
+            utils_1.logger.wait('compiling...');
+        });
+        compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+            const { errors, warnings } = stats.toJson({
+                all: false,
+                warnings: true,
+                errors: true,
+                colors: true,
+            });
+            const hasErrors = !!(errors === null || errors === void 0 ? void 0 : errors.length);
+            const hasWarnings = !!(warnings === null || warnings === void 0 ? void 0 : warnings.length);
+            hasWarnings;
+            if (hasErrors) {
+                errors.forEach((error) => {
+                    utils_1.logger.error(`${error.moduleName}${error.loc ? `:${error.loc}` : ''}`);
+                    console.log(error.message);
+                });
+            }
+            else {
+                const prefix = this.options.name ? `${this.options.name} ` : '';
+                utils_1.logger.event(`${prefix}compiled successfully in ${stats.endTime - stats.startTime} ms (${stats.compilation.modules.size} modules)`);
+            }
+        });
+    }
+    updateProgress(opts) {
+        opts;
+    }
+}
+exports.default = UmiProgressPlugin;

package/dist/plugins/_SamplePlugin.d.ts

@@ -0,0 +1,9 @@
+import { Compiler } from '@umijs/bundler-webpack/compiled/webpack';
+interface IOpts {
+}
+declare class _SamplePlugin {
+    options: IOpts;
+    constructor(options?: IOpts);
+    apply(compiler: Compiler): void;
+}
+export default _SamplePlugin;

package/dist/plugins/_SamplePlugin.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PLUGIN_NAME = 'SamplePlugin';
+class _SamplePlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (_) => { });
+        });
+    }
+}
+exports.default = _SamplePlugin;

package/dist/requireHook.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/requireHook.js

@@ -0,0 +1,31 @@
+"use strict";
+// MIT: copy from https://github.com/vercel/next.js/blob/canary/packages/next/build/webpack/require-hook.ts
+// sync injects a hook for webpack and webpack/... requires to use the internal ncc webpack version
+// this is in order for userland plugins to attach to the same webpack instance as umi
+// the individual compiled modules are as defined for the compilation in bundles/webpack/packages/*
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const deepImports_json_1 = __importDefault(require("@umijs/bundler-webpack/compiled/webpack/deepImports.json"));
+const hookPropertyMap = new Map([
+    ['webpack', '@umijs/bundler-webpack/compiled/webpack'],
+    ['webpack/package', '@umijs/bundler-webpack/compiled/webpack/package'],
+    ['webpack/package.json', '@umijs/bundler-webpack/compiled/webpack/package'],
+    ['webpack/lib/webpack', '@umijs/bundler-webpack/compiled/webpack'],
+    ['webpack/lib/webpack.js', '@umijs/bundler-webpack/compiled/webpack'],
+]);
+deepImports_json_1.default.forEach((item) => {
+    const name = item.split('/').unshift();
+    hookPropertyMap.set(item, `@umijs/bundler-webpack/compiled/webpack/${name}`);
+    hookPropertyMap.set(`${item}.js`, `@umijs/bundler-webpack/compiled/webpack/${name}`);
+});
+const mod = require('module');
+const resolveFilename = mod._resolveFilename;
+mod._resolveFilename = function (request, parent, isMain, options) {
+    const hookResolved = hookPropertyMap.get(request);
+    if (hookResolved)
+        request = hookResolved;
+    return resolveFilename.call(mod, request, parent, isMain, options);
+};

package/dist/schema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="hapi__joi" />
+import type { Root } from '@hapi/joi';
+export declare function getSchemas(): Record<string, (Joi: Root) => any>;

package/dist/schema.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemas = void 0;
+const types_1 = require("./types");
+const options = [
+    'cheap-source-map',
+    'cheap-eval-source-map',
+    'cheap-hidden-source-map',
+    'cheap-inline-source-map',
+    'cheap-module-source-map',
+    'cheap-module-eval-source-map',
+    'cheap-module-hidden-source-map',
+    'cheap-module-inline-source-map',
+    'eval',
+    'eval-source-map',
+    'source-map',
+    'hidden-source-map',
+    'inline-source-map',
+];
+const DEVTOOL_REGEX = new RegExp('^' + // start of string
+    '(#@|@|#)?' + // maybe one of the pragmas
+    `(${options.join('$|')})`);
+function getSchemas() {
+    return {
+        alias: (Joi) => Joi.object(),
+        autoCSSModules: (Joi) => Joi.boolean(),
+        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.none),
+        cssMinifierOptions: (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()),
+        externals: (Joi) => Joi.alternatives().try(Joi.object().pattern(/.+/, [
+            Joi.string(),
+            Joi.boolean(),
+            Joi.object().pattern(/.+/, [Joi.string(), Joi.boolean()]),
+        ]), Joi.string(), Joi.func().arity(3), Joi.object().regex()),
+        extraBabelPlugins: (Joi) => Joi.alternatives().try(Joi.string(), Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.object()))),
+        extraBabelPresets: (Joi) => Joi.alternatives().try(Joi.string(), Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.object()))),
+        extraPostCSSPlugins: (Joi) => Joi.array(),
+        fastRefresh: (Joi) => Joi.boolean(),
+        hash: (Joi) => Joi.boolean(),
+        ignoreMomentLocale: (Joi) => Joi.boolean(),
+        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(),
+        mfsu: (Joi) => Joi.alternatives(Joi.object({
+            esbuild: Joi.boolean(),
+        }), Joi.boolean()),
+        outputPath: (Joi) => Joi.string(),
+        postcssLoader: (Joi) => Joi.object(),
+        proxy: (Joi) => Joi.object(),
+        publicPath: (Joi) => Joi.string(),
+        purgeCSS: (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(),
+        svgr: (Joi) => Joi.object(),
+        svgo: (Joi) => Joi.alternatives().try(Joi.object(), Joi.boolean()),
+        targets: (Joi) => Joi.object(),
+        writeToDisk: (Joi) => Joi.boolean(),
+        esm: (Joi) => Joi.object(),
+        theme: (Joi) => Joi.object(),
+    };
+}
+exports.getSchemas = getSchemas;