@umijs/core 4.0.0-beta.1 → 4.0.0-beta.2

package/dist/config/config.d.ts

@@ -30,7 +30,7 @@ export declare class Config {
             data: ReturnType<typeof Config.diffConfigs>;
             event: string;
             path: string;
-        }) => void;
+        }) => Promise<void>;
     }): () => Promise<void>;
     static getMainConfigFile(opts: {
         cwd: string;

package/dist/config/config.js

@@ -66,10 +66,14 @@ class Config {
                 updated,
                 onChangeTypes: opts.onChangeTypes,
             });
-            opts.onChange({
+            opts
+                .onChange({
                 data,
                 event,
                 path,
+            })
+                .catch((e) => {
+                throw new Error(e);
             });
         }, constants_1.WATCH_DEBOUNCE_STEP));
         return () => watcher.close();

package/dist/index.d.ts

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

package/dist/index.js

@@ -10,9 +10,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Env = void 0;
+exports.Env = exports.GeneratorType = void 0;
 __exportStar(require("./config/config"), exports);
 __exportStar(require("./route/route"), exports);
+var generator_1 = require("./service/generator");
+Object.defineProperty(exports, "GeneratorType", { enumerable: true, get: function () { return generator_1.GeneratorType; } });
 __exportStar(require("./service/pluginAPI"), exports);
 __exportStar(require("./service/service"), exports);
 var types_1 = require("./types");

package/dist/service/generatePlugin.d.ts

@@ -0,0 +1,4 @@
+import { PluginAPI } from './pluginAPI';
+import { IServicePluginAPI } from './service';
+declare const _default: (api: PluginAPI & IServicePluginAPI) => void;
+export default _default;

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/pluginAPI.d.ts

@@ -1,5 +1,6 @@
 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';
@@ -18,6 +19,7 @@ export declare class PluginAPI {
     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;

package/dist/service/pluginAPI.js

@@ -8,6 +8,7 @@ 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");
@@ -38,6 +39,12 @@ class PluginAPI {
             });
         }
     }
+    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] = []);

package/dist/service/service.d.ts

@@ -2,6 +2,7 @@ import { yParser } from '@umijs/utils';
 import { Config } from '../config/config';
 import { ApplyPluginsType, ConfigChangeType, EnableBy, Env, IEvent, IModify, ServiceStage } from '../types';
 import { Command } from './command';
+import { Generator } from './generator';
 import { Hook } from './hook';
 import { Plugin } from './plugin';
 interface IOpts {
@@ -17,6 +18,7 @@ export declare class Service {
     appData: Record<string, any>;
     args: yParser.Arguments;
     commands: Record<string, Command>;
+    generators: Record<string, Generator>;
     config: Record<string, any>;
     configSchemas: Record<string, any>;
     configDefaults: Record<string, any>;
@@ -49,7 +51,7 @@ export declare class Service {
         type?: ApplyPluginsType;
         initialValue?: any;
         args?: any;
-    }): Promise<T>;
+    }): Promise<typeof opts.initialValue | T>;
     run(opts: {
         name: string;
         args?: any;
@@ -72,6 +74,7 @@ export interface IServicePluginAPI {
     args: typeof Service.prototype.args;
     config: typeof Service.prototype.config;
     cwd: typeof Service.prototype.cwd;
+    generators: typeof Service.prototype.generators;
     pkg: typeof Service.prototype.pkg;
     name: typeof Service.prototype.name;
     paths: Required<typeof Service.prototype.paths>;

package/dist/service/service.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __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) {
@@ -36,7 +17,6 @@ const utils_1 = require("@umijs/utils");
 const assert_1 = __importDefault(require("assert"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const process = __importStar(require("process"));
 const tapable_1 = require("../../compiled/tapable");
 const config_1 = require("../config/config");
 const constants_1 = require("../constants");
@@ -51,6 +31,7 @@ class Service {
         this.appData = {};
         this.args = { _: [], $0: '' };
         this.commands = {};
+        this.generators = {};
         this.config = {};
         this.configSchemas = {};
         this.configDefaults = {};
@@ -180,7 +161,7 @@ class Service {
             const { plugins, presets } = plugin_1.Plugin.getPluginsAndPresets({
                 cwd: this.cwd,
                 pkg,
-                plugins: this.opts.plugins || [],
+                plugins: [require.resolve('./generatePlugin')].concat(this.opts.plugins || []),
                 presets: [require.resolve('./servicePlugin')].concat(this.opts.presets || []),
                 userConfig: this.userConfig,
                 prefix: this.opts.frameworkName || constants_1.DEFAULT_FRAMEWORK_NAME,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/core",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -25,8 +25,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@umijs/bundler-utils": "4.0.0-beta.1",
-    "@umijs/utils": "4.0.0-beta.1"
+    "@umijs/bundler-utils": "4.0.0-beta.2",
+    "@umijs/utils": "4.0.0-beta.2"
   },
   "devDependencies": {
     "@hapi/joi": "17.1.1",