@umijs/core 3.5.18 → 4.0.0-beta.2

package/dist/service/generatePlugin.js

@@ -0,0 +1,91 @@
+"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");
+exports.default = (api) => {
+    api.registerCommand({
+        name: 'generate',
+        alias: 'g',
+        details: `
+umi generate
+`,
+        description: 'generate code snippets quickly',
+        fn({ args }) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const [type] = args._;
+                const runGenerator = (generator) => {
+                    generator === null || generator === void 0 ? void 0 : generator.fn({
+                        api,
+                        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, {
+                            api,
+                            args,
+                        }));
+                        if (!enable) {
+                            throw new Error(`Generator ${type} is unable.The corresponding function has been turned on or is not available.`);
+                        }
+                    }
+                    runGenerator(generator);
+                }
+                else {
+                    const getEnableGenerators = (generators) => __awaiter(this, void 0, void 0, function* () {
+                        const questions = [];
+                        Object.keys(generators).forEach((key) => __awaiter(this, void 0, void 0, function* () {
+                            var _b, _c;
+                            if (generators[key].type === generator_1.GeneratorType.generate) {
+                                questions.push({
+                                    title: `${generators[key].name} -- ${generators[key].description}` ||
+                                        '',
+                                    value: generators[key].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, {
+                                    api,
+                                    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,
+                    });
+                    runGenerator(api.service.generators[gType]);
+                }
+            });
+        },
+    });
+};

package/dist/service/generator.d.ts

@@ -0,0 +1,60 @@
+import { prompts } from '@umijs/utils';
+import { Plugin } from './plugin';
+import { PluginAPI } from './pluginAPI';
+import { IServicePluginAPI } from './service';
+export declare enum GeneratorType {
+    generate = "generate",
+    enable = "enable"
+}
+export interface IGeneratorOpts {
+    key: string;
+    name?: string;
+    description?: string;
+    type?: GeneratorType;
+    checkEnable?: {
+        (opts: {
+            args: any;
+            api: PluginAPI & IServicePluginAPI;
+        }): boolean;
+    };
+    fn: {
+        (opts: {
+            args: any;
+            api: PluginAPI & IServicePluginAPI;
+            generateFile: {
+                (opts: {
+                    path: string;
+                    target: string;
+                    data?: any;
+                    questions?: prompts.PromptObject[];
+                }): void;
+            };
+            updatePackageJSON: {
+                (opts: {
+                    opts: object;
+                    cwd?: string;
+                }): void;
+            };
+            installDeps: {
+                (opts: {
+                    opts: {
+                        devDependencies?: string[];
+                        dependencies?: string[];
+                    };
+                    cwd?: string;
+                }): void;
+            };
+        }): 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);
+}

package/dist/service/generator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = 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;
+    }
+}
+exports.Generator = Generator;

package/dist/service/hook.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from './plugin';
+export interface IOpts {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+}
+export declare class Hook {
+    plugin: Plugin;
+    key: string;
+    fn: Function;
+    before?: string;
+    stage?: number;
+    constructor(opts: IOpts);
+}

package/dist/service/hook.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const assert_1 = __importDefault(require("assert"));
+class Hook {
+    constructor(opts) {
+        (0, assert_1.default)(opts.key && opts.fn, `Invalid hook ${opts}, key and fn must supplied.`);
+        this.plugin = opts.plugin;
+        this.key = opts.key;
+        this.fn = opts.fn;
+        this.before = opts.before;
+        this.stage = opts.stage || 0;
+    }
+}
+exports.Hook = Hook;

package/dist/service/path.d.ts

@@ -0,0 +1,13 @@
+import { Env } from '../types';
+export declare function getPaths(opts: {
+    cwd: string;
+    prefix: string;
+    env: Env;
+}): {
+    cwd: string;
+    absSrcPath: string;
+    absPagesPath: string;
+    absTmpPath: string;
+    absNodeModulesPath: string;
+    absOutputPath: string;
+};

package/dist/service/path.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaths = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const types_1 = require("../types");
+function winJoin(...args) {
+    return (0, utils_1.winPath)((0, path_1.join)(...args));
+}
+function getPaths(opts) {
+    const cwd = opts.cwd;
+    const src = winJoin(cwd, 'src');
+    const absSrcPath = (0, fs_1.existsSync)(src) && (0, fs_1.statSync)(src).isDirectory() ? src : cwd;
+    const absPagesPath = winJoin(absSrcPath, 'pages');
+    const tmp = opts.env === types_1.Env.development
+        ? `.${opts.prefix}`
+        : `.${opts.prefix}-${opts.env}`;
+    const absTmpPath = winJoin(absSrcPath, tmp);
+    const absNodeModulesPath = winJoin(cwd, 'node_modules');
+    const absOutputPath = winJoin(cwd, 'dist');
+    return {
+        cwd,
+        absSrcPath,
+        absPagesPath,
+        absTmpPath,
+        absNodeModulesPath,
+        absOutputPath,
+    };
+}
+exports.getPaths = getPaths;

package/dist/service/plugin.d.ts

@@ -0,0 +1,53 @@
+import { EnableBy, IPluginConfig } from '../types';
+declare type PluginType = 'plugin' | 'preset';
+interface IOpts {
+    path: string;
+    cwd: string;
+    type: PluginType;
+}
+export interface IPluginObject {
+    id: string;
+    key: string;
+    apply?: Function;
+    config?: IPluginConfig;
+    enableBy?: EnableBy | (() => boolean);
+}
+export declare class Plugin {
+    private cwd;
+    type: PluginType;
+    path: string;
+    id: string;
+    key: string;
+    apply: Function;
+    config: IPluginConfig;
+    enableBy: EnableBy | (() => boolean);
+    constructor(opts: IOpts);
+    merge(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: EnableBy | (() => boolean);
+    }): void;
+    getId(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+        pkgJSONPath: string | null;
+    }): any;
+    getKey(opts: {
+        pkg: any;
+        isPkgEntry: boolean;
+    }): string;
+    static isPluginOrPreset(type: 'plugin' | 'preset', name: string): boolean;
+    static stripNoneUmiScope(name: string): string;
+    static getPluginsAndPresets(opts: {
+        cwd: string;
+        pkg: any;
+        userConfig: any;
+        plugins?: string[];
+        presets?: string[];
+        prefix: string;
+    }): {
+        presets: Plugin[];
+        plugins: Plugin[];
+    };
+}
+export {};

