umi 4.0.0-rc.2 → 4.0.0-rc.22

package/client/client/plugin.js

@@ -1,3 +1,14 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -7,6 +18,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { assert, compose, isPromiseLike } from './utils';
 export var ApplyPluginsType;
 (function (ApplyPluginsType) {
@@ -14,27 +52,29 @@ export var ApplyPluginsType;
     ApplyPluginsType["modify"] = "modify";
     ApplyPluginsType["event"] = "event";
 })(ApplyPluginsType || (ApplyPluginsType = {}));
-export class PluginManager {
-    constructor(opts) {
+var PluginManager = /** @class */ (function () {
+    function PluginManager(opts) {
         this.hooks = {};
         this.opts = opts;
     }
-    register(plugin) {
-        assert(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
-        Object.keys(plugin.apply).forEach((key) => {
-            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]);
+    PluginManager.prototype.register = function (plugin) {
+        var _this = this;
+        assert(plugin.apply, "plugin register failed, apply must supplied");
+        Object.keys(plugin.apply).forEach(function (key) {
+            assert(_this.opts.validKeys.indexOf(key) > -1, "register failed, invalid key ".concat(key, " ").concat(plugin.path ? "from plugin ".concat(plugin.path) : '', "."));
+            _this.hooks[key] = (_this.hooks[key] || []).concat(plugin.apply[key]);
         });
-    }
-    getHooks(keyWithDot) {
-        const [key, ...memberKeys] = keyWithDot.split('.');
-        let hooks = this.hooks[key] || [];
+    };
+    PluginManager.prototype.getHooks = function (keyWithDot) {
+        var _a = keyWithDot.split('.'), key = _a[0], memberKeys = _a.slice(1);
+        var hooks = this.hooks[key] || [];
         if (memberKeys.length) {
             hooks = hooks
-                .map((hook) => {
+                .map(function (hook) {
                 try {
-                    let ret = hook;
-                    for (const memberKey of memberKeys) {
+                    var ret = hook;
+                    for (var _i = 0, memberKeys_1 = memberKeys; _i < memberKeys_1.length; _i++) {
+                        var memberKey = memberKeys_1[_i];
                         ret = ret[memberKey];
                     }
                     return ret;
@@ -46,76 +86,112 @@ export class PluginManager {
                 .filter(Boolean);
         }
         return hooks;
-    }
-    applyPlugins({ key, type, initialValue, args, async, }) {
-        const hooks = this.getHooks(key) || [];
+    };
+    PluginManager.prototype.applyPlugins = function (_a) {
+        var _this = this;
+        var key = _a.key, type = _a.type, initialValue = _a.initialValue, args = _a.args, async = _a.async;
+        var hooks = this.getHooks(key) || [];
         if (args) {
-            assert(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
+            assert(typeof args === 'object', "applyPlugins failed, args must be plain object.");
+        }
+        if (async) {
+            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((memo, hook) => __awaiter(this, void 0, void 0, function* () {
-                        assert(typeof hook === 'function' ||
-                            typeof hook === 'object' ||
-                            isPromiseLike(hook), `applyPlugins failed, all hooks for key ${key} must be function, plain object or Promise.`);
-                        if (isPromiseLike(memo)) {
-                            memo = yield memo;
-                        }
-                        if (typeof hook === 'function') {
-                            const ret = hook(memo, args);
-                            if (isPromiseLike(ret)) {
-                                return yield ret;
+                    return hooks.reduce(function (memo, hook) { return __awaiter(_this, void 0, void 0, function () {
+                        var ret;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    assert(typeof hook === 'function' ||
+                                        typeof hook === 'object' ||
+                                        isPromiseLike(hook), "applyPlugins failed, all hooks for key ".concat(key, " must be function, plain object or Promise."));
+                                    if (!isPromiseLike(memo)) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, memo];
+                                case 1:
+                                    memo = _a.sent();
+                                    _a.label = 2;
+                                case 2:
+                                    if (!(typeof hook === 'function')) return [3 /*break*/, 6];
+                                    ret = hook(memo, args);
+                                    if (!isPromiseLike(ret)) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, ret];
+                                case 3: return [2 /*return*/, _a.sent()];
+                                case 4: return [2 /*return*/, ret];
+                                case 5: return [3 /*break*/, 9];
+                                case 6:
+                                    if (!isPromiseLike(hook)) return [3 /*break*/, 8];
+                                    return [4 /*yield*/, hook];
+                                case 7:
+                                    hook = _a.sent();
+                                    _a.label = 8;
+                                case 8: return [2 /*return*/, __assign(__assign({}, memo), hook)];
+                                case 9: return [2 /*return*/];
                             }
-                            else {
-                                return ret;
-                            }
-                        }
-                        else {
-                            if (isPromiseLike(hook)) {
-                                hook = yield hook;
-                            }
-                            return Object.assign(Object.assign({}, memo), hook);
-                        }
-                    }), isPromiseLike(initialValue)
+                        });
+                    }); }, isPromiseLike(initialValue)
                         ? initialValue
                         : Promise.resolve(initialValue));
                 }
                 else {
-                    return hooks.reduce((memo, hook) => {
-                        assert(typeof hook === 'function' || typeof hook === 'object', `applyPlugins failed, all hooks for key ${key} must be function or plain object.`);
+                    return hooks.reduce(function (memo, hook) {
+                        assert(typeof hook === 'function' || typeof hook === 'object', "applyPlugins failed, all hooks for key ".concat(key, " must be function or plain object."));
                         if (typeof hook === 'function') {
                             return hook(memo, args);
                         }
                         else {
                             // TODO: deepmerge?
-                            return Object.assign(Object.assign({}, memo), hook);
+                            return __assign(__assign({}, memo), hook);
                         }
                     }, initialValue);
                 }
             case ApplyPluginsType.event:
-                return hooks.forEach((hook) => {
-                    assert(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
-                    hook(args);
-                });
+                return (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var _i, hooks_1, hook, ret;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _i = 0, hooks_1 = hooks;
+                                _a.label = 1;
+                            case 1:
+                                if (!(_i < hooks_1.length)) return [3 /*break*/, 4];
+                                hook = hooks_1[_i];
+                                assert(typeof hook === 'function', "applyPlugins failed, all hooks for key ".concat(key, " must be function."));
+                                ret = hook(args);
+                                if (!(async && isPromiseLike(ret))) return [3 /*break*/, 3];
+                                return [4 /*yield*/, ret];
+                            case 2:
+                                _a.sent();
+                                _a.label = 3;
+                            case 3:
+                                _i++;
+                                return [3 /*break*/, 1];
+                            case 4: return [2 /*return*/];
+                        }
+                    });
+                }); })();
             case ApplyPluginsType.compose:
-                return () => {
+                return function () {
                     return compose({
                         fns: hooks.concat(initialValue),
-                        args,
+                        args: args,
                     })();
                 };
         }
-    }
-    static create(opts) {
-        const pluginManager = new PluginManager({
+    };
+    PluginManager.create = function (opts) {
+        var pluginManager = new PluginManager({
             validKeys: opts.validKeys,
         });
-        opts.plugins.forEach((plugin) => {
+        opts.plugins.forEach(function (plugin) {
             pluginManager.register(plugin);
         });
         return pluginManager;
-    }
-}
+    };
+    return PluginManager;
+}());
+export { PluginManager };
 // plugins meta info (in tmp file)
 // hooks api: usePlugin

package/client/client/utils.js

@@ -2,12 +2,13 @@ export function assert(value, message) {
     if (!value)
         throw new Error(message);
 }
-export function compose({ fns, args, }) {
+export function compose(_a) {
+    var fns = _a.fns, args = _a.args;
     if (fns.length === 1) {
         return fns[0];
     }
-    const last = fns.pop();
-    return fns.reduce((a, b) => () => b(a, args), last);
+    var last = fns.pop();
+    return fns.reduce(function (a, b) { return function () { return b(a, args); }; }, last);
 }
 export function isPromiseLike(obj) {
     return !!obj && typeof obj === 'object' && typeof obj.then === 'function';

package/dist/cli/cli.js

@@ -1,13 +1,4 @@
 "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.run = void 0;
 const utils_1 = require("@umijs/utils");
@@ -15,44 +6,44 @@ const constants_1 = require("../constants");
 const service_1 = require("../service/service");
 const dev_1 = require("./dev");
 const node_1 = require("./node");
-function run(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        (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)();
+const printHelp_1 = require("./printHelp");
+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,
+            });
         }
-        else {
-            try {
-                yield new service_1.Service().run2({
-                    name: args._[0],
-                    args,
-                });
-            }
-            catch (e) {
-                utils_1.logger.error(e);
-                process.exit(1);
-            }
+        catch (e) {
+            utils_1.logger.fatal(e);
+            (0, printHelp_1.printHelp)();
+            process.exit(1);
         }
-    });
+    }
 }
 exports.run = run;

package/dist/cli/forkedDev.js

@@ -1,25 +1,17 @@
 "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 utils_1 = require("@umijs/utils");
 const constants_1 = require("../constants");
 const service_1 = require("../service/service");
 const node_1 = require("./node");
+const printHelp_1 = require("./printHelp");
 (0, node_1.setNodeTitle)(`${constants_1.FRAMEWORK_NAME}-dev`);
 (0, node_1.setNoDeprecation)();
-(() => __awaiter(void 0, void 0, void 0, function* () {
+(async () => {
     try {
         const args = (0, utils_1.yParser)(process.argv.slice(2));
         const service = new service_1.Service();
-        yield service.run2({
+        await service.run2({
             name: constants_1.DEV_COMMAND,
             args,
         });
@@ -45,7 +37,8 @@ const node_1 = require("./node");
         }
     }
     catch (e) {
-        utils_1.logger.error(e);
+        utils_1.logger.fatal(e);
+        (0, printHelp_1.printHelp)();
         process.exit(1);
     }
-}))();
+})();

package/dist/cli/node.js

@@ -5,8 +5,8 @@ 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 === constants_1.EXCLUDE_NODE_VERSION) {
-        utils_1.logger.error(`Your node version ${v} is not supported, please upgrade to ${constants_1.MIN_NODE_VERSION} or above except ${constants_1.EXCLUDE_NODE_VERSION}.`);
+    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);
     }
 }

package/dist/cli/printHelp.d.ts

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

package/dist/cli/printHelp.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = void 0;
+const utils_1 = require("@umijs/utils");
+function printHelp() {
+    utils_1.logger.fatal('A complete log of this run can be found in:');
+    utils_1.logger.fatal(utils_1.logger.getLatestLogFilePath());
+    utils_1.logger.fatal('Consider reporting a GitHub issue on https://github.com/umijs/umi-next/issues');
+}
+exports.printHelp = printHelp;

package/dist/client/plugin.js

@@ -1,13 +1,4 @@
 "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.PluginManager = exports.ApplyPluginsType = void 0;
 const utils_1 = require("./utils");
@@ -23,9 +14,9 @@ class PluginManager {
         this.opts = opts;
     }
     register(plugin) {
-        (0, utils_1.assert)(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
+        (0, utils_1.assert)(plugin.apply, `plugin register failed, apply 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}.`);
+            (0, utils_1.assert)(this.opts.validKeys.indexOf(key) > -1, `register failed, invalid key ${key} ${plugin.path ? `from plugin ${plugin.path}` : ''}.`);
             this.hooks[key] = (this.hooks[key] || []).concat(plugin.apply[key]);
         });
     }
@@ -55,20 +46,23 @@ class PluginManager {
         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((memo, hook) => __awaiter(this, void 0, void 0, function* () {
+                    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 = yield memo;
+                            memo = await memo;
                         }
                         if (typeof hook === 'function') {
                             const ret = hook(memo, args);
                             if ((0, utils_1.isPromiseLike)(ret)) {
-                                return yield ret;
+                                return await ret;
                             }
                             else {
                                 return ret;
@@ -76,11 +70,11 @@ class PluginManager {
                         }
                         else {
                             if ((0, utils_1.isPromiseLike)(hook)) {
-                                hook = yield hook;
+                                hook = await hook;
                             }
-                            return Object.assign(Object.assign({}, memo), hook);
+                            return { ...memo, ...hook };
                         }
-                    }), (0, utils_1.isPromiseLike)(initialValue)
+                    }, (0, utils_1.isPromiseLike)(initialValue)
                         ? initialValue
                         : Promise.resolve(initialValue));
                 }
@@ -92,15 +86,20 @@ class PluginManager {
                         }
                         else {
                             // TODO: deepmerge?
-                            return Object.assign(Object.assign({}, memo), hook);
+                            return { ...memo, ...hook };
                         }
                     }, initialValue);
                 }
             case ApplyPluginsType.event:
-                return hooks.forEach((hook) => {
-                    (0, utils_1.assert)(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
-                    hook(args);
-                });
+                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)({

package/dist/constants.d.ts

@@ -1,5 +1,4 @@
-export declare const MIN_NODE_VERSION = 16;
-export declare const EXCLUDE_NODE_VERSION = 15;
+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

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FRAMEWORK_NAME = exports.DEFAULT_CONFIG_FILES = exports.DEV_COMMAND = exports.EXCLUDE_NODE_VERSION = exports.MIN_NODE_VERSION = void 0;
-exports.MIN_NODE_VERSION = 16;
-exports.EXCLUDE_NODE_VERSION = 15;
+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',

package/dist/defineConfig.d.ts

@@ -1 +1,5 @@
-export declare function defineConfig(config: any): any;
+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/defineMock.d.ts

@@ -0,0 +1,8 @@
+import type { RequestHandler } from '@umijs/bundler-webpack/compiled/express';
+declare type MockDeclare = string | number | null | undefined | boolean | Record<string, any> | RequestHandler;
+export declare function defineMock(mockData: {
+    [key: string]: MockDeclare;
+}): {
+    [key: string]: MockDeclare;
+};
+export {};

package/dist/defineMock.js

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -10,7 +14,11 @@ 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 = void 0;
+exports.defineMock = 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; } });
+var defineMock_1 = require("./defineMock");
+Object.defineProperty(exports, "defineMock", { enumerable: true, get: function () { return defineMock_1.defineMock; } });
 __exportStar(require("./service/service"), exports);

