cnelf / node-cli-template Goto Github PK

#!/usr/bin/env node

console.log('Hello Node CLI');

which env ---> /usr/bin/env

{
    "bin": {
        "test-cli": "./bin/command.js"
    }
}

#!/usr/bin/env node
const { Command } = require('commander')
const pkginfo = require('pkginfo')
const program = new Command()

program.version(pkginfo.version, '-v, --version', '@calmer/terminal-cli 当前版本')

// ⭐ 注册主命令相关选项
program
  // .description('命令描述') // 命令描述
  .option('-d, --dir <dirname>', '带参选项描述', '选项默认值') // 带参选项（选项全称 取值时转成驼峰写法），支持设置默认值
  .option('-c, --copy', '布尔选项描述') // 布尔选项（区别于 选项全称后有没有 <xxx>），指令中-c，选项copy属性值为true
  .option('-rm, --remove <dirname...>', '带参选项描述') // 数组参数必填，指令中多个参数空格分割，不支持设置默认值
  .option('-i, --ip [dirname...]', '带参选项描述') // 数组参数，非必填(不填值为true)，指令中多个参数空格分割，不支持设置默认值
  .action(async (options: object) => {
    console.log('action', options) // option.dir   option.copy
  })

// 解析用户执行命令传入的参数
program.parse(process.argv)

/*
    命令行输入option方式

    serve -d 80
    serve -d80
    serve --dir 80
    serve --dir=80
*/
// 扩展：如下获取选项对象
program.opts();

program
  .command('gen')
  .description('子命令描述') // 命令描述
  .option('-e, --ele <ddd>', '布尔选项描述') // 选项不能和主命令选项重名，否则为空
  .argument('<argument1Name>', '参数1描述') // 参数，必填
  .argument('<argument2Name>', '参数2描述') // 参数，必填
  /*
        argument 与 option 共存时：参数1为argument，参数2为option；否则参数1是argument或option
        添加多个argument时，依次为action的参数1、参数2、参数3
    */
  .action(async (argument1Name: string, argument2Name: string, options: object) => {
    console.log('action', argument1Name, argument2Name, options)
  })

program
  .option('-t, --trace', 'display trace statements for commands')
  /*
        钩子
            preAction   action函数执行前（主+子命令）（thisCommand, actionCommand）
            postAction  action函数执行后（主+子命令）（thisCommand, actionCommand）
            preSubcommand   action命令解析前（子命令）（thisCommand, subcommand）
        参数
            thisCommand主命令，subCommand子命令、actionCommand 触发action的命令，对象API如下
                name()  命令名
                opts()  选项对象
                args    参数、选项的集合，按指令写入顺序以数组方式输出
    */
  .hook(
    'preSubcommand',
    (
      thisCommand: { opts: Function; name: Function },
      actionCommand: { name: Function; opts: Function; args: string[] }
    ) => {
      // 找选项
      console.log('thisCommand', thisCommand.name())
      console.log('actionCommand', actionCommand.name())
    }
  )

program.on('option:dir', function (optionValue: any) {
  console.log('option:dir', optionValue)
})

import inquirer from 'inquirer';


/*
        type 	表单类型
  name	答案变量
  message	提示信息
  default	默认值
*/
inquirer.prompt({
  type: 'input' // 交互组件类型
  name: 'name' // 数据属性名称
  message: '用户名' // 交互提示
  default: '' // 默认值
  choices: '' // 当交互类型为`选择类型`时, 该属性配置可选项目

  // 校验函数, 函数以当前回答为参数。 返回: true 通过 false 不通过,无提示 Error 不通过,显示错误信息
  validate(value){
    return !value.length ? new Error('项目名称不能为空') : true
  }

  // 过滤器, 返回修改后的回答。优先级高于 `validte`
  filter(value){
     return /vue/.test(value) ? `${value}-demo` : value
  }

  // 转换器, 返回转换后的值，只作为显示，不影响收集结果
  transformer(value){
     return /vue/.test(value) ? `${value}-demo` : value
  },

  // 是否显示问题
  when(answers){
     return !!answers.company
  },

  // message 前缀
  prefix: '',

  // message 后缀
  suffix: '',

  // 如果回答已存在, 是否依然提问
  askAnswered: false,
}).then((answers) => {
        // answers.project
}).catch((error) => {
  console.error('出错啦！', error);
});


