@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/reportPrepare.js

@@ -1,5 +1,5 @@
 import { formatGlyphLine, formatStatusLine, measureGlyphColumn, STATUS_GLYPHS, } from '@williamthorsen/nmr-core';
-import { bold, dim, sectionHeader } from "./format.js";
+import { bold, dim, renderSectionHeader } from "./format.js";
 import { formatBumpFiles, formatChangelogFiles, formatPreviewFiles } from "./formatPrepareFiles.js";
 import { formatChangeRecordWarnings, formatPolicyViolations, formatUnparseableWarning, formatWarnings, } from "./formatPrepareWarnings.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
@@ -12,15 +12,15 @@ export function reportPrepare(plan, options) {
     return formatSingleWorkspace(plan, options);
 }
 function formatSingleWorkspace(result, options) {
-    const dryRun = !options.applied;
+    const isDryRun = !options.applied;
     const { style } = options;
     const lines = [];
     const workspace = result.targets[0];
     if (workspace === undefined || workspace.kind === 'composite') {
         return '';
     }
-    const since = workspace.previousTag === undefined ? 'the beginning' : workspace.previousTag;
-    lines.push(dim(`Found ${workspace.commitCount} commits since ${since}`));
+    const sinceLabel = workspace.previousTag === undefined ? 'the beginning' : workspace.previousTag;
+    lines.push(dim(`Found ${workspace.commitCount} commits since ${sinceLabel}`));
     if (workspace.parsedCommitCount !== undefined) {
         lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
     }
@@ -32,8 +32,8 @@ function formatSingleWorkspace(result, options) {
         formatWarnings(lines, result, style);
         return lines.join('\n');
     }
-    if (workspace.setVersion !== undefined) {
-        lines.push(`  Using version override: ${workspace.setVersion}`);
+    if (workspace.versionOverride !== undefined) {
+        lines.push(`  Using version override: ${workspace.versionOverride}`);
     }
     else if (workspace.bumpOverride !== undefined) {
         lines.push(`  Using bump override: ${workspace.bumpOverride}`);
@@ -41,35 +41,35 @@ function formatSingleWorkspace(result, options) {
     if (workspace.releaseType !== undefined) {
         lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
     }
-    else if (workspace.setVersion !== undefined) {
+    else if (workspace.versionOverride !== undefined) {
         lines.push(dim(`Bumping versions (version override)...`));
     }
-    if (workspace.setVersion !== undefined) {
+    if (workspace.versionOverride !== undefined) {
         lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`));
     }
     else if (workspace.releaseType !== undefined) {
         lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`));
     }
     formatChangeRecordWarnings(lines, workspace, style);
-    formatBumpFiles(lines, workspace, dryRun);
+    formatBumpFiles(lines, workspace, isDryRun);
     lines.push(dim('Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, dryRun, style);
-    formatPreviewFiles(lines, workspace, dryRun);
+    formatChangelogFiles(lines, workspace, isDryRun, style);
+    formatPreviewFiles(lines, workspace, isDryRun);
     formatFormatCommand(lines, result, options);
     formatWarnings(lines, result, style);
     lines.push(formatStatusLine(style, 'passed', 'Release preparation complete.'), `   ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
     return lines.join('\n');
 }
 function formatMultiWorkspace(result, options) {
-    const dryRun = !options.applied;
+    const isDryRun = !options.applied;
     const { style } = options;
     const lines = [];
     for (const target of result.targets) {
         if (target.kind === 'composite') {
-            formatProjectSection(lines, target, dryRun, style);
+            formatProjectSection(lines, target, isDryRun, style);
         }
         else {
-            formatWorkspaceSection(lines, target, dryRun, style);
+            formatWorkspaceSection(lines, target, isDryRun, style);
         }
     }
     formatFormatCommand(lines, result, options);
@@ -85,10 +85,10 @@ function formatMultiWorkspace(result, options) {
     }
     return lines.join('\n');
 }
-function formatProjectSection(lines, project, dryRun, style) {
-    lines.push(`\n${sectionHeader(project.targetId === PROJECT_TARGET_ID ? 'project' : project.targetId)}`);
-    const since = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
-    lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
+function formatProjectSection(lines, project, isDryRun, style) {
+    lines.push(`\n${renderSectionHeader(project.targetId === PROJECT_TARGET_ID ? 'project' : project.targetId)}`);
+    const sinceLabel = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
+    lines.push(dim(`  Found ${project.commitCount} commits ${sinceLabel}`));
     formatPolicyViolations(lines, project.policyViolations, style, '  ');
     if (project.status === 'skipped') {
         formatUnparseableWarning(lines, project, style, '  ');
@@ -107,7 +107,7 @@ function formatProjectSection(lines, project, dryRun, style) {
     formatChangeRecordWarnings(lines, project, style, '  ');
     lines.push(dim(`  Bumping versions (${releaseType})...`), `  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${currentVersion} → ${bold(newVersion)} (${releaseType})`)}`);
     for (const file of project.bumpedFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`    [dry-run] Would bump ${file}`));
         }
         else {
@@ -115,16 +115,16 @@ function formatProjectSection(lines, project, dryRun, style) {
         }
     }
     lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, project, dryRun, style, '  ');
-    formatPreviewFiles(lines, project, dryRun, '  ');
+    formatChangelogFiles(lines, project, isDryRun, style, '  ');
+    formatPreviewFiles(lines, project, isDryRun, '  ');
     lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(tag))}`);
 }
-function formatWorkspaceSection(lines, workspace, dryRun, style) {
+function formatWorkspaceSection(lines, workspace, isDryRun, style) {
     if (workspace.name !== undefined) {
-        lines.push(`\n${sectionHeader(workspace.name)}`);
+        lines.push(`\n${renderSectionHeader(workspace.name)}`);
     }
-    const since = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
-    lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
+    const sinceLabel = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
+    lines.push(dim(`  Found ${workspace.commitCount} commits ${sinceLabel}`));
     if (workspace.status === 'skipped') {
         formatUnparseableWarning(lines, workspace, style, '  ');
         formatPolicyViolations(lines, workspace.policyViolations, style, '  ');
@@ -140,24 +140,24 @@ function formatWorkspaceSection(lines, workspace, dryRun, style) {
     formatChangeRecordWarnings(lines, workspace, style, '  ');
     formatBumpLabels(lines, workspace, isPropagatedOnly);
     formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style);
-    formatBumpFiles(lines, workspace, dryRun, '  ');
+    formatBumpFiles(lines, workspace, isDryRun, '  ');
     lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, dryRun, style, '  ');
-    formatPreviewFiles(lines, workspace, dryRun, '  ');
+    formatChangelogFiles(lines, workspace, isDryRun, style, '  ');
+    formatPreviewFiles(lines, workspace, isDryRun, '  ');
     lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
 }
 function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
     if (isPropagatedOnly && propagatedFrom !== undefined) {
-        const depNames = propagatedFrom.map((p) => p.packageName).join(', ');
-        lines.push(dim(`  Bumped via dependency: ${depNames}`));
+        const dependencyNames = propagatedFrom.map((p) => p.packageName).join(', ');
+        lines.push(dim(`  Bumped via dependency: ${dependencyNames}`));
     }
     else if (workspace.parsedCommitCount !== undefined && workspace.parsedCommitCount > 0) {
         lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
     }
 }
 function formatBumpLabels(lines, workspace, isPropagatedOnly) {
-    if (workspace.setVersion !== undefined) {
-        lines.push(`  Using version override: ${workspace.setVersion}`);
+    if (workspace.versionOverride !== undefined) {
+        lines.push(`  Using version override: ${workspace.versionOverride}`);
     }
     else if (workspace.bumpOverride !== undefined && !isPropagatedOnly) {
         lines.push(`  Using bump override: ${workspace.bumpOverride}`);
@@ -165,13 +165,13 @@ function formatBumpLabels(lines, workspace, isPropagatedOnly) {
     if (workspace.releaseType !== undefined) {
         lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
     }
-    else if (workspace.setVersion !== undefined) {
+    else if (workspace.versionOverride !== undefined) {
         lines.push(dim(`  Bumping versions (version override)...`));
     }
 }
 function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style) {
     const versions = `${workspace.currentVersion} → ${bold(workspace.newVersion)}`;
-    if (workspace.setVersion !== undefined) {
+    if (workspace.versionOverride !== undefined) {
         lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (version override)`)}`);
     }
     else if (workspace.releaseType !== undefined) {

package/dist/esm/resolveCommandTags.js

@@ -29,12 +29,12 @@ export function resolveCommandTags(tags, userConfig) {
             singleWorkspace = deriveWorkspaceConfig('.');
         }
         else {
-            const merged = mergeMonorepoConfig(workspace.packageDirs, userConfig, readRootPackageVersion());
-            const excluded = merged.excludedWorkspaces ?? [];
-            workspaces = [...merged.workspaces, ...excluded];
-            directories = merged.directories ?? [];
-            project = merged.project;
-            excludedPaths = new Set(excluded.map((excludedWorkspace) => excludedWorkspace.workspacePath));
+            const mergedConfig = mergeMonorepoConfig(workspace.packageDirs, userConfig, readRootPackageVersion());
+            const excludedWorkspaces = mergedConfig.excludedWorkspaces ?? [];
+            workspaces = [...mergedConfig.workspaces, ...excludedWorkspaces];
+            directories = mergedConfig.directories ?? [];
+            project = mergedConfig.project;
+            excludedPaths = new Set(excludedWorkspaces.map((excludedWorkspace) => excludedWorkspace.workspacePath));
         }
     }
     catch (error) {
@@ -69,15 +69,15 @@ export function resolveCommandTags(tags, userConfig) {
     return dropExcludedTags(resolvedTags, excludedPaths, userConfig?.releases === undefined ? 'legacy' : 'releases');
 }
 function dropExcludedTags(resolvedTags, excludedPaths, surface) {
-    const retained = [];
+    const retainedTags = [];
     for (const resolvedTag of resolvedTags) {
         if (resolvedTag.kind === 'package' && excludedPaths.has(resolvedTag.workspacePath)) {
             const setting = surface === 'releases' ? `releases.${resolvedTag.dir}: false` : undefined;
             console.warn(formatExcludedSkip(resolvedTag, setting));
         }
         else {
-            retained.push(resolvedTag);
+            retainedTags.push(resolvedTag);
         }
     }
-    return retained;
+    return retainedTags;
 }

package/dist/esm/resolveReleaseDeclaration.d.ts

@@ -24,9 +24,9 @@ export interface DeclaredDirectory {
 /** The release targets that a config declares over the discovered workspaces. */
 export interface ReleaseDeclaration {
     /** Retained workspaces in discovery order, each with its target name and legacy identities applied. */
-    retained: WorkspaceConfig[];
+    retainedWorkspaces: WorkspaceConfig[];
     /** Discovered workspaces that the config excludes, in discovery order. */
-    excluded: WorkspaceConfig[];
+    excludedWorkspaces: WorkspaceConfig[];
     /** Directories that `releases` entries declare as targets, in config order. */
     directories: DeclaredDirectory[];
     composite?: DeclaredComposite;

package/dist/esm/resolveReleaseDeclaration.js

@@ -3,8 +3,8 @@ export function getTargetName(workspace) {
     return workspace.targetName ?? workspace.dir;
 }
 export function normalizeWorkspacePath(configuredPath) {
-    const normalized = path.posix.normalize(configuredPath.replaceAll('\\', '/'));
-    return normalized.replace(/^\.\//, '').replace(/\/+$/, '');
+    const normalizedPath = path.posix.normalize(configuredPath.replaceAll('\\', '/'));
+    return normalizedPath.replace(/^\.\//, '').replace(/\/+$/, '');
 }
 export function resolveReleaseDeclaration(workspaces, userConfig) {
     if (userConfig?.releases !== undefined) {
@@ -19,9 +19,9 @@ function applyLegacyIdentities(workspace, legacyIdentities) {
     return { ...workspace, legacyIdentities: legacyIdentities.map((identity) => ({ ...identity })) };
 }
 function claimPath(entryByPath, name, claimedPath, kind) {
-    const claimedBy = entryByPath.get(claimedPath);
-    if (claimedBy !== undefined) {
-        throw new Error(`releases.${name}: ${kind} '${claimedPath}' is already declared by releases.${claimedBy}; declare each ${kind} once`);
+    const claimingEntryName = entryByPath.get(claimedPath);
+    if (claimingEntryName !== undefined) {
+        throw new Error(`releases.${name}: ${kind} '${claimedPath}' is already declared by releases.${claimingEntryName}; declare each ${kind} once`);
     }
     entryByPath.set(claimedPath, name);
 }
@@ -40,9 +40,9 @@ function declareDirectory(name, entry, normalizedPath) {
         }),
     };
 }
-function resolveCompositeMembers(composite, retained, excluded, directories) {
+function resolveCompositeMembers(composite, retainedWorkspaces, excludedWorkspaces, directories) {
     const membersByName = new Map([
-        ...retained.map((workspace) => [getTargetName(workspace), { name: getTargetName(workspace), paths: workspace.paths }]),
+        ...retainedWorkspaces.map((workspace) => [getTargetName(workspace), { name: getTargetName(workspace), paths: workspace.paths }]),
         ...directories.map((directory) => [directory.name, { name: directory.name, paths: directory.paths }]),
     ]);
     return composite.includes.map((memberName) => {
@@ -54,7 +54,7 @@ function resolveCompositeMembers(composite, retained, excluded, directories) {
         if (memberName === composite.name) {
             throw new Error(`${label} is the composite itself; a composite includes package and directory targets only`);
         }
-        if (excluded.some((workspace) => workspace.dir === memberName)) {
+        if (excludedWorkspaces.some((workspace) => workspace.dir === memberName)) {
             throw new Error(`${label} is excluded, so the composite cannot include it`);
         }
         throw new Error(`${label} is not a release target. Known targets: ${membersByName.keys().toArray().join(', ')}`);
@@ -62,18 +62,18 @@ function resolveCompositeMembers(composite, retained, excluded, directories) {
 }
 function resolveLegacyBlocks(workspaces, overrides, project) {
     const overridesByDir = new Map(overrides.map((override) => [override.dir, override]));
-    const retained = [];
-    const excluded = [];
+    const retainedWorkspaces = [];
+    const excludedWorkspaces = [];
     for (const workspace of workspaces) {
         const override = overridesByDir.get(workspace.dir);
         if (override?.shouldExclude === true) {
-            excluded.push(workspace);
+            excludedWorkspaces.push(workspace);
         }
         else {
-            retained.push(applyLegacyIdentities(workspace, override?.legacyIdentities));
+            retainedWorkspaces.push(applyLegacyIdentities(workspace, override?.legacyIdentities));
         }
     }
-    const declaration = { retained, excluded, directories: [] };
+    const declaration = { retainedWorkspaces, excludedWorkspaces, directories: [] };
     if (project !== undefined) {
         declaration.composite = {
             ...(project.paths !== undefined && { paths: [...project.paths] }),
@@ -87,7 +87,7 @@ function resolveReleasesBlock(workspaces, releases) {
     const workspaceByDir = new Map(workspaces.map((workspace) => [workspace.dir, workspace]));
     const entryByPath = new Map();
     const excludedPaths = new Set();
-    const renamed = new Map();
+    const renamedWorkspaces = new Map();
     const directories = [];
     let composite;
     for (const [name, entry] of Object.entries(releases)) {
@@ -126,22 +126,22 @@ function resolveReleasesBlock(workspaces, releases) {
                 "whose tag prefix derives from its package name; declare the workspace's earlier prefixes in legacyIdentities");
         }
         claimPath(entryByPath, name, workspace.workspacePath, 'workspace');
-        const named = applyLegacyIdentities(workspace, entry.legacyIdentities);
-        renamed.set(workspace.workspacePath, name === workspace.dir ? named : { ...named, targetName: name });
+        const identifiedWorkspace = applyLegacyIdentities(workspace, entry.legacyIdentities);
+        renamedWorkspaces.set(workspace.workspacePath, name === workspace.dir ? identifiedWorkspace : { ...identifiedWorkspace, targetName: name });
     }
-    const retained = [];
-    const excluded = [];
+    const retainedWorkspaces = [];
+    const excludedWorkspaces = [];
     for (const workspace of workspaces) {
         if (excludedPaths.has(workspace.workspacePath)) {
-            excluded.push(workspace);
+            excludedWorkspaces.push(workspace);
         }
         else {
-            retained.push(renamed.get(workspace.workspacePath) ?? workspace);
+            retainedWorkspaces.push(renamedWorkspaces.get(workspace.workspacePath) ?? workspace);
         }
     }
-    const declaration = { retained, excluded, directories };
+    const declaration = { retainedWorkspaces, excludedWorkspaces, directories };
     if (composite !== undefined) {
-        const members = resolveCompositeMembers(composite, retained, excluded, directories);
+        const members = resolveCompositeMembers(composite, retainedWorkspaces, excludedWorkspaces, directories);
         declaration.composite = {
             name: composite.name,
             members: members.map((member) => member.name),

package/dist/esm/resolveReleaseTags.js

@@ -22,32 +22,34 @@ export function resolveReleaseTags(args) {
     return resolveSinglePackageTags(tags, args.singleWorkspace);
 }
 function resolveSinglePackageTags(tags, singleWorkspace) {
-    const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
+    const matchedTags = tags.filter((tag) => VERSION_PATTERN.test(tag));
     const isPublishable = singleWorkspace?.isPublishable ?? true;
-    if (matched.length > 1) {
-        console.warn(`Warning: Multiple version tags found on HEAD: ${matched.join(', ')}. ` +
+    if (matchedTags.length > 1) {
+        console.warn(`Warning: Multiple version tags found on HEAD: ${matchedTags.join(', ')}. ` +
             `Publishing the same package multiple times is almost certainly unintended. Using only the first tag.`);
-        return matched.slice(0, 1).map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
+        return matchedTags
+            .slice(0, 1)
+            .map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
     }
-    return matched.map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
+    return matchedTags.map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
 }
 function resolveMonorepoTags(tags, workspaces, directories, project) {
     const sortedWorkspaces = workspaces.toSorted((a, b) => b.tagPrefix.length - a.tagPrefix.length);
-    const resolved = [];
+    const resolvedTags = [];
     for (const tag of tags) {
-        const match = findMatchingWorkspace(tag, sortedWorkspaces);
+        const matchedWorkspace = findMatchingWorkspace(tag, sortedWorkspaces);
         const directory = directories.find((candidate) => hasVersionAfterPrefix(tag, candidate.tagPrefix));
-        if (match !== undefined) {
-            resolved.push({
+        if (matchedWorkspace !== undefined) {
+            resolvedTags.push({
                 tag,
                 kind: 'package',
-                dir: getTargetName(match),
-                workspacePath: match.workspacePath,
-                isPublishable: match.isPublishable,
+                dir: getTargetName(matchedWorkspace),
+                workspacePath: matchedWorkspace.workspacePath,
+                isPublishable: matchedWorkspace.isPublishable,
             });
         }
         else if (directory !== undefined) {
-            resolved.push({
+            resolvedTags.push({
                 tag,
                 kind: 'directory',
                 dir: directory.name,
@@ -56,7 +58,7 @@ function resolveMonorepoTags(tags, workspaces, directories, project) {
             });
         }
         else if (project !== undefined && hasVersionAfterPrefix(tag, project.tagPrefix)) {
-            resolved.push({
+            resolvedTags.push({
                 tag,
                 kind: 'project',
                 dir: project.name ?? PROJECT_TARGET_ID,
@@ -65,7 +67,7 @@ function resolveMonorepoTags(tags, workspaces, directories, project) {
             });
         }
     }
-    return resolved;
+    return resolvedTags;
 }
 function findMatchingWorkspace(tag, sortedWorkspaces) {
     return sortedWorkspaces.find((workspace) => hasVersionAfterPrefix(tag, workspace.tagPrefix));

package/dist/esm/resolveReleaseTargets.js

@@ -13,8 +13,8 @@ export function resolveReleaseTargets(userConfig, discovery) {
     return projectMonorepoConfig(mergeMonorepoConfig(discovery.packageDirs, userConfig, readRootPackageVersion()));
 }
 export function isSinglePackageTargets(targets) {
-    const [only] = targets;
-    return targets.length === 1 && only?.kind === 'package' && !only.isWorkspace;
+    const [onlyTarget] = targets;
+    return targets.length === 1 && onlyTarget?.kind === 'package' && !onlyTarget.isWorkspace;
 }
 export function projectMonorepoConfig(config) {
     const targets = [

package/dist/esm/showTagPrefixesCommand.js

@@ -59,12 +59,12 @@ function renderWorkspaceRow(row, style) {
     lines.push(`  ${row.workspacePath}: derived prefix '${row.derivedPrefix}', ${statusMarker}`);
     for (const entry of row.legacyEntries) {
         if (entry.tagCount > 0) {
-            const recognized = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
-            lines.push(`      ${formatStatusLine(style, 'passed', recognized)}`);
+            const recognizedMessage = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
+            lines.push(`      ${formatStatusLine(style, 'passed', recognizedMessage)}`);
         }
         else {
-            const tagless = `recorded legacy prefix '${entry.prefix}' does not have any tags`;
-            lines.push(`      ${formatStatusLine(style, 'warning', tagless)}`);
+            const taglessMessage = `recorded legacy prefix '${entry.prefix}' does not have any tags`;
+            lines.push(`      ${formatStatusLine(style, 'warning', taglessMessage)}`);
         }
     }
     return lines;

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -20,7 +20,7 @@ export declare function loadRepoLabelsConfig(stderrStyle: OutputStyle, configPat
 /** Options for the `sync-labels generate` subcommand. */
 interface GenerateOptions {
     /** Compares the regenerated content against the committed file instead of writing. */
-    check?: boolean;
+    shouldCheck?: boolean;
     /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
     configPath?: string;
     styles: StreamStyles;
@@ -28,11 +28,11 @@ interface GenerateOptions {
 /**
  * Runs the `sync-labels generate` command and returns the process exit code.
  *
- * Writes `.github/labels.yaml` from the config's `repoLabels` block, or, with `check`, reports whether the committed
+ * Writes `.github/labels.yaml` from the config's `repoLabels` block, or, with `shouldCheck`, reports whether the committed
  * file is stale and writes nothing.
  *
  * The header names the config by its POSIX path relative to the working directory, the repo root, so that the file
  * does not depend on the invocation directory or on the machine on which the command ran.
  */
-export declare function generateCommand({ check, configPath, styles }: GenerateOptions): Promise<number>;
+export declare function generateCommand({ shouldCheck, configPath, styles }: GenerateOptions): Promise<number>;
 export {};

package/dist/esm/sync-labels/generateCommand.js

@@ -15,14 +15,14 @@ export function formatLabelsYaml(labels, presetHashes, configFilePath = CONFIG_F
     for (const [name, hash] of sortedPresetHashes) {
         headerLines.push(`# ${name} preset hash: ${hash}`);
     }
