@umijs/bundler-webpack 4.0.0-canary.20220429.2 → 4.0.0-canary.20220506.1

package/dist/dev.d.ts

@@ -0,0 +1,25 @@
+import { IOpts as IConfigOpts } from './config/config';
+import { IConfig } from './types';
+declare type IOpts = {
+    afterMiddlewares?: any[];
+    beforeMiddlewares?: any[];
+    onDevCompileDone?: Function;
+    onProgress?: Function;
+    onMFSUProgress?: Function;
+    port?: number;
+    host?: string;
+    babelPreset?: any;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    beforeBabelPlugins?: any[];
+    beforeBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    extraBabelPresets?: any[];
+    cwd: string;
+    rootDir?: string;
+    config: IConfig;
+    entry: Record<string, string>;
+} & Pick<IConfigOpts, 'cache'>;
+export declare function stripUndefined(obj: any): any;
+export declare function dev(opts: IOpts): Promise<void>;
+export {};

package/dist/dev.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = exports.stripUndefined = void 0;
+const mfsu_1 = require("@umijs/mfsu");
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+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 stripUndefined(obj) {
+    Object.keys(obj).forEach((key) => {
+        if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    });
+    return obj;
+}
+exports.stripUndefined = stripUndefined;
+async function dev(opts) {
+    var _a, _b, _c, _d, _e, _f;
+    var _g;
+    const enableMFSU = opts.config.mfsu !== false;
+    let mfsu = null;
+    if (enableMFSU) {
+        if (opts.config.srcTranspiler === types_1.Transpiler.swc) {
+            utils_1.logger.warn(`Swc currently not supported for use with mfsu, recommended you use srcTranspiler: 'esbuild' in dev.`);
+        }
+        mfsu = new mfsu_1.MFSU({
+            implementor: webpack_1.default,
+            buildDepWithESBuild: (_a = opts.config.mfsu) === null || _a === void 0 ? void 0 : _a.esbuild,
+            depBuildConfig: {
+                extraPostCSSPlugins: ((_b = opts.config) === null || _b === void 0 ? void 0 : _b.extraPostCSSPlugins) || [],
+            },
+            mfName: (_c = opts.config.mfsu) === null || _c === void 0 ? void 0 : _c.mfName,
+            runtimePublicPath: opts.config.runtimePublicPath,
+            tmpBase: ((_d = opts.config.mfsu) === null || _d === void 0 ? void 0 : _d.cacheDirectory) ||
+                (0, path_1.join)(opts.rootDir || opts.cwd, 'node_modules/.cache/mfsu'),
+            onMFSUProgress: opts.onMFSUProgress,
+            getCacheDependency() {
+                return stripUndefined({
+                    version: require('../package.json').version,
+                    mfsu: opts.config.mfsu,
+                    alias: opts.config.alias,
+                    externals: opts.config.externals,
+                    theme: opts.config.theme,
+                    runtimePublicPath: opts.config.runtimePublicPath,
+                    publicPath: opts.config.publicPath,
+                });
+            },
+        });
+    }
+    const webpackConfig = await (0, config_1.getConfig)({
+        cwd: opts.cwd,
+        rootDir: opts.rootDir,
+        env: types_1.Env.development,
+        entry: opts.entry,
+        userConfig: opts.config,
+        babelPreset: opts.babelPreset,
+        extraBabelPlugins: [
+            ...(opts.beforeBabelPlugins || []),
+            ...((mfsu === null || mfsu === void 0 ? void 0 : mfsu.getBabelPlugins()) || []),
+            ...(opts.extraBabelPlugins || []),
+        ],
+        extraBabelPresets: [
+            ...(opts.beforeBabelPresets || []),
+            ...(opts.extraBabelPresets || []),
+        ],
+        extraBabelIncludes: opts.config.extraBabelIncludes,
+        extraEsbuildLoaderHandler: (mfsu === null || mfsu === void 0 ? void 0 : mfsu.getEsbuildLoaderHandler()) || [],
+        chainWebpack: opts.chainWebpack,
+        modifyWebpackConfig: opts.modifyWebpackConfig,
+        hmr: true,
+        analyze: process.env.ANALYZE,
+        cache: opts.cache,
+    });
+    const depConfig = await (0, config_1.getConfig)({
+        cwd: opts.cwd,
+        rootDir: opts.rootDir,
+        env: types_1.Env.development,
+        entry: opts.entry,
+        userConfig: opts.config,
+        hash: true,
+        staticPathPrefix: mfsu_1.MF_DEP_PREFIX,
+        name: constants_1.MFSU_NAME,
+        chainWebpack: (_e = opts.config.mfsu) === null || _e === void 0 ? void 0 : _e.chainWebpack,
+        cache: {
+            buildDependencies: (_f = opts.cache) === null || _f === void 0 ? void 0 : _f.buildDependencies,
+            cacheDirectory: (0, path_1.join)(opts.rootDir || opts.cwd, 'node_modules', '.cache', 'mfsu-deps'),
+        },
+    });
+    (_g = webpackConfig.resolve).alias || (_g.alias = {});
+    // TODO: REMOVE ME
+    ['@umijs/utils/compiled/strip-ansi', 'react-error-overlay'].forEach((dep) => {
+        // @ts-ignore
+        webpackConfig.resolve.alias[dep] = require.resolve(dep);
+    });
+    await (mfsu === null || mfsu === void 0 ? void 0 : mfsu.setWebpackConfig({
+        config: webpackConfig,
+        depConfig: depConfig,
+    }));
+    if (mfsu &&
+        webpackConfig.cache &&
+        typeof webpackConfig.cache === 'object' &&
+        webpackConfig.cache.type === 'filesystem') {
+        const webpackCachePath = (0, path_1.join)(webpackConfig.cache.cacheDirectory, `default-development`, 'index.pack');
+        const mfsuCacheExists = (0, fs_1.existsSync)(mfsu.depInfo.cacheFilePath);
+        const webpackCacheExists = (0, fs_1.existsSync)(webpackCachePath);
+        if (webpackCacheExists && !mfsuCacheExists) {
+            utils_1.logger.warn(`Invalidate webpack cache since mfsu cache is missing`);
+            utils_1.rimraf.sync(webpackConfig.cache.cacheDirectory);
+        }
+    }
+    await (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,
+        onProgress: opts.onProgress,
+    });
+}
+exports.dev = dev;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type webpack from '../compiled/webpack';
+export type { RequestHandler } from '@umijs/bundler-utils/compiled/express';
+export type { Compiler, Stats } from '../compiled/webpack';
+export * from './build';
+export * from './config/config';
+export * from './dev';
+export * from './schema';
+export { webpack };

