@modulify/conventional-release 0.1.0 → 0.1.2

package/bin/cli.mjs

@@ -1,291 +1,30 @@
+import { run } from "../dist/index.mjs";
+import { parseArgv } from "../dist/cli/args.mjs";
+import { createReporter } from "../dist/cli/reporter.mjs";
+import { ConsoleOutput, Output } from "../dist/cli/output.mjs";
 import { GitCommander } from "@modulify/git-toolkit";
 import { Runner } from "@modulify/git-toolkit/shell";
-import { run } from "../dist/index.mjs";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import chalk from "chalk";
-import figures from "figures";
-import * as util from "node:util";
-const DEFAULTS = {
-  dry: false,
-  verbose: false,
-  tags: false
-};
-class CliParseError extends Error {
-  help;
-}
-async function parseArgv(argv = process.argv) {
-  const parser = yargs(hideBin(argv)).locale("en").scriptName("conventional-release").usage("Usage: $0 [options]").option("release-as", {
-    alias: "r",
-    describe: "Specify the release type (major|minor|patch)",
-    requiresArg: true,
-    string: true
-  }).option("prerelease", {
-    alias: "p",
-    describe: "Specify the prerelease type (alpha|beta|rc)",
-    requiresArg: true,
-    string: true
-  }).option("dry", {
-    type: "boolean",
-    default: DEFAULTS.dry,
-    describe: "See the commands that running release would run"
-  }).option("verbose", {
-    type: "boolean",
-    default: DEFAULTS.verbose,
-    describe: "Show detailed per-slice progress output"
-  }).option("tags", {
-    type: "boolean",
-    default: DEFAULTS.tags,
-    describe: "Show generated tags in the final output"
-  }).exitProcess(false).check((options) => {
-    if (!["alpha", "beta", "rc", void 0].includes(options.prerelease)) {
-      throw new Error("prerelease should be one of alpha, beta, rc or undefined");
-    }
-    return true;
-  }).showHelpOnFail(false).fail((message) => {
-    throw new Error(message);
-  }).alias("version", "v").alias("help", "h").example("$0", "Update changelog and tag release").example("$0 --dry --verbose", "Show a detailed dry-run release preview").pkgConf("release").wrap(97);
-  let parsed;
-  try {
-    parsed = await parser.parseAsync();
-  } catch (error) {
-    const failure = new CliParseError(error.message);
-    const help = await parser.getHelp();
-    failure.help = [help].flat().join("\n");
-    throw failure;
-  }
-  return {
-    releaseAs: parsed.releaseAs,
-    prerelease: parsed.prerelease,
-    dry: parsed.dry,
-    verbose: parsed.verbose,
-    tags: parsed.tags
-  };
-}
-function createReporter({
-  output,
-  git,
-  showTags = false,
-  verbosity = "summary"
-}) {
-  if (verbosity === "detailed") {
-    return new DetailedReporter({
-      output,
-      git,
-      showTags
-    });
-  }
-  return new SummaryReporter({
-    output,
-    git,
-    showTags
-  });
-}
-class SummaryReporter {
-  output;
-  git;
-  showTags;
-  scope = null;
-  position = /* @__PURE__ */ new Map();
-  constructor({
-    output,
-    git,
-    showTags
-  }) {
-    this.output = output;
-    this.git = git;
-    this.showTags = showTags;
-  }
-  async onStart(context) {
-    this.output.info(
-      context.dry ? "Starting dry release" : "Starting release"
-    );
-  }
-  async onScope(scope, context) {
-    this.scope = scope;
-    this.position = new Map(
-      scope.slices.map((slice, index) => [slice.id, index + 1])
-    );
-  }
-  async onSliceStart(slice) {
-    this.output.info("Running slice %s", [this.describeProgress(slice)]);
-  }
-  async onSuccess(result) {
-    if (!result.changed) {
-      this.output.success("No changes since last release");
-      return;
-    }
-    const changed = result.slices.filter((slice) => slice.changed);
-    const primary = changed[0];
-    const packages = collectPackages(changed);
-    this.output.success("Release slices: %s", [String(changed.length)]);
-    this.output.success("Updated packages: %s", [String(packages.length)]);
-    if (primary) {
-      this.output.success("Next version: %s", [primary.nextVersion]);
-    }
-    if (result.dry) {
-      this.output.info("No committing or tagging since this was a dry run");
-      return;
-    }
-    this.output.success("Committed %s staged files", [String(result.files.length)]);
-    if (this.showTags) {
-      const tags = collectTags(changed);
-      if (tags.length) {
-        this.output.success("Tags: %s", [tags.join(", ")]);
-      }
-    }
-    this.output.info("Run `%s` to publish", [
-      `git push --follow-tags origin ${await this.resolveBranch()}`
-    ]);
-  }
-  async onError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    this.output.error(message);
-  }
-  describeProgress(slice) {
-    const position = this.position.get(slice.id);
-    const total = this.scope?.slices.length;
-    const label = describeSlice(slice);
-    return position && total ? `${position}/${total}: ${label}` : label;
-  }
-  async resolveBranch() {
-    try {
-      return await this.git.revParse("HEAD", { abbrevRef: true });
-    } catch {
-      return "%branch%";
-    }
-  }
-}
-class DetailedReporter extends SummaryReporter {
-  async onScope(scope, context) {
-    await super.onScope(scope, context);
-    this.output.info("%s scope: %s packages, %s affected, %s slices", [
-      scope.mode,
-      String(scope.packages.length),
-      String(scope.affected.length),
-      String(scope.slices.length)
-    ]);
-  }
-  async onSliceSuccess(slice) {
-    if (!slice.changed) {
-      this.output.warn("Completed slice %s without version changes (%s)", [
-        describeSlice(slice),
-        slice.currentVersion
-      ]);
-      return;
-    }
-    this.output.success("Completed slice %s: %s -> %s (%s)", [
-      describeSlice(slice),
-      slice.currentVersion,
-      slice.nextVersion,
-      slice.releaseType
-    ]);
-    if (this.showTags && slice.tag) {
-      this.output.info("Tag: %s", [slice.tag]);
-    }
-  }
-  async onSuccess(result) {
-    await super.onSuccess(result);
-    if (!result.changed) {
-      return;
-    }
-    const packages = collectPackages(result.slices.filter((slice) => slice.changed));
-    this.output.info("Updated packages: %s", [describePackages(packages)]);
-  }
-}
-function describeSlice(slice) {
-  if (slice.partition) {
-    return `${slice.partition} [${describePackages(slice.packages)}]`;
-  }
-  return describePackages(slice.packages);
-}
-function describePackages(packages) {
-  return packages.map((pkg) => pkg.name ?? pkg.path).join(", ");
-}
-function collectTags(slices) {
-  return slices.map((slice) => slice.tag).filter((tag) => !!tag);
-}
-function collectPackages(slices) {
-  const packages = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const slice of slices) {
-    for (const pkg of slice.packages) {
-      const identity = pkg.name ?? pkg.path;
-      if (seen.has(identity)) {
-        continue;
-      }
-      seen.add(identity);
-      packages.push(pkg);
-    }
-  }
-  return packages;
-}
-class ConsoleOutput {
-  write(message) {
-    console.info(message);
-  }
-  writeError(message) {
-    console.error(message);
-  }
-}
-class Output {
-  output;
-  theme;
-  constructor({
-    dry,
-    output = new ConsoleOutput(),
-    theme = createDefaultTheme(dry)
-  }) {
-    this.output = output;
-    this.theme = theme;
-  }
-  info(template, context = [], figure = this.theme.info) {
-    this.output.write(format(template, context, figure));
-  }
-  success(template, context = [], figure = this.theme.success) {
-    this.output.write(format(template, context, figure));
-  }
-  warn(template, context = [], figure = this.theme.warning) {
-    this.output.write(format(template, context, figure));
-  }
-  error(template, context = [], figure = this.theme.error) {
-    this.output.writeError(format(template, context, figure));
-  }
-}
-function createDefaultTheme(dry) {
-  return {
-    success: dry ? chalk.yellow(figures.tick) : chalk.green(figures.tick),
-    warning: chalk.yellow(figures.warning),
-    error: chalk.red(figures.cross),
-    info: chalk.blue(figures.info)
-  };
-}
-function format(template, context, figure) {
-  const bold = (arg) => chalk.bold(arg);
-  const message = util.format(template, ...context.map(bold));
-  return `${figure} ${message}`;
-}
+//#region src/cli.ts
 async function main(argv = process.argv) {
-  const cwd = process.cwd();
-  const options = await parseArgv(argv);
-  const output = new Output({
-    dry: options.dry,
-    output: new ConsoleOutput()
-  });
-  const git = new GitCommander({ sh: new Runner(cwd) });
-  await run({
-    cwd,
-    dry: options.dry,
-    releaseAs: options.releaseAs,
-    prerelease: options.prerelease,
-    reporter: createReporter({
-      output,
-      git,
-      showTags: options.tags,
-      verbosity: options.verbose ? "detailed" : "summary"
-    })
-  });
-}
-export {
-  main
-};
+	const cwd = process.cwd();
+	const options = await parseArgv(argv);
+	const output = new Output({
+		dry: options.dry,
+		output: new ConsoleOutput()
+	});
+	const git = new GitCommander({ sh: new Runner(cwd) });
+	await run({
+		cwd,
+		dry: options.dry,
+		releaseAs: options.releaseAs,
+		prerelease: options.prerelease,
+		reporter: createReporter({
+			output,
+			git,
+			showTags: options.tags,
+			verbosity: options.verbose ? "detailed" : "summary"
+		})
+	});
+}
+//#endregion
+export { main };

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/cli/args.cjs

