@umijs/core 4.0.0-rc.13 → 4.0.0-rc.16

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './config/config';
 export * from './route/route';
-export { GeneratorType, IGeneratorOpts } from './service/generator';
+export { Generator, GeneratorType } from './service/generator';
 export * from './service/pluginAPI';
 export * from './service/service';
 export { Env, IAdd, IEvent, IModify, IRoute } from './types';

package/dist/route/routesConfig.d.ts

@@ -1,5 +1,6 @@
 interface IOpts {
     routes: any[];
+    onResolveComponent?: (component: string) => string;
 }
 export declare function getConfigRoutes(opts: IOpts): any[];
 export {};

package/dist/route/routesConfig.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,30 +7,68 @@ exports.getConfigRoutes = void 0;
 const assert_1 = __importDefault(require("assert"));
 function getConfigRoutes(opts) {
     const memo = { ret: {}, id: 1 };
-    transformRoutes({ routes: opts.routes, parentId: undefined, memo });
+    transformRoutes({
+        routes: opts.routes,
+        parentId: undefined,
+        memo,
+        onResolveComponent: opts.onResolveComponent,
+    });
     return memo.ret;
 }
 exports.getConfigRoutes = getConfigRoutes;
 function transformRoutes(opts) {
     opts.routes.forEach((route) => {
-        transformRoute({ route, parentId: opts.parentId, memo: opts.memo });
+        transformRoute({
+            route,
+            parentId: opts.parentId,
+            memo: opts.memo,
+            onResolveComponent: opts.onResolveComponent,
+        });
     });
 }
 function transformRoute(opts) {
     (0, assert_1.default)(!opts.route.children, 'children is not allowed in route props, use routes instead.');
     const id = String(opts.memo.id++);
-    const _a = opts.route, { routes, component } = _a, routeProps = __rest(_a, ["routes", "component"]);
+    const { routes, component, wrappers, ...routeProps } = opts.route;
     let absPath = opts.route.path;
     if ((absPath === null || absPath === void 0 ? void 0 : absPath.charAt(0)) !== '/') {
         const parentAbsPath = opts.parentId
-            ? opts.memo.ret[opts.parentId].absPath.replace(/\/*$/, '/') // to remove '/'s on the tail
+            ? opts.memo.ret[opts.parentId].absPath.replace(/\/+$/, '/') // to remove '/'s on the tail
             : '/';
         absPath = parentAbsPath + absPath;
     }
-    opts.memo.ret[id] = Object.assign(Object.assign(Object.assign(Object.assign({}, routeProps), { path: opts.route.path }), (component ? { file: component } : {})), { parentId: opts.parentId, id });
+    opts.memo.ret[id] = {
+        ...routeProps,
+        path: opts.route.path,
+        ...(component
+            ? {
+                file: opts.onResolveComponent
+                    ? opts.onResolveComponent(component)
+                    : component,
+            }
+            : {}),
+        parentId: opts.parentId,
+        id,
+    };
     if (absPath) {
         opts.memo.ret[id].absPath = absPath;
     }
+    if (wrappers === null || wrappers === void 0 ? void 0 : wrappers.length) {
+        let parentId = opts.parentId;
+        let path = opts.route.path;
+        wrappers.forEach((wrapper) => {
+            const { id } = transformRoute({
+                route: { path, component: wrapper },
+                parentId,
+                memo: opts.memo,
+                onResolveComponent: opts.onResolveComponent,
+            });
+            parentId = id;
+            path = '';
+        });
+        opts.memo.ret[id].parentId = parentId;
+        opts.memo.ret[id].path = path;
+    }
     if (opts.route.routes) {
         transformRoutes({
             routes: opts.route.routes,
@@ -49,4 +76,5 @@ function transformRoute(opts) {
             memo: opts.memo,
         });
     }
+    return { id };
 }

package/dist/route/routesConvention.js

@@ -44,7 +44,7 @@ function visitFiles(opts) {
         let file = (0, path_1.resolve)(opts.dir, filename);
         let stat = (0, fs_1.lstatSync)(file);
         if (stat.isDirectory()) {
-            visitFiles(Object.assign(Object.assign({}, opts), { dir: file }));
+            visitFiles({ ...opts, dir: file });
         }
         else if (stat.isFile() &&
             ['.tsx', '.ts', '.js', '.jsx', '.md', '.mdx', '.vue'].includes((0, path_1.extname)(file))) {

package/dist/service/command.d.ts

@@ -1,5 +1,6 @@
 import { yParser } from '@umijs/utils';
 import { Plugin } from './plugin';
+import { ResolveConfigMode } from './pluginAPI';
 export interface IOpts {
     name: string;
     description?: string;
@@ -11,12 +12,14 @@ export interface IOpts {
         }): void;
     };
     plugin: Plugin;
+    configResolveMode?: ResolveConfigMode;
 }
 export declare class Command {
     name: string;
     description?: string;
     options?: string;
     details?: string;
+    configResolveMode: ResolveConfigMode;
     fn: {
         ({ args }: {
             args: yParser.Arguments;

package/dist/service/command.js

@@ -9,6 +9,7 @@ class Command {
         this.details = opts.details;
         this.fn = opts.fn;
         this.plugin = opts.plugin;
+        this.configResolveMode = opts.configResolveMode || 'strict';
     }
 }
 exports.Command = Command;

package/dist/service/generatePlugin.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 });
 const utils_1 = require("@umijs/utils");
 const generator_1 = require("./generator");
@@ -19,70 +10,74 @@ exports.default = (api) => {
 umi generate
 `,
         description: 'generate code snippets quickly',
-        fn({ args }) {
+        configResolveMode: 'loose',
+        async fn({ args }) {
             var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const [type] = args._;
-                const runGenerator = (generator) => __awaiter(this, void 0, void 0, function* () {
-                    yield (generator === null || generator === void 0 ? void 0 : generator.fn({
+            const [type] = args._;
+            const runGenerator = async (generator) => {
+                await (generator === null || generator === void 0 ? void 0 : generator.fn({
+                    args,
+                    generateFile: utils_1.generateFile,
+                    installDeps: utils_1.installDeps,
+                    updatePackageJSON: utils_1.updatePackageJSON,
+                }));
+            };
+            if (type) {
+                const generator = api.service.generators[type];
+                if (!generator) {
+                    throw new Error(`Generator ${type} not found.`);
+                }
+                if (generator.type === generator_1.GeneratorType.enable) {
+                    const enable = await ((_a = generator.checkEnable) === null || _a === void 0 ? void 0 : _a.call(generator, {
                         args,
-                        generateFile: utils_1.generateFile,
-                        installDeps: utils_1.installDeps,
-                        updatePackageJSON: utils_1.updatePackageJSON,
                     }));
-                });
-                if (type) {
-                    const generator = api.service.generators[type];
-                    if (!generator) {
-                        throw new Error(`Generator ${type} not found.`);
-                    }
-                    if (generator.type === generator_1.GeneratorType.enable) {
-                        const enable = yield ((_a = generator.checkEnable) === null || _a === void 0 ? void 0 : _a.call(generator, {
-                            args,
-                        }));
-                        if (!enable) {
-                            throw new Error(`Generator ${type} is unable.The corresponding function has been turned on or is not available.`);
+                    if (!enable) {
+                        if (typeof generator.disabledDescription === 'function') {
+                            utils_1.logger.warn(generator.disabledDescription());
+                        }
+                        else {
+                            utils_1.logger.warn(generator.disabledDescription);
                         }
+                        return;
                     }
-                    yield runGenerator(generator);
                 }
-                else {
-                    const getEnableGenerators = (generators) => __awaiter(this, void 0, void 0, function* () {
-                        var _b, _c;
-                        const questions = [];
-                        for (const key of Object.keys(generators)) {
-                            if (generators[key].type === generator_1.GeneratorType.generate) {
+                await runGenerator(generator);
+            }
+            else {
+                const getEnableGenerators = async (generators) => {
+                    var _a;
+                    const questions = [];
+                    for (const key of Object.keys(generators)) {
+                        const g = generators[key];
+                        if (g.type === generator_1.GeneratorType.generate) {
+                            questions.push({
+                                title: `${g.name} -- ${g.description}` || '',
+                                value: g.key,
+                            });
+                        }
+                        else {
+                            const enable = await ((_a = g === null || g === void 0 ? void 0 : g.checkEnable) === null || _a === void 0 ? void 0 : _a.call(g, {
+                                args,
+                            }));
+                            if (enable) {
                                 questions.push({
-                                    title: `${generators[key].name} -- ${generators[key].description}` ||
-                                        '',
-                                    value: generators[key].key,
+                                    title: `${g.name} -- ${g.description}` || '',
+                                    value: g.key,
                                 });
                             }
-                            else {
-                                const enable = yield ((_c = (_b = generators[key]) === null || _b === void 0 ? void 0 : _b.checkEnable) === null || _c === void 0 ? void 0 : _c.call(_b, {
-                                    args,
-                                }));
-                                if (enable) {
-                                    questions.push({
-                                        title: `${generators[key].name} -- ${generators[key].description}` ||
-                                            '',
-                                        value: generators[key].key,
-                                    });
-                                }
-                            }
                         }
-                        return questions;
-                    });
-                    const questions = yield getEnableGenerators(api.service.generators);
-                    const { gType } = yield (0, utils_1.prompts)({
-                        type: 'select',
-                        name: 'gType',
-                        message: 'Pick generator type',
-                        choices: questions,
-                    });
-                    yield runGenerator(api.service.generators[gType]);
-                }
-            });
+                    }
+                    return questions;
+                };
+                const questions = await getEnableGenerators(api.service.generators);
+                const { gType } = await (0, utils_1.prompts)({
+                    type: 'select',
+                    name: 'gType',
+                    message: 'Pick generator type',
+                    choices: questions,
+                });
+                await runGenerator(api.service.generators[gType]);
+            }
         },
     });
 };

package/dist/service/generator.d.ts

@@ -4,16 +4,45 @@ export declare enum GeneratorType {
     generate = "generate",
     enable = "enable"
 }
-export interface IGeneratorOpts {
+declare type IGeneratorOptsWithoutEnableCheck = {
     key: string;
     name: string;
     description: string;
-    type?: GeneratorType;
-    checkEnable?: {
+    type: GeneratorType.generate;
+    fn: {
+        (opts: {
+            args: any;
+            generateFile: typeof generateFile;
+            updatePackageJSON: {
+                (opts: {
+                    opts: object;
+                    cwd?: string;
+                }): void;
+            };
+            installDeps: {
+                (opts: {
+                    opts: {
+                        devDependencies?: string[];
+                        dependencies?: string[];
+                    };
+                    cwd?: string;
+                }): void;
+            };
+        }): void;
+    };
+    plugin: Plugin;
+};
+declare type IGeneratorOptsWithEnableCheck = {
+    key: string;
+    name: string;
+    description: string;
+    type: GeneratorType.enable;
+    checkEnable: {
         (opts: {
             args: any;
         }): boolean;
     };
+    disabledDescription: string | (() => string);
     fn: {
         (opts: {
             args: any;
@@ -36,14 +65,7 @@ export interface IGeneratorOpts {
         }): void;
     };
     plugin: Plugin;
-}
-export declare class Generator {
-    key: IGeneratorOpts['key'];
-    name: IGeneratorOpts['name'];
-    description: IGeneratorOpts['description'];
-    type?: IGeneratorOpts['type'];
-    checkEnable?: IGeneratorOpts['checkEnable'];
-    fn: IGeneratorOpts['fn'];
-    plugin: IGeneratorOpts['plugin'];
-    constructor(opts: IGeneratorOpts);
-}
+};
+export declare type Generator = IGeneratorOptsWithEnableCheck | IGeneratorOptsWithoutEnableCheck;
+export declare function makeGenerator<T>(opts: T): T;
+export {};

package/dist/service/generator.js

@@ -1,20 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Generator = exports.GeneratorType = void 0;
+exports.makeGenerator = exports.GeneratorType = void 0;
 var GeneratorType;
 (function (GeneratorType) {
     GeneratorType["generate"] = "generate";
     GeneratorType["enable"] = "enable";
 })(GeneratorType = exports.GeneratorType || (exports.GeneratorType = {}));
-class Generator {
-    constructor(opts) {
-        this.key = opts.key;
-        this.name = opts.name;
-        this.type = opts.type;
-        this.description = opts.description;
-        this.checkEnable = opts.checkEnable;
-        this.fn = opts.fn;
-        this.plugin = opts.plugin;
-    }
+function makeGenerator(opts) {
+    return {
+        ...opts,
+    };
 }
-exports.Generator = Generator;
+exports.makeGenerator = makeGenerator;

package/dist/service/path.d.ts

@@ -12,3 +12,4 @@ export declare function getPaths(opts: {
     absNodeModulesPath: string;
     absOutputPath: string;
 };
+export declare type Paths = ReturnType<typeof getPaths>;

package/dist/service/pluginAPI.d.ts

@@ -1,11 +1,14 @@
 import { logger } from '@umijs/utils';
 import { EnableBy, Env, IPluginConfig } from '../types';
 import { IOpts as ICommandOpts } from './command';
-import { IGeneratorOpts } from './generator';
+import { Generator } from './generator';
 import { IOpts as IHookOpts } from './hook';
 import { Plugin } from './plugin';
 import { Service } from './service';
 declare type Logger = typeof logger;
+declare const resolveConfigModes: readonly ["strict", "loose"];
+export declare type ResolveConfigMode = typeof resolveConfigModes[number];
+declare type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 export declare class PluginAPI {
     service: Service;
     plugin: Plugin;
@@ -25,7 +28,7 @@ export declare class PluginAPI {
     registerCommand(opts: Omit<ICommandOpts, 'plugin'> & {
         alias?: string | string[];
     }): void;
-    registerGenerator(opts: Omit<IGeneratorOpts, 'plugin'>): void;
+    registerGenerator(opts: DistributiveOmit<Generator, 'plugin'>): void;
     register(opts: Omit<IHookOpts, 'plugin'>): void;
     registerMethod(opts: {
         name: string;

package/dist/service/pluginAPI.js

@@ -12,6 +12,7 @@ const generator_1 = require("./generator");
 const hook_1 = require("./hook");
 const plugin_1 = require("./plugin");
 const utils_2 = require("./utils");
+const resolveConfigModes = ['strict', 'loose'];
 class PluginAPI {
     constructor(opts) {
         this.service = opts.service;
@@ -48,15 +49,20 @@ class PluginAPI {
         delete opts.alias;
         const registerCommand = (commandOpts) => {
             var _a;
-            const { name } = commandOpts;
+            const { name, configResolveMode } = commandOpts;
+            (0, assert_1.default)(!configResolveMode ||
+                resolveConfigModes.indexOf(configResolveMode) >= 0, `configResolveMode must be one of ${resolveConfigModes.join(',')}, but got ${configResolveMode}`);
             (0, assert_1.default)(!this.service.commands[name], `api.registerCommand() failed, the command ${name} is exists from ${(_a = this.service.commands[name]) === null || _a === void 0 ? void 0 : _a.plugin.id}.`);
-            this.service.commands[name] = new command_1.Command(Object.assign(Object.assign({}, commandOpts), { plugin: this.plugin }));
+            this.service.commands[name] = new command_1.Command({
+                ...commandOpts,
+                plugin: this.plugin,
+            });
         };
         registerCommand(opts);
         if (alias) {
             const aliases = (0, utils_2.makeArray)(alias);
             aliases.forEach((alias) => {
-                registerCommand(Object.assign(Object.assign({}, opts), { name: alias }));
+                registerCommand({ ...opts, name: alias });
             });
         }
     }
@@ -64,13 +70,16 @@ class PluginAPI {
         var _a;
         const { key } = opts;
         (0, assert_1.default)(!this.service.generators[key], `api.registerGenerator() failed, the generator ${key} is exists from ${(_a = this.service.generators[key]) === null || _a === void 0 ? void 0 : _a.plugin.id}.`);
-        this.service.generators[key] = new generator_1.Generator(Object.assign(Object.assign({}, opts), { plugin: this.plugin }));
+        this.service.generators[key] = (0, generator_1.makeGenerator)({
+            ...opts,
+            plugin: this.plugin,
+        });
     }
     register(opts) {
         var _a, _b;
         (0, assert_1.default)(this.service.stage <= types_1.ServiceStage.initPlugins, 'api.register() should not be called after plugin register stage.');
         (_a = this.service.hooks)[_b = opts.key] || (_a[_b] = []);
-        this.service.hooks[opts.key].push(new hook_1.Hook(Object.assign(Object.assign({}, opts), { plugin: this.plugin })));
+        this.service.hooks[opts.key].push(new hook_1.Hook({ ...opts, plugin: this.plugin }));
     }
     registerMethod(opts) {
         (0, assert_1.default)(!this.service.pluginMethods[opts.name], `api.registerMethod() failed, method ${opts.name} is already exist.`);
@@ -81,7 +90,10 @@ class PluginAPI {
                 // 否则 pluginId 会不会，导致不能正确 skip plugin
                 function (fn) {
                     // @ts-ignore
-                    this.register(Object.assign({ key: opts.name }, (utils_1.lodash.isPlainObject(fn) ? fn : { fn })));
+                    this.register({
+                        key: opts.name,
+                        ...(utils_1.lodash.isPlainObject(fn) ? fn : { fn }),
+                    });
                 },
         };
     }

package/dist/service/service.d.ts

@@ -1,6 +1,6 @@
 import { yParser } from '@umijs/utils';
 import { Config } from '../config/config';
-import { ApplyPluginsType, ConfigChangeType, EnableBy, Env, IEvent, IModify, ServiceStage } from '../types';
+import { ApplyPluginsType, ConfigChangeType, EnableBy, Env, IEvent, IFrameworkType, IModify, ServiceStage } from '../types';
 import { Command } from './command';
 import { Generator } from './generator';
 import { Hook } from './hook';
@@ -22,6 +22,7 @@ export declare class Service {
             subpaths: string[];
             external?: boolean;
         }>;
+        framework?: IFrameworkType;
         [key: string]: any;
     };
     args: yParser.Arguments;
@@ -80,6 +81,10 @@ export declare class Service {
         name: string;
         args?: any;
     }): Promise<void>;
+    resolveConfig(): Promise<{
+        config: any;
+        defaultConfig: any;
+    }>;
     _baconPlugins(): void;
     initPreset(opts: {
         preset: Plugin;

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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -80,16 +71,16 @@ class Service {
                         continue;
                     tAdd.tapPromise({
                         name: hook.plugin.key,
-                        stage: hook.stage,
+                        stage: hook.stage || 0,
                         before: hook.before,
-                    }, (memo) => __awaiter(this, void 0, void 0, function* () {
+                    }, async (memo) => {
                         var _a, _b;
                         const dateStart = new Date();
-                        const items = yield hook.fn(opts.args);
+                        const items = await hook.fn(opts.args);
                         (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
                         hook.plugin.time.hooks[opts.key].push(new Date().getTime() - dateStart.getTime());
                         return memo.concat(items);
-                    }));
+                    });
                 }
                 return tAdd.promise(opts.initialValue || []);
             case types_1.ApplyPluginsType.modify:
@@ -99,16 +90,16 @@ class Service {
                         continue;
                     tModify.tapPromise({
                         name: hook.plugin.key,
-                        stage: hook.stage,
+                        stage: hook.stage || 0,
                         before: hook.before,
-                    }, (memo) => __awaiter(this, void 0, void 0, function* () {
-                        var _c, _d;
+                    }, async (memo) => {
+                        var _a, _b;
                         const dateStart = new Date();
-                        const ret = yield hook.fn(memo, opts.args);
-                        (_c = hook.plugin.time.hooks)[_d = opts.key] || (_c[_d] = []);
+                        const ret = await hook.fn(memo, opts.args);
+                        (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
                         hook.plugin.time.hooks[opts.key].push(new Date().getTime() - dateStart.getTime());
                         return ret;
-                    }));
+                    });
                 }
                 return tModify.promise(opts.initialValue);
             case types_1.ApplyPluginsType.event:
@@ -139,176 +130,186 @@ class Service {
                         name: hook.plugin.key,
                         stage: hook.stage || 0,
                         before: hook.before,
-                    }, () => __awaiter(this, void 0, void 0, function* () {
-                        var _f, _g;
+                    }, async () => {
+                        var _a, _b;
                         const dateStart = new Date();
-                        yield hook.fn(opts.args);
-                        (_f = hook.plugin.time.hooks)[_g = opts.key] || (_f[_g] = []);
+                        await hook.fn(opts.args);
+                        (_a = hook.plugin.time.hooks)[_b = opts.key] || (_a[_b] = []);
                         hook.plugin.time.hooks[opts.key].push(new Date().getTime() - dateStart.getTime());
-                    }));
+                    });
                 }
                 return tEvent.promise(1);
             default:
                 throw new Error(`applyPlugins failed, type is not defined or is not matched, got ${opts.type}.`);
         }
     }
-    run(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { name, args = {} } = opts;
-            args._ = args._ || [];
-            // shift the command itself
-            if (args._[0] === name)
-                args._.shift();
-            this.args = args;
-            this.name = name;
-            // loadEnv
-            this.stage = types_1.ServiceStage.init;
-            (0, env_1.loadEnv)({ cwd: this.cwd, envFile: '.env' });
-            // get pkg from package.json
-            let pkg = {};
-            let pkgPath = '';
-            try {
-                pkg = require((0, path_1.join)(this.cwd, 'package.json'));
-                pkgPath = (0, path_1.join)(this.cwd, 'package.json');
-            }
-            catch (_e) {
-                // APP_ROOT
-                if (this.cwd !== process.cwd()) {
-                    try {
-                        pkg = require((0, path_1.join)(process.cwd(), 'package.json'));
-                        pkgPath = (0, path_1.join)(process.cwd(), 'package.json');
-                    }
-                    catch (_e) { }
+    async run(opts) {
+        const { name, args = {} } = opts;
+        args._ = args._ || [];
+        // shift the command itself
+        if (args._[0] === name)
+            args._.shift();
+        this.args = args;
+        this.name = name;
+        // loadEnv
+        this.stage = types_1.ServiceStage.init;
+        (0, env_1.loadEnv)({ cwd: this.cwd, envFile: '.env' });
+        // get pkg from package.json
+        let pkg = {};
+        let pkgPath = '';
+        try {
+            pkg = require((0, path_1.join)(this.cwd, 'package.json'));
+            pkgPath = (0, path_1.join)(this.cwd, 'package.json');
+        }
+        catch (_e) {
+            // APP_ROOT
+            if (this.cwd !== process.cwd()) {
+                try {
+                    pkg = require((0, path_1.join)(process.cwd(), 'package.json'));
+                    pkgPath = (0, path_1.join)(process.cwd(), 'package.json');
                 }
+                catch (_e) { }
             }
-            this.pkg = pkg;
-            this.pkgPath = pkgPath || (0, path_1.join)(this.cwd, 'package.json');
-            const prefix = this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME;
-            // get user config
-            const configManager = new config_1.Config({
-                cwd: this.cwd,
-                env: this.env,
-                defaultConfigFiles: this.opts.defaultConfigFiles,
-                specifiedEnv: process.env[`${prefix}_ENV`.toUpperCase()],
+        }
+        this.pkg = pkg;
+        this.pkgPath = pkgPath || (0, path_1.join)(this.cwd, 'package.json');
+        const prefix = this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME;
+        // get user config
+        const configManager = new config_1.Config({
+            cwd: this.cwd,
+            env: this.env,
+            defaultConfigFiles: this.opts.defaultConfigFiles,
+            specifiedEnv: process.env[`${prefix}_ENV`.toUpperCase()],
+        });
+        this.configManager = configManager;
+        this.userConfig = configManager.getUserConfig().config;
+        // get paths
+        const paths = (0, path_2.getPaths)({
+            cwd: this.cwd,
+            env: this.env,
+            prefix: this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME,
+        });
+        // temporary paths for use by function generateFinalConfig.
+        // the value of paths may be updated by plugins later
+        this.paths = paths;
+        // resolve initial presets and plugins
+        const { plugins, presets } = plugin_1.Plugin.getPluginsAndPresets({
+            cwd: this.cwd,
+            pkg,
+            plugins: [require.resolve('./generatePlugin')].concat(this.opts.plugins || []),
+            presets: [require.resolve('./servicePlugin')].concat(this.opts.presets || []),
+            userConfig: this.userConfig,
+            prefix,
+        });
+        // register presets and plugins
+        this.stage = types_1.ServiceStage.initPresets;
+        const presetPlugins = [];
+        while (presets.length) {
+            await this.initPreset({
+                preset: presets.shift(),
+                presets,
+                plugins: presetPlugins,
             });
-            this.configManager = configManager;
-            this.userConfig = configManager.getUserConfig().config;
-            // get paths (move after?)
-            // resolve initial presets and plugins
-            const { plugins, presets } = plugin_1.Plugin.getPluginsAndPresets({
+        }
+        plugins.unshift(...presetPlugins);
+        this.stage = types_1.ServiceStage.initPlugins;
+        while (plugins.length) {
+            await this.initPlugin({ plugin: plugins.shift(), plugins });
+        }
+        const command = this.commands[name];
+        (0, assert_1.default)(command, `Invalid command ${name}, it's not registered.`);
+        // collect configSchemas and configDefaults
+        for (const id of Object.keys(this.plugins)) {
+            const { config, key } = this.plugins[id];
+            if (config.schema)
+                this.configSchemas[key] = config.schema;
+            if (config.default !== undefined) {
+                this.configDefaults[key] = config.default;
+            }
+            this.configOnChanges[key] = config.onChange || types_1.ConfigChangeType.reload;
+        }
+        // setup api.config from modifyConfig and modifyDefaultConfig
+        this.stage = types_1.ServiceStage.resolveConfig;
+        const { config, defaultConfig } = await this.resolveConfig();
+        if (this.config.outputPath) {
+            paths.absOutputPath = (0, path_1.isAbsolute)(this.config.outputPath)
+                ? this.config.outputPath
+                : (0, path_1.join)(this.cwd, this.config.outputPath);
+        }
+        this.paths = await this.applyPlugins({
+            key: 'modifyPaths',
+            initialValue: paths,
+        });
+        // applyPlugin collect app data
+        // TODO: some data is mutable
+        this.stage = types_1.ServiceStage.collectAppData;
+        this.appData = await this.applyPlugins({
+            key: 'modifyAppData',
+            initialValue: {
+                // base
                 cwd: this.cwd,
                 pkg,
-                plugins: [require.resolve('./generatePlugin')].concat(this.opts.plugins || []),
-                presets: [require.resolve('./servicePlugin')].concat(this.opts.presets || []),
+                pkgPath,
+                plugins,
+                presets,
+                name,
+                args,
+                // config
                 userConfig: this.userConfig,
-                prefix,
-            });
-            // register presets and plugins
-            this.stage = types_1.ServiceStage.initPresets;
-            const presetPlugins = [];
-            while (presets.length) {
-                yield this.initPreset({
-                    preset: presets.shift(),
-                    presets,
-                    plugins: presetPlugins,
-                });
-            }
-            plugins.unshift(...presetPlugins);
-            this.stage = types_1.ServiceStage.initPlugins;
-            while (plugins.length) {
-                yield this.initPlugin({ plugin: plugins.shift(), plugins });
-            }
-            // collect configSchemas and configDefaults
-            for (const id of Object.keys(this.plugins)) {
-                const { config, key } = this.plugins[id];
-                if (config.schema)
-                    this.configSchemas[key] = config.schema;
-                if (config.default !== undefined) {
-                    this.configDefaults[key] = config.default;
-                }
-                this.configOnChanges[key] = config.onChange || types_1.ConfigChangeType.reload;
-            }
-            // setup api.config from modifyConfig and modifyDefaultConfig
-            const paths = (0, path_2.getPaths)({
-                cwd: this.cwd,
-                env: this.env,
-                prefix: this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME,
-            });
-            this.stage = types_1.ServiceStage.resolveConfig;
-            const config = yield this.applyPlugins({
-                key: 'modifyConfig',
-                // why clone deep?
-                // user may change the config in modifyConfig
-                // e.g. memo.alias = xxx
-                initialValue: utils_1.lodash.cloneDeep(configManager.getConfig({
+                mainConfigFile: configManager.mainConfigFile,
+                config,
+                defaultConfig: defaultConfig,
+                // TODO
+                // moduleGraph,
+                // routes,
+                // npmClient,
+                // nodeVersion,
+                // gitInfo,
+                // gitBranch,
+                // debugger info,
+                // devPort,
+                // devHost,
+                // env
+            },
+        });
+        // applyPlugin onCheck
+        this.stage = types_1.ServiceStage.onCheck;
+        await this.applyPlugins({
+            key: 'onCheck',
+        });
+        // applyPlugin onStart
+        this.stage = types_1.ServiceStage.onStart;
+        await this.applyPlugins({
+            key: 'onStart',
+        });
+        // run command
+        this.stage = types_1.ServiceStage.runCommand;
+        let ret = await command.fn({ args });
+        this._baconPlugins();
+        return ret;
+    }
+    async resolveConfig() {
+        // configManager and paths are not available until the init stage
+        (0, assert_1.default)(this.stage > types_1.ServiceStage.init, `Can't generate final config before init stage`);
+        const resolveMode = this.commands[this.name].configResolveMode;
+        const config = await this.applyPlugins({
+            key: 'modifyConfig',
+            // why clone deep?
+            // user may change the config in modifyConfig
+            // e.g. memo.alias = xxx
+            initialValue: utils_1.lodash.cloneDeep(resolveMode === 'strict'
+                ? this.configManager.getConfig({
                     schemas: this.configSchemas,
-                }).config),
-                args: { paths },
-            });
-            const defaultConfig = yield this.applyPlugins({
-                key: 'modifyDefaultConfig',
-                initialValue: this.configDefaults,
-            });
-            this.config = utils_1.lodash.merge(defaultConfig, config);
-            if (this.config.outputPath) {
-                paths.absOutputPath = (0, path_1.isAbsolute)(this.config.outputPath)
-                    ? this.config.outputPath
-                    : (0, path_1.join)(this.cwd, this.config.outputPath);
-            }
-            this.paths = yield this.applyPlugins({
-                key: 'modifyPaths',
-                initialValue: paths,
-            });
-            // applyPlugin collect app data
-            // TODO: some data is mutable
-            this.stage = types_1.ServiceStage.collectAppData;
-            this.appData = yield this.applyPlugins({
-                key: 'modifyAppData',
-                initialValue: {
-                    // base
-                    cwd: this.cwd,
-                    pkg,
-                    pkgPath,
-                    plugins,
-                    presets,
-                    name,
-                    args,
-                    // config
-                    userConfig: this.userConfig,
-                    mainConfigFile: configManager.mainConfigFile,
-                    config,
-                    defaultConfig: defaultConfig,
-                    // TODO
-                    // moduleGraph,
-                    // routes,
-                    // npmClient,
-                    // nodeVersion,
-                    // gitInfo,
-                    // gitBranch,
-                    // debugger info,
-                    // devPort,
-                    // devHost,
-                    // env
-                },
-            });
-            // applyPlugin onCheck
-            this.stage = types_1.ServiceStage.onCheck;
-            yield this.applyPlugins({
-                key: 'onCheck',
-            });
-            // applyPlugin onStart
-            this.stage = types_1.ServiceStage.onStart;
-            yield this.applyPlugins({
-                key: 'onStart',
-            });
-            // run command
-            this.stage = types_1.ServiceStage.runCommand;
-            const command = this.commands[name];
-            (0, assert_1.default)(command, `Invalid command ${name}, it's not registered.`);
-            let ret = yield command.fn({ args });
-            this._baconPlugins();
-            return ret;
+                }).config
+                : this.configManager.getUserConfig().config),
+            args: { paths: this.paths },
         });
+        const defaultConfig = await this.applyPlugins({
+            key: 'modifyDefaultConfig',
+            initialValue: this.configDefaults,
+        });
+        this.config = utils_1.lodash.merge(defaultConfig, config);
+        return { config, defaultConfig };
     }
     _baconPlugins() {
         // TODO: prettier
@@ -320,80 +321,76 @@ class Service {
             }
         }
     }
-    initPreset(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { presets, plugins } = yield this.initPlugin({
-                plugin: opts.preset,
-                presets: opts.presets,
-                plugins: opts.plugins,
-            });
-            opts.presets.unshift(...(presets || []));
-            opts.plugins.push(...(plugins || []));
+    async initPreset(opts) {
+        const { presets, plugins } = await this.initPlugin({
+            plugin: opts.preset,
+            presets: opts.presets,
+            plugins: opts.plugins,
         });
+        opts.presets.unshift(...(presets || []));
+        opts.plugins.push(...(plugins || []));
     }
-    initPlugin(opts) {
+    async initPlugin(opts) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            // register to this.plugins
-            (0, assert_1.default)(!this.plugins[opts.plugin.id], `${opts.plugin.type} ${opts.plugin.id} is already registered by ${(_a = this.plugins[opts.plugin.id]) === null || _a === void 0 ? void 0 : _a.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`);
-            this.plugins[opts.plugin.id] = opts.plugin;
-            // apply with PluginAPI
-            const pluginAPI = new pluginAPI_1.PluginAPI({
-                plugin: opts.plugin,
-                service: this,
-            });
-            pluginAPI.registerPresets = pluginAPI.registerPresets.bind(pluginAPI, opts.presets || []);
-            pluginAPI.registerPlugins = pluginAPI.registerPlugins.bind(pluginAPI, opts.plugins);
-            const proxyPluginAPI = pluginAPI_1.PluginAPI.proxyPluginAPI({
+        // register to this.plugins
+        (0, assert_1.default)(!this.plugins[opts.plugin.id], `${opts.plugin.type} ${opts.plugin.id} is already registered by ${(_a = this.plugins[opts.plugin.id]) === null || _a === void 0 ? void 0 : _a.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`);
+        this.plugins[opts.plugin.id] = opts.plugin;
+        // apply with PluginAPI
+        const pluginAPI = new pluginAPI_1.PluginAPI({
+            plugin: opts.plugin,
+            service: this,
+        });
+        pluginAPI.registerPresets = pluginAPI.registerPresets.bind(pluginAPI, opts.presets || []);
+        pluginAPI.registerPlugins = pluginAPI.registerPlugins.bind(pluginAPI, opts.plugins);
+        const proxyPluginAPI = pluginAPI_1.PluginAPI.proxyPluginAPI({
+            service: this,
+            pluginAPI,
+            serviceProps: [
+                'appData',
+                'applyPlugins',
+                'args',
+                'config',
+                'cwd',
+                'pkg',
+                'pkgPath',
+                'name',
+                'paths',
+                'userConfig',
+                'env',
+                'isPluginEnable',
+            ],
+            staticProps: {
+                ApplyPluginsType: types_1.ApplyPluginsType,
+                ConfigChangeType: types_1.ConfigChangeType,
+                EnableBy: types_1.EnableBy,
+                ServiceStage: types_1.ServiceStage,
                 service: this,
-                pluginAPI,
-                serviceProps: [
-                    'appData',
-                    'applyPlugins',
-                    'args',
-                    'config',
-                    'cwd',
-                    'pkg',
-                    'pkgPath',
-                    'name',
-                    'paths',
-                    'userConfig',
-                    'env',
-                    'isPluginEnable',
-                ],
-                staticProps: {
-                    ApplyPluginsType: types_1.ApplyPluginsType,
-                    ConfigChangeType: types_1.ConfigChangeType,
-                    EnableBy: types_1.EnableBy,
-                    ServiceStage: types_1.ServiceStage,
-                    service: this,
-                },
-            });
-            let dateStart = new Date();
-            let ret = yield opts.plugin.apply()(proxyPluginAPI);
-            opts.plugin.time.register = new Date().getTime() - dateStart.getTime();
-            if (opts.plugin.type === 'plugin') {
-                (0, assert_1.default)(!ret, `plugin should return nothing`);
-            }
-            // key should be unique
-            (0, assert_1.default)(!this.keyToPluginMap[opts.plugin.key], `key ${opts.plugin.key} is already registered by ${(_b = this.keyToPluginMap[opts.plugin.key]) === null || _b === void 0 ? void 0 : _b.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`);
-            this.keyToPluginMap[opts.plugin.key] = opts.plugin;
-            if (ret === null || ret === void 0 ? void 0 : ret.presets) {
-                ret.presets = ret.presets.map((preset) => new plugin_1.Plugin({
-                    path: preset,
-                    type: types_1.PluginType.preset,
-                    cwd: this.cwd,
-                }));
-            }
-            if (ret === null || ret === void 0 ? void 0 : ret.plugins) {
-                ret.plugins = ret.plugins.map((plugin) => new plugin_1.Plugin({
-                    path: plugin,
-                    type: types_1.PluginType.plugin,
-                    cwd: this.cwd,
-                }));
-            }
-            return ret || {};
+            },
         });
+        let dateStart = new Date();
+        let ret = await opts.plugin.apply()(proxyPluginAPI);
+        opts.plugin.time.register = new Date().getTime() - dateStart.getTime();
+        if (opts.plugin.type === 'plugin') {
+            (0, assert_1.default)(!ret, `plugin should return nothing`);
+        }
+        // key should be unique
+        (0, assert_1.default)(!this.keyToPluginMap[opts.plugin.key], `key ${opts.plugin.key} is already registered by ${(_b = this.keyToPluginMap[opts.plugin.key]) === null || _b === void 0 ? void 0 : _b.path}, ${opts.plugin.type} from ${opts.plugin.path} register failed.`);
+        this.keyToPluginMap[opts.plugin.key] = opts.plugin;
+        if (ret === null || ret === void 0 ? void 0 : ret.presets) {
+            ret.presets = ret.presets.map((preset) => new plugin_1.Plugin({
+                path: preset,
+                type: types_1.PluginType.preset,
+                cwd: this.cwd,
+            }));
+        }
+        if (ret === null || ret === void 0 ? void 0 : ret.plugins) {
+            ret.plugins = ret.plugins.map((plugin) => new plugin_1.Plugin({
+                path: plugin,
+                type: types_1.PluginType.plugin,
+                cwd: this.cwd,
+            }));
+        }
+        return ret || {};
     }
     isPluginEnable(hook) {
         let plugin;

package/dist/types.d.ts

@@ -108,3 +108,4 @@ export interface IAdd<T, U> {
         };
     }): void;
 }
+export declare type IFrameworkType = 'vue' | 'react';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/core",
-  "version": "4.0.0-rc.13",
+  "version": "4.0.0-rc.16",
   "homepage": "https://github.com/umijs/umi-next/tree/master/packages/core#readme",
   "bugs": "https://github.com/umijs/umi-next/issues",
   "repository": {
@@ -16,13 +16,13 @@
   ],
   "scripts": {
     "build": "pnpm tsc",
-    "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
+    "build:deps": "umi-scripts bundleDeps",
     "dev": "pnpm build -- --watch",
-    "test": "jest -c ../../jest.turbo.config.ts"
+    "test": "umi-scripts jest-turbo"
   },
   "dependencies": {
-    "@umijs/bundler-utils": "4.0.0-rc.13",
-    "@umijs/utils": "4.0.0-rc.13"
+    "@umijs/bundler-utils": "4.0.0-rc.16",
+    "@umijs/utils": "4.0.0-rc.16"
   },
   "devDependencies": {
     "@hapi/joi": "17.1.1",