umi 4.0.0-canary.20220429.3 → 4.0.0-canary.20220506.2

package/dist/cli/cli.d.ts

@@ -0,0 +1,5 @@
+interface IOpts {
+    presets?: string[];
+}
+export declare function run(opts?: IOpts): Promise<void>;
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+const service_1 = require("../service/service");
+const dev_1 = require("./dev");
+const node_1 = require("./node");
+async function run(opts) {
+    (0, node_1.checkVersion)();
+    (0, node_1.checkLocal)();
+    (0, node_1.setNodeTitle)();
+    (0, node_1.setNoDeprecation)();
+    const args = (0, utils_1.yParser)(process.argv.slice(2), {
+        alias: {
+            version: ['v'],
+            help: ['h'],
+        },
+        boolean: ['version'],
+    });
+    const command = args._[0];
+    if ([constants_1.DEV_COMMAND, 'setup'].includes(command)) {
+        process.env.NODE_ENV = 'development';
+    }
+    else if (command === 'build') {
+        process.env.NODE_ENV = 'production';
+    }
+    if (opts === null || opts === void 0 ? void 0 : opts.presets) {
+        process.env.UMI_PRESETS = opts.presets.join(',');
+    }
+    if (command === constants_1.DEV_COMMAND) {
+        (0, dev_1.dev)();
+    }
+    else {
+        try {
+            await new service_1.Service().run2({
+                name: args._[0],
+                args,
+            });
+        }
+        catch (e) {
+            utils_1.logger.error(e);
+            process.exit(1);
+        }
+    }
+}
+exports.run = run;

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): void;

package/dist/cli/dev.js

@@ -0,0 +1,26 @@
+"use strict";
+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 fork_1 = __importDefault(require("./fork"));
+function dev() {
+    const child = (0, fork_1.default)({
+        scriptPath: require.resolve('../../bin/forkedDev'),
+    });
+    // ref:
+    // http://nodejs.cn/api/process/signal_events.html
+    // https://lisk.io/blog/development/why-we-stopped-using-npm-start-child-processes
+    process.on('SIGINT', () => {
+        child.kill('SIGINT');
+        // ref:
+        // https://github.com/umijs/umi/issues/6009
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        child.kill('SIGTERM');
+        process.exit(1);
+    });
+}
+exports.dev = dev;

package/dist/cli/fork.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+interface IOpts {
+    scriptPath: string;
+}
+export default function start({ scriptPath }: IOpts): import("child_process").ChildProcess;
+export {};

package/dist/cli/fork.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const usedPorts = [];
+function start({ scriptPath }) {
+    const execArgv = process.execArgv.slice(0);
+    const inspectArgvIndex = execArgv.findIndex((argv) => argv.includes('--inspect-brk'));
+    if (inspectArgvIndex > -1) {
+        const inspectArgv = execArgv[inspectArgvIndex];
+        execArgv.splice(inspectArgvIndex, 1, inspectArgv.replace(/--inspect-brk=(.*)/, (_match, s1) => {
+            let port;
+            try {
+                port = parseInt(s1) + 1;
+            }
+            catch (e) {
+                port = 9230; // node default inspect port plus 1.
+            }
+            if (usedPorts.includes(port)) {
+                port += 1;
+            }
+            usedPorts.push(port);
+            return `--inspect-brk=${port}`;
+        }));
+    }
+    const child = (0, child_process_1.fork)(scriptPath, process.argv.slice(2), { execArgv });
+    child.on('message', (data) => {
+        var _a;
+        const { type, payload } = data || {};
+        if (type === 'RESTART') {
+            child.kill();
+            if (payload === null || payload === void 0 ? void 0 : payload.port) {
+                process.env.PORT = payload.port;
+            }
+            start({ scriptPath });
+        }
+        (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, data);
+    });
+    return child;
+}
+exports.default = start;

package/dist/cli/forkedDev.d.ts

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