package/dist/service/plugin.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const types_1 = require("../types");
+const RE = {
+    plugin: /^(@umijs\/|umi-)plugin-/,
+    preset: /^(@umijs\/|umi-)preset-/,
+};
+class Plugin {
+    constructor(opts) {
+        this.config = {};
+        this.enableBy = types_1.EnableBy.register;
+        this.type = opts.type;
+        this.path = (0, utils_1.winPath)(opts.path);
+        this.cwd = opts.cwd;
+        (0, assert_1.default)((0, fs_1.existsSync)(this.path), `Invalid ${this.type} ${this.path}, it's not exists.`);
+        let pkg = null;
+        // path is the package entry
+        let isPkgEntry = false;
+        const pkgJSONPath = utils_1.pkgUp.sync({ cwd: this.path });
+        if (pkgJSONPath) {
+            pkg = require(pkgJSONPath);
+            isPkgEntry =
+                (0, utils_1.winPath)((0, path_1.join)((0, path_1.dirname)(pkgJSONPath), pkg.main || 'index.js')) ===
+                    (0, utils_1.winPath)(this.path);
+        }
+        this.id = this.getId({ pkg, isPkgEntry, pkgJSONPath });
+        this.key = this.getKey({ pkg, isPkgEntry });
+        this.apply = () => {
+            try {
+                const ret = require(this.path);
+                // use the default member for es modules
+                return ret.__esModule ? ret.default : ret;
+            }
+            catch (e) {
+                throw new Error(`Register ${this.type} ${this.path} failed, since ${e.message}`);
+            }
+        };
+    }
+    merge(opts) {
+        if (opts.key)
+            this.key = opts.key;
+        if (opts.config)
+            this.config = opts.config;
+        if (opts.enableBy)
+            this.enableBy = opts.enableBy;
+    }
+    getId(opts) {
+        let id;
+        if (opts.isPkgEntry) {
+            id = opts.pkg.name;
+        }
+        else if ((0, utils_1.winPath)(this.path).startsWith((0, utils_1.winPath)(this.cwd))) {
+            id = `./${(0, utils_1.winPath)((0, path_1.relative)(this.cwd, this.path))}`;
+        }
+        else if (opts.pkgJSONPath) {
+            id = (0, utils_1.winPath)((0, path_1.join)(opts.pkg.name, (0, path_1.relative)((0, path_1.dirname)(opts.pkgJSONPath), this.path)));
+        }
+        else {
+            id = (0, utils_1.winPath)(this.path);
+        }
+        id = id.replace('@umijs/preset-built-in/lib/plugins', '@@');
+        id = id.replace(/\.js$/, '');
+        return id;
+    }
+    getKey(opts) {
+        // e.g.
+        // initial-state -> initialState
+        // webpack.css-loader -> webpack.cssLoader
+        function nameToKey(name) {
+            return name
+                .split('.')
+                .map((part) => utils_1.lodash.camelCase(part))
+                .join('.');
+        }
+        return nameToKey(opts.isPkgEntry
+            ? Plugin.stripNoneUmiScope(opts.pkg.name).replace(RE[this.type], '')
+            : (0, path_1.basename)(this.path, (0, path_1.extname)(this.path)));
+    }
+    static isPluginOrPreset(type, name) {
+        return RE[type].test(Plugin.stripNoneUmiScope(name));
+    }
+    static stripNoneUmiScope(name) {
+        if (name.charAt(0) === '@' && !name.startsWith('@umijs/')) {
+            name = name.split('/')[1];
+        }
+        return name;
+    }
+    static getPluginsAndPresets(opts) {
+        function get(type) {
+            const types = `${type}s`;
+            return [
+                // opts
+                ...(opts[types] || []),
+                // env
+                ...(process.env[`${opts.prefix}_${types}`.toUpperCase()] || '')
+                    .split(',')
+                    .filter(Boolean),
+                // dependencies
+                ...Object.keys(opts.pkg.devDependencies || {})
+                    .concat(Object.keys(opts.pkg.dependencies || {}))
+                    .filter(Plugin.isPluginOrPreset.bind(null, type)),
+                // user config
+                ...(opts.userConfig[types] || []),
+            ].map((path) => {
+                (0, assert_1.default)(typeof path === 'string', `Invalid plugin ${path}, it must be string.`);
+                let resolved;
+                try {
+                    resolved = utils_1.resolve.sync(path, {
+                        basedir: opts.cwd,
+                        extensions: ['.tsx', '.ts', '.mjs', '.jsx', '.js'],
+                    });
+                }
+                catch (_e) {
+                    throw new Error(`Invalid plugin ${path}, can not be resolved.`);
+                }
+                return new Plugin({
+                    path: resolved,
+                    type,
+                    cwd: opts.cwd,
+                });
+            });
+        }
+        return {
+            presets: get('preset'),
+            plugins: get('plugin'),
+        };
+    }
+}
+exports.Plugin = Plugin;

