@mnaoumov/typescript-dev-toolkit 6.0.2 → 6.2.0

package/dist/lib/cjs/version.d.cts

@@ -9,6 +9,7 @@
  * Git operations such as tagging and pushing.
  */
 import { parseArgs } from 'node:util';
+import type { ChangelogStyle } from './changelog-grouping.cjs';
 /**
  * Options for {@link addUpdatedFilesToGit}.
  */
@@ -53,6 +54,13 @@ export interface PublishGitHubReleaseOptions {
      * @default `true`
      */
     readonly shouldCloseReleasedIssues?: boolean;
+    /**
+     * Whether to require every asset to exist, require an existing remote tag, and verify the published
+     * non-draft release and its uploaded assets before closing issues.
+     *
+     * @default `false`
+     */
+    readonly shouldVerifyRelease?: boolean;
 }
 /**
  * Options for {@link updateChangelog}.
@@ -69,6 +77,16 @@ export interface UpdateChangelogOptions {
      * @default the first-parent commit subjects since the previous version
      */
     readonly changelogFilePath?: string | undefined;
+    /**
+     * How the section generated from the commit messages is laid out: `grouped` sorts the entries under plain-language
+     * headings and counts the maintenance commits instead of listing them, `commits` writes one bullet per first-parent
+     * commit. See {@link ChangelogStyle}.
+     *
+     * Ignored when {@link changelogFilePath} is set.
+     *
+     * @default `'grouped'`
+     */
+    readonly changelogStyle?: ChangelogStyle | undefined;
     /**
      * Whether to open the generated changelog in the editor for an interactive review. When `false`,
      * the changelog is still generated from commit messages, but it is not opened in the editor for
@@ -95,6 +113,12 @@ export interface UpdateVersionOptions {
      * @default the first-parent commit subjects since the previous version
      */
     readonly changelogFilePath?: string | undefined;
+    /**
+     * How the section generated from the commit messages is laid out. See {@link UpdateChangelogOptions.changelogStyle}.
+     *
+     * @default `'grouped'`
+     */
+    readonly changelogStyle?: ChangelogStyle | undefined;
     /**
      * Returns the files to attach to the GitHub release. See {@link PublishGitHubReleaseOptions.getReleaseAssetPaths}.
      */
