@williamthorsen/release-kit 5.4.0 → 7.0.0

package/dist/esm/previewTagPrefixes.js

@@ -1,120 +1,125 @@
-import { execFileSync } from "node:child_process";
-import { basename } from "node:path";
+import { execFileSync } from 'node:child_process';
+import { basename } from 'node:path';
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { loadConfig } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
-async function previewTagPrefixes() {
-  const workspacePaths = await discoverWorkspaces() ?? [];
-  const userConfig = await loadUserConfig();
-  const overridesByDir = buildOverrideMap(userConfig);
-  const workspaces = [];
-  for (const workspacePath of workspacePaths) {
-    workspaces.push(buildPreviewRow(workspacePath, overridesByDir));
-  }
-  const retiredPackages = buildRetiredPreviewEntries(userConfig?.retiredPackages ?? []);
-  const collisions = detectCollisions(workspaces);
-  const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages);
-  const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
-  return { workspaces, collisions, undeclaredCandidates, retiredPackages };
+export async function previewTagPrefixes() {
+    const workspacePaths = (await discoverWorkspaces()) ?? [];
+    const userConfig = await loadUserConfig();
+    const overridesByDir = buildOverrideMap(userConfig);
+    const workspaces = [];
+    for (const workspacePath of workspacePaths) {
+        workspaces.push(buildPreviewRow(workspacePath, overridesByDir));
+    }
+    const retiredPackages = buildRetiredPreviewEntries(userConfig?.retiredPackages ?? []);
+    const collisions = detectCollisions(workspaces);
+    const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages);
+    const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
+    return { workspaces, collisions, undeclaredCandidates, retiredPackages };
 }
 async function loadUserConfig() {
-  let raw;
-  try {
-    raw = await loadConfig();
-  } catch {
-    return void 0;
-  }
-  if (raw === void 0) return void 0;
-  const { config, errors } = validateConfig(raw);
-  return errors.length === 0 ? config : void 0;
+    let raw;
+    try {
+        raw = await loadConfig();
+    }
+    catch {
+        return undefined;
+    }
+    if (raw === undefined)
+        return undefined;
+    const { config, errors } = validateConfig(raw);
+    return errors.length === 0 ? config : undefined;
 }
 function buildOverrideMap(userConfig) {
-  const map = /* @__PURE__ */ new Map();
-  if (userConfig?.workspaces === void 0) return map;
-  for (const entry of userConfig.workspaces) {
-    if (entry.legacyIdentities !== void 0) {
-      map.set(entry.dir, entry.legacyIdentities);
+    const map = new Map();
+    if (userConfig?.workspaces === undefined)
+        return map;
+    for (const entry of userConfig.workspaces) {
+        if (entry.legacyIdentities !== undefined) {
+            map.set(entry.dir, entry.legacyIdentities);
+        }
     }
-  }
-  return map;
+    return map;
 }
 function buildPreviewRow(workspacePath, overridesByDir) {
-  const dir = basename(workspacePath);
-  let derivedPrefix = null;
-  let derivationError = null;
-  try {
-    derivedPrefix = deriveWorkspaceConfig(workspacePath).tagPrefix;
-  } catch (error) {
-    derivationError = error instanceof Error ? error.message : String(error);
-  }
-  const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix);
-  const declaredIdentities = overridesByDir.get(dir) ?? [];
-  const legacyEntries = declaredIdentities.map((identity) => ({
-    prefix: identity.tagPrefix,
-    tagCount: countTagsMatching(identity.tagPrefix)
-  }));
-  return {
-    workspacePath,
-    dir,
-    derivedPrefix,
-    derivationError,
-    derivedTagCount,
-    legacyEntries
-  };
+    const dir = basename(workspacePath);
+    let derivedPrefix = null;
+    let derivationError = null;
+    try {
+        derivedPrefix = deriveWorkspaceConfig(workspacePath).tagPrefix;
+    }
+    catch (error) {
+        derivationError = error instanceof Error ? error.message : String(error);
+    }
+    const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix);
+    const declaredIdentities = overridesByDir.get(dir) ?? [];
+    const legacyEntries = declaredIdentities.map((identity) => ({
+        prefix: identity.tagPrefix,
+        tagCount: countTagsMatching(identity.tagPrefix),
+    }));
+    return {
+        workspacePath,
+        dir,
+        derivedPrefix,
+        derivationError,
+        derivedTagCount,
+        legacyEntries,
+    };
 }
 function countTagsMatching(prefix) {
-  try {
-    const output = execFileSync("git", ["tag", "--list", `${prefix}*`], {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return output.split("\n").filter((line) => line.trim() !== "").length;
-  } catch {
-    return 0;
-  }
+    try {
+        const output = execFileSync('git', ['tag', '--list', `${prefix}*`], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.split('\n').filter((line) => line.trim() !== '').length;
+    }
+    catch {
+        return 0;
+    }
 }
 function detectCollisions(rows) {
-  const pathsByPrefix = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (row.derivedPrefix === null) continue;
-    const existing = pathsByPrefix.get(row.derivedPrefix);
-    if (existing === void 0) {
-      pathsByPrefix.set(row.derivedPrefix, [row.workspacePath]);
-    } else {
-      existing.push(row.workspacePath);
+    const pathsByPrefix = new Map();
+    for (const row of rows) {
+        if (row.derivedPrefix === null)
+            continue;
+        const existing = pathsByPrefix.get(row.derivedPrefix);
+        if (existing === undefined) {
+            pathsByPrefix.set(row.derivedPrefix, [row.workspacePath]);
+        }
+        else {
+            existing.push(row.workspacePath);
+        }
     }
-  }
-  const collisions = [];
-  for (const [tagPrefix, workspacePaths] of pathsByPrefix) {
-    if (workspacePaths.length > 1) {
-      collisions.push({ tagPrefix, workspacePaths });
+    const collisions = [];
+    for (const [tagPrefix, workspacePaths] of pathsByPrefix) {
+        if (workspacePaths.length > 1) {
+            collisions.push({ tagPrefix, workspacePaths });
+        }
     }
-  }
-  return collisions;
+    return collisions;
 }
 function collectKnownPrefixes(rows, retiredPackages) {
-  const known = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    if (row.derivedPrefix !== null) known.add(row.derivedPrefix);
-    for (const entry of row.legacyEntries) {
-      known.add(entry.prefix);
+    const known = new Set();
+    for (const row of rows) {
+        if (row.derivedPrefix !== null)
+            known.add(row.derivedPrefix);
+        for (const entry of row.legacyEntries) {
+            known.add(entry.prefix);
+        }
+    }
+    for (const retired of retiredPackages) {
+        known.add(retired.tagPrefix);
     }
-  }
-  for (const retired of retiredPackages) {
-    known.add(retired.tagPrefix);
-  }
-  return [...known];
+    return [...known];
 }
 function buildRetiredPreviewEntries(retiredPackages) {
-  return retiredPackages.map((retired) => ({
-    name: retired.name,
-    tagPrefix: retired.tagPrefix,
-    tagCount: countTagsMatching(retired.tagPrefix),
-    ...retired.successor !== void 0 ? { successor: retired.successor } : {}
-  }));
+    return retiredPackages.map((retired) => ({
+        name: retired.name,
+        tagPrefix: retired.tagPrefix,
+        tagCount: countTagsMatching(retired.tagPrefix),
+        ...(retired.successor !== undefined ? { successor: retired.successor } : {}),
+    }));
 }
-export {
-  previewTagPrefixes
-};

package/dist/esm/propagateBumps.d.ts

@@ -1,5 +1,5 @@
-import type { DependencyGraph } from './buildDependencyGraph.ts';
-import type { PropagationSource, ReleaseType } from './types.ts';
+import type { DependencyGraph } from './buildDependencyGraph.js';
+import type { PropagationSource, ReleaseType } from './types.js';
 export interface ReleaseEntry {
     releaseType: ReleaseType;
     propagatedFrom?: PropagationSource[];

package/dist/esm/propagateBumps.js

@@ -1,54 +1,52 @@
 import { bumpVersion } from "./bumpVersion.js";
-function propagateBumps(directBumps, graph, currentVersions) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [dir, entry] of directBumps) {
-    result.set(dir, { ...entry });
-  }
-  const queue = [...directBumps.keys()];
-  const visited = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
-    const dir = queue.shift();
-    if (dir === void 0) {
-      break;
+export function propagateBumps(directBumps, graph, currentVersions) {
+    const result = new Map();
+    for (const [dir, entry] of directBumps) {
+        result.set(dir, { ...entry });
     }
-    if (visited.has(dir)) {
-      continue;
+    const queue = [...directBumps.keys()];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        if (dir === undefined) {
+            break;
+        }
+        if (visited.has(dir)) {
+            continue;
+        }
+        visited.add(dir);
+        const packageName = graph.dirToPackageName.get(dir);
+        if (packageName === undefined) {
+            continue;
+        }
+        const currentVersion = currentVersions.get(dir);
+        const entry = result.get(dir);
+        if (currentVersion === undefined || entry === undefined) {
+            continue;
+        }
+        const newVersion = entry.newVersionOverride ?? bumpVersion(currentVersion, entry.releaseType);
+        const dependents = graph.dependentsOf.get(packageName);
+        if (dependents === undefined) {
+            continue;
+        }
+        for (const dependent of dependents) {
+            const dependentDir = dependent.dir;
+            const existing = result.get(dependentDir);
+            const propagationInfo = { packageName, newVersion };
+            if (existing === undefined) {
+                result.set(dependentDir, {
+                    releaseType: 'patch',
+                    propagatedFrom: [propagationInfo],
+                });
+            }
+            else {
+                const existingPropagated = existing.propagatedFrom ?? [];
+                existing.propagatedFrom = [...existingPropagated, propagationInfo];
+            }
+            if (!visited.has(dependentDir)) {
+                queue.push(dependentDir);
+            }
+        }
     }
-    visited.add(dir);
-    const packageName = graph.dirToPackageName.get(dir);
-    if (packageName === void 0) {
-      continue;
-    }
-    const currentVersion = currentVersions.get(dir);
-    const entry = result.get(dir);
-    if (currentVersion === void 0 || entry === void 0) {
-      continue;
-    }
-    const newVersion = entry.newVersionOverride ?? bumpVersion(currentVersion, entry.releaseType);
-    const dependents = graph.dependentsOf.get(packageName);
-    if (dependents === void 0) {
-      continue;
-    }
-    for (const dependent of dependents) {
-      const dependentDir = dependent.dir;
-      const existing = result.get(dependentDir);
-      const propagationInfo = { packageName, newVersion };
-      if (existing === void 0) {
-        result.set(dependentDir, {
-          releaseType: "patch",
-          propagatedFrom: [propagationInfo]
-        });
-      } else {
-        const existingPropagated = existing.propagatedFrom ?? [];
-        existing.propagatedFrom = [...existingPropagated, propagationInfo];
-      }
-      if (!visited.has(dependentDir)) {
-        queue.push(dependentDir);
-      }
-    }
-  }
-  return result;
+    return result;
 }
-export {
-  propagateBumps
-};

package/dist/esm/publish.d.ts

@@ -1,5 +1,5 @@
-import type { PackageManager } from './detectPackageManager.ts';
-import type { ResolvedTag } from './resolveReleaseTags.ts';
+import type { PackageManager } from './detectPackageManager.js';
+import type { ResolvedTag } from './resolveReleaseTags.js';
 export interface PublishOptions {
     dryRun: boolean;
     provenance: boolean;

package/dist/esm/publish.js

@@ -1,33 +1,27 @@
-import { execFileSync } from "node:child_process";
-function publishPackage(resolvedTag, packageManager, options) {
-  const { dryRun, provenance } = options;
-  const executable = resolveExecutable(packageManager);
-  const args = buildPublishArgs(packageManager, { dryRun, provenance });
-  console.info(
-    `
-${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${resolvedTag.workspacePath})`
-  );
-  execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: "inherit" });
+import { execFileSync } from 'node:child_process';
+export function publishPackage(resolvedTag, packageManager, options) {
+    const { dryRun, provenance } = options;
+    const executable = resolveExecutable(packageManager);
+    const args = buildPublishArgs(packageManager, { dryRun, provenance });
+    console.info(`\n${dryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
+    execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
 }
 function resolveExecutable(packageManager) {
-  if (packageManager === "yarn-berry") {
-    return "yarn";
-  }
-  return packageManager;
+    if (packageManager === 'yarn-berry') {
+        return 'yarn';
+    }
+    return packageManager;
 }
 function buildPublishArgs(packageManager, options) {
-  const args = packageManager === "yarn-berry" ? ["npm", "publish"] : ["publish"];
-  if (options.dryRun) {
-    args.push("--dry-run");
-  }
-  if (packageManager === "pnpm") {
-    args.push("--no-git-checks");
-  }
-  if (options.provenance && packageManager !== "yarn") {
-    args.push("--provenance");
-  }
-  return args;
+    const args = packageManager === 'yarn-berry' ? ['npm', 'publish'] : ['publish'];
+    if (options.dryRun) {
+        args.push('--dry-run');
+    }
+    if (packageManager === 'pnpm') {
+        args.push('--no-git-checks');
+    }
+    if (options.provenance && packageManager !== 'yarn') {
+        args.push('--provenance');
+    }
+    return args;
 }
-export {
-  publishPackage
-};

package/dist/esm/publishCommand.js

@@ -1,6 +1,6 @@
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
@@ -9,95 +9,84 @@ import { publishPackage } from "./publish.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
 const publishFlagSchema = {
-  dryRun: { long: "--dry-run", type: "boolean" },
-  noGitChecks: { long: "--no-git-checks", type: "boolean" },
-  provenance: { long: "--provenance", type: "boolean" },
-  tags: { long: "--tags", type: "string" }
+    dryRun: { long: '--dry-run', type: 'boolean' },
+    noGitChecks: { long: '--no-git-checks', type: 'boolean' },
+    provenance: { long: '--provenance', type: 'boolean' },
+    tags: { long: '--tags', type: 'string' },
 };
-async function publishCommand(argv) {
-  let parsed;
-  try {
-    parsed = parseArgs(argv, publishFlagSchema);
-  } catch (error) {
-    console.error(`Error: ${translateParseError(error)}`);
-    process.exit(1);
-  }
-  const { dryRun, noGitChecks, provenance } = parsed.flags;
-  if (!dryRun && !noGitChecks) {
-    try {
-      assertCleanWorkingTree();
-    } catch (error) {
-      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-      process.exit(1);
-    }
-  }
-  const requestedTags = parseRequestedTags(parsed.flags.tags);
-  const resolvedTags = await resolveCommandTags(requestedTags);
-  if (resolvedTags.length === 0) {
-    return;
-  }
-  const publishableTags = filterPublishableTags(resolvedTags, requestedTags !== void 0);
-  if (publishableTags.length === 0) {
-    console.info("Nothing to publish.");
-    return;
-  }
-  const packageManager = detectPackageManager();
-  const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig();
-  const shouldInject = releaseNotes.shouldInjectIntoReadme;
-  console.info(dryRun ? "[dry-run] Would publish:" : "Publishing:");
-  for (const { tag, workspacePath } of publishableTags) {
-    console.info(`  ${tag} (${workspacePath})`);
-  }
-  const published = [];
-  try {
-    for (const resolvedTag of publishableTags) {
-      let readmePath;
-      let originalReadme;
-      if (shouldInject) {
-        readmePath = resolveReadmePath(resolvedTag.workspacePath);
-        if (readmePath !== void 0) {
-          originalReadme = injectReleaseNotesIntoReadme(
-            readmePath,
-            join(resolvedTag.workspacePath, changelogJsonOutputPath),
-            resolvedTag.tag,
-            sectionOrder
-          );
+export async function publishCommand(argv) {
+    const parsed = parseArgsOrExit(argv, publishFlagSchema);
+    const { dryRun, noGitChecks, provenance } = parsed.flags;
+    if (!dryRun && !noGitChecks) {
+        try {
+            assertCleanWorkingTree();
+        }
+        catch (error) {
+            reportError(error instanceof Error ? error.message : String(error));
+            process.exit(1);
         }
-      }
-      try {
-        publishPackage(resolvedTag, packageManager, { dryRun, provenance });
-        published.push(resolvedTag.tag);
-      } finally {
-        if (readmePath !== void 0 && originalReadme !== void 0) {
-          writeFileSync(readmePath, originalReadme, "utf8");
+    }
+    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const resolvedTags = await resolveCommandTags(requestedTags);
+    if (resolvedTags.length === 0) {
+        return;
+    }
+    const publishableTags = filterPublishableTags(resolvedTags, requestedTags !== undefined);
+    if (publishableTags.length === 0) {
+        console.info('Nothing to publish.');
+        return;
+    }
+    const packageManager = detectPackageManager();
+    const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig();
+    const shouldInject = releaseNotes.shouldInjectIntoReadme;
+    console.info(dryRun ? '[dry-run] Would publish:' : 'Publishing:');
+    for (const { tag, workspacePath } of publishableTags) {
+        console.info(`  ${tag} (${workspacePath})`);
+    }
+    const published = [];
+    try {
+        for (const resolvedTag of publishableTags) {
+            let readmePath;
+            let originalReadme;
+            if (shouldInject) {
+                readmePath = resolveReadmePath(resolvedTag.workspacePath);
+                if (readmePath !== undefined) {
+                    originalReadme = injectReleaseNotesIntoReadme(readmePath, join(resolvedTag.workspacePath, changelogJsonOutputPath), resolvedTag.tag, sectionOrder);
+                }
+            }
+            try {
+                publishPackage(resolvedTag, packageManager, { dryRun, provenance });
+                published.push(resolvedTag.tag);
+            }
+            finally {
+                if (readmePath !== undefined && originalReadme !== undefined) {
+                    writeFileSync(readmePath, originalReadme, 'utf8');
+                }
+            }
         }
-      }
     }
-  } catch (error) {
-    if (published.length > 0) {
-      console.warn("Packages published before failure:");
-      for (const t of published) {
-        console.warn(`  ${t}`);
-      }
+    catch (error) {
+        if (published.length > 0) {
+            console.warn('Packages published before failure:');
+            for (const t of published) {
+                console.warn(`  ${t}`);
+            }
+        }
+        reportError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
     }
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
 }
 function filterPublishableTags(resolvedTags, isExplicit) {
-  const publishable = [];
-  const unpublishable = [];
-  for (const tag of resolvedTags) {
-    (tag.isPublishable ? publishable : unpublishable).push(tag);
-  }
-  if (isExplicit && unpublishable.length > 0) {
-    for (const { tag, workspacePath } of unpublishable) {
-      console.error(`Error: ${tag} (${workspacePath}) cannot be published: package.json#private is true.`);
+    const publishable = [];
+    const unpublishable = [];
+    for (const tag of resolvedTags) {
+        (tag.isPublishable ? publishable : unpublishable).push(tag);
     }
-    process.exit(1);
-  }
-  return publishable;
+    if (isExplicit && unpublishable.length > 0) {
+        for (const { tag, workspacePath } of unpublishable) {
+            reportError(`${tag} (${workspacePath}) cannot be published: package.json#private is true.`);
+        }
+        process.exit(1);
+    }
+    return publishable;
 }
-export {
-  publishCommand
-};