@cabloy/cli 1.0.1

package/LICENSE.en-US

@@ -0,0 +1,3 @@
+Copyright (c) 2016-present CabloyJS
+
+CabloyJS 5.0 internal beta version, still under continuous development, not yet open source, please do not spread it

package/LICENSE.zh-CN

@@ -0,0 +1,3 @@
+Copyright (c) 2016-present CabloyJS
+
+CabloyJS 5.0 内测版，仍在持续开发中，尚未开源，请勿扩散

package/README.md

@@ -0,0 +1 @@
+# @cabloy/cli

package/dist/bin/cabloy.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cabloy.d.ts.map

package/dist/bin/cabloy.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const start_js_1 = require("../start.js");
+new start_js_1.CabloyCommand().start();
+//# sourceMappingURL=cabloy.js.map

package/dist/config.d.ts

@@ -0,0 +1,43 @@
+export declare const commandsConfig: {
+    sets: {
+        core: string;
+        api: string;
+        front: string;
+    };
+    helper: {
+        chalk: {
+            options: {
+                level: number;
+            };
+        };
+        boxen: {
+            options: {
+                padding: number;
+                margin: number;
+                align: string;
+                borderColor: string;
+                borderStyle: string;
+            };
+        };
+    };
+    template: {
+        render: {
+            fileMapping: {
+                gitignore: string;
+                _gitignore: string;
+                '_.gitignore': string;
+                '_package.json': string;
+                '_.eslintrc': string;
+                '_.eslintignore': string;
+                '_.npmignore': string;
+                '_.eslintrc.js': string;
+                '_jsconfig.json': string;
+                '_tsconfig.json': string;
+                '_tsconfig.base.json': string;
+                '_tsconfig.build.json': string;
+            };
+            ignore: string[];
+        };
+    };
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandsConfig = void 0;
+exports.commandsConfig = {
+    sets: {
+        core: '@cabloy/cli-set-core',
+        api: '@cabloy/cli-set-api',
+        front: '@cabloy/cli-set-front',
+    },
+    helper: {
+        chalk: {
+            options: { level: 2 },
+        },
+        boxen: {
+            options: { padding: 1, margin: 1, align: 'center', borderColor: 'yellow', borderStyle: 'round' },
+        },
+    },
+    template: {
+        render: {
+            fileMapping: {
+                gitignore: '.gitignore',
+                _gitignore: '.gitignore',
+                '_.gitignore': '.gitignore',
+                '_package.json': 'package.json',
+                '_.eslintrc': '.eslintrc',
+                '_.eslintignore': '.eslintignore',
+                '_.npmignore': '.npmignore',
+                '_.eslintrc.js': '.eslintrc.js',
+                '_jsconfig.json': 'jsconfig.json',
+                '_tsconfig.json': 'tsconfig.json',
+                '_tsconfig.base.json': 'tsconfig.base.json',
+                '_tsconfig.build.json': 'tsconfig.build.json',
+            },
+            ignore: ['.DS_Store'],
+        },
+    },
+};
+//# sourceMappingURL=config.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types/index.js';
+export * from './start.js';
+export * from './lib/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./start.js"), exports);
+__exportStar(require("./lib/index.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/bean.cli.base.d.ts

@@ -0,0 +1,34 @@
+import { glob } from '@cabloy/module-glob';
+import { LocalConsole } from './local.console.js';
+import { LocalHelper } from './local.helper.js';
+import { LocalTemplate } from './local.template.js';
+import { CmdOptions } from '../types/argv.js';
+import { TypeProjectMode } from '@cabloy/module-info';
+export declare class BeanCliBase {
+    options: CmdOptions;
+    terminal: any;
+    __console: LocalConsole;
+    __helper: LocalHelper;
+    __template: LocalTemplate;
+    modulesMeta: Awaited<ReturnType<typeof glob>>;
+    constructor(options: CmdOptions);
+    get console(): LocalConsole;
+    get helper(): LocalHelper;
+    get template(): LocalTemplate;
+    get context(): import("../types/argv.js").ICommandContext;
+    get cliFullName(): string;
+    meta(): Promise<any>;
+    execute(): Promise<any>;
+    _loadModulesMeta(projectMode?: TypeProjectMode): Promise<void>;
+    _commandMeta(): any;
+    _commandMeta_groups({ groups }: any): any;
+    _commandMeta_group({ group }: any): {
+        description: any;
+        condition: any;
+        questions: {};
+    };
+    _commandMeta_options({ options }: any): any;
+    _commandMeta_info({ info, argv }: any): any;
+    _commandMeta_info_welcomes({ info }: any): any;
+}
+//# sourceMappingURL=bean.cli.base.d.ts.map

package/dist/lib/bean.cli.base.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanCliBase = void 0;
+const module_glob_1 = require("@cabloy/module-glob");
+const local_console_js_1 = require("./local.console.js");
+const local_helper_js_1 = require("./local.helper.js");
+const local_template_js_1 = require("./local.template.js");
+class BeanCliBase {
+    constructor(options) {
+        this.options = options;
+        this.terminal = options.terminal !== false;
+    }
+    get console() {
+        if (!this.__console) {
+            this.__console = new local_console_js_1.LocalConsole(this);
+        }
+        return this.__console;
+    }
+    get helper() {
+        if (!this.__helper) {
+            this.__helper = new local_helper_js_1.LocalHelper(this);
+        }
+        return this.__helper;
+    }
+    get template() {
+        if (!this.__template) {
+            this.__template = new local_template_js_1.LocalTemplate(this);
+        }
+        return this.__template;
+    }
+    get context() {
+        return this.options.context;
+    }
+    get cliFullName() {
+        return this.options.context.argv.cliFullName;
+    }
+    async meta() {
+        await this._loadModulesMeta();
+        const metaLocale = this._commandMeta();
+        return metaLocale;
+    }
+    async execute() {
+        await this._loadModulesMeta();
+    }
+    async _loadModulesMeta(projectMode) {
+        //
+        if (this.modulesMeta)
+            return;
+        //
+        if (!projectMode) {
+            if (this.cliFullName.indexOf('api:') === 0) {
+                projectMode = 'api';
+            }
+            else if (this.cliFullName.indexOf('front:') === 0) {
+                projectMode = 'front';
+            }
+        }
+        if (!projectMode)
+            return;
+        // all modules
+        this.modulesMeta = await (0, module_glob_1.glob)({
+            projectPath: this.context.argv.projectPath,
+            disabledModules: undefined,
+            disabledSuites: undefined,
+            log: false,
+            projectMode,
+            loadPackage: false,
+        });
+    }
+    _commandMeta() {
+        const { command } = this.options;
+        const { argv } = this.context;
+        const meta = {};
+        meta.info = this._commandMeta_info({ info: command.info, argv });
+        meta.options = this._commandMeta_options({ options: command.options, argv });
+        meta.groups = this._commandMeta_groups({ groups: command.groups, argv });
+        return meta;
+    }
+    _commandMeta_groups({ groups }) {
+        const metaGroups = {};
+        if (groups) {
+            for (const groupName in groups) {
+                const group = groups[groupName];
+                metaGroups[groupName] = this._commandMeta_group({ group });
+            }
+        }
+        return metaGroups;
+    }
+    _commandMeta_group({ group }) {
+        const metaGroup = {
+            description: group.description,
+            condition: group.condition,
+            questions: {},
+        };
+        for (const key in group.questions) {
+            const question = group.questions[key];
+            metaGroup.questions[key] = {
+                ...question,
+                message: question.message,
+            };
+        }
+        return metaGroup;
+    }
+    _commandMeta_options({ options }) {
+        const metaOptions = {};
+        if (options) {
+            for (const key in options) {
+                const option = options[key];
+                metaOptions[key] = {
+                    ...option,
+                    description: option.description,
+                };
+            }
+        }
+        return metaOptions;
+    }
+    _commandMeta_info({ info, argv }) {
+        // info
+        const metaInfo = {
+            version: info.version,
+            title: info.title,
+            usage: info.usage,
+        };
+        // usage
+        if (!metaInfo.usage) {
+            metaInfo.usage = `${'Usage'}: npm run cli ${argv.cliFullName} -- [options] [-h] [-v] [-t]`;
+        }
+        // welcomes
+        metaInfo.welcomes = this._commandMeta_info_welcomes({ info });
+        // ok
+        return metaInfo;
+    }
+    _commandMeta_info_welcomes({ info }) {
+        let welcomes = info.welcomes || [];
+        if (!Array.isArray(welcomes))
+            welcomes = [welcomes];
+        welcomes = welcomes.map(item => item);
+        return welcomes;
+    }
+}
+exports.BeanCliBase = BeanCliBase;
+//# sourceMappingURL=bean.cli.base.js.map

package/dist/lib/bean.cli.d.ts

@@ -0,0 +1,16 @@
+import { ICommandContext } from '../types/argv.js';
+export declare class BeanCli {
+    meta({ context }: {
+        context: ICommandContext;
+    }): Promise<any>;
+    execute({ context }: {
+        context: ICommandContext;
+    }): Promise<void>;
+    _findCliCommand({ cliFullName }: {
+        cliFullName: string;
+    }): {
+        command: any;
+        BeanClass: any;
+    };
+}
+//# sourceMappingURL=bean.cli.d.ts.map

package/dist/lib/bean.cli.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanCli = void 0;
+const commands_js_1 = require("./commands.js");
+class BeanCli {
+    async meta({ context }) {
+        // command
+        const { argv } = context;
+        const cliFullName = argv.cliFullName;
+        const { command, BeanClass } = await this._findCliCommand({ cliFullName });
+        // command bean
+        const beanCommand = new BeanClass({ command, context, terminal: false });
+        if (!beanCommand)
+            throw new Error(`cli command bean not found: ${command.beanFullName}`);
+        // meta
+        return await beanCommand.meta();
+    }
+    async execute({ context }) {
+        // command
+        const { argv } = context;
+        const cliFullName = argv.cliFullName;
+        const { command, BeanClass } = await this._findCliCommand({ cliFullName });
+        // command bean
+        const beanCommand = new BeanClass({ command, context, terminal: false });
+        if (!beanCommand)
+            throw new Error(`cli command bean not found: ${command.beanFullName}`);
+        // execute
+        await beanCommand.execute();
+    }
+    _findCliCommand({ cliFullName }) {
+        const { command, BeanClass } = (0, commands_js_1.findCommand)(cliFullName);
+        if (!command)
+            throw new Error(`cli command not found: ${cliFullName}`);
+        return { command, BeanClass };
+    }
+}
+exports.BeanCli = BeanCli;
+//# sourceMappingURL=bean.cli.js.map

package/dist/lib/cli.d.ts

@@ -0,0 +1,53 @@
+export class CliCommand extends BaseCommand {
+    constructor(rawArgv: any, { meta, argv }: {
+        meta: any;
+        argv: any;
+    });
+    usage: any;
+    version: any;
+    options: any;
+    __meta: any;
+    __groups: any;
+    __argv: any;
+    __cabloyConfig: any;
+    cabloyConfig: any;
+    run({ argv, cwd, env, rawArgv }: {
+        argv: any;
+        cwd: any;
+        env: any;
+        rawArgv: any;
+    }): Promise<void>;
+    _getMetaWelcomes(): any;
+    _logMetaWelcomes(): void;
+    _logCliDocs(): void;
+    _adjustEnv({ env }: {
+        env: any;
+    }): {};
+    _promptGroups({ context, groups }: {
+        context: any;
+        groups: any;
+    }): Promise<void>;
+    _promptGroup({ group, context }: {
+        group: any;
+        context: any;
+    }): Promise<void>;
+    _prepareQuestionPropertyExpression({ group, question, key, context, propName }: {
+        group: any;
+        question: any;
+        key: any;
+        context: any;
+        propName: any;
+    }): ((value: any) => any) | null;
+    _prepareQuestion({ group, question, key, context }: {
+        group: any;
+        question: any;
+        key: any;
+        context: any;
+    }): any;
+    _checkGroupCondition({ group, context }: {
+        group: any;
+        context: any;
+    }): any;
+}
+import BaseCommand from '@zhennann/common-bin';
+//# sourceMappingURL=cli.d.ts.map

package/dist/lib/cli.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliCommand = void 0;
+const is_type_of_1 = __importDefault(require("is-type-of"));
+const chalk_1 = __importDefault(require("chalk"));
+const enquirer_1 = __importDefault(require("enquirer"));
+const egg_born_utils_1 = __importDefault(require("egg-born-utils"));
+const common_bin_1 = __importDefault(require("@zhennann/common-bin"));
+const bean_cli_js_1 = require("./bean.cli.js");
+const __envFields = ['TERM', 'TERM_PROGRAM', 'TERM_PROGRAM_VERSION', 'SHELL', 'COLOR', 'LANG', 'npm_config_registry'];
+const __comment_seperator = '====================================================================';
+class CliCommand extends common_bin_1.default {
+    constructor(rawArgv, { meta, argv }) {
+        super(rawArgv);
+        this.usage = meta.info.usage;
+        this.version = meta.info.version;
+        this.options = meta.options;
+        this.__meta = meta;
+        this.__groups = meta.groups;
+        this.__argv = argv;
+        this.__cabloyConfig = null;
+        this.cabloyConfig = null;
+    }
+    async run({ argv, cwd, env, rawArgv }) {
+        // argv
+        argv = Object.assign({}, argv, this.__argv);
+        delete argv.t;
+        delete argv.token;
+        delete argv.$0;
+        // context
+        const context = { argv, cwd, env: this._adjustEnv({ env }), rawArgv };
+        // log start
+        console.log(`cabloy ${chalk_1.default.cyan(argv.cliFullName)} at %s\n`, cwd);
+        // log meta welcomes
+        this._logMetaWelcomes();
+        // prompt
+        await this._promptGroups({ context, groups: this.__groups });
+        // execute
+        const beanCli = new bean_cli_js_1.BeanCli();
+        await beanCli.execute({ context });
+        // done: log cli docs
+        this._logCliDocs();
+        // done
+        console.log(chalk_1.default.cyan('\n  cli successfully!\n'));
+    }
+    _getMetaWelcomes() {
+        let welcomes = this.__meta.info.welcomes;
+        if (!welcomes)
+            return null;
+        if (!Array.isArray(welcomes))
+            welcomes = [welcomes];
+        if (welcomes.length === 0)
+            return null;
+        return welcomes;
+    }
+    _logMetaWelcomes() {
+        const welcomes = this._getMetaWelcomes();
+        if (!welcomes)
+            return;
+        console.log(__comment_seperator);
+        for (const welcome of welcomes) {
+            console.log(welcome);
+        }
+        console.log(__comment_seperator);
+        console.log('');
+    }
+    _logCliDocs() {
+        const welcomes = this._getMetaWelcomes();
+        if (!welcomes)
+            return;
+        const welcome = welcomes[0];
+        if (!welcome || welcome.indexOf('articles/cli-introduce.html') === -1)
+            return;
+        console.log('');
+        console.log(__comment_seperator);
+        console.log(welcome);
+        console.log(__comment_seperator);
+    }
+    _adjustEnv({ env }) {
+        const res = {};
+        for (const field of __envFields) {
+            if (env[field])
+                res[field] = env[field];
+        }
+        return res;
+    }
+    async _promptGroups({ context, groups }) {
+        for (const groupName in groups) {
+            const group = groups[groupName];
+            await this._promptGroup({ group, context });
+        }
+    }
+    async _promptGroup({ group, context }) {
+        const { argv } = context;
+        // check
+        const check = this._checkGroupCondition({ group, context });
+        if (!check)
+            return;
+        // prepare
+        const varsWant = [];
+        for (const key in group.questions) {
+            const value = argv[key];
+            if (value !== undefined)
+                continue;
+            const question = group.questions[key];
+            const varWant = this._prepareQuestion({ group, question, key, context });
+            if (varWant) {
+                varsWant.push(varWant);
+            }
+        }
+        if (varsWant.length === 0)
+            return;
+        // log description
+        if (group.description) {
+            console.log('===>', group.description);
+        }
+        // prompt
+        await enquirer_1.default.prompt(varsWant);
+    }
+    _prepareQuestionPropertyExpression({ group, question, key, context, propName }) {
+        // expression
+        const expression = question[propName] && question[propName].expression;
+        if (!expression)
+            return null;
+        return function (value) {
+            return egg_born_utils_1.default.tools.evaluateExpression({ expression, scope: { value, group, question, key, context } });
+        };
+    }
+    _prepareQuestion({ group, question, key, context }) {
+        const { argv } = context;
+        // want
+        const varWant = {
+            name: key,
+            ...question,
+        };
+        // message/skip/initial/format/validate
+        for (const propName of ['message', 'skip', 'initial', 'format', 'validate']) {
+            const propFunction = this._prepareQuestionPropertyExpression({ group, question, key, context, propName });
+            if (propFunction) {
+                varWant[propName] = propFunction;
+            }
+        }
+        // result
+        varWant.result = value => {
+            const propFunction = this._prepareQuestionPropertyExpression({
+                group,
+                question,
+                key,
+                context,
+                propName: 'result',
+            });
+            if (propFunction) {
+                value = propFunction(value);
+            }
+            argv[key] = value;
+            return value;
+        };
+        // required
+        if (question.required) {
+            varWant.validate = value => {
+                if (!value)
+                    return 'Required';
+                return true;
+            };
+        }
+        // silent
+        if (question.silent) {
+            let initial = varWant.initial;
+            if (is_type_of_1.default.function(initial)) {
+                initial = initial();
+            }
+            argv[key] = initial;
+            return null;
+        }
+        // ok
+        return varWant;
+    }
+    _checkGroupCondition({ group, context }) {
+        const expression = group.condition && group.condition.expression;
+        if (!expression)
+            return true;
+        return egg_born_utils_1.default.tools.evaluateExpression({ expression, scope: { group, context } });
+    }
+}
+exports.CliCommand = CliCommand;
+//# sourceMappingURL=cli.js.map

package/dist/lib/commands.d.ts

@@ -0,0 +1,6 @@
+export declare const commandsMeta: {
+    commandsMap: any;
+    commandsAll: any;
+};
+export declare function findCommand(cliFullName: string): any;
+//# sourceMappingURL=commands.d.ts.map

package/dist/lib/commands.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCommand = exports.commandsMeta = void 0;
+const config_js_1 = require("../config.js");
+let __commandsMap;
+let __commandsAll;
+function _collectCommands() {
+    const _commandsMap = {};
+    const _commandsAll = {};
+    const sets = config_js_1.commandsConfig.sets;
+    for (const setName in sets) {
+        const setModuleName = sets[setName];
+        const setModule = require(setModuleName);
+        const commands = setModule.commands;
+        if (!commands)
+            continue;
+        const _commandsSet = (_commandsAll[setName] = {});
+        for (const groupName in commands) {
+            const group = commands[groupName];
+            const _commandsGroup = (_commandsSet[groupName] = {});
+            for (const key in group) {
+                const command = group[key];
+                const fullKey = `${setName}:${groupName}:${key}`;
+                // command BeanClass
+                const BeanClass = setModule.beans[command.bean];
+                // ok
+                _commandsMap[fullKey] = _commandsGroup[key] = { command, BeanClass };
+            }
+        }
+    }
+    // ok
+    __commandsMap = _commandsMap;
+    __commandsAll = _commandsAll;
+}
+_collectCommands();
+exports.commandsMeta = { commandsMap: __commandsMap, commandsAll: __commandsAll };
+function findCommand(cliFullName) {
+    return __commandsMap[cliFullName];
+}
+exports.findCommand = findCommand;
+//# sourceMappingURL=commands.js.map

package/dist/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bean.cli.base.js';
+export * from './commands.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bean.cli.base.js"), exports);
+__exportStar(require("./commands.js"), exports);
+//# sourceMappingURL=index.js.map