package/dist/pluginUtils.d.ts

@@ -1 +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

@@ -1,13 +1,39 @@
 "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]; } });
+    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/service.js

@@ -1,13 +1,4 @@
 "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.Service = void 0;
 const core_1 = require("@umijs/core");
@@ -19,24 +10,30 @@ 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(Object.assign(Object.assign({}, 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: [
+        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) }));
-    }
-    run2(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 yield this.run(Object.assign(Object.assign({}, opts), { name }));
+            ].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/eslint.js

@@ -0,0 +1,7 @@
+try {
+  require.resolve('@umijs/lint/package.json');
+} catch (err) {
+  throw new Error('@umijs/lint is not built-in, please install it manually before run umi lint.');
+}
+
+module.exports = process.env.LEGACY_ESLINT ? require('@umijs/lint/dist/config/eslint/legacy') : require('@umijs/lint/dist/config/eslint');

package/index.d.ts

@@ -1,3 +1,10 @@
+// @ts-ignore
 export * from '@@/exports';
-export type { IApi } from '@umijs/preset-umi';
+export type {
+  IApi,
+  webpack,
+  IRoute,
+  UmiApiRequest,
+  UmiApiResponse,
+} from '@umijs/preset-umi';
 export * from './dist';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umi",
-  "version": "4.0.0-rc.2",
+  "version": "4.0.0-rc.22",
   "description": "umi",
   "homepage": "https://github.com/umijs/umi-next/tree/master/packages/umi#readme",
   "bugs": "https://github.com/umijs/umi-next/issues",