-    const declared = labels.map(({ aliases, archived, color, description, name }) => ({
+    const declaredLabels = labels.map(({ aliases, archived, color, description, name }) => ({
         name,
         color,
         description: description ?? '',
         ...(aliases !== undefined && { aliases }),
         ...(archived !== undefined && { archived }),
     }));
-    const yamlBody = stringify(declared, { singleQuote: true, lineWidth: 0 });
+    const yamlBody = stringify(declaredLabels, { singleQuote: true, lineWidth: 0 });
     return headerLines.join('\n') + '\n' + yamlBody;
 }
 export async function loadRepoLabelsConfig(stderrStyle, configPath) {
@@ -41,7 +41,7 @@ export async function loadRepoLabelsConfig(stderrStyle, configPath) {
     }
     return result.config.repoLabels;
 }
-export async function generateCommand({ check = false, configPath, styles }) {
+export async function generateCommand({ shouldCheck = false, configPath, styles }) {
     if (checkRetiredSyncLabelsConfig(configPath)) {
         return 1;
     }
@@ -63,8 +63,8 @@ export async function generateCommand({ check = false, configPath, styles }) {
     for (const presetName of presetNames) {
         presetHashes.set(presetName, hashPreset(presetName));
     }
-    const content = formatLabelsYaml(labels, presetHashes, toRootRelativePosixPath(configPath ?? CONFIG_FILE_PATH));
-    if (check) {
+    const content = formatLabelsYaml(labels, presetHashes, convertToRootRelativePosixPath(configPath ?? CONFIG_FILE_PATH));
+    if (shouldCheck) {
         return compareAgainstCommittedFile(content);
     }
     try {
@@ -79,22 +79,22 @@ export async function generateCommand({ check = false, configPath, styles }) {
     console.info(`Generated ${LABELS_OUTPUT_PATH} with ${String(labels.length)} labels.`);
     return 0;
 }
-function compareAgainstCommittedFile(expected) {
-    let existing;
+function compareAgainstCommittedFile(expectedContent) {
+    let existingContent;
     try {
-        existing = readFileSync(LABELS_OUTPUT_PATH, 'utf8');
+        existingContent = readFileSync(LABELS_OUTPUT_PATH, 'utf8');
     }
     catch {
         reportError(`${LABELS_OUTPUT_PATH} is missing. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
-    if (existing !== expected) {
+    if (existingContent !== expectedContent) {
         reportError(`${LABELS_OUTPUT_PATH} is stale. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
     console.info(`${LABELS_OUTPUT_PATH} is up to date.`);
     return 0;
 }
-function toRootRelativePosixPath(filePath) {
+function convertToRootRelativePosixPath(filePath) {
     return path.relative(process.cwd(), path.resolve(filePath)).split(path.sep).join('/');
 }

package/dist/esm/sync-labels/initCommand.d.ts

@@ -3,8 +3,8 @@ import { type StreamStyles } from '@williamthorsen/nmr-core';
 interface InitOptions {
     /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
     configPath?: string;
-    dryRun: boolean;
-    force: boolean;
+    isDryRun: boolean;
+    shouldForce: boolean;
     styles: StreamStyles;
 }
 /**
@@ -17,5 +17,5 @@ interface InitOptions {
  * `configPath` names the config to read. Because the command fails when the named config does not exist, it
  * reaches the scaffolding branch only under the default path, and that branch always writes to `CONFIG_FILE_PATH`.
  */
-export declare function syncLabelsInitCommand({ configPath, dryRun, force, styles }: InitOptions): Promise<number>;
+export declare function syncLabelsInitCommand({ configPath, isDryRun, shouldForce, styles, }: InitOptions): Promise<number>;
 export {};

package/dist/esm/sync-labels/initCommand.js

@@ -6,14 +6,14 @@ import { CONFIG_FILE_PATH } from "../loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
 import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
-import { buildScopeLabels, readSyncLabelsWorkflowTemplate, renderRepoLabelsBlock, repoLabelsConfigScript, } from "./templates.js";
+import { buildScopeLabels, readSyncLabelsWorkflowTemplate, renderRepoLabelsBlock, renderRepoLabelsConfigScript, } from "./templates.js";
 const WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
-export async function syncLabelsInitCommand({ configPath, dryRun, force, styles }) {
+export async function syncLabelsInitCommand({ configPath, isDryRun, shouldForce, styles, }) {
     const configFilePath = configPath ?? CONFIG_FILE_PATH;
     if (checkRetiredSyncLabelsConfig(configPath)) {
         return 1;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run mode]');
     }
     console.info('\n> Discovering workspaces');
@@ -36,8 +36,8 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
     else {
         console.info(`  Found ${String(workspace.packageDirs.length)} workspaces`);
     }
-    const configExists = configPath !== undefined || existsSync(CONFIG_FILE_PATH);
-    const retiredNames = configExists ? await loadRetiredPackageNames(styles, configPath) : [];
+    const doesConfigExist = configPath !== undefined || existsSync(CONFIG_FILE_PATH);
+    const retiredNames = doesConfigExist ? await loadRetiredPackageNames(styles, configPath) : [];
     if (retiredNames === undefined) {
         return 1;
     }
@@ -51,9 +51,9 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
         process.stderr.write(`  ${describeError(error)}\n`);
         return 1;
     }
-    const workflowResult = writeFileWithCheck(WORKFLOW_PATH, workflow, { isDryRun: dryRun, shouldOverwrite: force });
-    reportWriteResult(workflowResult, dryRun, styles);
-    if (configExists) {
+    const workflowResult = writeFileWithCheck(WORKFLOW_PATH, workflow, { isDryRun, shouldOverwrite: shouldForce });
+    reportWriteResult(workflowResult, isDryRun, styles);
+    if (doesConfigExist) {
         console.info(`\n> ${configFilePath} already exists; add this block to the object passed to defineConfig:\n`);
         console.info(renderRepoLabelsBlock(scopeLabels));
         if (workflowResult.outcome === 'failed') {
@@ -69,16 +69,16 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
 `);
         return 0;
     }
-    const configResult = writeFileWithCheck(CONFIG_FILE_PATH, repoLabelsConfigScript(scopeLabels), {
-        isDryRun: dryRun,
-        shouldOverwrite: force,
+    const configResult = writeFileWithCheck(CONFIG_FILE_PATH, renderRepoLabelsConfigScript(scopeLabels), {
+        isDryRun,
+        shouldOverwrite: shouldForce,
     });
-    reportWriteResult(configResult, dryRun, styles);
+    reportWriteResult(configResult, isDryRun, styles);
     if (workflowResult.outcome === 'failed' || configResult.outcome === 'failed') {
         process.stderr.write('Failed to scaffold one or more files.\n');
         return 1;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`\n> [dry-run] Would generate ${LABELS_OUTPUT_PATH}`);
     }
     else {
@@ -109,8 +109,8 @@ async function loadRetiredPackageNames(styles, configPath) {
     if (result.status === 'missing') {
         return [];
     }
-    return (result.config.retiredPackages ?? []).map((retired) => toUnscopedName(retired.name));
+    return (result.config.retiredPackages ?? []).map((retired) => stripNpmScope(retired.name));
 }
-function toUnscopedName(name) {
+function stripNpmScope(name) {
     return name.startsWith('@') ? name.slice(name.indexOf('/') + 1) : name;
 }

package/dist/esm/sync-labels/presets.js

@@ -25,12 +25,12 @@ export function loadPreset(presetName) {
     catch (error) {
         throw chainError(`Failed to read preset "${presetName}"`, error);
     }
-    const parsed = parse(content);
-    if (!Array.isArray(parsed)) {
+    const parsedYaml = parse(content);
+    if (!Array.isArray(parsedYaml)) {
         throw new TypeError(`Preset "${presetName}" must be a YAML array of label definitions`);
     }
     const labels = [];
-    for (const entry of parsed) {
+    for (const entry of parsedYaml) {
         if (!isRecord(entry)) {
             throw new Error(`Preset "${presetName}" contains an invalid label entry: ${JSON.stringify(entry)}`);
         }