@williamthorsen/release-kit 15.0.2 → 16.0.0

package/dist/esm/buildChangelogEntries.js

@@ -12,7 +12,23 @@ const UNRELEASED_TAG = 'unreleased';
 const CANONICAL_SECTION_ORDER = new Map(Object.values(DEFAULT_WORK_TYPES).map((config, index) => [stripGroupDecorations(config.header), index]));
 export function buildChangelogEntries(config, tag, options) {
     const history = readReleaseHistory(config, options);
-    return { entries: toChangelogEntries(history, tag), diagnostics: history.unreleased.diagnostics };
+    return { entries: convertToChangelogEntries(history, tag), diagnostics: history.unreleasedReading.diagnostics };
+}
+export function convertToChangelogEntries(history, tag) {
+    const { unreleasedReading } = history;
+    if (unreleasedReading.sections.length === 0) {
+        return [...history.releasedEntries];
+    }
+    return [
+        { version: extractVersion(tag), date: unreleasedReading.date, sections: unreleasedReading.sections },
+        ...history.releasedEntries,
+    ];
+}
+export function convertToReleaseEntries(history, tag, today) {
+    if (history.unreleasedReading.sections.length === 0) {
+        return [buildEmptyReleaseEntry(extractVersion(tag), today), ...history.releasedEntries];
+    }
+    return convertToChangelogEntries(history, tag);
 }
 export function readReleaseHistory(config, options) {
     try {
@@ -39,22 +55,6 @@ export function readReleaseHistory(config, options) {
 export function stripGroupDecorations(group) {
     return stripEmojiPrefix(group);
 }
-export function toChangelogEntries(history, tag) {
-    const { unreleased } = history;
-    if (unreleased.sections.length === 0) {
-        return [...history.releasedEntries];
-    }
-    return [
-        { version: extractVersion(tag), date: unreleased.date, sections: unreleased.sections },
-        ...history.releasedEntries,
-    ];
-}
-export function toReleaseEntries(history, tag, today) {
-    if (history.unreleased.sections.length === 0) {
-        return [buildEmptyReleaseEntry(extractVersion(tag), today), ...history.releasedEntries];
-    }
-    return toChangelogEntries(history, tag);
-}
 function appendItem(sectionMap, header, item) {
     let items = sectionMap.get(header);
     if (items === undefined) {
@@ -72,15 +72,15 @@ function buildSections(sectionMap, devOnlySections) {
             items,
         });
     }
-    return sections.toSorted((a, b) => canonicalSectionPriority(a.title) - canonicalSectionPriority(b.title));
+    return sections.toSorted((a, b) => getCanonicalSectionPriority(a.title) - getCanonicalSectionPriority(b.title));
 }
-function canonicalSectionPriority(title) {
+function formatDate(timestampSec) {
+    return new Date(timestampSec * 1_000).toISOString().slice(0, 10);
+}
+function getCanonicalSectionPriority(title) {
     const index = CANONICAL_SECTION_ORDER.get(stripGroupDecorations(title));
     return index ?? Infinity;
 }
-function formatDate(timestamp) {
-    return new Date(timestamp * 1_000).toISOString().slice(0, 10);
-}
 function readCommit(commit, context, diagnostics) {
     if (isNonChangeSubject(commit.subject)) {
         return { items: [], isUnparseable: false };
@@ -100,10 +100,10 @@ function readCommit(commit, context, diagnostics) {
     const classification = classifyChangelogCommit(commit, context.workTypes, {
         breakingPolicies: context.breakingPolicies,
         ...(diagnostics !== undefined && {
-            onPolicyViolation: (violating, type, surface) => {
+            onPolicyViolation: (violatingCommit, type, surface) => {
                 diagnostics.policyViolations.push({
-                    commitHash: violating.hash,
-                    commitSubject: violating.subject,
+                    commitHash: violatingCommit.hash,
+                    commitSubject: violatingCommit.subject,
                     type,
                     surface,
                 });
@@ -130,47 +130,51 @@ function transformReleases(windows, context) {
         unroutedEntryScopes: [],
     };
     const signals = [];
-    const unparseable = [];
+    const unparseableCommits = [];
     let parsedCommitCount = 0;
     const sectionMap = new Map();
     const unreleasedCommits = unreleasedWindow?.commits ?? [];
     for (const commit of unreleasedCommits) {
         const reading = readCommit(commit, context, diagnostics);
-        for (const derived of reading.items) {
-            appendItem(sectionMap, derived.header, derived.item);
-            signals.push(derived.signal);
+        for (const derivedItem of reading.items) {
+            appendItem(sectionMap, derivedItem.header, derivedItem.item);
+            signals.push(derivedItem.signal);
         }
         if (reading.items.length > 0) {
             parsedCommitCount += 1;
         }
         else if (reading.isUnparseable) {
-            unparseable.push(commit);
+            unparseableCommits.push(commit);
         }
     }
     const releasedEntries = [];
     for (const release of windows.slice(1)) {
         const releaseSections = new Map();
         for (const commit of release.commits) {
-            for (const derived of readCommit(commit, context, undefined).items) {
-                appendItem(releaseSections, derived.header, derived.item);
+            for (const derivedItem of readCommit(commit, context, undefined).items) {
+                appendItem(releaseSections, derivedItem.header, derivedItem.item);
             }
         }
         const sections = buildSections(releaseSections, context.devOnlySections);
         if (sections.length > 0) {
-            releasedEntries.push({ version: extractVersion(release.version), date: formatDate(release.timestamp), sections });
+            releasedEntries.push({
+                version: extractVersion(release.version),
+                date: formatDate(release.timestampSec),
+                sections,
+            });
         }
     }
     return {
         previousTag: baselineWindow?.version,
         releasedEntries,
-        unreleased: {
+        unreleasedReading: {
             bump: determineBumpType(signals, context.workTypes, context.versionPatterns),
             commits: unreleasedCommits.filter((commit) => !isReleaseSubject(commit.subject)).toReversed(),
-            date: formatDate(unreleasedWindow?.timestamp ?? Math.floor(Date.now() / 1_000)),
+            date: formatDate(unreleasedWindow?.timestampSec ?? Math.floor(Date.now() / 1_000)),
             diagnostics,
             parsedCommitCount,
             sections: buildSections(sectionMap, context.devOnlySections),
-            unparseableCommits: unparseable.length > 0 ? unparseable.toReversed() : undefined,
+            unparseableCommits: unparseableCommits.length > 0 ? unparseableCommits.toReversed() : undefined,
         },
     };
 }

package/dist/esm/buildChangelogItem.js

@@ -36,10 +36,10 @@ export function buildEntryItem(commit, entry, position, prNumber, context, diagn
         prefixSurface: 'entry',
         onPolicyViolation: diagnostics === undefined
             ? undefined
-            : (violating, violatedType, surface) => {
+            : (violatingCommit, violatedType, surface) => {
                 diagnostics.policyViolations.push({
-                    commitHash: violating.hash,
-                    commitSubject: violating.subject,
+                    commitHash: violatingCommit.hash,
+                    commitSubject: violatingCommit.subject,
                     type: violatedType,
                     surface,
                     entryPosition: position,
@@ -65,7 +65,7 @@ export function buildTitleItem(commit, isParsedBreaking, workTypes) {
     if (body !== undefined) {
         item.body = body;
     }
-    if (isParsedBreaking && subjectHasBreakingMarker(commit.message, workTypes)) {
+    if (isParsedBreaking && hasBreakingMarkerInSubject(commit.message, workTypes)) {
         item.breaking = true;
     }
     const migration = extractMigration(body);
@@ -80,43 +80,43 @@ export function hasRoutedEntry(entries, routing) {
 }
 function extractBody(message) {
     const lines = message.split('\n').slice(1);
-    let start = 0;
-    while (start < lines.length && (lines[start] ?? '').trim() === '') {
-        start += 1;
+    let startIndex = 0;
+    while (startIndex < lines.length && (lines[startIndex] ?? '').trim() === '') {
+        startIndex += 1;
     }
-    let end = lines.length;
-    while (end > start) {
-        const line = lines[end - 1] ?? '';
-        const trimmed = line.trim();
-        if (trimmed === '') {
-            end -= 1;
+    let endIndex = lines.length;
+    while (endIndex > startIndex) {
+        const line = lines[endIndex - 1] ?? '';
+        const trimmedLine = line.trim();
+        if (trimmedLine === '') {
+            endIndex -= 1;
             continue;
         }
-        if (TRAILER_PATTERNS.some((pattern) => pattern.test(trimmed))) {
-            end -= 1;
+        if (TRAILER_PATTERNS.some((pattern) => pattern.test(trimmedLine))) {
+            endIndex -= 1;
             continue;
         }
         break;
     }
-    if (end <= start) {
+    if (endIndex <= startIndex) {
         return undefined;
     }
-    return lines.slice(start, end).join('\n').trim();
+    return lines.slice(startIndex, endIndex).join('\n').trim();
 }
 function extractDescription(message) {
     const firstLine = message.split('\n', 1)[0] ?? message;
-    const afterColon = firstLine.split(': ').slice(1).join(': ');
-    return afterColon.charAt(0).toUpperCase() + afterColon.slice(1);
+    const descriptionText = firstLine.split(': ').slice(1).join(': ');
+    return descriptionText.charAt(0).toUpperCase() + descriptionText.slice(1);
+}
+function hasBreakingMarkerInSubject(message, workTypes) {
+    return parseSubject(message.split('\n', 1)[0] ?? '', workTypes)?.breaking === true;
 }
 function isRoutedTo(scopes, routing) {
     if (scopes.length === 0) {
         return true;
     }
     return scopes.some((scope) => {
-        const resolved = routing.scopeAliases[scope] ?? scope;
-        return resolved === '*' || resolved === routing.scope;
+        const resolvedScope = routing.scopeAliases[scope] ?? scope;
+        return resolvedScope === '*' || resolvedScope === routing.scope;
     });
 }
-function subjectHasBreakingMarker(message, workTypes) {
-    return parseSubject(message.split('\n', 1)[0] ?? '', workTypes)?.breaking === true;
-}

package/dist/esm/buildDependencyGraph.js

@@ -15,36 +15,36 @@ export function buildDependencyGraph(targets) {
         if (primaryPackageFile === undefined) {
             continue;
         }
-        const pkg = readPackageJsonSubset(primaryPackageFile);
-        targetPackages.set(target, pkg);
-        if (typeof pkg.version === 'string') {
-            dirToVersion.set(target.id, pkg.version);
+        const packageJson = readPackageJsonSubset(primaryPackageFile);
+        targetPackages.set(target, packageJson);
+        if (typeof packageJson.version === 'string') {
+            dirToVersion.set(target.id, packageJson.version);
         }
-        if (pkg.name === undefined) {
+        if (packageJson.name === undefined) {
             continue;
         }
-        packageNameToDir.set(pkg.name, target.id);
-        dirToPackageName.set(target.id, pkg.name);
+        packageNameToDir.set(packageJson.name, target.id);
+        dirToPackageName.set(target.id, packageJson.name);
     }
-    for (const [target, pkg] of targetPackages) {
-        const allDeps = { ...pkg.dependencies, ...pkg.peerDependencies };
-        for (const [depName, depVersion] of Object.entries(allDeps)) {
-            if (typeof depVersion !== 'string' || !depVersion.startsWith('workspace:')) {
+    for (const [target, packageJson] of targetPackages) {
+        const allDependencies = { ...packageJson.dependencies, ...packageJson.peerDependencies };
+        for (const [dependencyName, dependencyVersion] of Object.entries(allDependencies)) {
+            if (typeof dependencyVersion !== 'string' || !dependencyVersion.startsWith('workspace:')) {
                 continue;
             }
-            const existing = dependentsOf.get(depName);
-            if (existing === undefined) {
-                dependentsOf.set(depName, [target]);
+            const existingDependents = dependentsOf.get(dependencyName);
+            if (existingDependents === undefined) {
+                dependentsOf.set(dependencyName, [target]);
             }
             else {
-                existing.push(target);
+                existingDependents.push(target);
             }
-            const forward = dependenciesOf.get(target.id);
-            if (forward === undefined) {
-                dependenciesOf.set(target.id, new Set([depName]));
+            const forwardDependencies = dependenciesOf.get(target.id);
+            if (forwardDependencies === undefined) {
+                dependenciesOf.set(target.id, new Set([dependencyName]));
             }
             else {
-                forward.add(depName);
+                forwardDependencies.add(dependencyName);
             }
         }
     }
@@ -58,15 +58,15 @@ function readPackageJsonSubset(filePath) {
     catch (error) {
         throw chainError(`Failed to read ${filePath}`, error);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(content);
+        parsedJson = JSON.parse(content);
     }
     catch (error) {
         throw chainError(`Failed to parse JSON in ${filePath}`, error);
     }
-    if (!isPackageJsonSubset(parsed)) {
+    if (!isPackageJsonSubset(parsedJson)) {
         throw new Error(`Invalid package.json at ${filePath}`);
     }
-    return parsed;
+    return parsedJson;
 }

package/dist/esm/buildReleasedResult.js

@@ -17,62 +17,64 @@ export function buildReleasedResult(target, fields, release, decision, history)
     }
 }
 function buildReleasedComposite(fields, release, decision, history) {
-    const { unreleased } = history;
+    const { unreleasedReading } = history;
     const result = {
         ...fields,
         status: 'released',
         kind: 'composite',
-        parsedCommitCount: unreleased.parsedCommitCount,
+        parsedCommitCount: unreleasedReading.parsedCommitCount,
         releaseType: release.releaseType,
-        commits: unreleased.commits,
-        ...(unreleased.unparseableCommits !== undefined && { unparseableCommits: unreleased.unparseableCommits }),
+        commits: unreleasedReading.commits,
+        ...(unreleasedReading.unparseableCommits !== undefined && {
+            unparseableCommits: unreleasedReading.unparseableCommits,
+        }),
         ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
     };
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
+    attachChangelogDiagnostics(result, unreleasedReading.diagnostics);
     return result;
 }
 function buildReleasedDirectory(target, fields, release, decision, history) {
-    const { unreleased } = history;
+    const { unreleasedReading } = history;
     const setVersion = decision?.setVersion;
     const result = {
         ...fields,
         status: 'released',
         kind: 'directory',
         name: target.id,
-        commits: unreleased.commits,
+        commits: unreleasedReading.commits,
         ...(setVersion === undefined && {
             releaseType: release.releaseType,
-            parsedCommitCount: unreleased.parsedCommitCount,
+            parsedCommitCount: unreleasedReading.parsedCommitCount,
         }),
         ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
-        ...(setVersion !== undefined && { setVersion }),
+        ...(setVersion !== undefined && { versionOverride: setVersion }),
     };
-    if (setVersion === undefined && unreleased.unparseableCommits !== undefined) {
-        result.unparseableCommits = unreleased.unparseableCommits;
+    if (setVersion === undefined && unreleasedReading.unparseableCommits !== undefined) {
+        result.unparseableCommits = unreleasedReading.unparseableCommits;
     }
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
+    attachChangelogDiagnostics(result, unreleasedReading.diagnostics);
     return result;
 }
 function buildReleasedPackage(target, fields, release, decision, history) {
-    const { unreleased } = history;
+    const { unreleasedReading } = history;
     const setVersion = decision?.setVersion;
     const hasParseCounts = decision !== undefined && setVersion === undefined;
     const result = {
         ...fields,
         status: 'released',
         kind: 'package',
-        commits: unreleased.commits,
+        commits: unreleasedReading.commits,
         ...(target.isWorkspace && { name: target.id }),
         ...(setVersion === undefined && { releaseType: release.releaseType }),
-        ...(hasParseCounts && { parsedCommitCount: unreleased.parsedCommitCount }),
+        ...(hasParseCounts && { parsedCommitCount: unreleasedReading.parsedCommitCount }),
         ...(decision === undefined && { propagatedOnly: true }),
         ...(release.propagatedFrom !== undefined && { propagatedFrom: release.propagatedFrom }),
         ...(decision?.bumpOverride !== undefined && { bumpOverride: decision.bumpOverride }),
-        ...(setVersion !== undefined && { setVersion }),
+        ...(setVersion !== undefined && { versionOverride: setVersion }),
     };
-    if (setVersion === undefined && unreleased.unparseableCommits !== undefined) {
-        result.unparseableCommits = unreleased.unparseableCommits;
+    if (setVersion === undefined && unreleasedReading.unparseableCommits !== undefined) {
+        result.unparseableCommits = unreleasedReading.unparseableCommits;
     }
-    attachChangelogDiagnostics(result, unreleased.diagnostics);
+    attachChangelogDiagnostics(result, unreleasedReading.diagnostics);
     return result;
 }

package/dist/esm/buildSyntheticChangelogEntry.js

@@ -1,6 +1,6 @@
 export function buildSyntheticChangelogEntry(propagatedFrom, version, date, sectionTitle) {
-    const items = propagatedFrom.map((dep) => ({
-        description: `Bumped \`${dep.packageName}\` to ${dep.newVersion}`,
+    const items = propagatedFrom.map((dependency) => ({
+        description: `Bumped \`${dependency.packageName}\` to ${dependency.newVersion}`,
     }));
     return {
         version,

package/dist/esm/bumpVersion.js

@@ -9,18 +9,18 @@ export function bumpVersion(version, releaseType) {
     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);
+    const majorNumber = Number.parseInt(major, 10);
+    const minorNumber = Number.parseInt(minor, 10);
+    const patchNumber = Number.parseInt(patch, 10);
     switch (releaseType) {
         case 'major':
-            if (majorNum === 0) {
-                return `0.${minorNum + 1}.0`;
+            if (majorNumber === 0) {
+                return `0.${minorNumber + 1}.0`;
             }
-            return `${majorNum + 1}.0.0`;
+            return `${majorNumber + 1}.0.0`;
         case 'minor':
-            return `${majorNum}.${minorNum + 1}.0`;
+            return `${majorNumber}.${minorNumber + 1}.0`;
         case 'patch':
-            return `${majorNum}.${minorNum}.${patchNum + 1}`;
+            return `${majorNumber}.${minorNumber}.${patchNumber + 1}`;
     }
 }

package/dist/esm/changelogArchive.d.ts

@@ -2,7 +2,7 @@
 export declare const CHANGELOG_ARCHIVE_DIRECTORY = "changelogs";
 /** An archive file that exists on disk. */
 export interface ChangelogArchivePath {
-    major: number;
+    majorVersion: number;
     path: string;
 }
 /** Returns the path, relative to the changelog directory, of the archive file for a major version. */

package/dist/esm/changelogArchive.js

@@ -13,9 +13,9 @@ export function listArchiveFiles(changelogDir) {
     for (const name of readdirSync(archiveDir)) {
         const match = ARCHIVE_FILE_PATTERN.exec(name);
         if (match?.[1] !== undefined) {
-            archives.push({ major: Number(match[1]), path: join(archiveDir, name) });
+            archives.push({ majorVersion: Number(match[1]), path: join(archiveDir, name) });
         }
     }
-    return archives.toSorted((a, b) => b.major - a.major);
+    return archives.toSorted((a, b) => b.majorVersion - a.majorVersion);
 }
 const ARCHIVE_FILE_PATTERN = /^CHANGELOG-v(\d+)\.md$/;

package/dist/esm/changelogJsonFile.js

@@ -12,8 +12,8 @@ export function renderChangelogJson(entries) {
     return stringify(sortNewestFirst(entries), { maxLength: 100 }) + '\n';
 }
 export function mergeChangelogEntriesWithDisk(filePath, entries) {
-    const existing = readExistingEntries(filePath);
-    return mergeEntries(entries, existing);
+    const existingEntries = readExistingEntries(filePath);
+    return mergeEntries(entries, existingEntries);
 }
 function sortNewestFirst(entries) {
     return [...entries].toSorted((a, b) => compareVersionsDescending(a.version, b.version));
@@ -24,11 +24,11 @@ function readExistingEntries(filePath) {
     }
     try {
         const content = readFileSync(filePath, 'utf8');
-        const parsed = JSON.parse(content);
-        if (!isUnknownArray(parsed)) {
+        const parsedJson = JSON.parse(content);
+        if (!isUnknownArray(parsedJson)) {
             return [];
         }
-        return parsed.filter(isChangelogEntry);
+        return parsedJson.filter(isChangelogEntry);
     }
     catch (error) {
         console.warn(`Warning: could not parse existing ${filePath}: ${describeError(error)}; treating as empty`);

package/dist/esm/changelogJsonUtils.js

@@ -16,11 +16,11 @@ export function readChangelogEntries(filePath) {
     }
     try {
         const content = readFileSync(filePath, 'utf8');
-        const parsed = JSON.parse(content);
-        if (!isUnknownArray(parsed)) {
+        const parsedJson = JSON.parse(content);
+        if (!isUnknownArray(parsedJson)) {
             return undefined;
         }
-        return parsed.filter(isChangelogEntry);
+        return parsedJson.filter(isChangelogEntry);
     }
     catch {
         return undefined;

package/dist/esm/changelogOverrides.d.ts

@@ -31,15 +31,15 @@ export declare function createOverrideContext(workspacePaths: readonly string[])
  * yields an empty map.
  */
 export declare function loadOverridesForScopes(scopes: {
-    project?: string;
+    projectPath?: string;
     workspaces?: string[];
 }): LoadOverridesForScopesResult;
 /** Result of {@link loadOverridesForScopes}: per-scope maps plus accumulated load/validation errors. */
 export interface LoadOverridesForScopesResult {
     /** Project-tier (root) overrides. Empty map when the project file is absent. */
-    project: Map<string, ChangelogOverride>;
+    projectOverrides: Map<string, ChangelogOverride>;
     /** Workspace-tier overrides keyed by `workspacePath` (e.g., `'packages/foo'`). Empty map when absent. */
-    perWorkspace: Map<string, Map<string, ChangelogOverride>>;
+    overridesByWorkspace: Map<string, Map<string, ChangelogOverride>>;
     /** All load and validation errors across every requested scope, prefixed with the offending file path. */
     errors: string[];
 }
@@ -50,8 +50,8 @@ export interface LoadOverridesForScopesResult {
  * that matches nothing in its own workspace is stale, and it is warned about at once rather than at the end of the run.
  */
 export interface OverrideContext {
-    project: Map<string, ChangelogOverride>;
-    perWorkspace: Map<string, Map<string, ChangelogOverride>>;
+    projectOverrides: Map<string, ChangelogOverride>;
+    overridesByWorkspace: Map<string, Map<string, ChangelogOverride>>;
     overrideWarnings: string[];
     globalMatchedRootKeys: Set<string>;
 }

package/dist/esm/changelogOverrides.js

@@ -3,15 +3,15 @@ import { applyChangelogOverrides, formatStaleOverrideKeyWarning } from "./applyC
 import { loadChangelogOverrides } from "./loadChangelogOverrides.js";
 const OVERRIDES_FILENAME = '.meta/changelog-overrides.json';
 export function applyWorkspaceOverrides(newEntries, workspacePath, overrideContext) {
-    const { project, perWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
-    const workspaceOverrides = workspacePath === undefined ? undefined : perWorkspace.get(workspacePath);
-    const composed = composeOverrides(project, workspaceOverrides);
-    const applied = applyChangelogOverrides(newEntries, composed);
-    if (applied.errors.length > 0) {
-        throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
+    const { projectOverrides, overridesByWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
+    const workspaceOverrides = workspacePath === undefined ? undefined : overridesByWorkspace.get(workspacePath);
+    const composedOverrides = composeOverrides(projectOverrides, workspaceOverrides);
+    const appliedResult = applyChangelogOverrides(newEntries, composedOverrides);
+    if (appliedResult.errors.length > 0) {
+        throw new Error(`Changelog override application failed:\n  - ${appliedResult.errors.join('\n  - ')}`);
     }
-    overrideWarnings.push(...applied.warnings);
-    const matchedSet = new Set(applied.matchedKeys);
+    overrideWarnings.push(...appliedResult.warnings);
+    const matchedSet = new Set(appliedResult.matchedKeys);
     if (workspaceOverrides !== undefined) {
         for (const key of workspaceOverrides.keys()) {
             if (!matchedSet.has(key)) {
@@ -19,45 +19,45 @@ export function applyWorkspaceOverrides(newEntries, workspacePath, overrideConte
             }
         }
     }
-    for (const key of applied.matchedKeys) {
+    for (const key of appliedResult.matchedKeys) {
         if (workspaceOverrides?.has(key))
             continue;
         globalMatchedRootKeys.add(key);
     }
-    return applied;
+    return appliedResult;
 }
 export function composeOverrides(rootEntries, workspaceEntries) {
-    const composed = new Map(rootEntries);
+    const composedOverrides = new Map(rootEntries);
     if (workspaceEntries !== undefined) {
         for (const [key, value] of workspaceEntries) {
-            composed.set(key, value);
+            composedOverrides.set(key, value);
         }
     }
-    return composed;
+    return composedOverrides;
 }
 export function createOverrideContext(workspacePaths) {
-    const result = loadOverridesForScopes({ project: '.', workspaces: [...workspacePaths] });
+    const result = loadOverridesForScopes({ projectPath: '.', workspaces: [...workspacePaths] });
     if (result.errors.length > 0) {
         throw new Error(`Failed to load changelog overrides:\n  - ${result.errors.join('\n  - ')}`);
     }
     return {
-        project: result.project,
-        perWorkspace: result.perWorkspace,
+        projectOverrides: result.projectOverrides,
+        overridesByWorkspace: result.overridesByWorkspace,
         overrideWarnings: [],
         globalMatchedRootKeys: new Set(),
     };
 }
 export function loadOverridesForScopes(scopes) {
     const errors = [];
-    let project = new Map();
-    const perWorkspace = new Map();
-    if (scopes.project !== undefined) {
-        const result = loadChangelogOverrides(resolveOverridePath(scopes.project));
+    let projectOverrides = new Map();
+    const overridesByWorkspace = new Map();
+    if (scopes.projectPath !== undefined) {
+        const result = loadChangelogOverrides(resolveOverridePath(scopes.projectPath));
         if ('errors' in result) {
             errors.push(...result.errors);
         }
         else {
-            project = result.overrides;
+            projectOverrides = result.overrides;
         }
     }
     const workspacePaths = scopes.workspaces ?? [];
@@ -67,10 +67,10 @@ export function loadOverridesForScopes(scopes) {
             errors.push(...result.errors);
         }
         else if (result.overrides.size > 0) {
-            perWorkspace.set(workspacePath, result.overrides);
+            overridesByWorkspace.set(workspacePath, result.overrides);
         }
     }
-    return { project, perWorkspace, errors };
+    return { projectOverrides, overridesByWorkspace, errors };
 }
 export function resolveOverridePath(scopeRoot) {
     return path.posix.join(scopeRoot, OVERRIDES_FILENAME);

package/dist/esm/classifyChangelogCommit.js

@@ -10,18 +10,18 @@ export function classifyChangelogCommit(commit, workTypes, options) {
     if (!hasTicketPrefix(subject)) {
         return { kind: 'unparseable' };
     }
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, undefined, options);
-    if (parsed === undefined) {
+    const parsedCommit = parseCommitMessage(commit.message, commit.hash, workTypes, undefined, options);
+    if (parsedCommit === undefined) {
         return { kind: 'unparseable' };
     }
-    const config = workTypes[parsed.type];
+    const config = workTypes[parsedCommit.type];
     if (config === undefined) {
         return { kind: 'unparseable' };
     }
     if (config.excludedFromChangelog === true) {
         return { kind: 'excluded' };
     }
-    return { kind: 'header', header: config.header, type: parsed.type, breaking: parsed.breaking };
+    return { kind: 'header', header: config.header, type: parsedCommit.type, breaking: parsedCommit.breaking };
 }
 export function isNonChangeSubject(subject) {
     return isReleaseSubject(subject) || MERGE_SUBJECT_PATTERN.test(subject);