@@ -22,19 +22,36 @@
     "bin",
     "plugin.js",
     "plugin-utils.d.ts",
-    "plugin-utils.js"
+    "plugin-utils.js",
+    "prettier.js",
+    "test.d.ts",
+    "test.js",
+    "eslint.js",
+    "stylelint.js"
   ],
   "scripts": {
     "build": "pnpm tsc",
     "build:client": "pnpm tsc --project ./tsconfig.client.json",
-    "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
-    "dev": "pnpm build -- --watch"
+    "build:deps": "umi-scripts bundleDeps",
+    "dev": "pnpm build -- --watch",
+    "dev:client": "pnpm build:client -- --watch",
+    "test": "umi-scripts jest-turbo"
   },
   "dependencies": {
-    "@umijs/core": "4.0.0-rc.2",
-    "@umijs/preset-umi": "4.0.0-rc.2",
-    "@umijs/renderer-react": "4.0.0-rc.2",
-    "@umijs/utils": "4.0.0-rc.2"
+    "@umijs/bundler-utils": "4.0.0-rc.22",
+    "@umijs/bundler-webpack": "4.0.0-rc.22",
+    "@umijs/core": "4.0.0-rc.22",
+    "@umijs/lint": "4.0.0-rc.22",
+    "@umijs/preset-umi": "4.0.0-rc.22",
+    "@umijs/renderer-react": "4.0.0-rc.22",
+    "@umijs/server": "4.0.0-rc.22",
+    "@umijs/test": "4.0.0-rc.22",
+    "@umijs/utils": "4.0.0-rc.22",
+    "prettier-plugin-organize-imports": "^2.3.4",
+    "prettier-plugin-packagejson": "^2.2.17"
+  },
+  "engines": {
+    "node": ">=14"
   },
   "publishConfig": {
     "access": "public"

package/prettier.js

@@ -0,0 +1,12 @@
+module.exports = {
+  printWidth: 80,
+  singleQuote: true,
+  trailingComma: 'all',
+  proseWrap: 'never',
+  endOfLine: 'lf',
+  overrides: [{ files: '.prettierrc', options: { parser: 'json' } }],
+  plugins: [
+    require.resolve('prettier-plugin-packagejson'),
+    require.resolve('prettier-plugin-organize-imports'),
+  ],
+};

package/stylelint.js

@@ -0,0 +1,7 @@
+try {
+  require.resolve('@umijs/lint/package.json');
+} catch (err) {
+  throw new Error('@umijs/lint is not built-in, please install it manually before run umi lint.');
+}
+
+module.exports = require('@umijs/lint/dist/config/stylelint');

package/test.d.ts

@@ -0,0 +1 @@
+export * from './dist/test';

package/test.js

@@ -0,0 +1 @@
+module.exports = require('./dist/test');