package/dist/service/pluginAPI.d.ts

@@ -0,0 +1,37 @@
+import { EnableBy, IPluginConfig } from '../types';
+import { IOpts as ICommandOpts } from './command';
+import { IGeneratorOpts } from './generator';
+import { IOpts as IHookOpts } from './hook';
+import { Plugin } from './plugin';
+import { Service } from './service';
+export declare class PluginAPI {
+    service: Service;
+    plugin: Plugin;
+    constructor(opts: {
+        service: Service;
+        plugin: Plugin;
+    });
+    describe(opts: {
+        key?: string;
+        config?: IPluginConfig;
+        enableBy?: EnableBy | (() => boolean);
+    }): void;
+    registerCommand(opts: Omit<ICommandOpts, 'plugin'> & {
+        alias?: string | string[];
+    }): void;
+    registerGenerator(opts: Omit<IGeneratorOpts, 'plugin'>): void;
+    register(opts: Omit<IHookOpts, 'plugin'>): void;
+    registerMethod(opts: {
+        name: string;
+        fn?: Function;
+    }): void;
+    registerPresets(source: Plugin[], presets: any[]): void;
+    registerPlugins(source: Plugin[], plugins: any[]): void;
+    skipPlugins(ids: string[]): void;
+    static proxyPluginAPI(opts: {
+        pluginAPI: PluginAPI;
+        service: Service;
+        serviceProps: string[];
+        staticProps: Record<string, any>;
+    }): PluginAPI;
+}

