1、lerna入口是lerna/core/lerna/cli.js这个文件

  1.  #!/usr/bin/env node   //执行node命令
  3. "use strict";
  5. /* eslint-disable import/no-dynamic-require, global-require */
  6. //当我们本地node_modules存在一个脚手架命令，同时全局在node_modules中也存在这个脚手架命令的时候，优先选用本地node_modules中的版本
  7. const importLocal = require("import-local");  
  9. if (importLocal(__filename)) {
  10.   require("npmlog").info("cli", "using local version of lerna");
  11. } else {
  12.   //.相当于./index.js
  13.   require(".")(process.argv.slice(2));
  14. }

2、进入lerna/core/lerna/index.js

  1. "use strict";
  3. //依次加载相应命令
  4. const cli = require("@lerna/cli");
  5. const addCmd = require("@lerna/add/command");
  6. const bootstrapCmd = require("@lerna/bootstrap/command");
  7. const changedCmd = require("@lerna/changed/command");
  8. const cleanCmd = require("@lerna/clean/command");
  9. const createCmd = require("@lerna/create/command");
  10. const diffCmd = require("@lerna/diff/command");
  11. const execCmd = require("@lerna/exec/command");
  12. const importCmd = require("@lerna/import/command");
  13. const infoCmd = require("@lerna/info/command");
  14. const initCmd = require("@lerna/init/command");
  15. const linkCmd = require("@lerna/link/command");
  16. const listCmd = require("@lerna/list/command");
  17. const publishCmd = require("@lerna/publish/command");
  18. const runCmd = require("@lerna/run/command");
  19. const versionCmd = require("@lerna/version/command");
  21. const pkg = require("./package.json");
  23. module.exports = main;
  25. function main(argv) {
  26.   const context = {
  27.     lernaVersion: pkg.version,
  28.   };
  30.   return cli()
  31.      //添加命令
  32.     .command(addCmd)
  33.     .command(bootstrapCmd)
  34.     .command(changedCmd)
  35.     .command(cleanCmd)
  36.     .command(createCmd)
  37.     .command(diffCmd)
  38.     .command(execCmd)
  39.     .command(importCmd)
  40.     .command(infoCmd)
  41.     .command(initCmd)
  42.     .command(linkCmd)
  43.     .command(listCmd)
  44.     .command(publishCmd)
  45.     .command(runCmd)
  46.     .command(versionCmd)
  47.      // 合并参数 , 将 argv 和自定义的 context 中的属性合并到 argv 中
  48.     .parse(argv, context);
  49. }

3、进入@lerna/cli/index.js

  1. "use strict";
  3. const dedent = require("dedent");
  4. const log = require("npmlog");
  5. const yargs = require("yargs/yargs");
  6. const { globalOptions } = require("@lerna/global-options");
  8. module.exports = lernaCLI;
  10. /**
  11.  * A factory that returns a yargs() instance configured with everything except commands.
  12.  * Chain .parse() from this method to invoke.
  13.  *
  14.  * @param {Array = []} argv
  15.  * @param {String = process.cwd()} cwd
  16.  */
  17. function lernaCLI(argv, cwd) {
  18.    // 对 yargs 进行初始化  
  19.   const cli = yargs(argv, cwd);
  21.   //globalOptions 也是一个方法 把 yargs 作为参数传入 返回的还是这个 yargs 对象 
  22.   //运用构造者模式，对一个对象调用方法，然后返回这个对象本身
  23.   return globalOptions(cli)
  24.     /// 配置 cli 的开始内容  $0 表示再 argv 中寻找 $0 这个值进行替换
  25.     .usage("Usage: $0 <command> [options]")
  26.     // 配置输入的最小命令,为1，否则弹出提示
  27.     .demandCommand(1, "A command is required. Pass --help to see all available commands and options.")
  28.       // 配置 command 的与错误最相近的 command 提示
  29.     .recommendCommands()
  30.       // 开启严格模式 
  31.     .strict() 
  32.     //命令不存在时，弹出警告
  33.     .fail((msg, err) => {
  34.       // certain yargs validations throw strings :P
  35.       const actual = err || new Error(msg);
  37.       // ValidationErrors are already logged, as are package errors
  38.       if (actual.name !== "ValidationError" && !actual.pkg) {
  39.         // the recommendCommands() message is too terse
  40.         if (/Did you mean/.test(actual.message)) {
  41.           log.error("lerna", `Unknown command "${cli.parsed.argv._[0]}"`);
  42.         }
  43.         //日记打印
  44.         log.error("lerna", actual.message);
  45.       }
  47.       // exit non-zero so the CLI can be usefully chained
  48.       cli.exit(actual.exitCode > 0 ? actual.exitCode : 1, actual);
  49.     })
  50.     //命令别名
  51.     .alias("h", "help")
  52.     .alias("v", "version")
  53.     // 配置cli的宽度和命令行一样
  54.     .wrap(cli.terminalWidth())
  55.     // 配置 cli 结尾的内容
  56.     .epilogue(dedent`
  57.       When a command fails, all logs are written to lerna-debug.log in the current working directory.
  59.       For more information, find our manual at https://github.com/lerna/lerna
  60.     `);
  61. }

