feat: 文件大小写

packages/fes-core/src/Config/index.js

@@ -0,0 +1,286 @@
+import { existsSync } from 'fs';
+import { extname, join } from 'path';
+import {
+    chalk,
+    chokidar,
+    compatESModuleRequire,
+    deepmerge,
+    cleanRequireCache,
+    lodash,
+    parseRequireDeps,
+    winPath,
+    getFile
+} from '@umijs/utils';
+import assert from 'assert';
+import joi from 'joi';
+import { ServiceStage } from '../service/enums';
+import {
+    getUserConfigWithKey,
+    updateUserConfigWithKey
+} from './utils/configUtils';
+import isEqual from './utils/isEqual';
+import mergeDefault from './utils/mergeDefault';
+
+const CONFIG_FILES = ['.fes.js', 'config/config.js'];
+
+// TODO:
+// 1. custom config file
+export default class Config {
+    cwd;
+
+    service;
+
+    config;
+
+    localConfig;
+
+    configFile;
+
+    constructor(opts) {
+        this.cwd = opts.cwd || process.cwd();
+        this.service = opts.service;
+        this.localConfig = opts.localConfig;
+    }
+
+    async getDefaultConfig() {
+        const pluginIds = Object.keys(this.service.plugins);
+
+        // collect default config
+        const defaultConfig = pluginIds.reduce((memo, pluginId) => {
+            const { key, config = {} } = this.service.plugins[pluginId];
+            if ('default' in config) memo[key] = config.default;
+            return memo;
+        }, {});
+
+        return defaultConfig;
+    }
+
+    getConfig({ defaultConfig }) {
+        assert(
+            this.service.stage >= ServiceStage.pluginReady,
+            'Config.getConfig() failed, it should not be executed before plugin is ready.'
+        );
+
+        const userConfig = this.getUserConfig();
+        // 用于提示用户哪些 key 是未定义的
+        // TODO: 考虑不排除 false 的 key
+        const userConfigKeys = Object.keys(userConfig).filter(
+            key => userConfig[key] !== false
+        );
+
+        // get config
+        const pluginIds = Object.keys(this.service.plugins);
+        pluginIds.forEach((pluginId) => {
+            const { key, config = {} } = this.service.plugins[pluginId];
+            // recognize as key if have schema config
+            if (!config.schema) return;
+
+            const value = getUserConfigWithKey({
+                key,
+                userConfig
+            });
+            // 不校验 false 的值，此时已禁用插件
+            if (value === false) return;
+
+            // do validate
+            const schema = config.schema(joi);
+            assert(
+                joi.isSchema(schema),
+                `schema return from plugin ${pluginId} is not valid schema.`
+            );
+            const { error } = schema.validate(value);
+            if (error) {
+                const e = new Error(
+                    `Validate config "${key}" failed, ${error.message}`
+                );
+                e.stack = error.stack;
+                throw e;
+            }
+
+            // remove key
+            const index = userConfigKeys.indexOf(key.split('.')[0]);
+            if (index !== -1) {
+                userConfigKeys.splice(index, 1);
+            }
+
+            // update userConfig with defaultConfig
+            if (key in defaultConfig) {
+                const newValue = mergeDefault({
+                    defaultConfig: defaultConfig[key],
+                    config: value
+                });
+                updateUserConfigWithKey({
+                    key,
+                    value: newValue,
+                    userConfig
+                });
+            }
+        });
+
+        if (userConfigKeys.length) {
+            const keys = userConfigKeys.length > 1 ? 'keys' : 'key';
+            throw new Error(
+                `Invalid config ${keys}: ${userConfigKeys.join(', ')}`
+            );
+        }
+
+        return userConfig;
+    }
+
+    getUserConfig() {
+        const configFile = this.getConfigFile();
+        this.configFile = configFile;
+        // 潜在问题：
+        // .local 和 .env 的配置必须有 configFile 才有效
+        if (configFile) {
+            let envConfigFile;
+            if (process.env.FES_ENV) {
+                const envConfigFileName = this.addAffix(
+                    configFile,
+                    process.env.FES_ENV
+                );
+                const fileNameWithoutExt = envConfigFileName.replace(
+                    extname(envConfigFileName),
+                    ''
+                );
+                envConfigFile = getFile({
+                    base: this.cwd,
+                    fileNameWithoutExt,
+                    type: 'javascript'
+                }).filename;
+                if (!envConfigFile) {
+                    throw new Error(
+                        `get user config failed, ${envConfigFile} does not exist, but process.env.FES_ENV is set to ${process.env.FES_ENV}.`
+                    );
+                }
+            }
+            const files = [
+                configFile,
+                envConfigFile,
+                this.localConfig && this.addAffix(configFile, 'local')
+            ]
+                .filter(f => !!f)
+                .map(f => join(this.cwd, f))
+                .filter(f => existsSync(f));
+
+            // clear require cache and set babel register
+            const requireDeps = files.reduce((memo, file) => {
+                memo = memo.concat(parseRequireDeps(file));
+                return memo;
+            }, []);
+            requireDeps.forEach(cleanRequireCache);
+            this.service.babelRegister.setOnlyMap({
+                key: 'config',
+                value: requireDeps
+            });
+
+            // require config and merge
+            return this.mergeConfig(...this.requireConfigs(files));
+        }
+        return {};
+    }
+
+    addAffix(file, affix) {
+        const ext = extname(file);
+        return file.replace(new RegExp(`${ext}$`), `.${affix}${ext}`);
+    }
+
+    requireConfigs(configFiles) {
+        // eslint-disable-next-line
+        return configFiles.map((f) => compatESModuleRequire(require(f)));
+    }
+
+    mergeConfig(...configs) {
+        let ret = {};
+        for (const config of configs) {
+            // TODO: 精细化处理，比如处理 dotted config key
+            ret = deepmerge(ret, config);
+        }
+        return ret;
+    }
+
+    getConfigFile() {
+        // TODO: support custom config file
+        const configFile = CONFIG_FILES.find(f => existsSync(join(this.cwd, f)));
+        return configFile ? winPath(configFile) : null;
+    }
+
+    getWatchFilesAndDirectories() {
+        const fesEnv = process.env.FES_ENV;
+        const configFiles = lodash.clone(CONFIG_FILES);
+        CONFIG_FILES.forEach((f) => {
+            if (this.localConfig) configFiles.push(this.addAffix(f, 'local'));
+            if (fesEnv) configFiles.push(this.addAffix(f, fesEnv));
+        });
+
+        const configDir = winPath(join(this.cwd, 'config'));
+
+        const files = configFiles
+            .reduce((memo, f) => {
+                const file = winPath(join(this.cwd, f));
+                if (existsSync(file)) {
+                    memo = memo.concat(parseRequireDeps(file));
+                } else {
+                    memo.push(file);
+                }
+                return memo;
+            }, [])
+            .filter(f => !f.startsWith(configDir));
+
+        return [configDir].concat(files);
+    }
+
+    watch(opts) {
+        let paths = this.getWatchFilesAndDirectories();
+        let userConfig = opts.userConfig;
+        const watcher = chokidar.watch(paths, {
+            ignoreInitial: true,
+            cwd: this.cwd
+        });
+        watcher.on('all', (event, path) => {
+            console.log(chalk.green(`[${event}] ${path}`));
+            const newPaths = this.getWatchFilesAndDirectories();
+            const diffs = lodash.difference(newPaths, paths);
+            if (diffs.length) {
+                watcher.add(diffs);
+                paths = paths.concat(diffs);
+            }
+
+            const newUserConfig = this.getUserConfig();
+            const pluginChanged = [];
+            const valueChanged = [];
+            Object.keys(this.service.plugins).forEach((pluginId) => {
+                const { key, config = {} } = this.service.plugins[pluginId];
+                // recognize as key if have schema config
+                if (!config.schema) return;
+                if (!isEqual(newUserConfig[key], userConfig[key])) {
+                    const changed = {
+                        key,
+                        pluginId
+                    };
+                    if (
+                        newUserConfig[key] === false
+                        || userConfig[key] === false
+                    ) {
+                        pluginChanged.push(changed);
+                    } else {
+                        valueChanged.push(changed);
+                    }
+                }
+            });
+
+            if (pluginChanged.length || valueChanged.length) {
+                opts.onChange({
+                    userConfig: newUserConfig,
+                    pluginChanged,
+                    valueChanged
+                });
+            }
+            userConfig = newUserConfig;
+        });
+
+        return () => {
+            watcher.close();
+        };
+    }
+}

