@williamthorsen/release-kit 5.4.0 → 7.0.0

package/dist/esm/bumpAllVersions.js

@@ -1,62 +1,61 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from 'node:fs';
 import { bumpVersion } from "./bumpVersion.js";
 function isPackageJson(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 bumpAllVersions(packageFiles, releaseType, dryRun) {
-  const firstFile = packageFiles[0];
-  if (firstFile === void 0) {
-    throw new Error("No package files specified");
-  }
-  const firstPkg = readPackageJson(firstFile);
-  const currentVersion = firstPkg.version;
-  const newVersion = bumpVersion(currentVersion, releaseType);
-  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
-  return { currentVersion, newVersion, files: [...packageFiles] };
+export function bumpAllVersions(packageFiles, releaseType, dryRun) {
+    const firstFile = packageFiles[0];
+    if (firstFile === undefined) {
+        throw new Error('No package files specified');
+    }
+    const firstPkg = readPackageJson(firstFile);
+    const currentVersion = firstPkg.version;
+    const newVersion = bumpVersion(currentVersion, releaseType);
+    writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+    return { currentVersion, newVersion, files: [...packageFiles] };
 }
-function setAllVersions(packageFiles, newVersion, dryRun) {
-  const firstFile = packageFiles[0];
-  if (firstFile === void 0) {
-    throw new Error("No package files specified");
-  }
-  const firstPkg = readPackageJson(firstFile);
-  const currentVersion = firstPkg.version;
-  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
-  return { currentVersion, newVersion, files: [...packageFiles] };
+export function setAllVersions(packageFiles, newVersion, dryRun) {
+    const firstFile = packageFiles[0];
+    if (firstFile === undefined) {
+        throw new Error('No package files specified');
+    }
+    const firstPkg = readPackageJson(firstFile);
+    const currentVersion = firstPkg.version;
+    writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+    return { currentVersion, newVersion, files: [...packageFiles] };
 }
 function writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun) {
-  for (const filePath of packageFiles) {
-    if (dryRun) {
-      continue;
-    }
-    const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
-    pkg.version = newVersion;
-    try {
-      writeFileSync(filePath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-    } catch (error) {
-      throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    for (const filePath of packageFiles) {
+        if (dryRun) {
+            continue;
+        }
+        const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
+        pkg.version = newVersion;
+        try {
+            writeFileSync(filePath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-  }
 }
 function readPackageJson(filePath) {
-  let content;
-  try {
-    content = readFileSync(filePath, "utf8");
-  } catch (error) {
-    throw new Error(`Failed to read ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (error) {
-    throw new Error(`Failed to parse JSON in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!isPackageJson(parsed)) {
-    throw new Error(`No valid 'version' field found in ${filePath}`);
-  }
-  return parsed;
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isPackageJson(parsed)) {
+        throw new Error(`No valid 'version' field found in ${filePath}`);
+    }
+    return parsed;
 }
-export {
-  bumpAllVersions,
-  setAllVersions
-};

package/dist/esm/bumpVersion.d.ts

@@ -1,2 +1,2 @@
-import type { ReleaseType } from './types.ts';
+import type { ReleaseType } from './types.js';
 export declare function bumpVersion(version: string, releaseType: ReleaseType): string;

package/dist/esm/bumpVersion.js

@@ -1,29 +1,26 @@
-function bumpVersion(version, releaseType) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) {
-    throw new Error(`Invalid semver version: '${version}'`);
-  }
-  const major = match[1];
-  const minor = match[2];
-  const patch = match[3];
-  if (major === void 0 || minor === void 0 || patch === void 0) {
-    throw new Error(`Invalid semver version: '${version}'`);
-  }
-  const majorNum = Number.parseInt(major, 10);
-  const minorNum = Number.parseInt(minor, 10);
-  const patchNum = Number.parseInt(patch, 10);
-  switch (releaseType) {
-    case "major":
-      if (majorNum === 0) {
-        return `0.${minorNum + 1}.0`;
-      }
-      return `${majorNum + 1}.0.0`;
-    case "minor":
-      return `${majorNum}.${minorNum + 1}.0`;
-    case "patch":
-      return `${majorNum}.${minorNum}.${patchNum + 1}`;
-  }
+export function bumpVersion(version, releaseType) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid semver version: '${version}'`);
+    }
+    const major = match[1];
+    const minor = match[2];
+    const patch = match[3];
+    if (major === undefined || minor === undefined || patch === undefined) {
+        throw new Error(`Invalid semver version: '${version}'`);
+    }
+    const majorNum = Number.parseInt(major, 10);
+    const minorNum = Number.parseInt(minor, 10);
+    const patchNum = Number.parseInt(patch, 10);
+    switch (releaseType) {
+        case 'major':
+            if (majorNum === 0) {
+                return `0.${minorNum + 1}.0`;
+            }
+            return `${majorNum + 1}.0.0`;
+        case 'minor':
+            return `${majorNum}.${minorNum + 1}.0`;
+        case 'patch':
+            return `${majorNum}.${minorNum}.${patchNum + 1}`;
+    }
 }
-export {
-  bumpVersion
-};

package/dist/esm/changelogJsonFile.d.ts

@@ -1,4 +1,4 @@
-import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+import type { ChangelogEntry, ReleaseConfig } from './types.js';
 export declare function resolveChangelogJsonPath(config: Pick<ReleaseConfig, 'changelogJson'>, changelogPath: string): string;
 export declare function writeChangelogJson(filePath: string, entries: ChangelogEntry[]): string;
 export declare function upsertChangelogJson(filePath: string, entries: ChangelogEntry[]): string;

package/dist/esm/changelogJsonFile.js

@@ -1,78 +1,75 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import stringify from "json-stringify-pretty-compact";
-import semver from "semver";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import stringify from 'json-stringify-pretty-compact';
+import semver from 'semver';
 import { isChangelogEntry } from "./changelogJsonUtils.js";
 import { isUnknownArray } from "./typeGuards.js";
-function resolveChangelogJsonPath(config, changelogPath) {
-  return join(changelogPath, config.changelogJson.outputPath);
+export function resolveChangelogJsonPath(config, changelogPath) {
+    return join(changelogPath, config.changelogJson.outputPath);
 }
-function writeChangelogJson(filePath, entries) {
-  const sorted = sortNewestFirst(entries);
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, stringify(sorted, { maxLength: 100 }) + "\n", "utf8");
-  return filePath;
+export function writeChangelogJson(filePath, entries) {
+    const sorted = sortNewestFirst(entries);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, stringify(sorted, { maxLength: 100 }) + '\n', 'utf8');
+    return filePath;
 }
-function upsertChangelogJson(filePath, entries) {
-  upsertChangelogJsonAndReturn(filePath, entries);
-  return filePath;
+export function upsertChangelogJson(filePath, entries) {
+    upsertChangelogJsonAndReturn(filePath, entries);
+    return filePath;
 }
-function upsertChangelogJsonAndReturn(filePath, entries) {
-  const existing = readExistingEntries(filePath);
-  const merged = mergeEntries(entries, existing);
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
-  return merged;
+export function upsertChangelogJsonAndReturn(filePath, entries) {
+    const existing = readExistingEntries(filePath);
+    const merged = mergeEntries(entries, existing);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, stringify(merged, { maxLength: 100 }) + '\n', 'utf8');
+    return merged;
 }
-function mergeChangelogEntriesWithDisk(filePath, entries) {
-  const existing = readExistingEntries(filePath);
-  return mergeEntries(entries, existing);
+export function mergeChangelogEntriesWithDisk(filePath, entries) {
+    const existing = readExistingEntries(filePath);
+    return mergeEntries(entries, existing);
 }
 function sortNewestFirst(entries) {
-  return [...entries].sort((a, b) => compareVersionsDescending(a.version, b.version));
+    return [...entries].sort((a, b) => compareVersionsDescending(a.version, b.version));
 }
 function readExistingEntries(filePath) {
-  if (!existsSync(filePath)) {
-    return [];
-  }
-  try {
-    const content = readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(content);
-    if (!isUnknownArray(parsed)) {
-      return [];
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (!isUnknownArray(parsed)) {
+            return [];
+        }
+        return parsed.filter(isChangelogEntry);
+    }
+    catch (error) {
+        console.warn(`Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`);
+        return [];
     }
-    return parsed.filter(isChangelogEntry);
-  } catch (error) {
-    console.warn(
-      `Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`
-    );
-    return [];
-  }
 }
 function mergeEntries(newEntries, existingEntries) {
-  const versionMap = /* @__PURE__ */ new Map();
-  for (const entry of existingEntries) {
-    versionMap.set(entry.version, entry);
-  }
-  for (const entry of newEntries) {
-    versionMap.set(entry.version, entry);
-  }
-  return sortNewestFirst(versionMap.values());
+    const versionMap = new Map();
+    for (const entry of existingEntries) {
+        versionMap.set(entry.version, entry);
+    }
+    for (const entry of newEntries) {
+        versionMap.set(entry.version, entry);
+    }
+    return sortNewestFirst(versionMap.values());
 }
 function compareVersionsDescending(a, b) {
-  const aValid = semver.valid(a);
-  const bValid = semver.valid(b);
-  if (aValid && bValid) return semver.rcompare(aValid, bValid);
-  if (aValid) return -1;
-  if (bValid) return 1;
-  if (a > b) return -1;
-  if (a < b) return 1;
-  return 0;
+    const aValid = semver.valid(a);
+    const bValid = semver.valid(b);
+    if (aValid && bValid)
+        return semver.rcompare(aValid, bValid);
+    if (aValid)
+        return -1;
+    if (bValid)
+        return 1;
+    if (a > b)
+        return -1;
+    if (a < b)
+        return 1;
+    return 0;
 }
-export {
-  mergeChangelogEntriesWithDisk,
-  resolveChangelogJsonPath,
-  upsertChangelogJson,
-  upsertChangelogJsonAndReturn,
-  writeChangelogJson
-};

package/dist/esm/changelogJsonUtils.d.ts

@@ -1,4 +1,4 @@
-import type { ChangelogEntry, ChangelogItem } from './types.ts';
+import type { ChangelogEntry, ChangelogItem } from './types.js';
 export declare function isChangelogItem(value: unknown): value is ChangelogItem;
 export declare function isChangelogEntry(value: unknown): value is ChangelogEntry;
 export declare function extractVersion(tag: string): string;

package/dist/esm/changelogJsonUtils.js

@@ -1,38 +1,41 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from 'node:fs';
 import { isRecord, isUnknownArray } from "./typeGuards.js";
-function isChangelogItem(value) {
-  if (!isRecord(value)) return false;
-  if (typeof value.description !== "string") return false;
-  if (value.body !== void 0 && typeof value.body !== "string") return false;
-  if (value.breaking !== void 0 && typeof value.breaking !== "boolean") return false;
-  if (value.hash !== void 0 && typeof value.hash !== "string") return false;
-  return true;
+export function isChangelogItem(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.description !== 'string')
+        return false;
+    if (value.body !== undefined && typeof value.body !== 'string')
+        return false;
+    if (value.breaking !== undefined && typeof value.breaking !== 'boolean')
+        return false;
+    if (value.hash !== undefined && typeof value.hash !== 'string')
+        return false;
+    return true;
 }
-function isChangelogEntry(value) {
-  return isRecord(value) && typeof value.version === "string" && typeof value.date === "string" && isUnknownArray(value.sections);
+export function isChangelogEntry(value) {
+    return (isRecord(value) &&
+        typeof value.version === 'string' &&
+        typeof value.date === 'string' &&
+        isUnknownArray(value.sections));
 }
-function extractVersion(tag) {
-  const match = /(\d+\.\d+\.\d+.*)$/.exec(tag);
-  return match?.[1] ?? tag;
+export function extractVersion(tag) {
+    const match = /(\d+\.\d+\.\d+.*)$/.exec(tag);
+    return match?.[1] ?? tag;
 }
-function readChangelogEntries(filePath) {
-  if (!existsSync(filePath)) {
-    return void 0;
-  }
-  try {
-    const content = readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(content);
-    if (!isUnknownArray(parsed)) {
-      return void 0;
+export function readChangelogEntries(filePath) {
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (!isUnknownArray(parsed)) {
+            return undefined;
+        }
+        return parsed.filter(isChangelogEntry);
+    }
+    catch {
+        return undefined;
     }
-    return parsed.filter(isChangelogEntry);
-  } catch {
-    return void 0;
-  }
 }
-export {
-  extractVersion,
-  isChangelogEntry,
-  isChangelogItem,
-  readChangelogEntries
-};

package/dist/esm/changelogOverrides.d.ts

@@ -1,4 +1,4 @@
-import type { ChangelogEntry, ChangelogOverride, WorkspaceConfig } from './types.ts';
+import type { ChangelogEntry, ChangelogOverride, WorkspaceConfig } from './types.js';
 export type LoadChangelogOverridesResult = {
     overrides: Map<string, ChangelogOverride>;
 } | {