// 使用方式二
(async () => {
  const { project } = await inquirer.prompt({
    type: 'input',
    name: 'project',
    message: '项目名称',
    default: 'copyLeft',
  });

  console.log(project);
});

inquirer.prompt([{
    type: "confirm",
    message: "是否发送 Kim 通知？",
    name: "confirm",
}, {
    type: "checkbox",
    message: "选择更新类型（可多选）:",
    name: "updateTypes",
    when: function (answers) { // 当confirm为true的时候才会提问当前问题
        return answers.confirm
    },
    choices: [
        "feat（新功能）",
        "fix（修补bug）",
        "docs（更新文档）",
        "style（代码格式优化：不影响代码运行的变动，注意这里指的不是css style）",
        "refactor（重构：即不是新增功能，也不是修改bug的代码变动）",
        "chore（构建优化，工具优化等）",
        "test（增加测试用例，测试代码等）",
        "revert（回滚提交）"
    ],
    validate: (answer) => {
        if (!answer.length) {
            return '请选择更新类型';
        }

        return true;
    },
}]);

inquirer.prompt({
  type: 'input',
  name: 'name',
  message: '请输入',
  default: '默认输入的内容'
})

inquirer.prompt({
  type: 'number',
  name: 'age',
  message: '请输入',
  default: 111
})

inquirer.prompt({
  type: 'password',
  name: 'password',
  message: '请输入',
  default: '密码'
})

inquirer.prompt({
  type: 'list',
  name: 'listAnswer',
  message: '单选',
  choices: [
    { name: '1', value: 1 },
    { name: '2', value: 2 },
    { name: '3', value: 3 }
  ]
})

inquirer.prompt({
  type: 'rawlist',
  name: 'rawlistAnswer',
  message: '列表',
  choices: [
    { name: '1', value: 1 },
    { name: '2', value: 2 },
    { name: '3', value: 3 }
  ]
})

inquirer.prompt({
  type: 'checkbox',
  name: 'checkboxAnswer',
  message: '多选',
  choices: [
    { name: '1', value: 1 },
    { name: '2', value: 2 },
    { name: '3', value: 3 }
  ]
})

inquirer.prompt({
  type: 'confirm',
  name: 'confirmAnswer',
  message: '判断',
})

import inquirer from 'inquirer';
import inquirerPrompt from 'inquirer-autocomplete-prompt';

inquirer.registerPrompt('autocomplete', inquirerPrompt);

inquirer.prompt({
  // @ts-ignore
  type: 'autocomplete',
  name: 'component',
  message: '请选择要开发的组件',
        source: (answersSoFar, input) => {
    return [1, 2].filter(val => val.includes(input))
  },
}).then((answers) => {
  console.log('inquirer-answers', answers);
})

inquirer.prompt([
  {
    type: 'checkbox',
    name: '多选',
    message: 'checkbox',
    choices: [ "Choice A", new inquirer.Separator(), "choice B" ]
  }
])

import ora from 'ora';

const spinner = ora({
  text: "链接网络中"
}).start(); // 开始状态 => 加载状态

setTimeout(() => {
  spinner.color = "yellow";
  spinner.text = "网速有点慢";
}, 1000); // 还是 加载状态, 更新文案和颜色

setTimeout(() => {
  spinner.succeed("下载成功"); // 加载状态 => 成功状态
}, 2000);

import ora from 'ora'

const spinerList = [ // 挑了几个更加图形化的模式
    'timeTravel',
    'speaker',
    'soccerHeader',
    'fistBump',
    'weather',
    'moon',
    'earth',
    'smiley'
]
let index = 0

const spinner = ora({
    prefixText: 'spinnerName：‘timeTravel’',
    spinner: 'timeTravel'
}).start()

setInterval(function () {
    spinner.prefixText = `spinnerName: timeTravel`
    spinner.spinner = spinerList[index]
    index = ++index % spinerList.length;
}, 1500)