package/dist/cli/forkedDev.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+const service_1 = require("../service/service");
+const node_1 = require("./node");
+(0, node_1.setNodeTitle)(`${constants_1.FRAMEWORK_NAME}-dev`);
+(0, node_1.setNoDeprecation)();
+(async () => {
+    try {
+        const args = (0, utils_1.yParser)(process.argv.slice(2));
+        const service = new service_1.Service();
+        await service.run2({
+            name: constants_1.DEV_COMMAND,
+            args,
+        });
+        let closed = false;
+        // kill(2) Ctrl-C
+        process.once('SIGINT', () => onSignal('SIGINT'));
+        // kill(3) Ctrl-\
+        process.once('SIGQUIT', () => onSignal('SIGQUIT'));
+        // kill(15) default
+        process.once('SIGTERM', () => onSignal('SIGTERM'));
+        function onSignal(signal) {
+            if (closed)
+                return;
+            closed = true;
+            // 退出时触发插件中的 onExit 事件
+            service.applyPlugins({
+                key: 'onExit',
+                args: {
+                    signal,
+                },
+            });
+            process.exit(0);
+        }
+    }
+    catch (e) {
+        utils_1.logger.error(e);
+        process.exit(1);
+    }
+})();

package/dist/cli/node.d.ts

@@ -0,0 +1,4 @@
+export declare function checkVersion(): void;
+export declare function checkLocal(): void;
+export declare function setNodeTitle(name?: string): void;
+export declare function setNoDeprecation(): void;

package/dist/cli/node.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNoDeprecation = exports.setNodeTitle = exports.checkLocal = exports.checkVersion = void 0;
+const utils_1 = require("@umijs/utils");
+const constants_1 = require("../constants");
+function checkVersion() {
+    const v = parseInt(process.version.slice(1));
+    if (v < constants_1.MIN_NODE_VERSION || v === 15 || v === 17) {
+        utils_1.logger.error(`Your node version ${v} is not supported, please upgrade to ${constants_1.MIN_NODE_VERSION} or above except 15 or 17.`);
+        process.exit(1);
+    }
+}
+exports.checkVersion = checkVersion;
+function checkLocal() {
+    if (__filename.includes(`packages/${constants_1.FRAMEWORK_NAME}`)) {
+        utils_1.logger.info('@local');
+    }
+}
+exports.checkLocal = checkLocal;
+function setNodeTitle(name) {
+    if (process.title === 'node') {
+        process.title = name || constants_1.FRAMEWORK_NAME;
+    }
+}
+exports.setNodeTitle = setNodeTitle;
+function setNoDeprecation() {
+    // Use magic to suppress node deprecation warnings
+    // See: https://github.com/nodejs/node/blob/master/lib/internal/process/warning.js#L77
+    // @ts-ignore
+    process.noDeprecation = '1';
+}
+exports.setNoDeprecation = setNoDeprecation;

package/dist/client/plugin.d.ts

@@ -0,0 +1,34 @@
+export declare enum ApplyPluginsType {
+    compose = "compose",
+    modify = "modify",
+    event = "event"
+}
+interface IPlugin {
+    path?: string;
+    apply: Record<string, any>;
+}
+export declare class PluginManager {
+    opts: {
+        validKeys: string[];
+    };
+    hooks: {
+        [key: string]: any;
+    };
+    constructor(opts: {
+        validKeys: string[];
+    });
+    register(plugin: IPlugin): void;
+    getHooks(keyWithDot: string): any;
+    applyPlugins({ key, type, initialValue, args, async, }: {
+        key: string;
+        type: ApplyPluginsType;
+        initialValue?: any;
+        args?: object;
+        async?: boolean;
+    }): any;
+    static create(opts: {
+        validKeys: string[];
+        plugins: IPlugin[];
+    }): PluginManager;
+}
+export {};

