@lerna/publish/dist/libs/core/src/lib/command/index.js

Publish packages in the current project

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var command_exports = {};
__export(command_exports, {
  Command: () => Command
});
module.exports = __toCommonJS(command_exports);
var import_clone_deep = __toESM(require("clone-deep"));
var import_dedent = __toESM(require("dedent"));
var import_execa = __toESM(require("execa"));
var import_npmlog = __toESM(require("npmlog"));
var import_os = __toESM(require("os"));
var import_package_graph = require("../package-graph");
var import_project = require("../project");
var import_validation_error = require("../validation-error");
var import_write_log_file = require("../write-log-file");
var import_clean_stack = require("./clean-stack");
var import_default_options = require("./default-options");
var import_log_package_error = require("./log-package-error");
var import_warn_if_hanging = require("./warn-if-hanging");
const DEFAULT_CONCURRENCY = import_os.default.cpus().length;
class Command {
  name;
  composed;
  options = {};
  runner;
  concurrency;
  toposort = false;
  execOpts;
  packageGraph;
  logger;
  _project;
  get project() {
    if (this._project === void 0) {
      throw new import_validation_error.ValidationError("ENOPROJECT", "Lerna Project not initialized!");
    }
    return this._project;
  }
  set project(project) {
    this._project = project;
  }
  constructor(_argv, { skipValidations } = { skipValidations: false }) {
    import_npmlog.default.pause();
    import_npmlog.default.heading = "lerna";
    const argv = (0, import_clone_deep.default)(_argv);
    import_npmlog.default.silly("argv", argv);
    this.name = this.constructor.name.replace(/Command$/, "").toLowerCase();
    this.composed = typeof argv.composed === "string" && argv.composed !== this.name;
    if (!this.composed) {
      import_npmlog.default.notice("cli", `v${argv.lernaVersion}`);
    }
    let runner = new Promise((resolve, reject) => {
      let chain = Promise.resolve();
      chain = chain.then(() => {
        this.project = new import_project.Project(argv.cwd);
      });
      chain = chain.then(() => this.configureEnvironment());
      chain = chain.then(() => this.configureOptions());
      chain = chain.then(() => this.configureProperties());
      chain = chain.then(() => this.configureLogging());
      if (!skipValidations) {
        chain = chain.then(() => this.runValidations());
      }
      chain = chain.then(() => this.runPreparations());
      chain = chain.then(() => this.runCommand());
      chain.then(
        (result) => {
          (0, import_warn_if_hanging.warnIfHanging)();
          resolve(result);
        },
        (err) => {
          if (err.pkg) {
            (0, import_log_package_error.logPackageError)(err, this.options.stream);
          } else if (err.name !== "ValidationError") {
            import_npmlog.default.error("", (0, import_clean_stack.cleanStack)(err, this.constructor.name));
          }
          if (err.name !== "ValidationError" && !err.pkg) {
            (0, import_write_log_file.writeLogFile)(this.project.rootPath);
          }
          (0, import_warn_if_hanging.warnIfHanging)();
          reject(err);
        }
      );
    });
    if (argv.onResolved || argv.onRejected) {
      runner = runner.then(argv.onResolved, argv.onRejected);
      delete argv.onResolved;
      delete argv.onRejected;
    }
    for (const key of ["cwd", "$0"]) {
      Object.defineProperty(argv, key, { enumerable: false });
    }
    Object.defineProperty(this, "argv", {
      value: Object.freeze(argv)
    });
    this.runner = runner;
  }
  // proxy "Promise" methods to "private" instance
  then(onResolved, onRejected) {
    return this.runner.then(onResolved, onRejected);
  }
  /* istanbul ignore next */
  catch(onRejected) {
    return this.runner.catch(onRejected);
  }
  get requiresGit() {
    return true;
  }
  // Override this to inherit config from another command.
  // For example `changed` inherits config from `publish`.
  get otherCommandConfigs() {
    return [];
  }
  configureEnvironment() {
    const ci = require("is-ci");
    let loglevel;
    let progress;
    if (ci || !process.stderr.isTTY) {
      import_npmlog.default.disableColor();
      progress = false;
    } else if (!process.stdout.isTTY) {
      progress = false;
      loglevel = "error";
    } else if (process.stderr.isTTY) {
      import_npmlog.default.enableColor();
      import_npmlog.default.enableUnicode();
    }
    Object.defineProperty(this, "envDefaults", {
      value: {
        ci,
        progress,
        loglevel
      }
    });
  }
  configureOptions() {
    const commandConfig = this.project.config.command || {};
    const overrides = [this.name, ...this.otherCommandConfigs].map((key) => commandConfig[key]);
    this.options = (0, import_default_options.defaultOptions)(
      // CLI flags, which if defined overrule subsequent values
      this.argv,
      ...overrides,
      // Global options from `lerna.json`
      this.project.config,
      // Environmental defaults prepared in previous step
      this.envDefaults
    );
    if (this.options.verbose && this.options.loglevel !== "silly") {
      this.options.loglevel = "verbose";
    }
  }
  argv(argv, arg1, config, envDefaults) {
    throw new Error("Method not implemented.");
  }
  envDefaults(argv, arg1, config, envDefaults) {
    throw new Error("Method not implemented.");
  }
  configureProperties() {
    const { concurrency = 0, sort, maxBuffer } = this.options;
    this.concurrency = Math.max(1, +concurrency || DEFAULT_CONCURRENCY);
    this.toposort = sort === void 0 || sort;
    this.execOpts = {
      cwd: this.project.rootPath,
      maxBuffer
    };
  }
  configureLogging() {
    const { loglevel } = this.options;
    if (loglevel) {
      import_npmlog.default.level = loglevel;
    }
    import_npmlog.default.addLevel("success", 3001, { fg: "green", bold: true });
    Object.defineProperty(this, "logger", {
      value: import_npmlog.default["newGroup"](this.name)
    });
    import_npmlog.default.resume();
  }
  enableProgressBar() {
    if (this.options.progress !== false) {
      import_npmlog.default.enableProgress();
    }
  }
  gitInitialized() {
    const opts = {
      cwd: this.project.rootPath,
      // don't throw, just want boolean
      reject: false,
      // only return code, no stdio needed
      stdio: "ignore"
    };
    return import_execa.default.sync("git", ["rev-parse"], opts).exitCode === 0;
  }
  runValidations() {
    if ((this.options.since !== void 0 || this.requiresGit) && !this.gitInitialized()) {
      throw new import_validation_error.ValidationError("ENOGIT", "The git binary was not found, or this is not a git repository.");
    }
    if (!this.project.manifest) {
      throw new import_validation_error.ValidationError("ENOPKG", "`package.json` does not exist, have you run `lerna init`?");
    }
    if (this.project.configNotFound) {
      throw new import_validation_error.ValidationError("ENOLERNA", "`lerna.json` does not exist, have you run `lerna init`?");
    }
    if (!this.project.version) {
      throw new import_validation_error.ValidationError("ENOVERSION", "Required property version does not exist in `lerna.json`");
    }
    if (this.options.independent && !this.project.isIndependent()) {
      throw new import_validation_error.ValidationError(
        "EVERSIONMODE",
        import_dedent.default`
          You ran lerna with --independent or -i, but the repository is not set to independent mode.
          To use independent mode you need to set lerna.json's "version" property to "independent".
          Then you won't need to pass the --independent or -i flags.
        `
      );
    }
    if (this.options.npmClient === "pnpm" && !this.options.useWorkspaces) {
      throw new import_validation_error.ValidationError(
        "ENOWORKSPACES",
        "Usage of pnpm without workspaces is not supported. To use pnpm with lerna, set useWorkspaces to true in lerna.json and configure pnpm to use workspaces: https://pnpm.io/workspaces."
      );
    }
  }
  runPreparations() {
    if (!this.composed && this.project.isIndependent()) {
      import_npmlog.default.info("versioning", "independent");
    }
    if (!this.composed && this.options.ci) {
      import_npmlog.default.info("ci", "enabled");
    }
    let chain = Promise.resolve();
    chain = chain.then(() => this.project.getPackages());
    chain = chain.then((packages) => {
      this.packageGraph = new import_package_graph.PackageGraph(packages);
    });
    return chain;
  }
  runCommand() {
    return Promise.resolve().then(() => this.initialize()).then((proceed) => {
      if (proceed !== false) {
        return this.execute();
      }
    });
  }
  initialize() {
    throw new import_validation_error.ValidationError(this.name, "initialize() needs to be implemented.");
  }
  execute() {
    throw new import_validation_error.ValidationError(this.name, "execute() needs to be implemented.");
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Command
});