@@ -133,6 +157,16 @@ export interface UpdateVersionOptions {
      * @default `true`
      */
     readonly shouldEditChangelog?: boolean;
+    /**
+     * Whether to publish and verify the GitHub release before pushing the version commit to the branch.
+     * Preparation and asset validation happen before any push. Only the release tag is pushed first;
+     * a failed preparation, publication or verification leaves the remote branch unchanged.
+     * Uses the `origin` remote and pushes the verified commit to the original branch without force.
+     * Ignored when {@link shouldRelease} is `false`.
+     *
+     * @default `false`
+     */
+    readonly shouldPublishBeforePush?: boolean;
     /**
      * Whether to publish the release. When `false`, all local steps are executed (version bump,
      * changelog, commit, tag), but the changes are not pushed and no GitHub release is published.
@@ -317,6 +351,9 @@ export declare const VERSION_ARGUMENT_OPTIONS: {
     readonly 'changelog-file': {
         readonly type: "string";
     };
+    readonly 'changelog-style': {
+        readonly type: "string";
+    };
     readonly 'no-build': {
         readonly type: "boolean";
     };
@@ -364,6 +401,7 @@ export declare function isPreRelease(version: string): boolean;
  * value instead and has no default. Recognized flags:
  * - `--changelog-file=<path>` — use this file's contents as the new version's changelog section instead of
  *   the commit-derived bullets, and skip the interactive review entirely.
+ * - `--changelog-style=<grouped|commits>` — how the commit-derived section is laid out (default `grouped`).
  * - `--no-build` — skip the build step (only safe when the build output already matches the current code).
  * - `--no-changelog-editing` — generate the changelog without opening it for manual review.
  * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).
@@ -431,6 +469,9 @@ export declare function updateChangelog(newVersion: string, options?: UpdateChan
  * 11. Prepares and publishes a GitHub release.
  * 12. Closes the issues the release carries, with a link to it.
  *
+ * With {@link UpdateVersionOptions.shouldPublishBeforePush}, preparation and asset validation precede
+ * the tag push. Publication and verification then precede the branch push, and issue closing remains last.
+ *
  * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).
  * @param options - The {@link UpdateVersionOptions} controlling the release behavior.
  * @returns A {@link Promise} that resolves when the version update is complete.

package/dist/lib/esm/changelog-grouping.d.mts

@@ -0,0 +1,59 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Groups the commit-derived entries of a new changelog section into plain-language sections, so the release notes a
+ * release writes with nobody reviewing them can be scanned rather than read commit by commit.
+ *
+ * The input is still the first-parent commit history, so this is a deterministic transformation of what the author
+ * already wrote: it sorts entries by their Conventional-Commits type, leaves out the commit types that do not change
+ * what a user gets, merges entries that say the same thing, and swaps a `re #<n>` subject for the issue title its body
+ * carries. Prose a human (or an agent) writes still goes in through `--changelog-file`.
+ */
+/**
+ * How the generated changelog section of a release is laid out.
+ *
+ * - `grouped` — a one-line summary, then the entries under `### Breaking changes`, `### New`, `### Fixed`,
+ *   `### Improved`, `### Documentation` and `### Other changes`, with maintenance commits counted rather than listed.
+ * - `commits` — one bullet per first-parent commit, in history order, as every release wrote before `grouped` existed.
+ */
+export type ChangelogStyle = 'commits' | 'grouped';
+/**
+ * Every {@link ChangelogStyle}, in the order the `--changelog-style` error lists them.
+ */
+export declare const CHANGELOG_STYLES: readonly ChangelogStyle[];
+/**
+ * One first-parent commit, as {@link renderGroupedChangelogSection} takes it.
+ */
+export interface ChangelogCommitEntry {
+    /**
+     * The body lines that are neither the entry itself nor an issue reference line nor a breaking-change footer, in
+     * order. The first of them is the issue title an issue-closing `re #<n>` merge carries.
+     */
+    readonly detailLines: readonly string[];
+    /**
+     * The changelog line the commit produces before grouping: its subject, or the body line lifted onto a default merge
+     * subject.
+     */
+    readonly entry: string;
+    /**
+     * Whether the commit carries a `BREAKING CHANGE:` footer. The `!` marker is read off {@link entry} itself.
+     */
+    readonly hasBreakingFooter: boolean;
+    /**
+     * The issue references the body names that {@link entry} does not already show, rendered as the line shows them.
+     */
+    readonly references: readonly string[];
+}
+/**
+ * The commit types that change nothing a user of the release gets, so the grouped section counts them instead of
+ * listing them. A commit of one of these types that is marked breaking is still listed, under breaking changes.
+ */
+export declare const MAINTENANCE_COMMIT_TYPES: ReadonlySet<string>;
+/**
+ * Renders the body of a new changelog section in the {@link ChangelogStyle} `grouped` layout.
+ *
+ * @param entries - The first-parent commits since the previous release, in `git log` order.
+ * @returns The section body, without its `## <version>` heading and without a trailing newline.
+ */
+export declare function renderGroupedChangelogSection(entries: readonly ChangelogCommitEntry[]): string;

package/dist/lib/esm/changelog-grouping.mjs

@@ -0,0 +1,106 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+const CHANGELOG_STYLES = ["grouped", "commits"];
+const MAINTENANCE_COMMIT_TYPES = /* @__PURE__ */ new Set(["build", "chore", "ci", "refactor", "style", "test"]);
+const BREAKING_SECTION = { heading: "Breaking changes", plural: "breaking changes", singular: "breaking change" };
+const NEW_SECTION = { heading: "New", plural: "new features", singular: "new feature" };
+const FIXED_SECTION = { heading: "Fixed", plural: "fixes", singular: "fix" };
+const IMPROVED_SECTION = { heading: "Improved", plural: "improvements", singular: "improvement" };
+const DOCUMENTATION_SECTION = { heading: "Documentation", plural: "documentation changes", singular: "documentation change" };
+const OTHER_SECTION = { heading: "Other changes", plural: "other changes", singular: "other change" };
+const SECTIONS = [BREAKING_SECTION, NEW_SECTION, FIXED_SECTION, IMPROVED_SECTION, DOCUMENTATION_SECTION, OTHER_SECTION];
+const SECTIONS_BY_TYPE = /* @__PURE__ */ new Map([
+  ["docs", DOCUMENTATION_SECTION],
+  ["feat", NEW_SECTION],
+  ["fix", FIXED_SECTION],
+  ["perf", IMPROVED_SECTION]
+]);
+const CONVENTIONAL_ENTRY_REG_EXP = /^(?<type>[a-z]+)(?:\((?<scope>[^()]*)\))?(?<breaking>!)?:\s+(?<description>\S.*)$/i;
+const ISSUE_ONLY_DESCRIPTION_REG_EXP = /^re (?<issue>#\d+)$/i;
+function renderGroupedChangelogSection(entries) {
+  const sectionEntries = /* @__PURE__ */ new Map();
+  let maintenanceCount = 0;
+  for (const entry of entries) {
+    const classified = classifyEntry(entry);
+    if (!classified) {
+      maintenanceCount++;
+      continue;
+    }
+    const list = sectionEntries.get(classified.section) ?? [];
+    sectionEntries.set(classified.section, list);
+    const existing = list.find((sectionEntry) => sectionEntry.text === classified.text);
+    if (!existing) {
+      list.push({ references: [...classified.references], text: classified.text });
+      continue;
+    }
+    existing.references = [.../* @__PURE__ */ new Set([...existing.references, ...classified.references])];
+  }
+  const blocks = [toSummaryLine(sectionEntries, maintenanceCount)];
+  for (const section of SECTIONS) {
+    const list = sectionEntries.get(section);
+    if (!list) {
+      continue;
+    }
+    blocks.push(`### ${section.heading}`, list.map((sectionEntry) => `- ${toEntryLine(sectionEntry)}`).join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function classifyEntry(entry) {
+  const groups = CONVENTIONAL_ENTRY_REG_EXP.exec(entry.entry)?.groups;
+  if (!groups) {
+    return { references: entry.references, section: entry.hasBreakingFooter ? BREAKING_SECTION : OTHER_SECTION, text: entry.entry };
+  }
+  const type = String(groups["type"]).toLowerCase();
+  const isBreaking = groups["breaking"] !== void 0 || entry.hasBreakingFooter;
+  const section = isBreaking ? BREAKING_SECTION : toTypeSection(type);
+  if (!section) {
+    return null;
+  }
+  const description = String(groups["description"]);
+  const issue = ISSUE_ONLY_DESCRIPTION_REG_EXP.exec(description)?.groups?.["issue"];
+  const issueTitle = entry.detailLines[0];
+  const isIssueTitleUsed = issue !== void 0 && issueTitle !== void 0;
+  const text = isIssueTitleUsed ? issueTitle : description;
+  const references = isIssueTitleUsed ? [issue, ...entry.references] : entry.references;
+  const scope = groups["scope"];
+  return {
+    references,
+    section,
+    text: scope ? `**${scope}:** ${text}` : text
+  };
+}
+function countPhrase(count, section) {
+  return `${String(count)} ${count === 1 ? section.singular : section.plural}`;
+}
+function joinPhrases(phrases) {
+  const last = phrases.slice(-1).join("");
+  return phrases.length === 1 ? last : `${phrases.slice(0, -1).join(", ")} and ${last}`;
+}
+function toEntryLine(sectionEntry) {
+  return sectionEntry.references.length === 0 ? sectionEntry.text : `${sectionEntry.text} (${sectionEntry.references.join(", ")})`;
+}
+function toSummaryLine(sectionEntries, maintenanceCount) {
+  const phrases = SECTIONS.map((section) => ({ count: sectionEntries.get(section)?.length ?? 0, section })).filter(({ count }) => count > 0).map(({ count, section }) => countPhrase(count, section));
+  const isOne = maintenanceCount === 1;
+  const maintenance = maintenanceCount === 0 ? "" : ` ${String(maintenanceCount)} maintenance ${isOne ? "commit" : "commits"} (tests, build, CI, refactoring, dependencies) ${isOne ? "is" : "are"} not listed.`;
+  if (phrases.length > 0) {
+    return `This release has ${joinPhrases(phrases)}.${maintenance}`;
+  }
+  return maintenanceCount === 0 ? "This release has no changes." : `This release has maintenance changes only.${maintenance}`;
+}
+function toTypeSection(type) {
+  const section = SECTIONS_BY_TYPE.get(type);
+  if (section) {
+    return section;
+  }
+  return MAINTENANCE_COMMIT_TYPES.has(type) ? null : OTHER_SECTION;
+}
+export {
+  CHANGELOG_STYLES,
+  MAINTENANCE_COMMIT_TYPES,
+  renderGroupedChangelogSection
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/changelog-grouping.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Groups the commit-derived entries of a new changelog section into plain-language sections, so the release notes a\n * release writes with nobody reviewing them can be scanned rather than read commit by commit.\n *\n * The input is still the first-parent commit history, so this is a deterministic transformation of what the author\n * already wrote: it sorts entries by their Conventional-Commits type, leaves out the commit types that do not change\n * what a user gets, merges entries that say the same thing, and swaps a `re #<n>` subject for the issue title its body\n * carries. Prose a human (or an agent) writes still goes in through `--changelog-file`.\n */\n\n/**\n * How the generated changelog section of a release is laid out.\n *\n * - `grouped` \u2014 a one-line summary, then the entries under `### Breaking changes`, `### New`, `### Fixed`,\n *   `### Improved`, `### Documentation` and `### Other changes`, with maintenance commits counted rather than listed.\n * - `commits` \u2014 one bullet per first-parent commit, in history order, as every release wrote before `grouped` existed.\n */\nexport type ChangelogStyle = 'commits' | 'grouped';\n\n/**\n * Every {@link ChangelogStyle}, in the order the `--changelog-style` error lists them.\n */\nexport const CHANGELOG_STYLES: readonly ChangelogStyle[] = ['grouped', 'commits'];\n\n/**\n * One first-parent commit, as {@link renderGroupedChangelogSection} takes it.\n */\nexport interface ChangelogCommitEntry {\n  /**\n   * The body lines that are neither the entry itself nor an issue reference line nor a breaking-change footer, in\n   * order. The first of them is the issue title an issue-closing `re #<n>` merge carries.\n   */\n  readonly detailLines: readonly string[];\n\n  /**\n   * The changelog line the commit produces before grouping: its subject, or the body line lifted onto a default merge\n   * subject.\n   */\n  readonly entry: string;\n\n  /**\n   * Whether the commit carries a `BREAKING CHANGE:` footer. The `!` marker is read off {@link entry} itself.\n   */\n  readonly hasBreakingFooter: boolean;\n\n  /**\n   * The issue references the body names that {@link entry} does not already show, rendered as the line shows them.\n   */\n  readonly references: readonly string[];\n}\n\n/**\n * The commit types that change nothing a user of the release gets, so the grouped section counts them instead of\n * listing them. A commit of one of these types that is marked breaking is still listed, under breaking changes.\n */\nexport const MAINTENANCE_COMMIT_TYPES: ReadonlySet<string> = new Set(['build', 'chore', 'ci', 'refactor', 'style', 'test']);\n\ninterface ClassifiedEntry {\n  readonly references: readonly string[];\n  readonly section: SectionDefinition;\n  readonly text: string;\n}\n\ninterface SectionDefinition {\n  readonly heading: string;\n  readonly plural: string;\n  readonly singular: string;\n}\n\ninterface SectionEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Merged entries collect references in place.\n  references: string[];\n  readonly text: string;\n}\n\nconst BREAKING_SECTION: SectionDefinition = { heading: 'Breaking changes', plural: 'breaking changes', singular: 'breaking change' };\nconst NEW_SECTION: SectionDefinition = { heading: 'New', plural: 'new features', singular: 'new feature' };\nconst FIXED_SECTION: SectionDefinition = { heading: 'Fixed', plural: 'fixes', singular: 'fix' };\nconst IMPROVED_SECTION: SectionDefinition = { heading: 'Improved', plural: 'improvements', singular: 'improvement' };\nconst DOCUMENTATION_SECTION: SectionDefinition = { heading: 'Documentation', plural: 'documentation changes', singular: 'documentation change' };\nconst OTHER_SECTION: SectionDefinition = { heading: 'Other changes', plural: 'other changes', singular: 'other change' };\n\n/**\n * The sections, in the order they are rendered and summarized.\n */\nconst SECTIONS: readonly SectionDefinition[] = [BREAKING_SECTION, NEW_SECTION, FIXED_SECTION, IMPROVED_SECTION, DOCUMENTATION_SECTION, OTHER_SECTION];\n\nconst SECTIONS_BY_TYPE = new Map<string, SectionDefinition>([\n  ['docs', DOCUMENTATION_SECTION],\n  ['feat', NEW_SECTION],\n  ['fix', FIXED_SECTION],\n  ['perf', IMPROVED_SECTION]\n]);\n\nconst CONVENTIONAL_ENTRY_REG_EXP = /^(?<type>[a-z]+)(?:\\((?<scope>[^()]*)\\))?(?<breaking>!)?:\\s+(?<description>\\S.*)$/i;\n\n/**\n * An issue-closing merge subject, whose readable half is the issue title on the body's first line.\n */\nconst ISSUE_ONLY_DESCRIPTION_REG_EXP = /^re (?<issue>#\\d+)$/i;\n\n/**\n * Renders the body of a new changelog section in the {@link ChangelogStyle} `grouped` layout.\n *\n * @param entries - The first-parent commits since the previous release, in `git log` order.\n * @returns The section body, without its `## <version>` heading and without a trailing newline.\n */\nexport function renderGroupedChangelogSection(entries: readonly ChangelogCommitEntry[]): string {\n  const sectionEntries = new Map<SectionDefinition, SectionEntry[]>();\n  let maintenanceCount = 0;\n\n  for (const entry of entries) {\n    const classified = classifyEntry(entry);\n    if (!classified) {\n      maintenanceCount++;\n      continue;\n    }\n\n    const list = sectionEntries.get(classified.section) ?? [];\n    sectionEntries.set(classified.section, list);\n    const existing = list.find((sectionEntry) => sectionEntry.text === classified.text);\n    if (!existing) {\n      list.push({ references: [...classified.references], text: classified.text });\n      continue;\n    }\n\n    existing.references = [...new Set([...existing.references, ...classified.references])];\n  }\n\n  const blocks = [toSummaryLine(sectionEntries, maintenanceCount)];\n  for (const section of SECTIONS) {\n    const list = sectionEntries.get(section);\n    if (!list) {\n      continue;\n    }\n\n    blocks.push(`### ${section.heading}`, list.map((sectionEntry) => `- ${toEntryLine(sectionEntry)}`).join('\\n'));\n  }\n\n  return blocks.join('\\n\\n');\n}\n\nfunction classifyEntry(entry: ChangelogCommitEntry): ClassifiedEntry | null {\n  const groups = CONVENTIONAL_ENTRY_REG_EXP.exec(entry.entry)?.groups;\n  if (!groups) {\n    return { references: entry.references, section: entry.hasBreakingFooter ? BREAKING_SECTION : OTHER_SECTION, text: entry.entry };\n  }\n\n  // The regular expression's `type` and `description` groups are not optional, so a match always fills them.\n  const type = String(groups['type']).toLowerCase();\n  const isBreaking = groups['breaking'] !== undefined || entry.hasBreakingFooter;\n  const section = isBreaking ? BREAKING_SECTION : toTypeSection(type);\n  if (!section) {\n    return null;\n  }\n\n  const description = String(groups['description']);\n  const issue = ISSUE_ONLY_DESCRIPTION_REG_EXP.exec(description)?.groups?.['issue'];\n  const issueTitle = entry.detailLines[0];\n  const isIssueTitleUsed = issue !== undefined && issueTitle !== undefined;\n  const text = isIssueTitleUsed ? issueTitle : description;\n  const references = isIssueTitleUsed ? [issue, ...entry.references] : entry.references;\n  const scope = groups['scope'];\n  return {\n    references,\n    section,\n    text: scope ? `**${scope}:** ${text}` : text\n  };\n}\n\nfunction countPhrase(count: number, section: SectionDefinition): string {\n  return `${String(count)} ${count === 1 ? section.singular : section.plural}`;\n}\n\nfunction joinPhrases(phrases: readonly string[]): string {\n  const last = phrases.slice(-1).join('');\n  return phrases.length === 1 ? last : `${phrases.slice(0, -1).join(', ')} and ${last}`;\n}\n\nfunction toEntryLine(sectionEntry: SectionEntry): string {\n  return sectionEntry.references.length === 0 ? sectionEntry.text : `${sectionEntry.text} (${sectionEntry.references.join(', ')})`;\n}\n\nfunction toSummaryLine(sectionEntries: ReadonlyMap<SectionDefinition, readonly SectionEntry[]>, maintenanceCount: number): string {\n  const phrases = SECTIONS\n    .map((section) => ({ count: sectionEntries.get(section)?.length ?? 0, section }))\n    .filter(({ count }) => count > 0)\n    .map(({ count, section }) => countPhrase(count, section));\n  const isOne = maintenanceCount === 1;\n  const maintenance = maintenanceCount === 0\n    ? ''\n    : ` ${String(maintenanceCount)} maintenance ${isOne ? 'commit' : 'commits'} (tests, build, CI, refactoring, dependencies) ${isOne ? 'is' : 'are'} not listed.`;\n\n  if (phrases.length > 0) {\n    return `This release has ${joinPhrases(phrases)}.${maintenance}`;\n  }\n\n  return maintenanceCount === 0 ? 'This release has no changes.' : `This release has maintenance changes only.${maintenance}`;\n}\n\nfunction toTypeSection(type: string): null | SectionDefinition {\n  const section = SECTIONS_BY_TYPE.get(type);\n  if (section) {\n    return section;\n  }\n\n  return MAINTENANCE_COMMIT_TYPES.has(type) ? null : OTHER_SECTION;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -6,6 +6,7 @@
 export * as 'build' from './build.mjs';
 export * as 'bulk-concurrency' from './bulk-concurrency.mjs';
 export * as 'bundlers' from './bundlers/index.mjs';
+export * as 'changelog-grouping' from './changelog-grouping.mjs';
 export * as 'check-project-types' from './check-project-types.mjs';
 export * as 'cli-utils' from './cli-utils.mjs';
 export * as 'code-generator' from './code-generator.mjs';

package/dist/lib/esm/index.mjs

@@ -6,6 +6,7 @@ if you want to view the source, please visit the github repository of this plugi
 import * as build from "./build.mjs";
 import * as bulk_concurrency from "./bulk-concurrency.mjs";
 import * as bundlers from "./bundlers/index.mjs";
+import * as changelog_grouping from "./changelog-grouping.mjs";
 import * as check_project_types from "./check-project-types.mjs";
 import * as cli_utils from "./cli-utils.mjs";
 import * as code_generator from "./code-generator.mjs";
@@ -45,6 +46,7 @@ export {
   build,
   bulk_concurrency as "bulk-concurrency",
   bundlers,
+  changelog_grouping as "changelog-grouping",
   check_project_types as "check-project-types",
   cli_utils as "cli-utils",
   code_generator as "code-generator",
@@ -81,4 +83,4 @@ export {
   validate_dependencies as "validate-dependencies",
   version
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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