const Spinner = require('cli-spinner').Spinner;
const spinner = new Spinner('loading.. %s');
spinner.setSpinnerString('|/-\');

spinner.start()

setTimeout(() => {
    spinner.stop()
}, 3000);

import chalk from 'chalk';

console.log(chalk.blue('Hello world!'));
console.log(chalk.blue.bgRed.bold('Hello world!'));

var ProgressBar = require('progress');

var bar = new ProgressBar(':bar', { total: 10 });
var timer = setInterval(function () {
  bar.tick();
  if (bar.complete) {
    console.log('\ncomplete\n');
    clearInterval(timer);
  }
}, 100);

import Configstore from 'configstore';


const config = new Configstore('name', {foo: 'bar'});
console.log(config.get('foo'));
//=> 'bar'

config.set('awesome', true);
console.log(config.get('awesome'));
//=> true

// Use dot-notation to access nested properties.
config.set('bar.baz', true);
console.log(config.get('bar'));
//=> {baz: true}

config.delete('awesome');
console.log(config.get('awesome'));
//=> undefined

const Conf = require('conf');

const config = new Conf();

config.set('unicorn', '🦄');
console.log(config.get('unicorn'));
//=> '🦄'

// Use dot-notation to access nested properties
config.set('foo.bar', true);
console.log(config.get('foo'));
//=> {bar: true}

config.delete('unicorn');
console.log(config.get('unicorn'));
//=> undefined

#!/usr/bin/env node

import {
    spawn
} from 'child_process';

const child = spawn('npm', ['install']);

child.stdout.on('data', function (data) {
    console.log(data);
});

child.stderr.on('data', function (data) {
    console.log('Error:', data);
});

#!/usr/bin/env node

import {
    exec
} from 'child_process';

const child = exec('npm install', function (err, stdout, stderr) {
    if (err) throw err;
    console.log(stdout);
});

child.stdout.on('data', function (data) {
    console.log(data);
});

child.stderr.on('data', function (data) {
    console.log('Error:', data);
});

// parent.js
const {fork} = require('child_process');
const forked = fork('child.js');
forked.on('message', (msg) => {
    console.log('messsgae from child', msg);
});

forked.send({hello: 'world'});

// child.js
process.on('message', (msg) => {
    console.log('message from parent:', msg);
});
let conter = 0;
setInterval(() => {
    process.send({counter: counter++});
}, 1000);

const shell = require('shelljs');

// 判断是否有相关开发环境
function hasGitNpm() {
  if (!shell.which('git')) {
    console.log('Sorry, this script requires git');
    shell.exit(1);
  }

  if (!shell.which('npm')) {
    console.log('Sorry, this script requires npm');
    shell.exit(1);
  }
}

hasGitNpm();

// 安装 npm 包
function installPkg(pkg, type) {
  const npm = shell.which('npm');
  if (!npm) {
    console.log('请先安装 npm');
    return;
  }
  const { code } = shell.exec(
    `${npm.stdout} install ${pkg} ${type || '--save'}`
  );
  if (code) {
    console.log(`安装 ${pkg} 失败，请手动安装`);
  }
}

#!/usr/bin/env zx

await $`cat package.json | grep name`

let branch = await $`git branch --show-current`
await $`dep deploy --branch=${branch}`

await Promise.all([
  $`sleep 1; echo 1`,
  $`sleep 2; echo 2`,
  $`sleep 3; echo 3`,
])

let name = 'foo bar'
await $`mkdir /tmp/${name}`

{
    "scripts": {
        "test": "cross-env NODE_ENV=production node ./src/index.js"
    }
}

console.log(process.env.NODE_ENV)

{
    "scripts": {
        "test": "cross-env-shell GREETING=Hi sh ./src/index.sh"
    }
}

echo $GREETING

{
    "scripts": {
        "test": "node ./src/index.js -build --show"
     }
}

#!/usr/bin/env node
import minimist from 'minimist';

// 方式1
console.log('hello ', process.argv.splice(2)); // ['-build', '--show']

// 方式2
const isShow = require('minimist')(process.argv.slice(2)).show;

{
  "scripts": {
    "dev": "npm run start"
  }
}

{
    "scripts": {
        "lint": "jshint **/*.js",
        "test": "tap test/*.js",
        "build1": " npm run script1.js & npm run script2.js"
        "build2": " npm run script1.js && npm run script2.js"
    }
}

{
    "scripts": {
        "lint": "jshint **/*.js",
        "test": "tap test/*.js",
        "build": " npm run script1.js & npm run script2.js"
        "prebuild": " npm run script1.js && npm run script2.js"
    }
}

npm run prebuild
npm run build
npm run postbuild

const TARGET = process.env.npm_lifecycle_event;

if (TARGET === 'test') {
  console.log(`正在执行 npm run test`);
}