package/dist/service/pluginAPI.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginAPI = void 0;
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const types_1 = require("../types");
+const command_1 = require("./command");
+const generator_1 = require("./generator");
+const hook_1 = require("./hook");
+const plugin_1 = require("./plugin");
+const utils_2 = require("./utils");
+class PluginAPI {
+    constructor(opts) {
+        this.service = opts.service;
+        this.plugin = opts.plugin;
+        // TODO
+        // logger
+    }
+    describe(opts) {
+        this.plugin.merge(opts);
+    }
+    registerCommand(opts) {
+        const { alias } = opts;
+        delete opts.alias;
+        const registerCommand = (commandOpts) => {
+            var _a;
+            const { name } = commandOpts;
+            (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 }));
+        };
+        registerCommand(opts);
+        if (alias) {
+            const aliases = (0, utils_2.makeArray)(alias);
+            aliases.forEach((alias) => {
+                registerCommand(Object.assign(Object.assign({}, opts), { name: alias }));
+            });
+        }
+    }
+    registerGenerator(opts) {
+        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 }));
+    }
+    register(opts) {
+        var _a, _b;
+        (_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 })));
+    }
+    registerMethod(opts) {
+        (0, assert_1.default)(!this.service.pluginMethods[opts.name], `api.registerMethod() failed, method ${opts.name} is already exist.`);
+        this.service.pluginMethods[opts.name] = {
+            plugin: this.plugin,
+            fn: opts.fn ||
+                ((fn) => {
+                    this.register(Object.assign({ key: opts.name }, (utils_1.lodash.isPlainObject(fn) ? fn : { fn })));
+                }),
+        };
+    }
+    registerPresets(source, presets) {
+        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets, `api.registerPresets() failed, it should only used in presets.`);
+        source.splice(0, 0, ...presets.map((preset) => {
+            return new plugin_1.Plugin({
+                path: preset,
+                cwd: this.service.cwd,
+                type: types_1.PluginType.plugin,
+            });
+        }));
+    }
+    registerPlugins(source, plugins) {
+        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets ||
+            this.service.stage === types_1.ServiceStage.initPlugins, `api.registerPlugins() failed, it should only be used in registering stage.`);
+        const mappedPlugins = plugins.map((plugin) => {
+            if (utils_1.lodash.isPlainObject(plugin)) {
+                (0, assert_1.default)(plugin.id && plugin.key, `Invalid plugin object, id and key must supplied.`);
+                plugin.type = types_1.PluginType.plugin;
+                plugin.enableBy = plugin.enableBy || types_1.EnableBy.register;
+                plugin.apply = plugin.apply || (() => () => { });
+                plugin.config = plugin.config || {};
+                return plugin;
+            }
+            else {
+                return new plugin_1.Plugin({
+                    path: plugin,
+                    cwd: this.service.cwd,
+                    type: types_1.PluginType.plugin,
+                });
+            }
+        });
+        if (this.service.stage === types_1.ServiceStage.initPresets) {
+            source.push(...mappedPlugins);
+        }
+        else {
+            source.splice(0, 0, ...mappedPlugins);
+        }
+    }
+    skipPlugins(ids) {
+        ids.forEach((id) => {
+            this.service.skipPluginIds.add(id);
+        });
+    }
+    static proxyPluginAPI(opts) {
+        return new Proxy(opts.pluginAPI, {
+            get: (target, prop) => {
+                if (opts.service.pluginMethods[prop]) {
+                    return opts.service.pluginMethods[prop].fn;
+                }
+                if (opts.serviceProps.includes(prop)) {
+                    // @ts-ignore
+                    const serviceProp = opts.service[prop];
+                    return typeof serviceProp === 'function'
+                        ? serviceProp.bind(opts.service)
+                        : serviceProp;
+                }
+                if (prop in opts.staticProps) {
+                    return opts.staticProps[prop];
+                }
+                // @ts-ignore
+                return target[prop];
+            },
+        });
+    }
+}
+exports.PluginAPI = PluginAPI;