package/dist/client/plugin.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = exports.ApplyPluginsType = void 0;
+const utils_1 = require("./utils");
+var ApplyPluginsType;
+(function (ApplyPluginsType) {
+    ApplyPluginsType["compose"] = "compose";
+    ApplyPluginsType["modify"] = "modify";
+    ApplyPluginsType["event"] = "event";
+})(ApplyPluginsType = exports.ApplyPluginsType || (exports.ApplyPluginsType = {}));
+class PluginManager {
+    constructor(opts) {
+        this.hooks = {};
+        this.opts = opts;
+    }
+    register(plugin) {
+        (0, utils_1.assert)(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
+        Object.keys(plugin.apply).forEach((key) => {
+            (0, utils_1.assert)(this.opts.validKeys.indexOf(key) > -1, `register failed, invalid key ${key} from plugin ${plugin.path}.`);
+            this.hooks[key] = (this.hooks[key] || []).concat(plugin.apply[key]);
+        });
+    }
+    getHooks(keyWithDot) {
+        const [key, ...memberKeys] = keyWithDot.split('.');
+        let hooks = this.hooks[key] || [];
+        if (memberKeys.length) {
+            hooks = hooks
+                .map((hook) => {
+                try {
+                    let ret = hook;
+                    for (const memberKey of memberKeys) {
+                        ret = ret[memberKey];
+                    }
+                    return ret;
+                }
+                catch (e) {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+        }
+        return hooks;
+    }
+    applyPlugins({ key, type, initialValue, args, async, }) {
+        const hooks = this.getHooks(key) || [];
+        if (args) {
+            (0, utils_1.assert)(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
+        }
+        if (async) {
+            (0, utils_1.assert)(type === ApplyPluginsType.modify || type === ApplyPluginsType.event, `async only works with modify and event type.`);
+        }
+        switch (type) {
+            case ApplyPluginsType.modify:
+                if (async) {
+                    return hooks.reduce(async (memo, hook) => {
+                        (0, utils_1.assert)(typeof hook === 'function' ||
+                            typeof hook === 'object' ||
+                            (0, utils_1.isPromiseLike)(hook), `applyPlugins failed, all hooks for key ${key} must be function, plain object or Promise.`);
+                        if ((0, utils_1.isPromiseLike)(memo)) {
+                            memo = await memo;
+                        }
+                        if (typeof hook === 'function') {
+                            const ret = hook(memo, args);
+                            if ((0, utils_1.isPromiseLike)(ret)) {
+                                return await ret;
+                            }
+                            else {
+                                return ret;
+                            }
+                        }
+                        else {
+                            if ((0, utils_1.isPromiseLike)(hook)) {
+                                hook = await hook;
+                            }
+                            return { ...memo, ...hook };
+                        }
+                    }, (0, utils_1.isPromiseLike)(initialValue)
+                        ? initialValue
+                        : Promise.resolve(initialValue));
+                }
+                else {
+                    return hooks.reduce((memo, hook) => {
+                        (0, utils_1.assert)(typeof hook === 'function' || typeof hook === 'object', `applyPlugins failed, all hooks for key ${key} must be function or plain object.`);
+                        if (typeof hook === 'function') {
+                            return hook(memo, args);
+                        }
+                        else {
+                            // TODO: deepmerge?
+                            return { ...memo, ...hook };
+                        }
+                    }, initialValue);
+                }
+            case ApplyPluginsType.event:
+                return (async () => {
+                    for (const hook of hooks) {
+                        (0, utils_1.assert)(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
+                        const ret = hook(args);
+                        if (async && (0, utils_1.isPromiseLike)(ret)) {
+                            await ret;
+                        }
+                    }
+                })();
+            case ApplyPluginsType.compose:
+                return () => {
+                    return (0, utils_1.compose)({
+                        fns: hooks.concat(initialValue),
+                        args,
+                    })();
+                };
+        }
+    }
+    static create(opts) {
+        const pluginManager = new PluginManager({
+            validKeys: opts.validKeys,
+        });
+        opts.plugins.forEach((plugin) => {
+            pluginManager.register(plugin);
+        });
+        return pluginManager;
+    }
+}
+exports.PluginManager = PluginManager;
+// plugins meta info (in tmp file)
+// hooks api: usePlugin

package/dist/client/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function assert(value: unknown, message: string): void;
+export declare function compose({ fns, args, }: {
+    fns: (Function | any)[];
+    args?: object;
+}): any;
+export declare function isPromiseLike(obj: any): boolean;

package/dist/client/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromiseLike = exports.compose = exports.assert = void 0;
+function assert(value, message) {
+    if (!value)
+        throw new Error(message);
+}
+exports.assert = assert;
+function compose({ fns, args, }) {
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    const last = fns.pop();
+    return fns.reduce((a, b) => () => b(a, args), last);
+}
+exports.compose = compose;
+function isPromiseLike(obj) {
+    return !!obj && typeof obj === 'object' && typeof obj.then === 'function';
+}
+exports.isPromiseLike = isPromiseLike;

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const MIN_NODE_VERSION = 14;
+export declare const DEV_COMMAND = "dev";
+export declare const DEFAULT_CONFIG_FILES: string[];
+export declare const FRAMEWORK_NAME = "umi";

package/dist/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAMEWORK_NAME = exports.DEFAULT_CONFIG_FILES = exports.DEV_COMMAND = exports.MIN_NODE_VERSION = void 0;
+exports.MIN_NODE_VERSION = 14;
+exports.DEV_COMMAND = 'dev';
+exports.DEFAULT_CONFIG_FILES = [
+    '.umirc.ts',
+    '.umirc.js',
+    'config/config.ts',
+    'config/config.js',
+];
+exports.FRAMEWORK_NAME = 'umi';

package/dist/defineConfig.d.ts

@@ -0,0 +1,5 @@
+import { IConfigFromPlugins } from '@@/core/pluginConfig';
+import type { IConfig } from '@umijs/preset-umi';
+declare type ConfigType = IConfigFromPlugins & IConfig;
+export declare function defineConfig(config: ConfigType): ConfigType;
+export {};

package/dist/defineConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+function defineConfig(config) {
+    return config;
+}
+exports.defineConfig = defineConfig;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { IServicePluginAPI, PluginAPI } from '@umijs/core';
+export { run } from './cli/cli';
+export { defineConfig } from './defineConfig';
+export * from './service/service';
+export declare type IApi = PluginAPI & IServicePluginAPI;

package/dist/index.js

@@ -0,0 +1,22 @@
+"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 });
+exports.defineConfig = exports.run = void 0;
+var cli_1 = require("./cli/cli");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return cli_1.run; } });
+var defineConfig_1 = require("./defineConfig");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return defineConfig_1.defineConfig; } });
+__exportStar(require("./service/service"), exports);