@@ -0,0 +1,67 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let yargs = require("yargs");
+yargs = require_runtime.__toESM(yargs, 1);
+let yargs_helpers = require("yargs/helpers");
+//#region src/cli/args.ts
+var DEFAULTS = {
+	releaseAs: void 0,
+	prerelease: void 0,
+	dry: false,
+	verbose: false,
+	tags: false
+};
+var CliParseError = class extends Error {
+	help;
+};
+async function parseArgv(argv = process.argv) {
+	const parser = (0, yargs.default)((0, yargs_helpers.hideBin)(argv)).locale("en").scriptName("conventional-release").usage("Usage: $0 [options]").option("release-as", {
+		alias: "r",
+		describe: "Specify the release type (major|minor|patch)",
+		requiresArg: true,
+		string: true
+	}).option("prerelease", {
+		alias: "p",
+		describe: "Specify the prerelease type (alpha|beta|rc)",
+		requiresArg: true,
+		string: true
+	}).option("dry", {
+		type: "boolean",
+		default: DEFAULTS.dry,
+		describe: "See the commands that running release would run"
+	}).option("verbose", {
+		type: "boolean",
+		default: DEFAULTS.verbose,
+		describe: "Show detailed per-slice progress output"
+	}).option("tags", {
+		type: "boolean",
+		default: DEFAULTS.tags,
+		describe: "Show generated tags in the final output"
+	}).exitProcess(false).check((options) => {
+		if (![
+			"alpha",
+			"beta",
+			"rc",
+			void 0
+		].includes(options.prerelease)) throw new Error("prerelease should be one of alpha, beta, rc or undefined");
+		return true;
+	}).showHelpOnFail(false).fail((message) => {
+		throw new Error(message);
+	}).alias("version", "v").alias("help", "h").example("$0", "Update changelog and tag release").example("$0 --dry --verbose", "Show a detailed dry-run release preview").pkgConf("release").wrap(97);
+	let parsed;
+	try {
+		parsed = await parser.parseAsync();
+	} catch (error) {
+		const failure = new CliParseError(error.message);
+		failure.help = [await parser.getHelp()].flat().join("\n");
+		throw failure;
+	}
+	return {
+		releaseAs: parsed.releaseAs,
+		prerelease: parsed.prerelease,
+		dry: parsed.dry,
+		verbose: parsed.verbose,
+		tags: parsed.tags
+	};
+}
+//#endregion
+exports.parseArgv = parseArgv;