4、进入@lerna/global-options/index.js

  1. "use strict";
  3. const os = require("os");
  5. module.exports.globalOptions = globalOptions;
  7. function globalOptions(yargs) {
  8.   // 适用于 每一条命令的全局选项
  9.   const opts = {
  10.     loglevel: {
  11.       defaultDescription: "info",
  12.       describe: "What level of logs to report.",
  13.       type: "string",
  14.     },
  15.     concurrency: {
  16.       defaultDescription: os.cpus().length,
  17.       describe: "How many processes to use when lerna parallelizes tasks.",
  18.       type: "number",
  19.       requiresArg: true,
  20.     },
  21.     "reject-cycles": {
  22.       describe: "Fail if a cycle is detected among dependencies.",
  23.       type: "boolean",
  24.     },
  25.     "no-progress": {
  26.       describe: "Disable progress bars. (Always off in CI)",
  27.       type: "boolean",
  28.     },
  29.     progress: {
  30.       // proxy for --no-progress
  31.       hidden: true,
  32.       type: "boolean",
  33.     },
  34.     "no-sort": {
  35.       describe: "Do not sort packages topologically (dependencies before dependents).",
  36.       type: "boolean",
  37.     },
  38.     sort: {
  39.       // proxy for --no-sort
  40.       hidden: true,
  41.       type: "boolean",
  42.     },
  43.     "max-buffer": {
  44.       describe: "Set max-buffer (in bytes) for subcommand execution",
  45.       type: "number",
  46.       requiresArg: true,
  47.     },
  48.   };
  50.   // 得到这个option的名称
  51.   const globalKeys = Object.keys(opts).concat(["help", "version"]);
  53.     // 给 yargs 添加 全局options 
  54.   return yargs.options(opts)
  55.    // 对 options 进行分组
  56.   .group(globalKeys, "Global Options:")
  57.     // 添加了一个隐藏的 option 
  58.   .option("ci", {
  59.     hidden: true,
  60.     type: "boolean",
  61.   });
  62. }

5、从2，进入@lerna/list/command中

  1. "use strict";
  3. //需要过滤的lerna子命令的选项
  4. const { filterOptions } = require("@lerna/filter-options");
  5. const listable = require("@lerna/listable");
  7. /**
  8.  * @see https://github.com/yargs/yargs/blob/master/docs/advanced.md#providing-a-command-module
  9.  */
  10. //command 的格式
  11. exports.command = "list";
  13. exports.aliases = ["ls", "la", "ll"];
  15. //对 command 的描述
  16. exports.describe = "List local packages";
  18. //builder 函数，在执行命令之前做的一些事情
  19. exports.builder = (yargs) => {
  20.   listable.options(yargs);
  22.   return filterOptions(yargs);
  23. };
  25. //handler 函数，执行 command 的行为
  26. exports.handler = function handler(argv) {
  27.   //调index.js函数，并把argv传入
  28.   return require(".")(argv);
  29. };
  30. //返回一个对象，包含command、aliases、describe等方法