package/dist/index.js

@@ -0,0 +1,20 @@
+"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 __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,58 @@
+"use strict";
+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)(async (contents, options, state) => {
+    const jsCode = await (0, core_1.transform)(contents, options, state);
+    const result = await (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/loader/swc.d.ts

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

package/dist/loader/swc.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@swc/core");
+const types_1 = require("../types");
+function getBaseOpts({ filename }) {
+    const isTSFile = filename.endsWith('.ts');
+    const isTypeScript = isTSFile || filename.endsWith('.tsx');
+    const isDev = process.env.NODE_ENV === types_1.Env.development;
+    /**
+     * Not use swc auto polyfill , depend on `preset-umi/features/polyfill/polyfill` imported polyfill file
+     *
+     * @issue https://github.com/swc-project/swc/issues/2607
+     *        https://github.com/swc-project/swc/issues/1604
+     */
+    const swcOpts = {
+        module: {
+            // @ts-ignore
+            type: 'es6',
+            ignoreDynamic: true,
+        },
+        jsc: {
+            parser: {
+                syntax: isTypeScript ? 'typescript' : 'ecmascript',
+                [isTypeScript ? 'tsx' : 'jsx']: !isTSFile,
+                dynamicImport: isTypeScript,
+            },
+            target: 'es2015',
+            transform: {
+                react: {
+                    runtime: 'automatic',
+                    pragma: 'React.createElement',
+                    pragmaFrag: 'React.Fragment',
+                    throwIfNamespace: true,
+                    development: isDev,
+                    useBuiltins: true,
+                },
+            },
+        },
+    };
+    return swcOpts;
+}
+function swcLoader(contents) {
+    // 启用异步模式
+    const callback = this.async();
+    const loaderOpts = this.getOptions();
+    const { sync = false, parseMap = false, ...otherOpts } = loaderOpts;
+    const filename = this.resourcePath;
+    const swcOpts = {
+        ...getBaseOpts({
+            filename,
+        }),
+        filename,
+        sourceMaps: this.sourceMap,
+        sourceFileName: filename,
+        ...otherOpts,
+    };
+    try {
+        if (sync) {
+            const output = (0, core_1.transformSync)(contents, swcOpts);
+            callback(null, output.code, parseMap ? JSON.parse(output.map) : output.map);
+        }
+        else {
+            (0, core_1.transform)(contents, swcOpts).then((output) => {
+                callback(null, output.code, parseMap ? JSON.parse(output.map) : output.map);
+            }, (err) => {
+                callback(err);
+            });
+        }
+    }
+    catch (e) {
+        callback(e);
+    }
+}
+exports.default = swcLoader;

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,52 @@
+"use strict";
+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,
+            }, async () => {
+                await this.transformAssets(compilation);
+            });
+        });
+    }
+    async transformAssets(compilation) {
+        const { options: { devtool }, } = compilation.compiler;
+        const sourcemap = this.options.sourcemap === undefined ? !!devtool : this.options.sourcemap;
+        const assets = compilation.getAssets().filter((asset) => {
+            return !asset.info.minimized && RE_CSS_FILE.test(asset.name);
+        });
+        await Promise.all(assets.map(async (asset) => {
+            const { source, map } = asset.source.sourceAndMap();
+            const sourceAsString = source.toString();
+            const result = await (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), { ...asset.info, minimized: true });
+        }));
+    }
+}
+exports.default = ESBuildCSSMinifyPlugin;