package/dist/cli/args.mjs

@@ -0,0 +1,65 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+//#region src/cli/args.ts
+var DEFAULTS = {
+	releaseAs: void 0,
+	prerelease: void 0,
+	dry: false,
+	verbose: false,
+	tags: false
+};
+var CliParseError = class extends Error {
+	help;
+};
+async function parseArgv(argv = process.argv) {
+	const parser = yargs(hideBin(argv)).locale("en").scriptName("conventional-release").usage("Usage: $0 [options]").option("release-as", {
+		alias: "r",
+		describe: "Specify the release type (major|minor|patch)",
+		requiresArg: true,
+		string: true
+	}).option("prerelease", {
+		alias: "p",
+		describe: "Specify the prerelease type (alpha|beta|rc)",
+		requiresArg: true,
+		string: true
+	}).option("dry", {
+		type: "boolean",
+		default: DEFAULTS.dry,
+		describe: "See the commands that running release would run"
+	}).option("verbose", {
+		type: "boolean",
+		default: DEFAULTS.verbose,
+		describe: "Show detailed per-slice progress output"
+	}).option("tags", {
+		type: "boolean",
+		default: DEFAULTS.tags,
+		describe: "Show generated tags in the final output"
+	}).exitProcess(false).check((options) => {
+		if (![
+			"alpha",
+			"beta",
+			"rc",
+			void 0
+		].includes(options.prerelease)) throw new Error("prerelease should be one of alpha, beta, rc or undefined");
+		return true;
+	}).showHelpOnFail(false).fail((message) => {
+		throw new Error(message);
+	}).alias("version", "v").alias("help", "h").example("$0", "Update changelog and tag release").example("$0 --dry --verbose", "Show a detailed dry-run release preview").pkgConf("release").wrap(97);
+	let parsed;
+	try {
+		parsed = await parser.parseAsync();
+	} catch (error) {
+		const failure = new CliParseError(error.message);
+		failure.help = [await parser.getHelp()].flat().join("\n");
+		throw failure;
+	}
+	return {
+		releaseAs: parsed.releaseAs,
+		prerelease: parsed.prerelease,
+		dry: parsed.dry,
+		verbose: parsed.verbose,
+		tags: parsed.tags
+	};
+}
+//#endregion
+export { parseArgv };