package/dist/pluginUtils.d.ts

@@ -0,0 +1,5 @@
+import express from '@umijs/bundler-utils/compiled/express';
+import * as httpProxyMiddleware from '@umijs/bundler-webpack/compiled/http-proxy-middleware';
+export { createServerRoutes } from '@umijs/server';
+export * from '@umijs/utils';
+export { httpProxyMiddleware, express };

package/dist/pluginUtils.js

@@ -0,0 +1,39 @@
+"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;
+};
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.express = exports.httpProxyMiddleware = exports.createServerRoutes = void 0;
+const express_1 = __importDefault(require("@umijs/bundler-utils/compiled/express"));
+exports.express = express_1.default;
+const httpProxyMiddleware = __importStar(require("@umijs/bundler-webpack/compiled/http-proxy-middleware"));
+exports.httpProxyMiddleware = httpProxyMiddleware;
+var server_1 = require("@umijs/server");
+Object.defineProperty(exports, "createServerRoutes", { enumerable: true, get: function () { return server_1.createServerRoutes; } });
+__exportStar(require("@umijs/utils"), exports);

package/dist/service/cwd.d.ts

@@ -0,0 +1 @@
+export declare function getCwd(): string;

package/dist/service/cwd.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCwd = void 0;
+const path_1 = require("path");
+function getCwd() {
+    const cwd = process.cwd();
+    const appRoot = process.env.APP_ROOT;
+    if (appRoot) {
+        return (0, path_1.isAbsolute)(appRoot) ? appRoot : (0, path_1.join)(cwd, appRoot);
+    }
+    return cwd;
+}
+exports.getCwd = getCwd;

