@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/releasePrepareProject.js

@@ -0,0 +1,109 @@
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { bumpAllVersions } from "./bumpAllVersions.js";
+import { resolveChangelogJsonPath, writeChangelogJson } from "./changelogJsonFile.js";
+import { decideRelease } from "./decideRelease.js";
+import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
+import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
+import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
+const ROOT_PACKAGE_FILE = "./package.json";
+const ROOT_CHANGELOG_PATH = ".";
+function releasePrepareProject(args) {
+  const { config, options, modifiedFiles, tags } = args;
+  const { dryRun, bumpOverride, withReleaseNotes, force } = options;
+  const project = config.project;
+  if (project === void 0) {
+    throw new Error("releasePrepareProject called without a configured project block");
+  }
+  const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
+  const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+  const contributingPaths = config.workspaces.flatMap((workspace) => workspace.paths);
+  const { tag, commits } = getCommitsSinceTarget([project.tagPrefix], contributingPaths);
+  const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+  const decision = decideRelease({
+    commits,
+    force,
+    bumpOverride,
+    workTypes,
+    versionPatterns,
+    scopeAliases: config.scopeAliases,
+    skipReasons: {
+      noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
+      noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`
+    }
+  });
+  if (decision.outcome === "skip") {
+    const skipped = {
+      status: "skipped",
+      commitCount: commits.length,
+      parsedCommitCount: decision.parsedCommitCount,
+      skipReason: decision.skipReason
+    };
+    if (tag !== void 0) {
+      skipped.previousTag = tag;
+    }
+    if (decision.unparseableCommits !== void 0) {
+      skipped.unparseableCommits = decision.unparseableCommits;
+    }
+    return skipped;
+  }
+  const { releaseType, parsedCommitCount, unparseableCommits } = decision;
+  const bump = bumpAllVersions([ROOT_PACKAGE_FILE], releaseType, dryRun);
+  const newTag = `${project.tagPrefix}${bump.newVersion}`;
+  const tagPattern = buildTagPattern([project.tagPrefix]);
+  const changelogFiles = generateChangelog(config, ROOT_CHANGELOG_PATH, newTag, dryRun, {
+    tagPattern,
+    includePaths: contributingPaths
+  });
+  const changelogJsonFiles = [];
+  if (config.changelogJson.enabled) {
+    const changelogJsonPath = resolveChangelogJsonPath(config, ROOT_CHANGELOG_PATH);
+    const entries = buildChangelogEntries(config, newTag, {
+      tagPattern,
+      includePaths: contributingPaths
+    });
+    if (!dryRun) {
+      writeChangelogJson(changelogJsonPath, entries);
+    }
+    changelogJsonFiles.push(changelogJsonPath);
+  }
+  const firstChangelogJsonPath = changelogJsonFiles[0];
+  if (withReleaseNotes === true && config.changelogJson.enabled && firstChangelogJsonPath !== void 0) {
+    const sectionOrder = deriveSectionOrder(workTypes);
+    writeReleaseNotesPreviews({
+      workspacePath: ROOT_CHANGELOG_PATH,
+      tag: newTag,
+      changelogJsonPath: firstChangelogJsonPath,
+      sectionOrder,
+      dryRun
+    });
+  }
+  tags.push(newTag);
+  modifiedFiles.push(ROOT_PACKAGE_FILE, ...changelogFiles, ...changelogJsonFiles);
+  const result = {
+    status: "released",
+    commitCount: commits.length,
+    parsedCommitCount,
+    releaseType,
+    currentVersion: bump.currentVersion,
+    newVersion: bump.newVersion,
+    tag: newTag,
+    bumpedFiles: bump.files,
+    changelogFiles,
+    commits
+  };
+  if (tag !== void 0) {
+    result.previousTag = tag;
+  }
+  if (unparseableCommits !== void 0) {
+    result.unparseableCommits = unparseableCommits;
+  }
+  if (bumpOverride !== void 0) {
+    result.bumpOverride = bumpOverride;
+  }
+  return result;
+}
+export {
+  releasePrepareProject
+};

package/dist/esm/renderReleaseNotes.d.ts

@@ -2,6 +2,7 @@ import type { ChangelogAudience, ChangelogEntry, ChangelogSection } from './type
 export interface RenderOptions {
     filter?: (section: ChangelogSection) => boolean;
     includeHeading?: boolean;
+    sectionOrder?: string[];
 }
 export declare function matchesAudience(audience: ChangelogAudience): (section: ChangelogSection) => boolean;
 export declare function renderReleaseNotesSingle(entry: ChangelogEntry, options?: RenderOptions): string;

package/dist/esm/renderReleaseNotes.js

@@ -10,7 +10,9 @@ function matchesAudience(audience) {
 function renderReleaseNotesSingle(entry, options) {
   const filter = options?.filter;
   const includeHeading = options?.includeHeading ?? true;
-  const sections = filter !== void 0 ? entry.sections.filter(filter) : entry.sections;
+  const sectionOrder = options?.sectionOrder;
+  const filtered = filter !== void 0 ? entry.sections.filter(filter) : entry.sections;
+  const sections = sectionOrder !== void 0 ? sortSectionsByOrder(filtered, sectionOrder) : filtered;
   if (sections.length === 0) {
     return "";
   }
@@ -23,12 +25,37 @@ function renderReleaseNotesSingle(entry, options) {
       lines.push("");
     }
     lines.push(`### ${section.title}`, "");
-    for (const item of section.items) {
+    for (const [index, item] of section.items.entries()) {
       lines.push(`- ${item.description}`);
+      if (item.body !== void 0 && item.body.length > 0) {
+        lines.push("", ...indentBodyLines(item.body));
+        if (index < section.items.length - 1) {
+          lines.push("");
+        }
+      }
     }
   }
   return lines.join("\n") + "\n";
 }
+function sortSectionsByOrder(sections, order) {
+  const priority = /* @__PURE__ */ new Map();
+  for (const [index, title] of order.entries()) {
+    priority.set(title, index);
+  }
+  const indexed = sections.map((section, index) => ({ section, index }));
+  indexed.sort((a, b) => {
+    const priorityA = priority.get(a.section.title) ?? Number.POSITIVE_INFINITY;
+    const priorityB = priority.get(b.section.title) ?? Number.POSITIVE_INFINITY;
+    if (priorityA !== priorityB) {
+      return priorityA - priorityB;
+    }
+    return a.index - b.index;
+  });
+  return indexed.map(({ section }) => section);
+}
+function indentBodyLines(body) {
+  return body.split("\n").map((line) => line.length === 0 ? "" : `  ${line}`);
+}
 function renderReleaseNotesMulti(entries, options) {
   const parts = entries.map((entry) => renderReleaseNotesSingle(entry, options)).filter((part) => part.length > 0);
   return parts.join("\n");

package/dist/esm/reportPrepare.js

@@ -1,86 +1,56 @@
 import { bold, dim, sectionHeader } from "./format.js";
 function reportPrepare(result) {
-  const isMultiComponent = result.components.some((c) => c.name !== void 0);
-  if (isMultiComponent) {
-    return formatMultiComponent(result);
+  const isMultiWorkspace = result.workspaces.some((w) => w.name !== void 0) || result.project !== void 0;
+  if (isMultiWorkspace) {
+    return formatMultiWorkspace(result);
   }
-  return formatSingleComponent(result);
+  return formatSingleWorkspace(result);
 }
-function formatSingleComponent(result) {
+function formatSingleWorkspace(result) {
   const lines = [];
-  const component = result.components[0];
-  if (component === void 0) {
+  const workspace = result.workspaces[0];
+  if (workspace === void 0) {
     return "";
   }
-  const since = component.previousTag === void 0 ? "the beginning" : component.previousTag;
-  lines.push(dim(`Found ${component.commitCount} commits since ${since}`));
-  if (component.parsedCommitCount !== void 0) {
-    lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
+  const since = workspace.previousTag === void 0 ? "the beginning" : workspace.previousTag;
+  lines.push(dim(`Found ${workspace.commitCount} commits since ${since}`));
+  if (workspace.parsedCommitCount !== void 0) {
+    lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
   }
-  formatUnparseableWarning(lines, component);
-  if (component.status === "skipped") {
-    lines.push(`\u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
+  formatUnparseableWarning(lines, workspace);
+  if (workspace.status === "skipped") {
+    lines.push(`\u23ED\uFE0F  ${workspace.skipReason}`);
     return lines.join("\n");
   }
-  if (component.parsedCommitCount === void 0 && component.releaseType !== void 0) {
-    lines.push(`  Using bump override: ${component.releaseType}`);
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  Using version override: ${workspace.setVersion}`);
+  } else if (workspace.bumpOverride !== void 0) {
+    lines.push(`  Using bump override: ${workspace.bumpOverride}`);
   }
-  if (component.releaseType !== void 0) {
-    lines.push(dim(`Bumping versions (${component.releaseType})...`));
+  if (workspace.releaseType !== void 0) {
+    lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
+  } else if (workspace.setVersion !== void 0) {
+    lines.push(dim(`Bumping versions (version override)...`));
   }
-  if (component.currentVersion !== void 0 && component.newVersion !== void 0 && component.releaseType !== void 0) {
-    lines.push(`\u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType})`);
+  if (workspace.setVersion !== void 0) {
+    lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
+  } else if (workspace.releaseType !== void 0) {
+    lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType})`);
   }
-  formatBumpFiles(lines, component, result.dryRun);
+  formatBumpFiles(lines, workspace, result.dryRun);
   lines.push(dim("Generating changelogs..."));
-  formatChangelogFiles(lines, component, result.dryRun);
+  formatChangelogFiles(lines, workspace, result.dryRun);
   formatFormatCommand(lines, result);
-  lines.push(`\u2705 Release preparation complete.`);
-  if (component.tag !== void 0) {
-    lines.push(`   \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
-  }
+  lines.push(`\u2705 Release preparation complete.`, `   \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
   return lines.join("\n");
 }
-function formatMultiComponent(result) {
+function formatMultiWorkspace(result) {
   const lines = [];
-  for (const component of result.components) {
-    if (component.name !== void 0) {
-      lines.push(`
-${sectionHeader(component.name)}`);
-    }
-    const since = component.previousTag === void 0 ? "(no previous release found)" : `since ${component.previousTag}`;
-    lines.push(dim(`  Found ${component.commitCount} commits ${since}`));
-    if (component.status === "skipped") {
-      lines.push(`  \u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
-      continue;
-    }
-    const { propagatedFrom } = component;
-    const isPropagatedOnly = propagatedFrom !== void 0 && component.commitCount === 0;
-    if (isPropagatedOnly) {
-      const depNames = propagatedFrom.map((p) => p.packageName).join(", ");
-      lines.push(dim(`  0 commits (bumped via dependency: ${depNames})`));
-    } else if (component.parsedCommitCount !== void 0) {
-      lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
-    }
-    formatUnparseableWarning(lines, component, "  ");
-    if (component.parsedCommitCount === void 0 && component.releaseType !== void 0 && !isPropagatedOnly) {
-      lines.push(`  Using bump override: ${component.releaseType}`);
-    }
-    if (component.releaseType !== void 0) {
-      lines.push(dim(`  Bumping versions (${component.releaseType})...`));
-    }
-    if (component.currentVersion !== void 0 && component.newVersion !== void 0 && component.releaseType !== void 0) {
-      const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : "";
-      lines.push(
-        `  \u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType}${suffix})`
-      );
-    }
-    formatBumpFiles(lines, component, result.dryRun, "  ");
-    lines.push(dim("  Generating changelogs..."));
-    formatChangelogFiles(lines, component, result.dryRun, "  ");
-    if (component.tag !== void 0) {
-      lines.push(`  \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
-    }
+  for (const workspace of result.workspaces) {
+    formatWorkspaceSection(lines, workspace, result.dryRun);
+  }
+  if (result.project !== void 0) {
+    formatProjectSection(lines, result.project, result.dryRun);
   }
   formatFormatCommand(lines, result);
   formatWarnings(lines, result);
@@ -92,12 +62,115 @@ ${sectionHeader(component.name)}`);
     }
   } else {
     lines.push(`
-\u23ED\uFE0F  No components had release-worthy changes.`);
+\u23ED\uFE0F  No workspaces had release-worthy changes.`);
   }
   return lines.join("\n");
 }
-function formatBumpFiles(lines, component, dryRun, indent = "") {
-  for (const file of component.bumpedFiles) {
+function formatProjectSection(lines, project, dryRun) {
+  lines.push(`
+${sectionHeader("project")}`);
+  const since = project.previousTag === void 0 ? "(no previous release found)" : `since ${project.previousTag}`;
+  lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
+  if (project.status === "skipped") {
+    lines.push(`  \u23ED\uFE0F  ${project.skipReason}`);
+    return;
+  }
+  const { releaseType, currentVersion, newVersion, tag } = project;
+  if (project.parsedCommitCount > 0) {
+    lines.push(dim(`  Parsed ${project.parsedCommitCount} typed commits`));
+  }
+  if (project.bumpOverride !== void 0) {
+    lines.push(`  Using bump override: ${project.bumpOverride}`);
+  }
+  formatProjectUnparseable(lines, project);
+  lines.push(
+    dim(`  Bumping versions (${releaseType})...`),
+    `  \u{1F4E6} ${currentVersion} \u2192 ${bold(newVersion)} (${releaseType})`
+  );
+  for (const file of project.bumpedFiles) {
+    if (dryRun) {
+      lines.push(dim(`    [dry-run] Would bump ${file}`));
+    } else {
+      lines.push(dim(`    Bumped ${file}`));
+    }
+  }
+  lines.push(dim("  Generating changelogs..."));
+  for (const file of project.changelogFiles) {
+    if (dryRun) {
+      lines.push(dim(`    [dry-run] Would run: npx --yes git-cliff ... --output ${file}`));
+    } else {
+      lines.push(dim(`    Generating changelog: ${file}`));
+    }
+  }
+  lines.push(`  \u{1F3F7}\uFE0F  ${bold(tag)}`);
+}
+function formatProjectUnparseable(lines, project) {
+  const unparseable = project.unparseableCommits;
+  if (unparseable === void 0 || unparseable.length === 0) {
+    return;
+  }
+  const count = unparseable.length;
+  const isPatchFloor = project.parsedCommitCount === 0;
+  const suffix = isPatchFloor ? " (defaulting to patch bump)" : "";
+  lines.push(`    \u26A0\uFE0F  ${count} commit${count === 1 ? "" : "s"} could not be parsed${suffix}`);
+  for (const commit of unparseable) {
+    const shortHash = commit.hash.slice(0, 7);
+    const truncatedMessage = commit.message.length > 72 ? `${commit.message.slice(0, 69)}...` : commit.message;
+    lines.push(`      \xB7 ${shortHash} ${truncatedMessage}`);
+  }
+}
+function formatWorkspaceSection(lines, workspace, dryRun) {
+  if (workspace.name !== void 0) {
+    lines.push(`
+${sectionHeader(workspace.name)}`);
+  }
+  const since = workspace.previousTag === void 0 ? "(no previous release found)" : `since ${workspace.previousTag}`;
+  lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
+  if (workspace.status === "skipped") {
+    lines.push(`  \u23ED\uFE0F  ${workspace.skipReason}`);
+    return;
+  }
+  const { propagatedFrom } = workspace;
+  const isPropagatedOnly = propagatedFrom !== void 0 && workspace.commitCount === 0;
+  formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
+  formatUnparseableWarning(lines, workspace, "  ");
+  formatBumpLabels(lines, workspace, isPropagatedOnly);
+  formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly);
+  formatBumpFiles(lines, workspace, dryRun, "  ");
+  lines.push(dim("  Generating changelogs..."));
+  formatChangelogFiles(lines, workspace, dryRun, "  ");
+  lines.push(`  \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
+}
+function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
+  if (isPropagatedOnly && propagatedFrom !== void 0) {
+    const depNames = propagatedFrom.map((p) => p.packageName).join(", ");
+    lines.push(dim(`  0 commits (bumped via dependency: ${depNames})`));
+  } else if (workspace.parsedCommitCount !== void 0 && workspace.parsedCommitCount > 0) {
+    lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
+  }
+}
+function formatBumpLabels(lines, workspace, isPropagatedOnly) {
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  Using version override: ${workspace.setVersion}`);
+  } else if (workspace.bumpOverride !== void 0 && !isPropagatedOnly) {
+    lines.push(`  Using bump override: ${workspace.bumpOverride}`);
+  }
+  if (workspace.releaseType !== void 0) {
+    lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
+  } else if (workspace.setVersion !== void 0) {
+    lines.push(dim(`  Bumping versions (version override)...`));
+  }
+}
+function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly) {
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  \u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
+  } else if (workspace.releaseType !== void 0) {
+    const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : "";
+    lines.push(`  \u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType}${suffix})`);
+  }
+}
+function formatBumpFiles(lines, workspace, dryRun, indent = "") {
+  for (const file of workspace.bumpedFiles) {
     if (dryRun) {
       lines.push(dim(`${indent}  [dry-run] Would bump ${file}`));
     } else {
@@ -105,8 +178,8 @@ function formatBumpFiles(lines, component, dryRun, indent = "") {
     }
   }
 }
-function formatChangelogFiles(lines, component, dryRun, indent = "") {
-  for (const file of component.changelogFiles) {
+function formatChangelogFiles(lines, workspace, dryRun, indent = "") {
+  for (const file of workspace.changelogFiles) {
     if (dryRun) {
       lines.push(dim(`${indent}  [dry-run] Would run: npx --yes git-cliff ... --output ${file}`));
     } else {
@@ -114,13 +187,13 @@ function formatChangelogFiles(lines, component, dryRun, indent = "") {
     }
   }
 }
-function formatUnparseableWarning(lines, component, indent = "") {
-  const unparseable = component.unparseableCommits;
+function formatUnparseableWarning(lines, workspace, indent = "") {
+  const unparseable = workspace.unparseableCommits;
   if (unparseable === void 0 || unparseable.length === 0) {
     return;
   }
   const count = unparseable.length;
-  const isPatchFloor = component.parsedCommitCount === 0;
+  const isPatchFloor = workspace.parsedCommitCount === 0;
   const suffix = isPatchFloor ? " (defaulting to patch bump)" : "";
   lines.push(`${indent}  \u26A0\uFE0F  ${count} commit${count === 1 ? "" : "s"} could not be parsed${suffix}`);
   for (const commit of unparseable) {

package/dist/esm/resolveCliffConfigPath.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { findPackageRoot } from "./findPackageRoot.js";
+import { findPackageRoot } from "@williamthorsen/nmr-core";
 function resolveCliffConfigPath(cliffConfigPath, metaUrl) {
   if (cliffConfigPath !== void 0) {
     return cliffConfigPath;

package/dist/esm/resolveCommandTags.d.ts

@@ -1,2 +1,2 @@
 import type { ResolvedTag } from './resolveReleaseTags.ts';
-export declare function resolveCommandTags(only: string[] | undefined): Promise<ResolvedTag[]>;
+export declare function resolveCommandTags(tags: string[] | undefined): Promise<ResolvedTag[]>;

package/dist/esm/resolveCommandTags.js

@@ -1,7 +1,7 @@
-import { basename } from "node:path";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
-async function resolveCommandTags(only) {
+async function resolveCommandTags(tags) {
   let discoveredPaths;
   try {
     discoveredPaths = await discoverWorkspaces();
@@ -9,25 +9,29 @@ async function resolveCommandTags(only) {
     console.error(`Error discovering workspaces: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
-  if (only !== void 0 && discoveredPaths === void 0) {
-    console.error("Error: --only is only supported for monorepo configurations");
-    process.exit(1);
+  let workspaces;
+  if (discoveredPaths !== void 0) {
+    try {
+      workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+    } catch (error) {
+      console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
   }
-  const workspaceMap = discoveredPaths === void 0 ? void 0 : new Map(discoveredPaths.map((p) => [basename(p), p]));
-  let resolvedTags = resolveReleaseTags(workspaceMap);
+  let resolvedTags = resolveReleaseTags(workspaces);
   if (resolvedTags.length === 0) {
     console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
     process.exit(1);
   }
-  if (only !== void 0) {
-    const availableNames = resolvedTags.map((t) => t.dir);
-    for (const name of only) {
-      if (!availableNames.includes(name)) {
-        console.error(`Error: Unknown package "${name}" in --only. Available: ${availableNames.join(", ")}`);
+  if (tags !== void 0) {
+    const availableTagNames = resolvedTags.map((t) => t.tag);
+    for (const name of tags) {
+      if (!availableTagNames.includes(name)) {
+        console.error(`Error: Unknown tag "${name}" in --tags. Available: ${availableTagNames.join(", ")}`);
         process.exit(1);
       }
     }
-    resolvedTags = resolvedTags.filter((t) => only.includes(t.dir));
+    resolvedTags = resolvedTags.filter((t) => tags.includes(t.tag));
   }
   return resolvedTags;
 }

package/dist/esm/resolveReleaseNotesConfig.d.ts

@@ -2,5 +2,12 @@ import type { ReleaseNotesConfig } from './types.ts';
 export interface ResolvedReleaseNotesConfig {
     releaseNotes: ReleaseNotesConfig;
     changelogJsonOutputPath: string;
+    sectionOrder: string[];
 }
-export declare function resolveReleaseNotesConfig(): Promise<ResolvedReleaseNotesConfig>;
+export interface ResolveReleaseNotesConfigOptions {
+    strictLoad?: boolean;
+}
+export declare function resolveReleaseNotesConfig(options?: ResolveReleaseNotesConfigOptions): Promise<ResolvedReleaseNotesConfig>;
+export declare function deriveSectionOrder(workTypes: Record<string, {
+    header: string;
+}>): string[];

package/dist/esm/resolveReleaseNotesConfig.js

@@ -1,19 +1,24 @@
 import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG } from "./defaults.js";
-import { loadConfig } from "./loadConfig.js";
+import { loadConfig, resolveWorkTypes } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
-async function resolveReleaseNotesConfig() {
+async function resolveReleaseNotesConfig(options = {}) {
+  const { strictLoad = false } = options;
   let rawConfig;
   try {
     rawConfig = await loadConfig();
   } catch (error) {
-    console.warn(
-      `Warning: failed to load config; using defaults: ${error instanceof Error ? error.message : String(error)}`
-    );
+    const message = error instanceof Error ? error.message : String(error);
+    if (strictLoad) {
+      console.error(`Error: failed to load config: ${message}`);
+      process.exit(1);
+    }
+    console.warn(`Warning: failed to load config; using defaults: ${message}`);
   }
   if (rawConfig === void 0) {
     return {
       releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG },
-      changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+      changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+      sectionOrder: deriveSectionOrder(resolveWorkTypes())
     };
   }
   const { config, errors, warnings } = validateConfig(rawConfig);
@@ -29,9 +34,14 @@ async function resolveReleaseNotesConfig() {
   }
   return {
     releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG, ...config.releaseNotes },
-    changelogJsonOutputPath: config.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+    changelogJsonOutputPath: config.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+    sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes))
   };
 }
+function deriveSectionOrder(workTypes) {
+  return Object.values(workTypes).map((entry) => entry.header);
+}
 export {
+  deriveSectionOrder,
   resolveReleaseNotesConfig
 };

package/dist/esm/resolveReleaseTags.d.ts

@@ -1,6 +1,7 @@
+import type { WorkspaceConfig } from './types.ts';
 export interface ResolvedTag {
     tag: string;
     dir: string;
     workspacePath: string;
 }
-export declare function resolveReleaseTags(workspaceMap?: Map<string, string>): ResolvedTag[];
+export declare function resolveReleaseTags(workspaces?: readonly WorkspaceConfig[]): ResolvedTag[];

package/dist/esm/resolveReleaseTags.js

@@ -1,12 +1,13 @@
 import { execFileSync } from "node:child_process";
 const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
-function resolveReleaseTags(workspaceMap) {
+const SEMVER_SUFFIX_PATTERN = /^\d+\.\d+\.\d+/;
+function resolveReleaseTags(workspaces) {
   const output = execFileSync("git", ["tag", "--points-at", "HEAD"], { encoding: "utf8" });
   const tags = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  if (workspaceMap === void 0) {
+  if (workspaces === void 0) {
     return resolveSinglePackageTags(tags);
   }
-  return resolveMonorepoTags(tags, workspaceMap);
+  return resolveMonorepoTags(tags, workspaces);
 }
 function resolveSinglePackageTags(tags) {
   const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
@@ -18,24 +19,28 @@ function resolveSinglePackageTags(tags) {
   }
   return matched.map((tag) => ({ tag, dir: ".", workspacePath: "." }));
 }
-function resolveMonorepoTags(tags, workspaceMap) {
+function resolveMonorepoTags(tags, workspaces) {
+  const sortedWorkspaces = [...workspaces].sort((a, b) => b.tagPrefix.length - a.tagPrefix.length);
   const resolved = [];
   for (const tag of tags) {
-    const dashV = tag.lastIndexOf("-v");
-    if (dashV === -1) {
-      continue;
+    const match = findMatchingWorkspace(tag, sortedWorkspaces);
+    if (match !== void 0) {
+      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath });
     }
-    const dir = tag.slice(0, dashV);
-    const versionPart = tag.slice(dashV + 1);
-    if (!VERSION_PATTERN.test(versionPart)) {
+  }
+  return resolved;
+}
+function findMatchingWorkspace(tag, sortedWorkspaces) {
+  for (const workspace of sortedWorkspaces) {
+    if (!tag.startsWith(workspace.tagPrefix)) {
       continue;
     }
-    const workspacePath = workspaceMap.get(dir);
-    if (workspacePath !== void 0) {
-      resolved.push({ tag, dir, workspacePath });
+    const versionSuffix = tag.slice(workspace.tagPrefix.length);
+    if (SEMVER_SUFFIX_PATTERN.test(versionSuffix)) {
+      return workspace;
     }
   }
-  return resolved;
+  return void 0;
 }
 export {
   resolveReleaseTags

package/dist/esm/showTagPrefixesCommand.d.ts

@@ -0,0 +1 @@
+export declare function showTagPrefixesCommand(): Promise<number>;