@mnaoumov/typescript-dev-toolkit 6.1.0 → 6.3.0

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

@@ -0,0 +1,108 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Rewrites the already-published sections of a `CHANGELOG.md` into the `grouped` layout a release now writes, so a
+ * project's history reads the same way as its next release.
+ *
+ * Only a section that is still the flat list of commit subjects a release used to write is rewritten. Its bullets are
+ * matched back to the first-parent commits of the section's tag range, which brings back what the bullet alone lost:
+ * the issue title an issue-closing `re #<n>` merge carries in its body, and the `BREAKING CHANGE:` footer. A bullet no
+ * commit matches (the history was rewritten, or the bullet was edited by hand) is grouped from its own text. A section
+ * that is anything other than a bullet list was written or edited by a person, so it is kept as it is.
+ */
+/**
+ * The outcome of {@link rewriteChangelog}.
+ */
+export interface ChangelogRewriteResult {
+    /**
+     * The new `CHANGELOG.md` content, with LF line endings.
+     */
+    readonly content: string;
+    /**
+     * The sections kept as they were, with the reason, newest first.
+     */
+    readonly kept: readonly KeptChangelogSection[];
+    /**
+     * The sections rewritten, newest first.
+     */
+    readonly rewritten: readonly RewrittenChangelogSection[];
+}
+/**
+ * What {@link rewriteChangelog} needs from the repository.
+ */
+export interface ChangelogRewriteSource {
+    /**
+     * Reads the full messages of the first-parent commits in a range, in `git log` order.
+     *
+     * @param fromTag - The tag the range starts after, or `undefined` for the whole history up to {@link toTag}.
+     * @param toTag - The tag the range ends at.
+     * @returns The full commit messages.
+     */
+    readonly getCommitMessages: (fromTag: string | undefined, toTag: string) => Promise<readonly string[]>;
+    /**
+     * The repository's tags.
+     */
+    readonly tags: readonly string[];
+}
+/**
+ * A section {@link rewriteChangelog} kept as it was.
+ */
+export interface KeptChangelogSection {
+    /**
+     * Why it was kept.
+     */
+    readonly reason: string;
+    /**
+     * The version its heading names.
+     */
+    readonly version: string;
+}
+/**
+ * A section {@link rewriteChangelog} rewrote.
+ */
+export interface RewrittenChangelogSection {
+    /**
+     * How many of its bullets were matched to a commit of its tag range.
+     */
+    readonly matchedCount: number;
+    /**
+     * The grouped section body, without its heading.
+     */
+    readonly newBody: string;
+    /**
+     * The section body as it was, without its heading.
+     */
+    readonly oldBody: string;
+    /**
+     * The tag the version was released under, when the repository has one.
+     */
+    readonly tag: string | undefined;
+    /**
+     * The version its heading names.
+     */
+    readonly version: string;
+}
+/**
+ * Rewrites every released section of a `CHANGELOG.md` that is still a flat list of commit subjects into the `grouped`
+ * layout, keeping each heading as it is.
+ *
+ * @param changelog - The current `CHANGELOG.md` content.
+ * @param source - The repository's tags and commits.
+ * @returns The new content and what happened to each section.
+ */
+export declare function rewriteChangelog(changelog: string, source: ChangelogRewriteSource): Promise<ChangelogRewriteResult>;
+/**
+ * Rewrites the release notes of a GitHub release whose changelog section {@link rewriteChangelog} rewrote.
+ *
+ * A release body a release wrote is its changelog section, a blank line, and a `**Full Changelog**` compare link. The
+ * body is rewritten only when its part above that link is still the section as it was, so a release edited by hand
+ * after publishing is not overwritten unless asked. The compare link is kept as it is.
+ *
+ * @param releaseBody - The release's current notes.
+ * @param section - The rewritten section.
+ * @param shouldOverwriteEdited - Whether notes that are no longer the section as it was are rewritten anyway. That is
+ *   right where the changelog was corrected after the release, for example to remove text that must not be public.
+ * @returns The new notes, or `null` when the release was edited and has to be left alone.
+ */
+export declare function rewriteReleaseNotes(releaseBody: string, section: RewrittenChangelogSection, shouldOverwriteEdited?: boolean): null | string;

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