package/dist/cli/output.cjs

@@ -0,0 +1,51 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk, 1);
+let figures = require("figures");
+figures = require_runtime.__toESM(figures, 1);
+let node_util = require("node:util");
+node_util = require_runtime.__toESM(node_util, 1);
+//#region src/cli/output.ts
+var ConsoleOutput = class {
+	write(message) {
+		console.info(message);
+	}
+	writeError(message) {
+		console.error(message);
+	}
+};
+var Output = class {
+	output;
+	theme;
+	constructor({ dry, output = new ConsoleOutput(), theme = createDefaultTheme(dry) }) {
+		this.output = output;
+		this.theme = theme;
+	}
+	info(template, context = [], figure = this.theme.info) {
+		this.output.write(format(template, context, figure));
+	}
+	success(template, context = [], figure = this.theme.success) {
+		this.output.write(format(template, context, figure));
+	}
+	warn(template, context = [], figure = this.theme.warning) {
+		this.output.write(format(template, context, figure));
+	}
+	error(template, context = [], figure = this.theme.error) {
+		this.output.writeError(format(template, context, figure));
+	}
+};
+function createDefaultTheme(dry) {
+	return {
+		success: dry ? chalk.default.yellow(figures.default.tick) : chalk.default.green(figures.default.tick),
+		warning: chalk.default.yellow(figures.default.warning),
+		error: chalk.default.red(figures.default.cross),
+		info: chalk.default.blue(figures.default.info)
+	};
+}
+function format(template, context, figure) {
+	const bold = (arg) => chalk.default.bold(arg);
+	return `${figure} ${node_util.format(template, ...context.map(bold))}`;
+}
+//#endregion
+exports.ConsoleOutput = ConsoleOutput;
+exports.Output = Output;

package/dist/cli/output.mjs

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import figures from "figures";
+import * as util from "node:util";
+//#region src/cli/output.ts
+var ConsoleOutput = class {
+	write(message) {
+		console.info(message);
+	}
+	writeError(message) {
+		console.error(message);
+	}
+};
+var Output = class {
+	output;
+	theme;
+	constructor({ dry, output = new ConsoleOutput(), theme = createDefaultTheme(dry) }) {
+		this.output = output;
+		this.theme = theme;
+	}
+	info(template, context = [], figure = this.theme.info) {
+		this.output.write(format(template, context, figure));
+	}
+	success(template, context = [], figure = this.theme.success) {
+		this.output.write(format(template, context, figure));
+	}
+	warn(template, context = [], figure = this.theme.warning) {
+		this.output.write(format(template, context, figure));
+	}
+	error(template, context = [], figure = this.theme.error) {
+		this.output.writeError(format(template, context, figure));
+	}
+};
+function createDefaultTheme(dry) {
+	return {
+		success: dry ? chalk.yellow(figures.tick) : chalk.green(figures.tick),
+		warning: chalk.yellow(figures.warning),
+		error: chalk.red(figures.cross),
+		info: chalk.blue(figures.info)
+	};
+}
+function format(template, context, figure) {
+	const bold = (arg) => chalk.bold(arg);
+	return `${figure} ${util.format(template, ...context.map(bold))}`;
+}
+//#endregion
+export { ConsoleOutput, Output };