package/dist/plugins/ParcelCSSMinifyPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { TransformOptions } from '@parcel/css';
+import type { Compiler } from '../../compiled/webpack/types';
+declare type MinifyPluginOpts = Omit<TransformOptions, 'filename' | 'code' | 'minify'>;
+export declare class ParcelCSSMinifyPlugin {
+    private readonly options;
+    constructor(opts?: MinifyPluginOpts);
+    apply(compiler: Compiler): void;
+    private transformAssets;
+}
+export {};

package/dist/plugins/ParcelCSSMinifyPlugin.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParcelCSSMinifyPlugin = void 0;
+const utils_1 = require("@umijs/utils");
+const buffer_1 = require("buffer");
+const path_1 = require("path");
+const webpack_sources_1 = require("../../compiled/webpack-sources");
+const pkgPath = (0, path_1.join)(__dirname, '../../package.json');
+const pkg = require(pkgPath);
+const PLUGIN_NAME = 'parcel-css-minify-plugin';
+const CSS_FILE_REG = /\.css(?:\?.*)?$/i;
+class ParcelCSSMinifyPlugin {
+    constructor(opts = {}) {
+        this.options = opts;
+    }
+    apply(compiler) {
+        const meta = JSON.stringify({
+            name: pkg.name,
+            version: pkg.version,
+            options: this.options,
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (_, hash) => hash.update(meta));
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                // @ts-ignore
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                additionalAssets: true,
+            }, async () => await this.transformAssets(compilation));
+            compilation.hooks.statsPrinter.tap(PLUGIN_NAME, (statsPrinter) => {
+                statsPrinter.hooks.print
+                    .for('asset.info.minimized')
+                    // @ts-ignore
+                    .tap(PLUGIN_NAME, (minimized, { green, formatFlag }) => {
+                    // @ts-ignore
+                    return minimized ? green(formatFlag('minimized')) : undefined;
+                });
+            });
+        });
+    }
+    async transformAssets(compilation) {
+        const { options: { devtool }, } = compilation.compiler;
+        const sourcemap = this.options.sourceMap === undefined
+            ? (devtool && devtool.includes('source-map'))
+            : this.options.sourceMap;
+        const assets = compilation.getAssets().filter((asset) => {
+            return !asset.info.minimized && CSS_FILE_REG.test(asset.name);
+        });
+        await Promise.all(assets.map(async (asset) => {
+            const { source, map } = asset.source.sourceAndMap();
+            const sourceAsString = source.toString();
+            const code = typeof source === 'string' ? buffer_1.Buffer.from(source) : source;
+            const { transform } = (0, utils_1.importLazy)('@parcel/css');
+            const result = await transform({
+                filename: asset.name,
+                code,
+                minify: true,
+                sourceMap: sourcemap,
+                ...this.options,
+            });
+            const codeString = result.code.toString();
+            compilation.updateAsset(asset.name, 
+            // @ts-ignore
+            sourcemap
+                ? new webpack_sources_1.SourceMapSource(codeString, asset.name, JSON.parse(result.map.toString()), sourceAsString, map, true)
+                : new webpack_sources_1.RawSource(codeString), {
+                ...asset.info,
+                minimized: true,
+            });
+        }));
+    }
+}
+exports.ParcelCSSMinifyPlugin = ParcelCSSMinifyPlugin;

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/RuntimePublicPathPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from '@umijs/bundler-webpack/compiled/webpack';
+export declare class RuntimePublicPathPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/plugins/RuntimePublicPathPlugin.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimePublicPathPlugin = void 0;
+const PLUGIN_NAME = 'RuntimePublicPath';
+// ref: https://gist.github.com/ScriptedAlchemy/60d0c49ce049184f6ce3e86ca351fdca
+class RuntimePublicPathPlugin {
+    apply(compiler) {
+        compiler.hooks.make.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (module) => {
+                // The hook to get the public path ('__webpack_require__.p')
+                // https://github.com/webpack/webpack/blob/master/lib/runtime/PublicPathRuntimeModule.js
+                if (module.constructor.name === 'PublicPathRuntimeModule') {
+                    // @ts-ignore
+                    module._cachedGeneratedCode = `__webpack_require__.p = (globalThis || window).publicPath;`;
+                }
+            });
+        });
+    }
+}
+exports.RuntimePublicPathPlugin = RuntimePublicPathPlugin;

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('/').pop();
+    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>;