package/dist/service/service.d.ts

@@ -0,0 +1,8 @@
+import { Service as CoreService } from '@umijs/core';
+export declare class Service extends CoreService {
+    constructor(opts?: any);
+    run2(opts: {
+        name: string;
+        args?: any;
+    }): Promise<void>;
+}

package/dist/service/service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const core_1 = require("@umijs/core");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const cwd_1 = require("./cwd");
+class Service extends core_1.Service {
+    constructor(opts) {
+        process.env.UMI_DIR = (0, path_1.dirname)(require.resolve('../../package'));
+        const cwd = (0, cwd_1.getCwd)();
+        super({
+            ...opts,
+            env: process.env.NODE_ENV,
+            cwd,
+            defaultConfigFiles: constants_1.DEFAULT_CONFIG_FILES,
+            frameworkName: constants_1.FRAMEWORK_NAME,
+            presets: [require.resolve('@umijs/preset-umi'), ...((opts === null || opts === void 0 ? void 0 : opts.presets) || [])],
+            plugins: [
+                (0, fs_1.existsSync)((0, path_1.join)(cwd, 'plugin.ts')) && (0, path_1.join)(cwd, 'plugin.ts'),
+                (0, fs_1.existsSync)((0, path_1.join)(cwd, 'plugin.js')) && (0, path_1.join)(cwd, 'plugin.js'),
+            ].filter(Boolean),
+        });
+    }
+    async run2(opts) {
+        let name = opts.name;
+        if ((opts === null || opts === void 0 ? void 0 : opts.args.version) || name === 'v') {
+            name = 'version';
+        }
+        else if ((opts === null || opts === void 0 ? void 0 : opts.args.help) || !name || name === 'h') {
+            name = 'help';
+        }
+        // TODO
+        // initWebpack
+        return await this.run({ ...opts, name });
+    }
+}
+exports.Service = Service;

package/dist/test.d.ts