7、从handler进入index.js,执行factory方法

  1. "use strict";
  3. const { Command } = require("@lerna/command");
  4. const listable = require("@lerna/listable");
  5. const { output } = require("@lerna/output");
  6. const { getFilteredPackages } = require("@lerna/filter-options");
  8. module.exports = factory;
  11. function factory(argv) {
  12.   //实例化一个 ListCommand
  13.   return new ListCommand(argv);
  14. }
  16. //继承Command
  17. class ListCommand extends Command {
  18.   get requiresGit() {
  19.     return false;
  20.   }
  22.   initialize() {
  23.     // 也是通过 chain 微任务队列的方式
  24.     let chain = Promise.resolve();
  26.     chain = chain.then(() => getFilteredPackages(this.packageGraph, this.execOpts, this.options));
  27.     chain = chain.then((filteredPackages) => {
  28.       this.result = listable.format(filteredPackages, this.options);
  29.     });
  31.     return chain;
  32.   }
  34.   execute() {
  35.     // piping to `wc -l` should not yield 1 when no packages matched
  36.     if (this.result.text.length) {
  37.       output(this.result.text);
  38.     }
  40.     this.logger.success(
  41.       "found",
  42.       "%d %s",
  43.       this.result.count,
  44.       this.result.count === 1 ? "package" : "packages"
  45.     );
  46.   }
  47. }
  49. module.exports.ListCommand = ListCommand;

8、继承Command

  1. "use strict";
  3. class Command {
  4.   constructor(_argv) {
  5.     //深拷贝argv
  6.     const argv = cloneDeep(_argv);
  9.     // 对constructor的name进行处理，ListCommand变成list  "FooCommand" => "foo"
  10.     this.name = this.constructor.name.replace(/Command$/, "").toLowerCase();
  12.     //  添加 composed 属性, 是否使用复合指令
  13.     this.composed = typeof argv.composed === "string" && argv.composed !== this.name;
  15.     //如果不是复合指令
  16.     if (!this.composed) {
  17.       // composed commands have already logged the lerna version
  18.       log.notice("cli", `v${argv.lernaVersion}`);
  19.     }
  21.     // 执行命令
  22.     let runner = new Promise((resolve, reject) => {
  23.       // 定义一个微任务 chain.then 会被加入到微任务队列，不会立即执行
  24.       let chain = Promise.resolve();
  26.     s     // 会行程队列,一个接一个执行
  27.       chain = chain.then(() => {
  28.         this.project = new Project(argv.cwd);
  29.       });
  30.       chain = chain.then(() => this.configureEnvironment());
  31.       chain = chain.then(() => this.configureOptions());
  32.       chain = chain.then(() => this.configureProperties());
  33.       chain = chain.then(() => this.configureLogging());
  34.       chain = chain.then(() => this.runValidations());
  35.       chain = chain.then(() => this.runPreparations());
  36.       //执行命令
  37.       chain = chain.then(() => this.runCommand());
  39.      ...
  41.     // argv中顶一个cwd和$0的参数
  42.     for (const key of ["cwd", "$0"]) {
  43.       Object.defineProperty(argv, key, { enumerable: false });
  44.     }
  45.      // 对 argv 属性做一些处理
  46.     Object.defineProperty(this, "argv", {
  47.       value: Object.freeze(argv),
  48.     });
  50.     // 对 runner 属性做一些处理
  51.     Object.defineProperty(this, "runner", {
  52.       value: runner,
  53.     });
  54.   }
  56.   ...
  58.   //核心内容
  59.   runCommand() {
  60.     return Promise.resolve()
  61.        // 调用 initialize 方法
  62.       .then(() => this.initialize())
  63.       .then((proceed) => {
  64.         if (proceed !== false) {
  65.           // 调用 execute方法
  66.           return this.execute();
  67.         }
  68.         // early exits set their own exitCode (if non-zero)
  69.       });
  70.   }
  72.    // initialize 和 execute 强制用户实现，否则会报错
  73.   initialize() {
  74.     throw new ValidationError(this.name, "initialize() needs to be implemented.");
  75.   }
  77.   execute() {
  78.     throw new ValidationError(this.name, "execute() needs to be implemented.");
  79.   }
  80. }
  82. module.exports.Command = Command;

6、注意：npm项目本地依赖引用方法

  1.   "dependencies": {
  2.     //依赖本地的文件相对于npm link，不用将文件导入到全局，占内存，更推荐
  3.     "@lerna/global-options": "file:../global-options",  
  4.     "dedent": "^0.7.0",
  5.     "npmlog": "^4.1.2",
  6.     "yargs": "^16.2.0"
  7.   }