@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/publish.js

@@ -1,26 +1,21 @@
 import { execFileSync } from 'node:child_process';
+import { resolveExecutable } from "./detectPackageManager.js";
 export function publishPackage(resolvedTag, packageManager, options) {
-    const { dryRun, provenance } = options;
+    const { isDryRun, shouldGenerateProvenance } = options;
     const executable = resolveExecutable(packageManager);
-    const args = buildPublishArgs(packageManager, { dryRun, provenance });
-    console.info(`\n${dryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
+    const args = buildPublishArgs(packageManager, { isDryRun, shouldGenerateProvenance });
+    console.info(`\n${isDryRun ? '[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;
-}
 function buildPublishArgs(packageManager, options) {
     const args = packageManager === 'yarn-berry' ? ['npm', 'publish'] : ['publish'];
-    if (options.dryRun) {
+    if (options.isDryRun) {
         args.push('--dry-run');
     }
     if (packageManager === 'pnpm') {
         args.push('--no-git-checks');
     }
-    if (options.provenance && packageManager !== 'yarn') {
+    if (options.shouldGenerateProvenance && packageManager !== 'yarn') {
         args.push('--provenance');
     }
     return args;

package/dist/esm/publishCommand.d.ts

@@ -1,7 +1,7 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
 /**
- * Orchestrates the CLI `publish` command: checks for a clean working tree, resolves the tags on HEAD, and publishes
- * each publishable one, injecting release notes into its README for the duration of the publish.
- * A relative `--config` resolves against `invocationDir`.
+ * Orchestrates the CLI `publish` command: checks for a clean working tree, resolves the tags on HEAD, checks the
+ * tarballs of the publishable ones from a clean checkout, and publishes each one, injecting release notes into its
+ * README for the duration of the publish. A relative `--config` resolves against `invocationDir`.
  */
 export declare function publishCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;

package/dist/esm/publishCommand.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
+import { assertTarballsComplete } from "./assertTarballsComplete.js";
 import { configFlagSchema } from "./configFlagSchema.js";
 import { deriveReleaseNotesConfig } from "./deriveReleaseNotesConfig.js";
 import { detectPackageManager } from "./detectPackageManager.js";
@@ -17,17 +18,17 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const publishFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    noGitChecks: { long: '--no-git-checks', type: 'boolean' },
-    provenance: { long: '--provenance', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
+    shouldSkipGitChecks: { long: '--no-git-checks', type: 'boolean' },
+    shouldGenerateProvenance: { long: '--provenance', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
 export async function publishCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, publishFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun, noGitChecks, provenance } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, publishFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun, shouldSkipGitChecks, shouldGenerateProvenance } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         try {
             assertCleanWorkingTree();
         }
@@ -36,7 +37,7 @@ export async function publishCommand(argv, styles, invocationDir) {
             process.exit(1);
         }
     }
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;
@@ -46,14 +47,21 @@ export async function publishCommand(argv, styles, invocationDir) {
         console.info('Nothing to publish.');
         return;
     }
+    try {
+        assertTarballsComplete(publishableTags.map(({ workspacePath }) => workspacePath), userConfig?.devExportConditions ?? []);
+    }
+    catch (error) {
+        reportError(describeError(error));
+        process.exit(1);
+    }
     const packageManager = detectPackageManager();
     const { releaseNotes, changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     const shouldInject = releaseNotes.shouldInjectIntoReadme;
-    console.info(dryRun ? '[dry-run] Would publish:' : 'Publishing:');
+    console.info(isDryRun ? '[dry-run] Would publish:' : 'Publishing:');
     for (const { tag, workspacePath } of publishableTags) {
         console.info(`  ${tag} (${workspacePath})`);
     }
-    const published = [];
+    const publishedTags = [];
     try {
         for (const resolvedTag of publishableTags) {
             let readmePath;
@@ -65,8 +73,8 @@ export async function publishCommand(argv, styles, invocationDir) {
                 }
             }
             try {
-                publishPackage(resolvedTag, packageManager, { dryRun, provenance });
-                published.push(resolvedTag.tag);
+                publishPackage(resolvedTag, packageManager, { isDryRun, shouldGenerateProvenance });
+                publishedTags.push(resolvedTag.tag);
             }
             finally {
                 if (readmePath !== undefined && originalReadme !== undefined) {
@@ -76,10 +84,10 @@ export async function publishCommand(argv, styles, invocationDir) {
         }
     }
     catch (error) {
-        if (published.length > 0) {
+        if (publishedTags.length > 0) {
             console.warn('Packages published before failure:');
-            for (const t of published) {
-                console.warn(`  ${t}`);
+            for (const tag of publishedTags) {
+                console.warn(`  ${tag}`);
             }
         }
         reportError(describeError(error));
@@ -87,17 +95,17 @@ export async function publishCommand(argv, styles, invocationDir) {
     }
 }
 function filterPublishableTags(resolvedTags, isExplicit) {
-    const publishable = [];
-    const unpublishable = [];
+    const publishableTags = [];
+    const unpublishableTags = [];
     for (const tag of resolvedTags) {
-        (tag.isPublishable ? publishable : unpublishable).push(tag);
+        (tag.isPublishable ? publishableTags : unpublishableTags).push(tag);
     }
     if (isExplicit) {
-        for (const resolvedTag of unpublishable) {
+        for (const resolvedTag of unpublishableTags) {
             console.warn(formatPublishSkip(resolvedTag));
         }
     }
-    return publishable;
+    return publishableTags;
 }
 function formatPublishSkip(resolvedTag) {
     switch (resolvedTag.kind) {

package/dist/esm/pushCommand.js

@@ -8,21 +8,21 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const pushFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
     tagsOnly: { long: '--tags-only', type: 'boolean' },
 };
 export async function pushCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, pushFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun, tagsOnly } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, pushFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun, tagsOnly } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;
     }
-    const prefix = dryRun ? '[dry-run] Would push' : 'Pushing';
+    const prefix = isDryRun ? '[dry-run] Would push' : 'Pushing';
     if (!tagsOnly) {
         console.info(`${prefix} branch and ${resolvedTags.length} tag(s):`);
     }
@@ -33,8 +33,8 @@ export async function pushCommand(argv, styles, invocationDir) {
         console.info(`  ${tag}`);
     }
     try {
-        const steps = pushRelease(resolvedTags, { dryRun, tagsOnly });
-        if (dryRun) {
+        const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
+        if (isDryRun) {
             for (const step of steps) {
                 console.info(`[dry-run] ${step.command.join(' ')}`);
             }

package/dist/esm/pushRelease.d.ts

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

package/dist/esm/pushRelease.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 export function pushRelease(resolvedTags, options = {}) {
-    const { dryRun = false, tagsOnly = false } = options;
+    const { isDryRun = false, tagsOnly = false } = options;
     const steps = [];
     if (!tagsOnly) {
         const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
@@ -16,7 +16,7 @@ export function pushRelease(resolvedTags, options = {}) {
         const command = ['git', 'push', '--no-follow-tags', 'origin', tag];
         steps.push({ type: 'tag', ref: tag, command });
     }
-    if (!dryRun) {
+    if (!isDryRun) {
         for (const step of steps) {
             execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
         }

package/dist/esm/readChangelogSections.d.ts

@@ -7,7 +7,7 @@ export interface VersionedMarkdownSection {
 }
 /** The `##` sections of a `CHANGELOG.md`, split by whether their heading names a version. */
 export interface ChangelogMarkdownSections {
-    versioned: VersionedMarkdownSection[];
+    versionedSections: VersionedMarkdownSection[];
     /** Headings of the `##` sections that do not name a version, as written. */
     unversionedHeadings: string[];
 }

package/dist/esm/readChangelogSections.js

@@ -9,14 +9,14 @@ export function planPreservedSections(changelogDir, entries) {
     const sections = [];
     const unversionedHeadings = [];
     for (const file of files) {
-        const read = readChangelogSections(file);
-        for (const section of read.versioned) {
+        const fileSections = readChangelogSections(file);
+        for (const section of fileSections.versionedSections) {
             if (seenVersions.has(section.version))
                 continue;
             seenVersions.add(section.version);
             sections.push(section);
         }
-        unversionedHeadings.push(...read.unversionedHeadings);
+        unversionedHeadings.push(...fileSections.unversionedHeadings);
     }
     if (sections.length === 0 && unversionedHeadings.length === 0) {
         return { sections, preservation: undefined };
@@ -32,29 +32,29 @@ export function planPreservedSections(changelogDir, entries) {
 }
 export function readChangelogSections(filePath) {
     if (!existsSync(filePath)) {
-        return { versioned: [], unversionedHeadings: [] };
+        return { versionedSections: [], unversionedHeadings: [] };
     }
     return parseChangelogSections(readFileSync(filePath, 'utf8'));
 }
 export function parseChangelogSections(content) {
     const sections = [];
-    let current;
+    let currentSection;
     let fence;
     for (const line of content.split(/\r?\n/)) {
         if (fence === undefined) {
             if (FOOTER_PATTERN.test(line)) {
-                current = undefined;
+                currentSection = undefined;
                 continue;
             }
             if (SECTION_HEADING_PATTERN.test(line)) {
-                current = { heading: line.trimEnd(), lines: [] };
-                sections.push(current);
+                currentSection = { heading: line.trimEnd(), lines: [] };
+                sections.push(currentSection);
             }
         }
         fence = updateFence(fence, line);
-        current?.lines.push(line);
+        currentSection?.lines.push(line);
     }
-    const versioned = [];
+    const versionedSections = [];
     const unversionedHeadings = [];
     for (const { heading, lines } of sections) {
         const version = extractHeadingVersion(heading);
@@ -62,10 +62,10 @@ export function parseChangelogSections(content) {
             unversionedHeadings.push(heading);
         }
         else {
-            versioned.push({ version, text: trimTrailingBlankLines(lines).join('\n') });
+            versionedSections.push({ version, text: trimTrailingBlankLines(lines).join('\n') });
         }
     }
-    return { versioned, unversionedHeadings };
+    return { versionedSections, unversionedHeadings };
 }
 const FOOTER_PATTERN = /^<!-- Generated by release-kit\b/;
 const SECTION_HEADING_PATTERN = /^## /;
@@ -78,11 +78,11 @@ function extractHeadingVersion(heading) {
     return semver.valid(token) ?? undefined;
 }
 function trimTrailingBlankLines(lines) {
-    let end = lines.length;
-    while (end > 0 && lines[end - 1]?.trim() === '') {
-        end--;
+    let endIndex = lines.length;
+    while (endIndex > 0 && lines[endIndex - 1]?.trim() === '') {
+        endIndex--;
     }
-    return lines.slice(0, end);
+    return lines.slice(0, endIndex);
 }
 function updateFence(fence, line) {
     const marker = FENCE_PATTERN.exec(line)?.[1];

package/dist/esm/releasePlan.js

@@ -4,17 +4,17 @@ import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 const HANDOFF_FILES = new Set([RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE]);
 export function applyReleasePlan(plan) {
-    const ordered = orderPlannedSteps(plan);
-    const applied = [];
-    for (const [index, step] of ordered.entries()) {
+    const orderedSteps = orderPlannedSteps(plan);
+    const appliedWrites = [];
+    for (const [index, step] of orderedSteps.entries()) {
         const outcome = applyStep(step);
         if (outcome.outcome === 'failed') {
-            const unwritten = ordered.slice(index).map((pending) => pending.path);
-            throw new Error(describeApplyFailure({ failedStep: step, error: outcome.error, applied, unwritten }));
+            const unwrittenPaths = orderedSteps.slice(index).map((pending) => pending.path);
+            throw new Error(describeApplyFailure({ failedStep: step, error: outcome.error, appliedWrites, unwrittenPaths }));
         }
-        applied.push({ path: step.path, created: outcome.outcome === 'created' });
+        appliedWrites.push({ path: step.path, created: outcome.outcome === 'created' });
     }
-    return applied.map((write) => write.path);
+    return appliedWrites.map((write) => write.path);
 }
 function applyStep(step) {
     if (step.kind === 'remove') {
@@ -33,43 +33,43 @@ function applyStep(step) {
     return { outcome: result.outcome === 'created' ? 'created' : 'applied' };
 }
 function orderPlannedSteps(plan) {
-    const ordered = [
+    const orderedSteps = [
         ...plan.writes.map((write) => ({ kind: 'write', ...write })),
         ...plan.removals.map((path) => ({ kind: 'remove', path })),
     ];
     if (plan.summary.length > 0) {
-        ordered.push({ kind: 'write', path: RELEASE_SUMMARY_FILE, content: plan.summary });
+        orderedSteps.push({ kind: 'write', path: RELEASE_SUMMARY_FILE, content: plan.summary });
     }
     if (plan.tags.length > 0) {
-        ordered.push({ kind: 'write', path: RELEASE_TAGS_FILE, content: plan.tags.join('\n') });
+        orderedSteps.push({ kind: 'write', path: RELEASE_TAGS_FILE, content: plan.tags.join('\n') });
     }
-    return ordered;
+    return orderedSteps;
 }
 function describeApplyFailure(args) {
-    const { failedStep, error, applied, unwritten } = args;
-    const total = applied.length + unwritten.length;
+    const { failedStep, error, appliedWrites, unwrittenPaths } = args;
+    const totalCount = appliedWrites.length + unwrittenPaths.length;
     const verb = failedStep.kind === 'remove' ? 'remove' : 'write';
     const lines = [`Failed to ${verb} ${failedStep.path}: ${error ?? 'unknown error'}`, ''];
-    if (applied.length === 0) {
-        lines.push(`The release was not applied. None of its ${total} files were written.`);
+    if (appliedWrites.length === 0) {
+        lines.push(`The release was not applied. None of its ${totalCount} files were written.`);
         return lines.join('\n');
     }
-    lines.push(`The release was partially applied. ${applied.length} of ${total} files were written:`, ...applied.map((write) => `  ${write.path}`), '', 'Not written:', ...unwritten.map((path) => `  ${path}`), ...describeRecovery(applied));
+    lines.push(`The release was partially applied. ${appliedWrites.length} of ${totalCount} files were written:`, ...appliedWrites.map((write) => `  ${write.path}`), '', 'Not written:', ...unwrittenPaths.map((path) => `  ${path}`), ...describeRecovery(appliedWrites));
     return lines.join('\n');
 }
-function describeRecovery(applied) {
-    const releaseWrites = applied.filter((write) => !HANDOFF_FILES.has(write.path));
-    const replaced = releaseWrites.filter((write) => !write.created).map((write) => write.path);
-    const created = releaseWrites.filter((write) => write.created).map((write) => write.path);
-    if (replaced.length === 0 && created.length === 0) {
+function describeRecovery(appliedWrites) {
+    const releaseWrites = appliedWrites.filter((write) => !HANDOFF_FILES.has(write.path));
+    const replacedPaths = releaseWrites.filter((write) => !write.created).map((write) => write.path);
+    const createdPaths = releaseWrites.filter((write) => write.created).map((write) => write.path);
+    if (replacedPaths.length === 0 && createdPaths.length === 0) {
         return [];
     }
     const lines = ['', 'Undo the written release files before re-running `release-kit prepare`:'];
-    if (replaced.length > 0) {
-        lines.push(`  git restore ${replaced.join(' ')}`);
+    if (replacedPaths.length > 0) {
+        lines.push(`  git restore ${replacedPaths.join(' ')}`);
     }
-    if (created.length > 0) {
-        lines.push(`  rm ${created.join(' ')}`);
+    if (createdPaths.length > 0) {
+        lines.push(`  rm ${createdPaths.join(' ')}`);
     }
     return lines;
 }

package/dist/esm/renderChangelogMarkdown.d.ts

@@ -13,7 +13,7 @@ export interface RenderChangelogMarkdownOptions {
 /** Options for `renderChangelogFiles`. */
 export interface RenderChangelogFilesOptions extends RenderChangelogMarkdownOptions {
     /** How many of the newest sections the main file keeps; every section when omitted. Must be at least 1. */
-    keepVersions?: number;
+    keptVersionCount?: number;
 }
 /** A rendered archive file: the sections of one major version that the main file does not keep. */
 export interface RenderedChangelogArchive {
@@ -28,9 +28,9 @@ export interface RenderedChangelogFiles {
 /**
  * Renders entries and preserved sections into `CHANGELOG.md` and its per-major archive files.
  *
- * The main file keeps the newest `keepVersions` sections, counting preserved sections, and links to each archive file
- * from a paragraph below its header. Each older section goes to the archive file of its major version. Every file
- * has the same header and footer.
+ * The main file keeps as many of the newest sections as `keptVersionCount` names, counting preserved sections, and
+ * links to each archive file from a paragraph below its header. Each older section goes to the archive file of its
+ * major version. Every file has the same header and footer.
  */
 export declare function renderChangelogFiles(entries: ChangelogEntry[], options?: RenderChangelogFilesOptions): RenderedChangelogFiles;
 /**

package/dist/esm/renderChangelogMarkdown.js

@@ -8,19 +8,25 @@ All notable changes to this project will be documented in this file.`;
 const CHANGELOG_FOOTER = `<!-- Generated by release-kit. Do not edit this file. Use .meta/changelog-overrides.json to override entries. -->`;
 export function renderChangelogFiles(entries, options) {
     const sections = interleavePreservedSections(entries.map((entry) => ({ version: entry.version, text: renderReleaseNotesSingle(entry, options) })), options?.preservedSections ?? []).filter((section) => section.text.length > 0);
-    const keepVersions = options?.keepVersions;
-    if (keepVersions === undefined || sections.length <= keepVersions) {
+    const keptVersionCount = options?.keptVersionCount;
+    if (keptVersionCount === undefined || sections.length <= keptVersionCount) {
         return { main: renderFile(sections), archives: [] };
     }
-    const archived = groupByMajor(sections.slice(keepVersions));
+    const archivedGroups = groupByMajor(sections.slice(keptVersionCount));
     return {
-        main: renderFile(sections.slice(0, keepVersions), describeArchivePointer(archived.map(({ major }) => major))),
-        archives: archived.map(({ major, sections: majorSections }) => ({ major, content: renderFile(majorSections) })),
+        main: renderFile(sections.slice(0, keptVersionCount), describeArchivePointer(archivedGroups.map(({ major }) => major))),
+        archives: archivedGroups.map(({ major, sections: majorSections }) => ({
+            major,
+            content: renderFile(majorSections),
+        })),
     };
 }
 export function renderChangelogMarkdown(entries, options) {
     return renderChangelogFiles(entries, options).main;
 }
+function appendTrailingNewline(section) {
+    return { version: section.version, text: `${section.text}\n` };
+}
 function describeArchivePointer(majors) {
     const links = majors.map((major) => `[v${major}](${describeArchivePath(major)})`);
     return `Earlier versions: ${links.join(', ')}.`;
@@ -39,21 +45,21 @@ function groupByMajor(sections) {
     }
     return Array.from(groups, ([major, majorSections]) => ({ major, sections: majorSections })).toSorted((a, b) => b.major - a.major);
 }
-function interleavePreservedSections(rendered, preserved) {
-    const sorted = preserved.toSorted((a, b) => compareVersionsDescending(a.version, b.version));
-    const pending = sorted.map(withTrailingNewline);
+function interleavePreservedSections(renderedSections, preservedSections) {
+    const sortedSections = preservedSections.toSorted((a, b) => compareVersionsDescending(a.version, b.version));
+    const pendingSections = sortedSections.map(appendTrailingNewline);
     const result = [];
     let index = 0;
-    for (const part of rendered) {
-        let section = pending[index];
+    for (const part of renderedSections) {
+        let section = pendingSections[index];
         while (section !== undefined && compareVersionsDescending(section.version, part.version) < 0) {
             result.push(section);
             index++;
-            section = pending[index];
+            section = pendingSections[index];
         }
         result.push(part);
     }
-    result.push(...pending.slice(index));
+    result.push(...pendingSections.slice(index));
     return result;
 }
 function renderFile(sections, paragraph) {
@@ -71,6 +77,3 @@ function renderFile(sections, paragraph) {
     parts.push(CHANGELOG_FOOTER);
     return parts.join('\n\n') + '\n';
 }
-function withTrailingNewline(section) {
-    return { version: section.version, text: `${section.text}\n` };
-}

package/dist/esm/renderReleaseNotes.d.ts

@@ -4,7 +4,7 @@ export interface RenderOptions {
     /** Predicate to filter sections. When absent, all sections are included. */
     filter?: (section: ChangelogSection) => boolean;
     /** Whether to include the version/date heading. Defaults to `true`. */
-    includeHeading?: boolean;
+    shouldIncludeHeading?: boolean;
     /**
      * Section titles in desired priority order. Known titles are emitted first in this order;
      * titles not listed preserve their relative position after known ones. When absent, section

package/dist/esm/renderReleaseNotes.js

@@ -3,26 +3,26 @@ function getBreakingPrefix() {
     const { emoji, label } = CANONICAL_TAXONOMY.markers.breaking;
     return `${emoji} **${label}:** `;
 }
-function allSections() {
+function matchAllSections() {
     return true;
 }
-function publicSections(section) {
+function matchPublicSections(section) {
     return section.audience === 'all';
 }
 export function matchesAudience(audience) {
-    return audience === 'dev' ? allSections : publicSections;
+    return audience === 'dev' ? matchAllSections : matchPublicSections;
 }
 export function renderReleaseNotesSingle(entry, options) {
     const filter = options?.filter;
-    const includeHeading = options?.includeHeading ?? true;
+    const shouldIncludeHeading = options?.shouldIncludeHeading ?? true;
     const sectionOrder = options?.sectionOrder;
-    const filtered = filter !== undefined ? entry.sections.filter(filter) : entry.sections;
-    const sections = sectionOrder !== undefined ? sortSectionsByOrder(filtered, sectionOrder) : filtered;
+    const filteredSections = filter !== undefined ? entry.sections.filter(filter) : entry.sections;
+    const sections = sectionOrder !== undefined ? sortSectionsByOrder(filteredSections, sectionOrder) : filteredSections;
     if (sections.length === 0) {
         return '';
     }
     const lines = [];
-    if (includeHeading) {
+    if (shouldIncludeHeading) {
         lines.push(`## ${entry.version} — ${entry.date}`);
     }
     for (const section of sections) {
@@ -45,20 +45,20 @@ export function renderReleaseNotesSingle(entry, options) {
     return lines.join('\n') + '\n';
 }
 function sortSectionsByOrder(sections, order) {
-    const priority = new Map();
+    const priorityByTitle = new Map();
     for (const [index, title] of order.entries()) {
-        priority.set(title, index);
+        priorityByTitle.set(title, index);
     }
-    const indexed = sections.map((section, index) => ({ section, index }));
-    indexed.sort((a, b) => {
-        const priorityA = priority.get(a.section.title) ?? Infinity;
-        const priorityB = priority.get(b.section.title) ?? Infinity;
-        if (priorityA !== priorityB) {
-            return priorityA - priorityB;
+    const indexedSections = sections.map((section, index) => ({ section, index }));
+    indexedSections.sort((a, b) => {
+        const aPriority = priorityByTitle.get(a.section.title) ?? Infinity;
+        const bPriority = priorityByTitle.get(b.section.title) ?? Infinity;
+        if (aPriority !== bPriority) {
+            return aPriority - bPriority;
         }
         return a.index - b.index;
     });
-    return indexed.map(({ section }) => section);
+    return indexedSections.map(({ section }) => section);
 }
 function indentBodyLines(body) {
     return body.split('\n').map((line) => (line.length === 0 ? '' : `  ${line}`));