@@ -0,0 +1,117 @@
+import { Config } from '@umijs/test';
+export * from '@umijs/test';
+export declare function configUmiAlias(config: Config.InitialOptions): Promise<Partial<{
+    automock: boolean;
+    bail: number | boolean;
+    cache: boolean;
+    cacheDirectory: string;
+    ci: boolean;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: string[];
+    collectCoverageOnlyFrom: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: string[];
+    coverageProvider: "babel" | "v8";
+    coverageReporters: Config.CoverageReporters;
+    coverageThreshold: {
+        [path: string]: Config.CoverageThresholdValue;
+        global: Config.CoverageThresholdValue;
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | Config.DisplayName;
+    expand: boolean;
+    extensionsToTreatAsEsm: string[];
+    extraGlobals: string[];
+    filter: string;
+    findRelatedTests: boolean;
+    forceCoverageMatch: string[];
+    forceExit: boolean;
+    json: boolean;
+    globals: Config.ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: Config.HasteConfig;
+    injectGlobals: boolean;
+    reporters: (string | Config.ReporterConfig)[];
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: string | number;
+    moduleDirectories: string[];
+    moduleFileExtensions: string[];
+    moduleLoader: string;
+    moduleNameMapper: {
+        [key: string]: string | string[];
+    };
+    modulePathIgnorePatterns: string[];
+    modulePaths: string[];
+    name: string;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    outputFile: string;
+    passWithNoTests: boolean;
+    preprocessorIgnorePatterns: string[];
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: (string | Config.InitialProjectOptions)[];
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: string[];
+    runner: string;
+    runTestsByPath: boolean;
+    scriptPreprocessor: string;
+    setupFiles: string[];
+    setupTestFrameworkScriptFile: string;
+    setupFilesAfterEnv: string[];
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: string;
+    snapshotSerializers: string[];
+    snapshotFormat: Config.PrettyFormatOptions;
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: string[];
+    testNamePattern: string;
+    testPathDirs: string[];
+    testPathIgnorePatterns: string[];
+    testRegex: string | string[];
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number;
+    timers: "real" | "fake" | "modern" | "legacy";
+    transform: {
+        [regex: string]: string | Config.TransformerConfig;
+    };
+    transformIgnorePatterns: string[];
+    watchPathIgnorePatterns: string[];
+    unmockedModulePathPatterns: string[];
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean | undefined;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: (string | [string, Record<string, unknown>])[];
+}>>;

package/dist/test.js

@@ -0,0 +1,51 @@
+"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 });
+exports.configUmiAlias = void 0;
+const fs_1 = require("fs");
+const service_1 = require("./service/service");
+__exportStar(require("@umijs/test"), exports);
+function getAliasPathWithKey(alias, key) {
+    const thePath = alias[key];
+    if (alias[thePath]) {
+        return getAliasPathWithKey(alias, thePath);
+    }
+    return thePath;
+}
+let service;
+async function configUmiAlias(config) {
+    if (!service) {
+        service = new service_1.Service();
+        await service.run2({
+            name: 'setup',
+            args: { quiet: true },
+        });
+    }
+    config.moduleNameMapper || (config.moduleNameMapper = {});
+    const { alias } = service.config;
+    for (const key of Object.keys(alias)) {
+        const aliasPath = getAliasPathWithKey(alias, key);
+        if ((0, fs_1.existsSync)(aliasPath) && (0, fs_1.statSync)(aliasPath).isDirectory()) {
+            config.moduleNameMapper[`^${key}/(.*)$`] = `${aliasPath}/$1`;
+            config.moduleNameMapper[`^${key}$`] = aliasPath;
+        }
+        else {
+            config.moduleNameMapper[`^${key}$`] = aliasPath;
+        }
+    }
+    return config;
+}
+exports.configUmiAlias = configUmiAlias;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umi",
-  "version": "4.0.0-canary.20220429.3",
+  "version": "4.0.0-canary.20220506.2",
   "description": "umi",
   "homepage": "https://github.com/umijs/umi-next/tree/master/packages/umi#readme",
   "bugs": "https://github.com/umijs/umi-next/issues",
@@ -37,15 +37,15 @@
     "test": "umi-scripts jest-turbo"
   },
   "dependencies": {
-    "@umijs/bundler-utils": "4.0.0-canary.20220429.3",
-    "@umijs/bundler-webpack": "4.0.0-canary.20220429.3",
-    "@umijs/core": "4.0.0-canary.20220429.3",
-    "@umijs/lint": "4.0.0-canary.20220429.3",
-    "@umijs/preset-umi": "4.0.0-canary.20220429.3",
-    "@umijs/renderer-react": "4.0.0-canary.20220429.3",
-    "@umijs/server": "4.0.0-canary.20220429.3",
-    "@umijs/test": "4.0.0-canary.20220429.3",
-    "@umijs/utils": "4.0.0-canary.20220429.3",
+    "@umijs/bundler-utils": "4.0.0-canary.20220506.2",
+    "@umijs/bundler-webpack": "4.0.0-canary.20220506.2",
+    "@umijs/core": "4.0.0-canary.20220506.2",
+    "@umijs/lint": "4.0.0-canary.20220506.2",
+    "@umijs/preset-umi": "4.0.0-canary.20220506.2",
+    "@umijs/renderer-react": "4.0.0-canary.20220506.2",
+    "@umijs/server": "4.0.0-canary.20220506.2",
+    "@umijs/test": "4.0.0-canary.20220506.2",
+    "@umijs/utils": "4.0.0-canary.20220506.2",
     "prettier-plugin-organize-imports": "^2.3.4",
     "prettier-plugin-packagejson": "^2.2.17"
   },