packages/fes-core/src/Service/PluginAPI.js

@@ -99,6 +99,26 @@ export default class PluginAPI {
         }
     }
 
+    registerPresets(presets) {
+        assert(
+            this.service.stage === ServiceStage.initPresets,
+            'api.registerPresets() failed, it should only used in presets.',
+        );
+        assert(
+            Array.isArray(presets),
+            'api.registerPresets() failed, presets must be Array.',
+        );
+        const extraPresets = presets.map(preset => (isValidPlugin(preset)
+            ? (preset)
+            : pathToObj({
+                type: PluginType.preset,
+                path: preset,
+                cwd: this.service.cwd
+            })));
+        // 插到最前面，下个 while 循环优先执行
+        this.service._extraPresets.splice(0, 0, ...extraPresets);
+    }
+
     registerMethod({
         name,
         fn,

packages/fes-core/src/Service/index.js

@@ -0,0 +1,522 @@
+import { join } from 'path';
+import { EventEmitter } from 'events';
+import assert from 'assert';
+import { AsyncSeriesWaterfallHook } from 'tapable';
+import { existsSync } from 'fs';
+import { BabelRegister, lodash } from '@umijs/utils';
+import { resolvePresets, pathToObj, resolvePlugins } from './utils/pluginUtils';
+import loadDotEnv from './utils/loadDotEnv';
+import isPromise from './utils/isPromise';
+import PluginAPI from './pluginAPI';
+import {
+    ApplyPluginsType,
+    ConfigChangeType,
+    EnableBy,
+    PluginType,
+    ServiceStage
+} from './enums';
+import Config from '../config';
+import { getUserConfigWithKey } from '../config/utils/configUtils';
+import getPaths from './getPaths';
+
+// TODO
+// 1. duplicated key
+// 2. Logger
+export default class Service extends EventEmitter {
+    cwd;
+
+    pkg;
+
+    skipPluginIds = new Set();
+
+    // lifecycle stage
+    stage = ServiceStage.uninitialized;
+
+    // registered commands
+    commands = {};
+
+    // including plugins
+    plugins = {};
+
+    // plugin methods
+    pluginMethods = {};
+
+    // initial presets and plugins from arguments, config, process.env, and package.json
+    initialPresets = [];
+
+    // initial plugins from arguments, config, process.env, and package.json
+    initialPlugins = [];
+
+    _extraPresets = [];
+
+    _extraPlugins = [];
+
+    // user config
+    userConfig;
+
+    configInstance;
+
+    config = null;
+
+    // babel register
+    babelRegister;
+
+    // hooks
+    hooksByPluginId = {};
+
+    hooks = {};
+
+    // paths
+    paths = {};
+
+    env;
+
+    ApplyPluginsType = ApplyPluginsType;
+
+    EnableBy = EnableBy;
+
+    ConfigChangeType = ConfigChangeType;
+
+    ServiceStage = ServiceStage;
+
+    args;
+
+    constructor(opts) {
+        super();
+        this.cwd = opts.cwd || process.cwd();
+        // repoDir should be the root dir of repo
+        this.pkg = opts.pkg || this.resolvePackage();
+        this.env = opts.env || process.env.NODE_ENV;
+
+        assert(existsSync(this.cwd), `cwd ${this.cwd} does not exist.`);
+
+        // register babel before config parsing
+        this.babelRegister = new BabelRegister();
+
+        // load .env or .local.env
+        this.loadEnv();
+
+        // get user config without validation
+        this.configInstance = new Config({
+            cwd: this.cwd,
+            service: this,
+            localConfig: this.env === 'development'
+        });
+        this.userConfig = this.configInstance.getUserConfig();
+
+        // get paths
+        this.paths = getPaths({
+            cwd: this.cwd,
+            config: this.userConfig,
+            env: this.env
+        });
+
+        // setup initial plugins
+        const baseOpts = {
+            pkg: this.pkg,
+            cwd: this.cwd
+        };
+        this.initialPresets = resolvePresets({
+            ...baseOpts,
+            presets: opts.presets || [],
+            userConfigPresets: this.userConfig.presets || []
+        });
+        this.initialPlugins = resolvePlugins({
+            ...baseOpts,
+            plugins: opts.plugins || [],
+            userConfigPlugins: this.userConfig.plugins || []
+        });
+    }
+
+    setStage(stage) {
+        this.stage = stage;
+    }
+
+    resolvePackage() {
+        try {
+            // eslint-disable-next-line
+            return require(join(this.cwd, "package.json"));
+        } catch (e) {
+            return {};
+        }
+    }
+
+    loadEnv() {
+        const basePath = join(this.cwd, '.env');
+        const localPath = `${basePath}.local`;
+        loadDotEnv(basePath);
+        loadDotEnv(localPath);
+    }
+
+    async init() {
+        this.setStage(ServiceStage.init);
+        await this.initPresetsAndPlugins();
+
+        // hooksByPluginId -> hooks
+        // hooks is mapped with hook key, prepared for applyPlugins()
+        this.setStage(ServiceStage.initHooks);
+        Object.keys(this.hooksByPluginId).forEach((id) => {
+            const hooks = this.hooksByPluginId[id];
+            hooks.forEach((hook) => {
+                const { key } = hook;
+                hook.pluginId = id;
+                this.hooks[key] = (this.hooks[key] || []).concat(hook);
+            });
+        });
+
+        // plugin is totally ready
+        this.setStage(ServiceStage.pluginReady);
+        await this.applyPlugins({
+            key: 'onPluginReady',
+            type: ApplyPluginsType.event
+        });
+
+        // get config, including:
+        // 1. merge default config
+        // 2. validate
+        this.setStage(ServiceStage.getConfig);
+        await this.setConfig();
+
+        // merge paths to keep the this.paths ref
+        this.setStage(ServiceStage.getPaths);
+        // config.outputPath may be modified by plugins
+        if (this.config.outputPath) {
+            this.paths.absOutputPath = join(this.cwd, this.config.outputPath);
+        }
+        const paths = await this.applyPlugins({
+            key: 'modifyPaths',
+            type: ApplyPluginsType.modify,
+            initialValue: this.paths
+        });
+        Object.keys(paths).forEach((key) => {
+            this.paths[key] = paths[key];
+        });
+    }
+
+    async setConfig() {
+        const defaultConfig = await this.applyPlugins({
+            key: 'modifyDefaultConfig',
+            type: this.ApplyPluginsType.modify,
+            initialValue: await this.configInstance.getDefaultConfig()
+        });
+        this.config = await this.applyPlugins({
+            key: 'modifyConfig',
+            type: this.ApplyPluginsType.modify,
+            initialValue: this.configInstance.getConfig({
+                defaultConfig
+            })
+        });
+    }
+
+    async initPresetsAndPlugins() {
+        this.setStage(ServiceStage.initPresets);
+        this._extraPlugins = [];
+        while (this.initialPresets.length) {
+            // eslint-disable-next-line
+            await this.initPreset(this.initialPresets.shift());
+        }
+
+        this.setStage(ServiceStage.initPlugins);
+        this._extraPlugins.push(...this.initialPlugins);
+        while (this._extraPlugins.length) {
+            // eslint-disable-next-line
+            await this.initPlugin(this._extraPlugins.shift());
+        }
+    }
+
+    getPluginAPI(opts) {
+        const pluginAPI = new PluginAPI(opts);
+
+        // register built-in methods
+        [
+            'onPluginReady',
+            'modifyPaths',
+            'onStart',
+            'modifyDefaultConfig',
+            'modifyConfig'
+        ].forEach((name) => {
+            pluginAPI.registerMethod({
+                name,
+                exitsError: false
+            });
+        });
+
+        return new Proxy(pluginAPI, {
+            get: (target, prop) => {
+                // 由于 pluginMethods 需要在 register 阶段可用
+                // 必须通过 proxy 的方式动态获取最新，以实现边注册边使用的效果
+                if (this.pluginMethods[prop]) return this.pluginMethods[prop];
+                if (
+                    [
+                        'applyPlugins',
+                        'ApplyPluginsType',
+                        'EnableBy',
+                        'ConfigChangeType',
+                        'babelRegister',
+                        'stage',
+                        'ServiceStage',
+                        'paths',
+                        'cwd',
+                        'pkg',
+                        'userConfig',
+                        'config',
+                        'env',
+                        'args',
+                        'hasPlugins',
+                        'hasPresets',
+                        'setConfig'
+                    ].includes(prop)
+                ) {
+                    return typeof this[prop] === 'function'
+                        ? this[prop].bind(this)
+                        : this[prop];
+                }
+                return target[prop];
+            }
+        });
+    }
+
+    async applyAPI(opts) {
+        let ret = opts.apply()(opts.api);
+        if (isPromise(ret)) {
+            ret = await ret;
+        }
+        return ret || {};
+    }
+
+    async initPreset(preset) {
+        const { id, key, apply } = preset;
+        preset.isPreset = true;
+
+        const api = this.getPluginAPI({ id, key, service: this });
+
+        // register before apply
+        this.registerPlugin(preset);
+        const { presets, plugins } = await this.applyAPI({
+            api,
+            apply
+        });
+
+        // register extra presets and plugins
+        if (presets) {
+            assert(
+                Array.isArray(presets),
+                `presets returned from preset ${id} must be Array.`,
+            );
+            // 插到最前面，下个 while 循环优先执行
+            this._extraPresets.splice(
+                0,
+                0,
+                ...presets.map(path => pathToObj({
+                    type: PluginType.preset,
+                    path,
+                    cwd: this.cwd
+                })),
+            );
+        }
+
+        // 深度优先
+        const extraPresets = lodash.clone(this._extraPresets);
+        this._extraPresets = [];
+        while (extraPresets.length) {
+            // eslint-disable-next-line
+            await this.initPreset(extraPresets.shift());
+        }
+
+        if (plugins) {
+            assert(
+                Array.isArray(plugins),
+                `plugins returned from preset ${id} must be Array.`,
+            );
+            this._extraPlugins.push(
+                ...plugins.map(path => pathToObj({
+                    type: PluginType.plugin,
+                    path,
+                    cwd: this.cwd
+                })),
+            );
+        }
+    }
+
+
+    async initPlugin(plugin) {
+        const { id, key, apply } = plugin;
+
+        const api = this.getPluginAPI({
+            id,
+            key,
+            service: this
+        });
+
+        // register before apply
+        this.registerPlugin(plugin);
+        await this.applyAPI({
+            api,
+            apply
+        });
+    }
+
+    getPluginOptsWithKey(key) {
+        return getUserConfigWithKey({
+            key,
+            userConfig: this.userConfig
+        });
+    }
+
+    registerPlugin(plugin) {
+        this.plugins[plugin.id] = plugin;
+    }
+
+    isPluginEnable(pluginId) {
+        // api.skipPlugins() 的插件
+        if (this.skipPluginIds.has(pluginId)) return false;
+
+        const { key, enableBy } = this.plugins[pluginId];
+
+        // 手动设置为 false
+        if (this.userConfig[key] === false) return false;
+
+        // 配置开启
+        if (enableBy === this.EnableBy.config && !(key in this.userConfig)) {
+            return false;
+        }
+
+        // 函数自定义开启
+        if (typeof enableBy === 'function') {
+            return enableBy();
+        }
+
+        // 注册开启
+        return true;
+    }
+
+    hasPresets(presetIds) {
+        return presetIds.every((presetId) => {
+            const preset = this.plugins[presetId];
+            return preset && preset.isPreset && this.isPluginEnable(presetId);
+        });
+    }
+
+    hasPlugins(pluginIds) {
+        return pluginIds.every((pluginId) => {
+            const plugin = this.plugins[pluginId];
+            return plugin && !plugin.isPreset && this.isPluginEnable(pluginId);
+        });
+    }
+
+    async applyPlugins(opts) {
+        const hooks = this.hooks[opts.key] || [];
+        switch (opts.type) {
+            case ApplyPluginsType.add:
+                if ('initialValue' in opts) {
+                    assert(
+                        Array.isArray(opts.initialValue),
+                        'applyPlugins failed, opts.initialValue must be Array if opts.type is add.'
+                    );
+                }
+                // eslint-disable-next-line
+                const tAdd = new AsyncSeriesWaterfallHook(["memo"]);
+                for (const hook of hooks) {
+                    if (!this.isPluginEnable(hook.pluginId)) {
+                        continue;
+                    }
+                    tAdd.tapPromise(
+                        {
+                            name: hook.pluginId,
+                            stage: hook.stage || 0,
+                            // @ts-ignore
+                            before: hook.before
+                        },
+                        async (memo) => {
+                            const items = await hook.fn(opts.args);
+                            return memo.concat(items);
+                        }
+                    );
+                }
+                return tAdd.promise(opts.initialValue || []);
+            case ApplyPluginsType.modify:
+                // eslint-disable-next-line
+                const tModify = new AsyncSeriesWaterfallHook(["memo"]);
+                for (const hook of hooks) {
+                    if (!this.isPluginEnable(hook.pluginId)) {
+                        continue;
+                    }
+                    tModify.tapPromise(
+                        {
+                            name: hook.pluginId,
+                            stage: hook.stage || 0,
+                            // @ts-ignore
+                            before: hook.before
+                        },
+                        async memo => hook.fn(memo, opts.args)
+                    );
+                }
+                return tModify.promise(opts.initialValue);
+            case ApplyPluginsType.event:
+                // eslint-disable-next-line
+                const tEvent = new AsyncSeriesWaterfallHook(["_"]);
+                for (const hook of hooks) {
+                    if (!this.isPluginEnable(hook.pluginId)) {
+                        continue;
+                    }
+                    tEvent.tapPromise(
+                        {
+                            name: hook.pluginId,
+                            stage: hook.stage || 0,
+                            // @ts-ignore
+                            before: hook.before
+                        },
+                        async () => {
+                            await hook.fn(opts.args);
+                        }
+                    );
+                }
+                return tEvent.promise();
+            default:
+                throw new Error(
+                    `applyPlugin failed, type is not defined or is not matched, got ${opts.type}.`
+                );
+        }
+    }
+
+    async run({ name, args = {} }) {
+        args._ = args._ || [];
+        // shift the command itself
+        if (args._[0] === name) args._.shift();
+
+        this.args = args;
+        await this.init();
+
+        this.setStage(ServiceStage.run);
+        await this.applyPlugins({
+            key: 'onStart',
+            type: ApplyPluginsType.event,
+            args: {
+                args
+            }
+        });
+
+        return this.runCommand({
+            name,
+            args
+        });
+    }
+
+    async runCommand({ name, args = {} }) {
+        assert(this.stage >= ServiceStage.init, 'service is not initialized.');
+
+        args._ = args._ || [];
+        // shift the command itself
+        if (args._[0] === name) args._.shift();
+
+        const command = typeof this.commands[name] === 'string'
+            ? this.commands[this.commands[name]]
+            : this.commands[name];
+        assert(command, `run command failed, command ${name} does not exists.`);
+
+        const { fn } = command;
+        return fn({
+            args
+        });
+    }
+}

packages/fes-core/src/Service/pluginAPI.js

@@ -0,0 +1,154 @@
+import assert from 'assert';
+import * as utils from '@umijs/utils';
+import { isValidPlugin, pathToObj } from './utils/pluginUtils';
+import { EnableBy, PluginType, ServiceStage } from './enums';
+import Logger from '../logger';
+// TODO
+// 标准化 logger
+export default class PluginAPI {
+    constructor(opts) {
+        this.id = opts.id;
+        this.key = opts.key;
+        this.service = opts.service;
+        this.utils = utils;
+        this.logger = new Logger(`fes:plugin:${this.id || this.key}`);
+    }
+
+    // TODO: reversed keys
+    describe({
+        id,
+        key,
+        config,
+        enableBy
+    } = {}) {
+        const { plugins } = this.service;
+        // this.id and this.key is generated automatically
+        // so we need to diff first
+        if (id && this.id !== id) {
+            if (plugins[id]) {
+                const name = plugins[id].isPreset ? 'preset' : 'plugin';
+                throw new Error(
+                    `api.describe() failed, ${name} ${id} is already registered by ${plugins[id].path}.`,
+                );
+            }
+            plugins[id] = plugins[this.id];
+            plugins[id].id = id;
+            delete plugins[this.id];
+            this.id = id;
+        }
+        if (key && this.key !== key) {
+            this.key = key;
+            plugins[this.id].key = key;
+        }
+
+        if (config) {
+            plugins[this.id].config = config;
+        }
+
+        plugins[this.id].enableBy = enableBy || EnableBy.register;
+    }
+
+    register(hook) {
+        assert(
+            hook.key && typeof hook.key === 'string',
+            `api.register() failed, hook.key must supplied and should be string, but got ${hook.key}.`,
+        );
+        assert(
+            hook.fn && typeof hook.fn === 'function',
+            `api.register() failed, hook.fn must supplied and should be function, but got ${hook.fn}.`,
+        );
+        this.service.hooksByPluginId[this.id] = (
+            this.service.hooksByPluginId[this.id] || []
+        ).concat(hook);
+    }
+
+    registerCommand(command) {
+        const { name, alias } = command;
+        assert(
+            !this.service.commands[name],
+            `api.registerCommand() failed, the command ${name} is exists.`,
+        );
+        this.service.commands[name] = command;
+        if (alias) {
+            this.service.commands[alias] = name;
+        }
+    }
+
+    // 在 preset 初始化阶段放后面，在插件注册阶段放前面
+    registerPlugins(plugins) {
+        assert(
+            this.service.stage === ServiceStage.initPresets
+        || this.service.stage === ServiceStage.initPlugins,
+            'api.registerPlugins() failed, it should only be used in registering stage.',
+        );
+        assert(
+            Array.isArray(plugins),
+            'api.registerPlugins() failed, plugins must be Array.',
+        );
+        const extraPlugins = plugins.map(plugin => (isValidPlugin(plugin)
+            ? (plugin)
+            : pathToObj({
+                type: PluginType.plugin,
+                path: plugin,
+                cwd: this.service.cwd
+            })));
+        if (this.service.stage === ServiceStage.initPresets) {
+            this.service._extraPlugins.push(...extraPlugins);
+        } else {
+            this.service._extraPlugins.splice(0, 0, ...extraPlugins);
+        }
+    }
+
+    registerPresets(presets) {
+        assert(
+            this.service.stage === ServiceStage.initPresets,
+            'api.registerPresets() failed, it should only used in presets.',
+        );
+        assert(
+            Array.isArray(presets),
+            'api.registerPresets() failed, presets must be Array.',
+        );
+        const extraPresets = presets.map(preset => (isValidPlugin(preset)
+            ? (preset)
+            : pathToObj({
+                type: PluginType.preset,
+                path: preset,
+                cwd: this.service.cwd
+            })));
+        // 插到最前面，下个 while 循环优先执行
+        this.service._extraPresets.splice(0, 0, ...extraPresets);
+    }
+
+    registerMethod({
+        name,
+        fn,
+        exitsError = true
+    }) {
+        if (this.service.pluginMethods[name]) {
+            if (exitsError) {
+                throw new Error(
+                    `api.registerMethod() failed, method ${name} is already exist.`,
+                );
+            } else {
+                return;
+            }
+        }
+        this.service.pluginMethods[name] = fn
+      // 这里不能用 arrow function，this 需指向执行此方法的 PluginAPI
+      // 否则 pluginId 会不会，导致不能正确 skip plugin
+      || function (hookFn) {
+          const hook = {
+              key: name,
+              ...(utils.lodash.isPlainObject(hookFn) ? hookFn : { fn: hookFn })
+          };
+          // @ts-ignore
+          this.register(hook);
+      };
+    }
+
+    skipPlugins(pluginIds) {
+        pluginIds.forEach((pluginId) => {
+            this.service.skipPluginIds.add(pluginId);
+        });
+    }
+}

packages/fes-core/src/Service/utils/pluginUtils.js

@@ -9,27 +9,37 @@ import {
     lodash
 } from '@umijs/utils';
 
+import { PluginType } from '../enums';
+
 const RE = {
-    plugin: /^(@webank\/)?fes-plugin-/
+    [PluginType.plugin]: /^(@webank\/)?fes-plugin-/,
+    [PluginType.preset]: /^(@webank\/)?fes-preset-/
 };
 
-export function isPlugin(name) {
+export function isPluginOrPreset(type, name) {
     const hasScope = name.charAt(0) === '@';
-    const re = RE.plugin;
+    const re = RE[type];
     if (hasScope) {
         return re.test(name.split('/')[1]) || re.test(name);
     }
     return re.test(name);
 }
 
-export function getPlugins(opts) {
+export function getPluginsOrPresets(type, opts) {
+    const upperCaseType = type.toUpperCase();
     return [
         // dependencies
-        ...opts.plugins,
+        // opts
+        ...((opts[type === PluginType.preset ? 'presets' : 'plugins']) || []),
+        // env
+        ...(process.env[`FES_${upperCaseType}S`] || '').split(',').filter(Boolean),
         ...Object.keys(opts.pkg.devDependencies || {})
             .concat(Object.keys(opts.pkg.dependencies || {}))
-            .filter(isPlugin.bind(null)),
-        ...opts.userConfigPlugins
+            .filter(isPluginOrPreset.bind(null, type)),
+        // user config
+        ...((opts[
+            type === PluginType.preset ? 'userConfigPresets' : 'userConfigPlugins'
+        ]) || [])
     ].map(path => resolve.sync(path, {
         basedir: opts.cwd,
         extensions: ['.js', '.ts']
@@ -46,14 +56,14 @@ function nameToKey(name) {
         .join('.');
 }
 
-function pkgNameToKey(pkgName) {
+function pkgNameToKey(pkgName, type) {
     if (pkgName.charAt(0) === '@' && !pkgName.startsWith('@webank/')) {
         pkgName = pkgName.split('/')[1];
     }
-    return nameToKey(pkgName.replace(RE.plugin, ''));
+    return nameToKey(pkgName.replace(RE[type], ''));
 }
 
-export function pathToObj({ path, cwd }) {
+export function pathToObj({ path, type, cwd }) {
     let pkg = null;
     let isPkgPlugin = false;
     const pkgJSONPath = pkgUp.sync({ cwd: path });
@@ -74,11 +84,11 @@ export function pathToObj({ path, cwd }) {
     } else {
         id = winPath(path);
     }
-    id = id.replace('@webank/fes-plugin-built-in/lib/plugins', '@@');
+    id = id.replace('@webank/fes-preset-built-in/lib/plugins', '@@');
     id = id.replace(/\.js$/, '');
 
     const key = isPkgPlugin
-        ? pkgNameToKey(pkg.name)
+        ? pkgNameToKey(pkg.name, type)
         : nameToKey(basename(path, extname(path)));
 
     return {
@@ -100,10 +110,22 @@ export function pathToObj({ path, cwd }) {
     };
 }
 
+export function resolvePresets(opts) {
+    const type = PluginType.preset;
+    const presets = [...getPluginsOrPresets(type, opts)];
+    return presets.map(path => pathToObj({
+        type,
+        path,
+        cwd: opts.cwd
+    }));
+}
+
 export function resolvePlugins(opts) {
-    const plugins = getPlugins(opts);
+    const type = PluginType.plugin;
+    const plugins = getPluginsOrPresets(type, opts);
     return plugins.map(path => pathToObj({
         path,
+        type,
         cwd: opts.cwd
     }));
 }