@@ -0,0 +1,118 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { renderGroupedChangelogSection } from "./changelog-grouping.mjs";
+import { toChangelogCommitEntry } from "./version.mjs";
+const BULLET_PREFIX = "- ";
+const FULL_CHANGELOG_PREFIX = "**Full Changelog**:";
+const SECTION_HEADING_PREFIX = "## ";
+async function rewriteChangelog(changelog, source) {
+  const lines = changelog.replaceAll("\r\n", "\n").split("\n");
+  const firstHeadingIndex = lines.findIndex((line) => line.startsWith(SECTION_HEADING_PREFIX));
+  const headerLines = firstHeadingIndex === -1 ? lines : lines.slice(0, firstHeadingIndex);
+  const sections = firstHeadingIndex === -1 ? [] : splitSections(lines.slice(firstHeadingIndex));
+  const tags = new Set(source.tags);
+  const kept = [];
+  const rewritten = [];
+  const outputBlocks = [trimTrailingBlankLines(headerLines).join("\n")];
+  for (const [index, section] of sections.entries()) {
+    const keptReason = getKeptReason(section);
+    if (keptReason) {
+      kept.push({ reason: keptReason, version: section.version });
+      outputBlocks.push(trimTrailingBlankLines(section.rawLines).join("\n"));
+      continue;
+    }
+    const tag = toTag(section.version, tags);
+    const previousSection = sections[index + 1];
+    const previousTag = previousSection ? toTag(previousSection.version, tags) : void 0;
+    const isRangeKnown = tag !== void 0 && (previousSection === void 0 || previousTag !== void 0);
+    const commitMessages = isRangeKnown ? await source.getCommitMessages(previousTag, tag) : [];
+    const { entries, matchedCount } = matchBullets(section.bodyLines, commitMessages);
+    const oldBody = section.bodyLines.join("\n");
+    const newBody = renderGroupedChangelogSection(entries);
+    rewritten.push({ matchedCount, newBody, oldBody, tag, version: section.version });
+    outputBlocks.push(`${section.heading}
+
+${newBody}`);
+  }
+  return {
+    content: `${outputBlocks.filter((block) => block !== "").join("\n\n")}
+`,
+    kept,
+    rewritten
+  };
+}
+function rewriteReleaseNotes(releaseBody, section, shouldOverwriteEdited = false) {
+  const lines = releaseBody.replaceAll("\r\n", "\n").trim().split("\n");
+  const linkIndex = findLastIndex(lines, (line) => line.startsWith(FULL_CHANGELOG_PREFIX));
+  const noteLines = linkIndex === -1 ? lines : lines.slice(0, linkIndex);
+  if (!shouldOverwriteEdited && toComparable(noteLines.join("\n")) !== toComparable(section.oldBody)) {
+    return null;
+  }
+  return linkIndex === -1 ? section.newBody : `${section.newBody}
+
+${lines.slice(linkIndex).join("\n")}`;
+}
+function findLastIndex(lines, isMatch) {
+  return lines.map((line) => isMatch(line)).lastIndexOf(true);
+}
+function findMatchingEntryIndex(entries, bullet) {
+  const comparable = toComparable(bullet);
+  const renderedIndex = entries.findIndex((entry) => toComparable(toRenderedLine(entry)) === comparable);
+  return renderedIndex === -1 ? entries.findIndex((entry) => toComparable(entry.entry) === comparable) : renderedIndex;
+}
+function getKeptReason(section) {
+  if (section.bodyLines.length === 0) {
+    return "the section is empty";
+  }
+  if (section.bodyLines.some((line) => !line.startsWith(BULLET_PREFIX))) {
+    return "the section is not a plain bullet list, so a person wrote or edited it";
+  }
+  return void 0;
+}
+function matchBullets(bodyLines, commitMessages) {
+  const unused = commitMessages.map((commitMessage) => toChangelogCommitEntry(commitMessage));
+  const entries = [];
+  let matchedCount = 0;
+  for (const line of bodyLines) {
+    const bullet = line.slice(BULLET_PREFIX.length).trim();
+    const index = findMatchingEntryIndex(unused, bullet);
+    if (index === -1) {
+      entries.push({ detailLines: [], entry: bullet, hasBreakingFooter: false, references: [] });
+      continue;
+    }
+    matchedCount++;
+    entries.push(...unused.splice(index, 1));
+  }
+  return { entries, matchedCount };
+}
+function splitSections(lines) {
+  const headingIndices = lines.map((line, index) => line.startsWith(SECTION_HEADING_PREFIX) ? index : -1).filter((index) => index !== -1);
+  return headingIndices.map((headingIndex, position) => toSection(lines.slice(headingIndex, headingIndices[position + 1] ?? lines.length)));
+}
+function toComparable(text) {
+  return text.replaceAll(/[`\\]/g, "").replaceAll(/\s+/g, " ").trim();
+}
+function toRenderedLine(entry) {
+  return entry.references.length === 0 ? entry.entry : `${entry.entry} (${entry.references.join(", ")})`;
+}
+function toSection(rawLines) {
+  const heading = rawLines.slice(0, 1).join("");
+  const bodyLines = rawLines.slice(1).filter((line) => line.trim() !== "");
+  const version = heading.slice(SECTION_HEADING_PREFIX.length).trim().split(/\s+/, 1).join("");
+  return { bodyLines, heading, rawLines, version };
+}
+function toTag(version, tags) {
+  return [version, `v${version}`].find((candidate) => tags.has(candidate));
+}
+function trimTrailingBlankLines(lines) {
+  const lastIndex = findLastIndex(lines, (line) => line.trim() !== "");
+  return lines.slice(0, lastIndex + 1);
+}
+export {
+  rewriteChangelog,
+  rewriteReleaseNotes
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/changelog-rewrite.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Rewrites the already-published sections of a `CHANGELOG.md` into the `grouped` layout a release now writes, so a\n * project's history reads the same way as its next release.\n *\n * Only a section that is still the flat list of commit subjects a release used to write is rewritten. Its bullets are\n * matched back to the first-parent commits of the section's tag range, which brings back what the bullet alone lost:\n * the issue title an issue-closing `re #<n>` merge carries in its body, and the `BREAKING CHANGE:` footer. A bullet no\n * commit matches (the history was rewritten, or the bullet was edited by hand) is grouped from its own text. A section\n * that is anything other than a bullet list was written or edited by a person, so it is kept as it is.\n */\n\nimport type { ChangelogCommitEntry } from './changelog-grouping.ts';\n\nimport { renderGroupedChangelogSection } from './changelog-grouping.ts';\nimport { toChangelogCommitEntry } from './version.ts';\n\n/**\n * The outcome of {@link rewriteChangelog}.\n */\nexport interface ChangelogRewriteResult {\n  /**\n   * The new `CHANGELOG.md` content, with LF line endings.\n   */\n  readonly content: string;\n\n  /**\n   * The sections kept as they were, with the reason, newest first.\n   */\n  readonly kept: readonly KeptChangelogSection[];\n\n  /**\n   * The sections rewritten, newest first.\n   */\n  readonly rewritten: readonly RewrittenChangelogSection[];\n}\n\n/**\n * What {@link rewriteChangelog} needs from the repository.\n */\nexport interface ChangelogRewriteSource {\n  /**\n   * Reads the full messages of the first-parent commits in a range, in `git log` order.\n   *\n   * @param fromTag - The tag the range starts after, or `undefined` for the whole history up to {@link toTag}.\n   * @param toTag - The tag the range ends at.\n   * @returns The full commit messages.\n   */\n  readonly getCommitMessages: (fromTag: string | undefined, toTag: string) => Promise<readonly string[]>;\n\n  /**\n   * The repository's tags.\n   */\n  readonly tags: readonly string[];\n}\n\n/**\n * A section {@link rewriteChangelog} kept as it was.\n */\nexport interface KeptChangelogSection {\n  /**\n   * Why it was kept.\n   */\n  readonly reason: string;\n\n  /**\n   * The version its heading names.\n   */\n  readonly version: string;\n}\n\n/**\n * A section {@link rewriteChangelog} rewrote.\n */\nexport interface RewrittenChangelogSection {\n  /**\n   * How many of its bullets were matched to a commit of its tag range.\n   */\n  readonly matchedCount: number;\n\n  /**\n   * The grouped section body, without its heading.\n   */\n  readonly newBody: string;\n\n  /**\n   * The section body as it was, without its heading.\n   */\n  readonly oldBody: string;\n\n  /**\n   * The tag the version was released under, when the repository has one.\n   */\n  readonly tag: string | undefined;\n\n  /**\n   * The version its heading names.\n   */\n  readonly version: string;\n}\n\ninterface ChangelogSection {\n  readonly bodyLines: readonly string[];\n  readonly heading: string;\n  readonly rawLines: readonly string[];\n  readonly version: string;\n}\n\ninterface MatchedBullets {\n  readonly entries: readonly ChangelogCommitEntry[];\n  readonly matchedCount: number;\n}\n\nconst BULLET_PREFIX = '- ';\nconst FULL_CHANGELOG_PREFIX = '**Full Changelog**:';\nconst SECTION_HEADING_PREFIX = '## ';\n\n/**\n * Rewrites every released section of a `CHANGELOG.md` that is still a flat list of commit subjects into the `grouped`\n * layout, keeping each heading as it is.\n *\n * @param changelog - The current `CHANGELOG.md` content.\n * @param source - The repository's tags and commits.\n * @returns The new content and what happened to each section.\n */\nexport async function rewriteChangelog(changelog: string, source: ChangelogRewriteSource): Promise<ChangelogRewriteResult> {\n  const lines = changelog.replaceAll('\\r\\n', '\\n').split('\\n');\n  const firstHeadingIndex = lines.findIndex((line) => line.startsWith(SECTION_HEADING_PREFIX));\n  const headerLines = firstHeadingIndex === -1 ? lines : lines.slice(0, firstHeadingIndex);\n  const sections = firstHeadingIndex === -1 ? [] : splitSections(lines.slice(firstHeadingIndex));\n  const tags = new Set(source.tags);\n\n  const kept: KeptChangelogSection[] = [];\n  const rewritten: RewrittenChangelogSection[] = [];\n  const outputBlocks = [trimTrailingBlankLines(headerLines).join('\\n')];\n\n  for (const [index, section] of sections.entries()) {\n    const keptReason = getKeptReason(section);\n    if (keptReason) {\n      kept.push({ reason: keptReason, version: section.version });\n      outputBlocks.push(trimTrailingBlankLines(section.rawLines).join('\\n'));\n      continue;\n    }\n\n    const tag = toTag(section.version, tags);\n    const previousSection = sections[index + 1];\n    const previousTag = previousSection ? toTag(previousSection.version, tags) : undefined;\n    const isRangeKnown = tag !== undefined && (previousSection === undefined || previousTag !== undefined);\n    const commitMessages = isRangeKnown ? await source.getCommitMessages(previousTag, tag) : [];\n    const { entries, matchedCount } = matchBullets(section.bodyLines, commitMessages);\n    const oldBody = section.bodyLines.join('\\n');\n    const newBody = renderGroupedChangelogSection(entries);\n    rewritten.push({ matchedCount, newBody, oldBody, tag, version: section.version });\n    outputBlocks.push(`${section.heading}\\n\\n${newBody}`);\n  }\n\n  return {\n    content: `${outputBlocks.filter((block) => block !== '').join('\\n\\n')}\\n`,\n    kept,\n    rewritten\n  };\n}\n\n/**\n * Rewrites the release notes of a GitHub release whose changelog section {@link rewriteChangelog} rewrote.\n *\n * A release body a release wrote is its changelog section, a blank line, and a `**Full Changelog**` compare link. The\n * body is rewritten only when its part above that link is still the section as it was, so a release edited by hand\n * after publishing is not overwritten unless asked. The compare link is kept as it is.\n *\n * @param releaseBody - The release's current notes.\n * @param section - The rewritten section.\n * @param shouldOverwriteEdited - Whether notes that are no longer the section as it was are rewritten anyway. That is\n *   right where the changelog was corrected after the release, for example to remove text that must not be public.\n * @returns The new notes, or `null` when the release was edited and has to be left alone.\n */\nexport function rewriteReleaseNotes(releaseBody: string, section: RewrittenChangelogSection, shouldOverwriteEdited = false): null | string {\n  const lines = releaseBody.replaceAll('\\r\\n', '\\n').trim().split('\\n');\n  const linkIndex = findLastIndex(lines, (line) => line.startsWith(FULL_CHANGELOG_PREFIX));\n  const noteLines = linkIndex === -1 ? lines : lines.slice(0, linkIndex);\n  if (!shouldOverwriteEdited && toComparable(noteLines.join('\\n')) !== toComparable(section.oldBody)) {\n    return null;\n  }\n\n  return linkIndex === -1 ? section.newBody : `${section.newBody}\\n\\n${lines.slice(linkIndex).join('\\n')}`;\n}\n\n// Array.prototype.findLastIndex is ES2023, above this package's lib.\nfunction findLastIndex(lines: readonly string[], isMatch: (line: string) => boolean): number {\n  return lines.map((line) => isMatch(line)).lastIndexOf(true);\n}\n\nfunction findMatchingEntryIndex(entries: readonly ChangelogCommitEntry[], bullet: string): number {\n  // The line a commit renders to today, then its bare entry: a bullet an older toolkit wrote may lack the references.\n  const comparable = toComparable(bullet);\n  const renderedIndex = entries.findIndex((entry) => toComparable(toRenderedLine(entry)) === comparable);\n  return renderedIndex === -1 ? entries.findIndex((entry) => toComparable(entry.entry) === comparable) : renderedIndex;\n}\n\nfunction getKeptReason(section: ChangelogSection): string | undefined {\n  if (section.bodyLines.length === 0) {\n    return 'the section is empty';\n  }\n\n  if (section.bodyLines.some((line) => !line.startsWith(BULLET_PREFIX))) {\n    return 'the section is not a plain bullet list, so a person wrote or edited it';\n  }\n\n  return undefined;\n}\n\nfunction matchBullets(bodyLines: readonly string[], commitMessages: readonly string[]): MatchedBullets {\n  const unused = commitMessages.map((commitMessage) => toChangelogCommitEntry(commitMessage));\n  const entries: ChangelogCommitEntry[] = [];\n  let matchedCount = 0;\n\n  for (const line of bodyLines) {\n    const bullet = line.slice(BULLET_PREFIX.length).trim();\n    const index = findMatchingEntryIndex(unused, bullet);\n    if (index === -1) {\n      entries.push({ detailLines: [], entry: bullet, hasBreakingFooter: false, references: [] });\n      continue;\n    }\n\n    matchedCount++;\n    entries.push(...unused.splice(index, 1));\n  }\n\n  return { entries, matchedCount };\n}\n\n/**\n * Splits the lines from the first section heading on into sections.\n *\n * @param lines - The lines, the first of which is a section heading.\n * @returns The sections, in file order.\n */\nfunction splitSections(lines: readonly string[]): ChangelogSection[] {\n  const headingIndices = lines.map((line, index) => line.startsWith(SECTION_HEADING_PREFIX) ? index : -1).filter((index) => index !== -1);\n  return headingIndices.map((headingIndex, position) => toSection(lines.slice(headingIndex, headingIndices[position + 1] ?? lines.length)));\n}\n\n/**\n * Reduces a line to what survives `lint:md:fix`: a published section was fixed after it was generated, which wraps\n * names in backticks and escapes brackets, and a GitHub release kept the text from before the fix.\n *\n * @param text - The text.\n * @returns The text without backticks, backslashes and repeated whitespace.\n */\nfunction toComparable(text: string): string {\n  return text.replaceAll(/[`\\\\]/g, '').replaceAll(/\\s+/g, ' ').trim();\n}\n\nfunction toRenderedLine(entry: ChangelogCommitEntry): string {\n  return entry.references.length === 0 ? entry.entry : `${entry.entry} (${entry.references.join(', ')})`;\n}\n\nfunction toSection(rawLines: readonly string[]): ChangelogSection {\n  const heading = rawLines.slice(0, 1).join('');\n  const bodyLines = rawLines.slice(1).filter((line) => line.trim() !== '');\n  const version = heading.slice(SECTION_HEADING_PREFIX.length).trim().split(/\\s+/, 1).join('');\n  return { bodyLines, heading, rawLines, version };\n}\n\nfunction toTag(version: string, tags: ReadonlySet<string>): string | undefined {\n  return [version, `v${version}`].find((candidate) => tags.has(candidate));\n}\n\nfunction trimTrailingBlankLines(lines: readonly string[]): readonly string[] {\n  const lastIndex = findLastIndex(lines, (line) => line.trim() !== '');\n  return lines.slice(0, lastIndex + 1);\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -6,6 +6,9 @@
 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 'changelog-rewrite-cli' from './changelog-rewrite-cli.mjs';
+export * as 'changelog-rewrite' from './changelog-rewrite.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,9 @@ 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 changelog_rewrite_cli from "./changelog-rewrite-cli.mjs";
+import * as changelog_rewrite from "./changelog-rewrite.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 +48,9 @@ export {
   build,
   bulk_concurrency as "bulk-concurrency",
   bundlers,
+  changelog_grouping as "changelog-grouping",
+  changelog_rewrite as "changelog-rewrite",
+  changelog_rewrite_cli as "changelog-rewrite-cli",
   check_project_types as "check-project-types",
   cli_utils as "cli-utils",
   code_generator as "code-generator",
@@ -81,4 +87,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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