@williamthorsen/release-kit 5.4.0 → 7.0.0

package/dist/esm/pushCommand.js

@@ -1,47 +1,40 @@
-import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { parseRequestedTags } from "./parseRequestedTags.js";
 import { pushRelease } from "./pushRelease.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
 const pushFlagSchema = {
-  dryRun: { long: "--dry-run", type: "boolean" },
-  tags: { long: "--tags", type: "string" },
-  tagsOnly: { long: "--tags-only", type: "boolean" }
+    dryRun: { long: '--dry-run', type: 'boolean' },
+    tags: { long: '--tags', type: 'string' },
+    tagsOnly: { long: '--tags-only', type: 'boolean' },
 };
-async function pushCommand(argv) {
-  let parsed;
-  try {
-    parsed = parseArgs(argv, pushFlagSchema);
-  } catch (error) {
-    console.error(`Error: ${translateParseError(error)}`);
-    process.exit(1);
-  }
-  const { dryRun, tagsOnly } = parsed.flags;
-  const requestedTags = parseRequestedTags(parsed.flags.tags);
-  const resolvedTags = await resolveCommandTags(requestedTags);
-  if (resolvedTags.length === 0) {
-    return;
-  }
-  const prefix = dryRun ? "[dry-run] Would push" : "Pushing";
-  if (!tagsOnly) {
-    console.info(`${prefix} branch and ${resolvedTags.length} tag(s):`);
-  } else {
-    console.info(`${prefix} ${resolvedTags.length} tag(s):`);
-  }
-  for (const { tag } of resolvedTags) {
-    console.info(`  ${tag}`);
-  }
-  try {
-    const steps = pushRelease(resolvedTags, { dryRun, tagsOnly });
-    if (dryRun) {
-      for (const step of steps) {
-        console.info(`[dry-run] ${step.command.join(" ")}`);
-      }
+export async function pushCommand(argv) {
+    const parsed = parseArgsOrExit(argv, pushFlagSchema);
+    const { dryRun, tagsOnly } = parsed.flags;
+    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const resolvedTags = await resolveCommandTags(requestedTags);
+    if (resolvedTags.length === 0) {
+        return;
+    }
+    const prefix = dryRun ? '[dry-run] Would push' : 'Pushing';
+    if (!tagsOnly) {
+        console.info(`${prefix} branch and ${resolvedTags.length} tag(s):`);
+    }
+    else {
+        console.info(`${prefix} ${resolvedTags.length} tag(s):`);
+    }
+    for (const { tag } of resolvedTags) {
+        console.info(`  ${tag}`);
+    }
+    try {
+        const steps = pushRelease(resolvedTags, { dryRun, tagsOnly });
+        if (dryRun) {
+            for (const step of steps) {
+                console.info(`[dry-run] ${step.command.join(' ')}`);
+            }
+        }
+    }
+    catch (error) {
+        reportError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
     }
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
 }
-export {
-  pushCommand
-};

package/dist/esm/pushRelease.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedTag } from './resolveReleaseTags.ts';
+import type { ResolvedTag } from './resolveReleaseTags.js';
 export interface PushReleaseOptions {
     dryRun?: boolean;
     tagsOnly?: boolean;

package/dist/esm/pushRelease.js

@@ -1,26 +1,23 @@
-import { execFileSync } from "node:child_process";
-function pushRelease(resolvedTags, options = {}) {
-  const { dryRun = false, tagsOnly = false } = options;
-  const steps = [];
-  if (!tagsOnly) {
-    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const command = ["git", "push", "origin", branch];
-    steps.push({ type: "branch", ref: branch, command });
-  }
-  for (const { tag } of resolvedTags) {
-    const command = ["git", "push", "--no-follow-tags", "origin", tag];
-    steps.push({ type: "tag", ref: tag, command });
-  }
-  if (!dryRun) {
-    for (const step of steps) {
-      execFileSync(step.command[0], step.command.slice(1), { stdio: "inherit" });
+import { execFileSync } from 'node:child_process';
+export function pushRelease(resolvedTags, options = {}) {
+    const { dryRun = false, tagsOnly = false } = options;
+    const steps = [];
+    if (!tagsOnly) {
+        const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const command = ['git', 'push', 'origin', branch];
+        steps.push({ type: 'branch', ref: branch, command });
     }
-  }
-  return steps;
+    for (const { tag } of resolvedTags) {
+        const command = ['git', 'push', '--no-follow-tags', 'origin', tag];
+        steps.push({ type: 'tag', ref: tag, command });
+    }
+    if (!dryRun) {
+        for (const step of steps) {
+            execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
+        }
+    }
+    return steps;
 }
-export {
-  pushRelease
-};

package/dist/esm/readCurrentVersion.js

@@ -1,21 +1,17 @@
-import { readFileSync } from "node:fs";
+import { readFileSync } from 'node:fs';
 function hasVersionField(value) {
-  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
+    return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
-function readCurrentVersion(filePath) {
-  try {
-    const content = readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(content);
-    if (hasVersionField(parsed)) {
-      return parsed.version;
+export function readCurrentVersion(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (hasVersionField(parsed)) {
+            return parsed.version;
+        }
     }
-  } catch (error) {
-    console.warn(
-      `Failed to read current version from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  return void 0;
+    catch (error) {
+        console.warn(`Failed to read current version from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return undefined;
 }
-export {
-  readCurrentVersion
-};

package/dist/esm/releasePrepare.d.ts

@@ -1,4 +1,4 @@
-import type { PrepareResult, ReleaseConfig, ReleaseType } from './types.ts';
+import type { PrepareResult, ReleaseConfig, ReleaseType } from './types.js';
 export interface ReleasePrepareOptions {
     dryRun: boolean;
     force?: boolean;

package/dist/esm/releasePrepare.js

@@ -1,17 +1,9 @@
-import { execSync } from "node:child_process";
+import { execSync } from 'node:child_process';
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
 import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
-import {
-  mergeChangelogEntriesWithDisk,
-  resolveChangelogJsonPath,
-  upsertChangelogJsonAndReturn
-} from "./changelogJsonFile.js";
-import {
-  applyChangelogOverrides,
-  formatStaleOverrideKeyWarning,
-  loadOverridesForScopes
-} from "./changelogOverrides.js";
+import { mergeChangelogEntriesWithDisk, resolveChangelogJsonPath, upsertChangelogJsonAndReturn, } from "./changelogJsonFile.js";
+import { applyChangelogOverrides, formatStaleOverrideKeyWarning, loadOverridesForScopes, } from "./changelogOverrides.js";
 import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { isForwardVersion } from "./compareVersions.js";
 import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
@@ -24,242 +16,232 @@ import { writeChangelogMarkdown } from "./renderChangelogMarkdown.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
 import { refreshGitCliffCache } from "./runGitCliff.js";
 import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
-function releasePrepare(config, options) {
-  const { dryRun, bumpOverride, setVersion, withReleaseNotes } = options;
-  const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
-  const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-  const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
-  const overridesResult = loadOverridesForScopes({ project: "." });
-  if (overridesResult.errors.length > 0) {
-    throw new Error(`Failed to load changelog overrides:
-  - ${overridesResult.errors.join("\n  - ")}`);
-  }
-  const overrides = overridesResult.project;
-  const { tag, commits } = getCommitsSinceTarget([config.tagPrefix]);
-  let releaseType;
-  let parsedCommitCount;
-  let unparseableCommits;
-  const collector = createPolicyViolationCollector();
-  let bump;
-  if (setVersion !== void 0) {
-    const primaryPackageFile = config.packageFiles[0];
-    if (primaryPackageFile === void 0) {
-      throw new Error("No package files specified");
+export function releasePrepare(config, options) {
+    const { dryRun, bumpOverride, setVersion, withReleaseNotes } = options;
+    const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
+    const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+    const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
+    const overridesResult = loadOverridesForScopes({ project: '.' });
+    if (overridesResult.errors.length > 0) {
+        throw new Error(`Failed to load changelog overrides:\n  - ${overridesResult.errors.join('\n  - ')}`);
     }
-    const currentVersion = readCurrentVersion(primaryPackageFile);
-    if (currentVersion === void 0) {
-      throw new Error(`Cannot validate --set-version: failed to read current version from ${primaryPackageFile}`);
+    const overrides = overridesResult.project;
+    const { tag, commits } = getCommitsSinceTarget([config.tagPrefix]);
+    let releaseType;
+    let parsedCommitCount;
+    let unparseableCommits;
+    const collector = createPolicyViolationCollector();
+    let bump;
+    if (setVersion !== undefined) {
+        const primaryPackageFile = config.packageFiles[0];
+        if (primaryPackageFile === undefined) {
+            throw new Error('No package files specified');
+        }
+        const currentVersion = readCurrentVersion(primaryPackageFile);
+        if (currentVersion === undefined) {
+            throw new Error(`Cannot validate --set-version: failed to read current version from ${primaryPackageFile}`);
+        }
+        if (!isForwardVersion(currentVersion, setVersion)) {
+            throw new Error(`--set-version ${setVersion} is not greater than current version ${currentVersion}`);
+        }
+        refreshGitCliffCache();
+        bump = setAllVersions(config.packageFiles, setVersion, dryRun);
     }
-    if (!isForwardVersion(currentVersion, setVersion)) {
-      throw new Error(`--set-version ${setVersion} is not greater than current version ${currentVersion}`);
+    else {
+        if (bumpOverride === undefined) {
+            const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases, {
+                breakingPolicies,
+                onPolicyViolation: collector.onPolicyViolation,
+            });
+            parsedCommitCount = determination.parsedCommitCount;
+            unparseableCommits = determination.unparseableCommits;
+            releaseType = determination.releaseType;
+        }
+        else {
+            releaseType = bumpOverride;
+        }
+        if (releaseType === undefined) {
+            const skipped = buildSkippedSinglePackage({
+                commitCount: commits.length,
+                previousTag: tag,
+                parsedCommitCount,
+                unparseableCommits,
+                policyViolations: collector.violations.length > 0 ? collector.violations : undefined,
+            });
+            return {
+                workspaces: [skipped],
+                tags: [],
+                dryRun,
+            };
+        }
+        refreshGitCliffCache();
+        bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
     }
-    refreshGitCliffCache();
-    bump = setAllVersions(config.packageFiles, setVersion, dryRun);
-  } else {
-    if (bumpOverride === void 0) {
-      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases, {
-        breakingPolicies,
-        onPolicyViolation: collector.onPolicyViolation
-      });
-      parsedCommitCount = determination.parsedCommitCount;
-      unparseableCommits = determination.unparseableCommits;
-      releaseType = determination.releaseType;
-    } else {
-      releaseType = bumpOverride;
+    const newTag = `${config.tagPrefix}${bump.newVersion}`;
+    const overrideWarnings = [];
+    const { changelogFiles, changelogJsonFiles } = writeSinglePackageChangelogs({
+        config,
+        commits,
+        newTag,
+        newVersion: bump.newVersion,
+        dryRun,
+        overrides,
+        overrideWarnings,
+    });
+    maybeWriteSinglePackagePreviews(withReleaseNotes === true, config, newTag, changelogJsonFiles[0], dryRun);
+    const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
+    let formatCommand;
+    if (formatCommandStr !== undefined) {
+        const modifiedFiles = [
+            ...config.packageFiles,
+            ...config.changelogPaths.map((p) => `${p}/CHANGELOG.md`),
+            ...changelogJsonFiles,
+        ];
+        const fullCommand = `${formatCommandStr} ${modifiedFiles.join(' ')}`;
+        if (dryRun) {
+            formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
+        }
+        else {
+            try {
+                execSync(fullCommand, { stdio: 'inherit' });
+            }
+            catch (error) {
+                const baseMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`format stage: ${baseMessage} (command: '${fullCommand}')`, { cause: error });
+            }
+            formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
+        }
     }
-    if (releaseType === void 0) {
-      const skipped = buildSkippedSinglePackage({
-        commitCount: commits.length,
+    const released = buildReleasedSinglePackage({
+        commits,
+        bump,
+        newTag,
+        changelogFiles,
         previousTag: tag,
         parsedCommitCount,
+        releaseType,
         unparseableCommits,
-        policyViolations: collector.violations.length > 0 ? collector.violations : void 0
-      });
-      return {
-        workspaces: [skipped],
-        tags: [],
-        dryRun
-      };
-    }
-    refreshGitCliffCache();
-    bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
-  }
-  const newTag = `${config.tagPrefix}${bump.newVersion}`;
-  const overrideWarnings = [];
-  const { changelogFiles, changelogJsonFiles } = writeSinglePackageChangelogs({
-    config,
-    commits,
-    newTag,
-    newVersion: bump.newVersion,
-    dryRun,
-    overrides,
-    overrideWarnings
-  });
-  maybeWriteSinglePackagePreviews(withReleaseNotes === true, config, newTag, changelogJsonFiles[0], dryRun);
-  const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
-  let formatCommand;
-  if (formatCommandStr !== void 0) {
-    const modifiedFiles = [
-      ...config.packageFiles,
-      ...config.changelogPaths.map((p) => `${p}/CHANGELOG.md`),
-      ...changelogJsonFiles
-    ];
-    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
-    if (dryRun) {
-      formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
-    } else {
-      try {
-        execSync(fullCommand, { stdio: "inherit" });
-      } catch (error) {
-        const baseMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`format stage: ${baseMessage} (command: '${fullCommand}')`, { cause: error });
-      }
-      formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
+        policyViolations: collector.violations.length > 0 ? collector.violations : undefined,
+        setVersion,
+    });
+    const result = {
+        workspaces: [released],
+        tags: [newTag],
+        formatCommand,
+        dryRun,
+    };
+    if (overrideWarnings.length > 0) {
+        result.warnings = overrideWarnings;
     }
-  }
-  const released = buildReleasedSinglePackage({
-    commits,
-    bump,
-    newTag,
-    changelogFiles,
-    previousTag: tag,
-    parsedCommitCount,
-    releaseType,
-    unparseableCommits,
-    policyViolations: collector.violations.length > 0 ? collector.violations : void 0,
-    setVersion
-  });
-  const result = {
-    workspaces: [released],
-    tags: [newTag],
-    formatCommand,
-    dryRun
-  };
-  if (overrideWarnings.length > 0) {
-    result.warnings = overrideWarnings;
-  }
-  return result;
+    return result;
 }
 function buildSkippedSinglePackage(args) {
-  const skipped = {
-    status: "skipped",
-    commitCount: args.commitCount,
-    skipReason: "No release-worthy changes found. Skipping."
-  };
-  if (args.previousTag !== void 0) {
-    skipped.previousTag = args.previousTag;
-  }
-  if (args.parsedCommitCount !== void 0) {
-    skipped.parsedCommitCount = args.parsedCommitCount;
-  }
-  if (args.unparseableCommits !== void 0) {
-    skipped.unparseableCommits = args.unparseableCommits;
-  }
-  if (args.policyViolations !== void 0) {
-    skipped.policyViolations = args.policyViolations;
-  }
-  return skipped;
+    const skipped = {
+        status: 'skipped',
+        commitCount: args.commitCount,
+        skipReason: 'No release-worthy changes found. Skipping.',
+    };
+    if (args.previousTag !== undefined) {
+        skipped.previousTag = args.previousTag;
+    }
+    if (args.parsedCommitCount !== undefined) {
+        skipped.parsedCommitCount = args.parsedCommitCount;
+    }
+    if (args.unparseableCommits !== undefined) {
+        skipped.unparseableCommits = args.unparseableCommits;
+    }
+    if (args.policyViolations !== undefined) {
+        skipped.policyViolations = args.policyViolations;
+    }
+    return skipped;
 }
 function buildReleasedSinglePackage(args) {
-  const {
-    commits,
-    bump,
-    newTag,
-    changelogFiles,
-    previousTag,
-    parsedCommitCount,
-    releaseType,
-    unparseableCommits,
-    policyViolations,
-    setVersion
-  } = args;
-  const released = {
-    status: "released",
-    commitCount: commits.length,
-    currentVersion: bump.currentVersion,
-    newVersion: bump.newVersion,
-    tag: newTag,
-    bumpedFiles: bump.files,
-    changelogFiles,
-    commits
-  };
-  if (previousTag !== void 0) {
-    released.previousTag = previousTag;
-  }
-  if (parsedCommitCount !== void 0) {
-    released.parsedCommitCount = parsedCommitCount;
-  }
-  if (releaseType !== void 0) {
-    released.releaseType = releaseType;
-  }
-  if (unparseableCommits !== void 0) {
-    released.unparseableCommits = unparseableCommits;
-  }
-  if (policyViolations !== void 0) {
-    released.policyViolations = policyViolations;
-  }
-  if (setVersion !== void 0) {
-    released.setVersion = setVersion;
-  }
-  return released;
+    const { commits, bump, newTag, changelogFiles, previousTag, parsedCommitCount, releaseType, unparseableCommits, policyViolations, setVersion, } = args;
+    const released = {
+        status: 'released',
+        commitCount: commits.length,
+        currentVersion: bump.currentVersion,
+        newVersion: bump.newVersion,
+        tag: newTag,
+        bumpedFiles: bump.files,
+        changelogFiles,
+        commits,
+    };
+    if (previousTag !== undefined) {
+        released.previousTag = previousTag;
+    }
+    if (parsedCommitCount !== undefined) {
+        released.parsedCommitCount = parsedCommitCount;
+    }
+    if (releaseType !== undefined) {
+        released.releaseType = releaseType;
+    }
+    if (unparseableCommits !== undefined) {
+        released.unparseableCommits = unparseableCommits;
+    }
+    if (policyViolations !== undefined) {
+        released.policyViolations = policyViolations;
+    }
+    if (setVersion !== undefined) {
+        released.setVersion = setVersion;
+    }
+    return released;
 }
 function writeSinglePackageChangelogs(args) {
-  const { config, commits, newTag, newVersion, dryRun, overrides, overrideWarnings } = args;
-  const isEmptyRange = commits.length === 0;
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const baseEntries = isEmptyRange ? [buildEmptyReleaseEntry(newVersion, today)] : buildChangelogEntries(config, newTag);
-  const applied = applyChangelogOverrides(baseEntries, overrides);
-  if (applied.errors.length > 0) {
-    throw new Error(`Changelog override application failed:
-  - ${applied.errors.join("\n  - ")}`);
-  }
-  overrideWarnings.push(...applied.warnings);
-  const matchedSet = new Set(applied.matchedKeys);
-  for (const overrideKey of overrides.keys()) {
-    if (!matchedSet.has(overrideKey)) {
-      overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
+    const { config, commits, newTag, newVersion, dryRun, overrides, overrideWarnings } = args;
+    const isEmptyRange = commits.length === 0;
+    const today = new Date().toISOString().slice(0, 10);
+    const baseEntries = isEmptyRange
+        ? [buildEmptyReleaseEntry(newVersion, today)]
+        : buildChangelogEntries(config, newTag);
+    const applied = applyChangelogOverrides(baseEntries, overrides);
+    if (applied.errors.length > 0) {
+        throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
     }
-  }
-  const sectionOrder = deriveSectionOrder(resolveWorkTypes(config.workTypes));
-  const changelogFiles = [];
-  const changelogJsonFiles = [];
-  for (const changelogPath of config.changelogPaths) {
-    const jsonPath = resolveChangelogJsonPath(config, changelogPath);
-    const shouldWriteJson = config.changelogJson.enabled && !dryRun;
-    const mergedEntries = shouldWriteJson ? upsertChangelogJsonAndReturn(jsonPath, applied.entries) : mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
-    if (config.changelogJson.enabled) {
-      changelogJsonFiles.push(jsonPath);
+    overrideWarnings.push(...applied.warnings);
+    const matchedSet = new Set(applied.matchedKeys);
+    for (const overrideKey of overrides.keys()) {
+        if (!matchedSet.has(overrideKey)) {
+            overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
+        }
     }
-    changelogFiles.push(
-      writeChangelogMarkdown({
-        changelogPath,
-        entries: mergedEntries,
-        sectionOrder,
-        dryRun
-      })
-    );
-  }
-  return { changelogFiles, changelogJsonFiles };
+    const sectionOrder = deriveSectionOrder(resolveWorkTypes(config.workTypes));
+    const changelogFiles = [];
+    const changelogJsonFiles = [];
+    for (const changelogPath of config.changelogPaths) {
+        const jsonPath = resolveChangelogJsonPath(config, changelogPath);
+        const shouldWriteJson = config.changelogJson.enabled && !dryRun;
+        const mergedEntries = shouldWriteJson
+            ? upsertChangelogJsonAndReturn(jsonPath, applied.entries)
+            : mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
+        if (config.changelogJson.enabled) {
+            changelogJsonFiles.push(jsonPath);
+        }
+        changelogFiles.push(writeChangelogMarkdown({
+            changelogPath,
+            entries: mergedEntries,
+            sectionOrder,
+            dryRun,
+        }));
+    }
+    return { changelogFiles, changelogJsonFiles };
 }
 function maybeWriteSinglePackagePreviews(withReleaseNotes, config, newTag, changelogJsonPath, dryRun) {
-  if (!withReleaseNotes) {
-    return;
-  }
-  if (!config.changelogJson.enabled) {
-    console.warn("Warning: --with-release-notes requires changelogJson.enabled; skipping preview generation");
-    return;
-  }
-  if (changelogJsonPath === void 0) {
-    return;
-  }
-  writeReleaseNotesPreviews({
-    workspacePath: process.cwd(),
-    tag: newTag,
-    changelogJsonPath,
-    sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes)),
-    dryRun
-  });
+    if (!withReleaseNotes) {
+        return;
+    }
+    if (!config.changelogJson.enabled) {
+        console.warn('Warning: --with-release-notes requires changelogJson.enabled; skipping preview generation');
+        return;
+    }
+    if (changelogJsonPath === undefined) {
+        return;
+    }
+    writeReleaseNotesPreviews({
+        workspacePath: process.cwd(),
+        tag: newTag,
+        changelogJsonPath,
+        sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes)),
+        dryRun,
+    });
 }
-export {
-  releasePrepare
-};