package/dist/cli/reporter.cjs

@@ -0,0 +1,127 @@
+//#region src/cli/reporter.ts
+function createReporter({ output, git, showTags = false, verbosity = "summary" }) {
+	if (verbosity === "detailed") return new DetailedReporter({
+		output,
+		git,
+		showTags
+	});
+	return new SummaryReporter({
+		output,
+		git,
+		showTags
+	});
+}
+var SummaryReporter = class {
+	output;
+	git;
+	showTags;
+	scope = null;
+	position = /* @__PURE__ */ new Map();
+	constructor({ output, git, showTags }) {
+		this.output = output;
+		this.git = git;
+		this.showTags = showTags;
+	}
+	async onStart(context) {
+		this.output.info(context.dry ? "Starting dry release" : "Starting release");
+	}
+	async onScope(scope, context) {
+		this.scope = scope;
+		this.position = new Map(scope.slices.map((slice, index) => [slice.id, index + 1]));
+	}
+	async onSliceStart(slice) {
+		this.output.info("Running slice %s", [this.describeProgress(slice)]);
+	}
+	async onSuccess(result) {
+		if (!result.changed) {
+			this.output.success("No changes since last release");
+			return;
+		}
+		const changed = result.slices.filter((slice) => slice.changed);
+		const primary = changed[0];
+		const packages = collectPackages(changed);
+		this.output.success("Release slices: %s", [String(changed.length)]);
+		this.output.success("Updated packages: %s", [String(packages.length)]);
+		if (primary) this.output.success("Next version: %s", [primary.nextVersion]);
+		if (result.dry) {
+			this.output.info("No committing or tagging since this was a dry run");
+			return;
+		}
+		this.output.success("Committed %s staged files", [String(result.files.length)]);
+		if (this.showTags) {
+			const tags = collectTags(changed);
+			if (tags.length) this.output.success("Tags: %s", [tags.join(", ")]);
+		}
+		this.output.info("Run `%s` to publish", [`git push --follow-tags origin ${await this.resolveBranch()}`]);
+	}
+	async onError(error) {
+		const message = error instanceof Error ? error.message : String(error);
+		this.output.error(message);
+	}
+	describeProgress(slice) {
+		const position = this.position.get(slice.id);
+		const total = this.scope?.slices.length;
+		const label = describeSlice(slice);
+		return position && total ? `${position}/${total}: ${label}` : label;
+	}
+	async resolveBranch() {
+		try {
+			return await this.git.revParse("HEAD", { abbrevRef: true });
+		} catch {
+			return "%branch%";
+		}
+	}
+};
+var DetailedReporter = class extends SummaryReporter {
+	async onScope(scope, context) {
+		await super.onScope(scope, context);
+		this.output.info("%s scope: %s packages, %s affected, %s slices", [
+			scope.mode,
+			String(scope.packages.length),
+			String(scope.affected.length),
+			String(scope.slices.length)
+		]);
+	}
+	async onSliceSuccess(slice) {
+		if (!slice.changed) {
+			this.output.warn("Completed slice %s without version changes (%s)", [describeSlice(slice), slice.currentVersion]);
+			return;
+		}
+		this.output.success("Completed slice %s: %s -> %s (%s)", [
+			describeSlice(slice),
+			slice.currentVersion,
+			slice.nextVersion,
+			slice.releaseType
+		]);
+		if (this.showTags && slice.tag) this.output.info("Tag: %s", [slice.tag]);
+	}
+	async onSuccess(result) {
+		await super.onSuccess(result);
+		if (!result.changed) return;
+		const packages = collectPackages(result.slices.filter((slice) => slice.changed));
+		this.output.info("Updated packages: %s", [describePackages(packages)]);
+	}
+};
+function describeSlice(slice) {
+	if (slice.partition) return `${slice.partition} [${describePackages(slice.packages)}]`;
+	return describePackages(slice.packages);
+}
+function describePackages(packages) {
+	return packages.map((pkg) => pkg.name ?? pkg.path).join(", ");
+}
+function collectTags(slices) {
+	return slices.map((slice) => slice.tag).filter((tag) => !!tag);
+}
+function collectPackages(slices) {
+	const packages = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const slice of slices) for (const pkg of slice.packages) {
+		const identity = pkg.name ?? pkg.path;
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		packages.push(pkg);
+	}
+	return packages;
+}
+//#endregion
+exports.createReporter = createReporter;