@williamthorsen/nmr 0.38.0 → 0.40.0

package/dist/esm/commands/build.js

@@ -60,18 +60,18 @@ export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json
     const resolvedChain = [];
     const seen = new Set();
     function walk(configPath) {
-        const normalized = path.resolve(configPath);
-        if (seen.has(normalized)) {
+        const normalizedPath = path.resolve(configPath);
+        if (seen.has(normalizedPath)) {
             return;
         }
-        seen.add(normalized);
-        resolvedChain.push(normalized);
-        const configFile = ts.readConfigFile(normalized, (fileName) => ts.sys.readFile(fileName));
+        seen.add(normalizedPath);
+        resolvedChain.push(normalizedPath);
+        const configFile = ts.readConfigFile(normalizedPath, (fileName) => ts.sys.readFile(fileName));
         if (configFile.error) {
-            throw new Error(`nmr-compile: failed to read ${normalized}.\n${formatDiagnostics([configFile.error])}`);
+            throw new Error(`nmr-compile: failed to read ${normalizedPath}.\n${formatDiagnostics([configFile.error])}`);
         }
         for (const entry of normalizeExtendsField(configFile.config)) {
-            walk(resolveExtendsTarget(entry, normalized));
+            walk(resolveExtendsTarget(entry, normalizedPath));
         }
     }
     walk(path.resolve(packageDir, configFileName));
@@ -84,26 +84,26 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     const emitDir = resolveEmitDir(packageDir, outdir);
     const scratchDirs = resolveScratchDirs(emitDir);
     await removeScratchDirs(scratchDirs);
-    const emitted = new Map();
+    const emittedFiles = new Map();
     function collect(fileName, text, writeByteOrderMark) {
-        emitted.set(fileName, { text, writeByteOrderMark });
+        emittedFiles.set(fileName, { text, writeByteOrderMark });
     }
     const host = createCachingCompilerHost(compilerOptions);
     const scriptProgram = ts.createProgram(rootNames, { ...compilerOptions, declaration: false }, host);
     assertEmitSucceeded(scriptProgram.emit(undefined, collect));
     const declarationProgram = ts.createProgram(rootNames, { ...compilerOptions, emitDeclarationOnly: true, removeComments: false }, host, scriptProgram);
     assertEmitSucceeded(declarationProgram.emit(undefined, collect));
-    const staged = new Map();
-    for (const [fileName, file] of emitted) {
-        staged.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
+    const stagedFiles = new Map();
+    for (const [fileName, file] of emittedFiles) {
+        stagedFiles.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
     }
-    if (staged.size === 0) {
+    if (stagedFiles.size === 0) {
         await rm(emitDir, { force: true, recursive: true });
         return 0;
     }
-    writeStagedOutput(staged, emitDir, scratchDirs.staging);
+    writeStagedOutput(stagedFiles, emitDir, scratchDirs.stagingDir);
     await swapIntoPlace(emitDir, scratchDirs);
-    return staged.size;
+    return stagedFiles.size;
 }
 function assertEmitSucceeded(result) {
     if (result.emitSkipped) {
@@ -112,14 +112,14 @@ function assertEmitSucceeded(result) {
 }
 function createCachingCompilerHost(compilerOptions) {
     const host = ts.createCompilerHost(compilerOptions);
-    const parsed = new Map();
+    const parsedFiles = new Map();
     const readSourceFile = host.getSourceFile.bind(host);
     host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-        if (parsed.has(fileName)) {
-            return parsed.get(fileName);
+        if (parsedFiles.has(fileName)) {
+            return parsedFiles.get(fileName);
         }
         const sourceFile = readSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-        parsed.set(fileName, sourceFile);
+        parsedFiles.set(fileName, sourceFile);
         return sourceFile;
     };
     return host;
@@ -132,29 +132,31 @@ async function discardScratchDirs(scratchDirs) {
     }
 }
 async function removeScratchDirs(scratchDirs) {
-    await rm(scratchDirs.previous, { force: true, recursive: true });
-    await rm(scratchDirs.staging, { force: true, recursive: true });
+    await rm(scratchDirs.previousDir, { force: true, recursive: true });
+    await rm(scratchDirs.stagingDir, { force: true, recursive: true });
 }
 function resolveEmitDir(packageDir, outdir) {
-    const resolved = path.resolve(packageDir, outdir);
-    const relative = path.relative(packageDir, resolved);
-    if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+    const resolvedDir = path.resolve(packageDir, outdir);
+    const relativePathFromPackage = path.relative(packageDir, resolvedDir);
+    if (relativePathFromPackage === '' ||
+        relativePathFromPackage.startsWith('..') ||
+        path.isAbsolute(relativePathFromPackage)) {
         throw new Error(`nmr-compile: refusing to build into '${outdir}', which does not resolve inside the package. ` +
-            'The build replaces its output directory on each emit, so the directory must sit below the package root.');
+            'The build replaces its output directory on each emit, so the directory must be below the package root.');
     }
-    return resolved;
+    return resolvedDir;
 }
 async function swapIntoPlace(emitDir, scratchDirs) {
     const hadPreviousOutput = existsSync(emitDir);
     if (hadPreviousOutput) {
-        await rename(emitDir, scratchDirs.previous);
+        await rename(emitDir, scratchDirs.previousDir);
     }
     try {
-        await rename(scratchDirs.staging, emitDir);
+        await rename(scratchDirs.stagingDir, emitDir);
     }
     catch (error) {
         if (hadPreviousOutput && !existsSync(emitDir)) {
-            await rename(scratchDirs.previous, emitDir);
+            await rename(scratchDirs.previousDir, emitDir);
         }
         throw error;
     }
@@ -166,13 +168,13 @@ function synthesizeCompilerOptions(packageDir, outdir) {
     if (configFile.error) {
         throw new Error(`nmr-compile: failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
     }
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
-    if (parsed.errors.length > 0) {
-        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsed.errors)}`);
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
+    if (parsedConfig.errors.length > 0) {
+        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsedConfig.errors)}`);
     }
     const resolvedOutDir = path.resolve(packageDir, outdir);
     return {
-        ...parsed.options,
+        ...parsedConfig.options,
         noEmit: false,
         emitDeclarationOnly: false,
         declaration: true,
@@ -185,8 +187,8 @@ function synthesizeCompilerOptions(packageDir, outdir) {
         noEmitOnError: false,
     };
 }
-function writeStagedOutput(staged, emitDir, stagingDir) {
-    for (const [fileName, file] of staged) {
+function writeStagedOutput(stagedFiles, emitDir, stagingDir) {
+    for (const [fileName, file] of stagedFiles) {
         if (!isWithin(emitDir, fileName)) {
             throw new Error(`nmr-compile: the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
                 "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
@@ -198,57 +200,57 @@ function rewriteSpecifiers(outputFile, text, compilerOptions, sourceRoot) {
     if (!isRewritableOutput(outputFile)) {
         return text;
     }
-    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
+    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, resolveScriptKind(outputFile));
     const aliasPrefixes = collectAliasPrefixes(compilerOptions);
     const sourceContainingFile = mapOutputToSource(outputFile, compilerOptions, sourceRoot);
     const edits = [];
-    forEachModuleSpecifier(sourceFile, (literal) => {
+    visitModuleSpecifiers(sourceFile, (literal) => {
         const replacement = resolveSpecifierReplacement(literal.text, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes);
         if (replacement === undefined) {
             return;
         }
-        const start = literal.getStart(sourceFile);
-        const quote = text[start] ?? '"';
-        edits.push({ start, end: literal.getEnd(), text: `${quote}${replacement}${quote}` });
+        const startOffset = literal.getStart(sourceFile);
+        const quote = text[startOffset] ?? '"';
+        edits.push({ startOffset, endOffset: literal.getEnd(), text: `${quote}${replacement}${quote}` });
     });
     if (edits.length === 0) {
         return text;
     }
-    const orderedEdits = [...edits].sort((a, b) => b.start - a.start);
+    const orderedEdits = edits.toSorted((a, b) => b.startOffset - a.startOffset);
     let updatedText = text;
     for (const edit of orderedEdits) {
-        updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
+        updatedText = updatedText.slice(0, edit.startOffset) + edit.text + updatedText.slice(edit.endOffset);
     }
     return updatedText;
 }
 function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes) {
     if (isRelativeSpecifier(specifier)) {
-        const rewritten = swapTypeScriptExtension(specifier);
-        return rewritten === specifier ? undefined : rewritten;
+        const rewrittenSpecifier = swapTypeScriptExtension(specifier);
+        return rewrittenSpecifier === specifier ? undefined : rewrittenSpecifier;
     }
     if (aliasPrefixes.every((prefix) => !(specifier === prefix || specifier.startsWith(prefix)))) {
         return undefined;
     }
-    const resolved = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
-    if (!resolved) {
+    const resolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
+    if (!resolvedModule) {
         throw new Error(`nmr-compile: could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
             `Verify the tsconfig 'paths' mapping and that the target file exists.`);
     }
-    if (!isWithin(sourceRoot, resolved.resolvedFileName)) {
+    if (!isWithin(sourceRoot, resolvedModule.resolvedFileName)) {
         const { paths: _paths, baseUrl: _baseUrl, rootDirs: _rootDirs, ...nodeResolutionOptions } = compilerOptions;
-        const bareResolved = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
-        if (bareResolved) {
+        const bareResolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
+        if (bareResolvedModule) {
             return undefined;
         }
         throw new Error(`nmr-compile: aliased import '${specifier}' from ${sourceContainingFile} resolves to ` +
-            `${resolved.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
+            `${resolvedModule.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
             `the way Node will at runtime, which ignores tsconfig 'paths', 'baseUrl', and 'rootDirs'. The ` +
             `emitted specifier would fail at runtime; re-anchor the alias inside the package.`);
     }
-    const relative = toRelativeSpecifier(path.dirname(sourceContainingFile), resolved.resolvedFileName);
-    return swapTypeScriptExtension(relative);
+    const relativeSpecifier = buildRelativeSpecifier(path.dirname(sourceContainingFile), resolvedModule.resolvedFileName);
+    return swapTypeScriptExtension(relativeSpecifier);
 }
-function forEachModuleSpecifier(sourceFile, visit) {
+function visitModuleSpecifiers(sourceFile, visit) {
     function walk(node) {
         const specifier = getModuleSpecifier(node);
         if (specifier !== undefined) {
@@ -274,12 +276,12 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent, style) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, isOutputPresent, style) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
-        if (outputPresent) {
+        if (isOutputPresent) {
             console.info(`${STATUS_GLYPHS[style].skipped.text} ${packageName}: No changes detected. Skipping build.`);
             return { changed: false, currentHash };
         }
@@ -307,7 +309,7 @@ function collectAliasPrefixes(compilerOptions) {
 }
 function describeEmit(fileCount, outdir) {
     if (fileCount === 0) {
-        return 'Emitted no output.';
+        return 'Did not emit any output.';
     }
     return `Compiled ${fileCount} files to ${outdir.replace(/\/+$/u, '')}.`;
 }
@@ -346,12 +348,12 @@ function resolveExtendsTarget(extendsEntry, fromConfigPath) {
         }
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not exist.`);
     }
-    const resolved = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
+    const resolvedPath = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
         resolvePackageSpecifier(`${extendsEntry}/tsconfig.json`, fromConfigPath);
-    if (resolved === undefined) {
+    if (resolvedPath === undefined) {
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not resolve to a file.`);
     }
-    return resolved;
+    return resolvedPath;
 }
 function resolvePackageSpecifier(specifier, fromConfigPath) {
     const { resolvedModule } = ts.resolveModuleName(specifier, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
@@ -361,8 +363,8 @@ function isRelativeSpecifier(specifier) {
     return specifier.startsWith('./') || specifier.startsWith('../');
 }
 function isWithin(parent, child) {
-    const relative = path.relative(parent, child);
-    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+    const relativePath = path.relative(parent, child);
+    return relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
 }
 function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const outDir = compilerOptions.outDir ?? path.dirname(outputFile);
@@ -370,11 +372,11 @@ function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const withoutExtension = relativeFromOut.replace(/\.d\.ts$|\.js$/, '');
     return path.join(sourceRoot, `${withoutExtension}.ts`);
 }
-function toRelativeSpecifier(fromDir, targetFile) {
-    const relative = path.relative(fromDir, targetFile).split(path.sep).join('/');
-    return relative.startsWith('.') ? relative : `./${relative}`;
+function buildRelativeSpecifier(fromDir, targetFile) {
+    const relativePath = path.relative(fromDir, targetFile).split(path.sep).join('/');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
 }
-function scriptKindFor(file) {
+function resolveScriptKind(file) {
     return file.endsWith('.d.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS;
 }
 function swapTypeScriptExtension(specifier) {

package/dist/esm/commands/clean.d.ts

@@ -1,7 +1,8 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
- * Removes a package's build output and the build-cache entry that describes it, so no state survives to
- * make the next build skip. Removal is idempotent: an already-clean package is a silent no-op.
+ * Removes a package's build output and the build-cache entry that describes it, so the package does not keep
+ * any state that would make the next build skip. Removal is idempotent: An already-clean package is a silent
+ * no-op.
  */
 export declare function cleanPackage(packageDir: string, style: OutputStyle): Promise<void>;
 /**
@@ -10,9 +11,8 @@ export declare function cleanPackage(packageDir: string, style: OutputStyle): Pr
  * From within a package this is the built-in clean itself: `nmr` has already resolved `clean` to this bin
  * before invoking it, so resolving again would apply the package's own override twice.
  *
- * This is the default `clean` script, shipped as a bin rather than delegating to `rimraf`. Under pnpm's
- * isolated layout, `pnpm exec` resolves only bins of the consuming project's own direct dependencies, so
- * a `rimraf` in nmr's dependency tree would be unreachable — while nmr's own bins are linked into the
- * consumer's `node_modules/.bin`, nmr being a direct dependency.
+ * This is the default `clean` script, and it is published as a bin because, under pnpm's isolated layout,
+ * `pnpm exec` resolves only the bins of the consuming project's direct dependencies: pnpm links nmr's own bins
+ * into the consumer's `node_modules/.bin`, but not the bins of nmr's dependencies.
  */
 export declare function runClean(cwd: string, style: OutputStyle): Promise<void>;

package/dist/esm/commands/clean.js

@@ -42,26 +42,26 @@ async function clearCheckCache(scopeDir, style) {
     await removeCheckCache(scopeDir);
     console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', 'Removed all recorded check results.'));
 }
-function describeSweep(cleaned, skipped) {
-    const packages = cleaned === 1 ? '1 package' : `${cleaned} packages`;
-    const skipClause = skipped === 0 ? '' : `, skipping ${skipped} with an empty clean override`;
+function describeSweep(cleanedCount, skippedCount) {
+    const packages = cleanedCount === 1 ? '1 package' : `${cleanedCount} packages`;
+    const skipClause = skippedCount === 0 ? '' : `, skipping ${skippedCount} with an empty clean override`;
     return `Cleaned ${packages}${skipClause}.`;
 }
 async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
-    let cleaned = 0;
-    let skipped = 0;
+    let cleanedCount = 0;
+    let skippedCount = 0;
     for (const packageDir of workspacePackageDirs) {
-        const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
-        const resolvedCommand = resolved === undefined ? undefined : renderChain(resolved.steps);
+        const resolvedScript = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
+        const resolvedCommand = resolvedScript === undefined ? undefined : renderChain(resolvedScript.steps);
         if (resolvedCommand === undefined || resolvedCommand === '') {
-            skipped++;
+            skippedCount++;
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
             await cleanPackage(packageDir, style);
-            cleaned++;
+            cleanedCount++;
             continue;
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
@@ -71,7 +71,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
         if (exitCode !== 0) {
             throw new Error(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
-        cleaned++;
+        cleanedCount++;
     }
-    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleaned, skipped)));
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleanedCount, skippedCount)));
 }

package/dist/esm/commands/ensure-prepublish-hooks.d.ts

@@ -12,19 +12,19 @@ export interface EnsurePrepublishHooksResult {
 }
 export declare const DEFAULT_HOOK = "npm run build";
 /**
- * Check (and optionally fix) whether all publishable workspace packages
+ * Checks (and optionally fixes) whether all publishable workspace packages
  * have a `prepublishOnly` script.
  */
 export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
-    fix: boolean;
-    dryRun: boolean;
+    shouldFix: boolean;
+    isDryRun: boolean;
     command?: string;
 }): EnsurePrepublishHooksResult;
 /**
- * Reports one line per publishable package and closes with what the run came to. Private packages appear in
- * neither: they publish nothing, so a `prepublishOnly` is not theirs to carry.
+ * Reports one line per publishable package and closes with a summary of the run. Private packages appear in
+ * neither: They publish nothing, so they do not need a `prepublishOnly`.
  *
- * Every line goes to stdout, a failure's included, and the exit code is what carries a failure. A report split
- * across two streams leaves no reader holding the whole list.
+ * Every line goes to stdout, a failure's included, and the exit code signals a failure. When a report is split
+ * across two streams, a reader of either stream does not see the whole list.
  */
 export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string, style: OutputStyle): void;

package/dist/esm/commands/ensure-prepublish-hooks.js

@@ -11,33 +11,33 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const packageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packages = [];
     for (const packageDir of packageDirs) {
-        const pkg = readPackageJson(packageDir);
-        const packageName = pkg.name ?? path.basename(packageDir);
-        const isPrivate = pkg.private === true;
+        const packageJson = readPackageJson(packageDir);
+        const packageName = packageJson.name ?? path.basename(packageDir);
+        const isPrivate = packageJson.private === true;
         if (isPrivate) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: true,
-                prepublishOnly: pkg.scripts?.['prepublishOnly'],
+                prepublishOnly: packageJson.scripts?.['prepublishOnly'],
                 action: 'ok',
             });
             continue;
         }
-        const existing = pkg.scripts?.['prepublishOnly'];
-        if (existing) {
+        const existingHook = packageJson.scripts?.['prepublishOnly'];
+        if (existingHook) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: false,
-                prepublishOnly: existing,
+                prepublishOnly: existingHook,
                 action: 'ok',
             });
             continue;
         }
-        if (options.fix) {
-            const action = options.dryRun ? 'would-fix' : 'fixed';
-            if (!options.dryRun) {
+        if (options.shouldFix) {
+            const action = options.isDryRun ? 'would-fix' : 'fixed';
+            if (!options.isDryRun) {
                 addPrepublishOnly(packageDir, hookCommand);
             }
             packages.push({
@@ -62,57 +62,57 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     return { packages, hasFailures };
 }
 export function reportPrepublishHooks(result, hookCommand, style) {
-    const publishable = result.packages.filter((pkg) => !pkg.isPrivate);
-    if (publishable.length === 0) {
+    const publishablePackages = result.packages.filter((packageStatus) => !packageStatus.isPrivate);
+    if (publishablePackages.length === 0) {
         console.info('No publishable packages found.');
         return;
     }
-    for (const pkg of publishable) {
-        console.info(renderHookStatus(pkg, hookCommand, style));
+    for (const packageStatus of publishablePackages) {
+        console.info(renderHookStatus(packageStatus, hookCommand, style));
     }
-    reportClosing(describeHookRun(publishable));
+    reportClosing(describeHookRun(publishablePackages));
 }
 function addPrepublishOnly(packageDir, command) {
     const filePath = path.join(packageDir, 'package.json');
-    const raw = readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!isObject(parsed)) {
+    const rawText = readFileSync(filePath, 'utf8');
+    const parsedManifest = JSON.parse(rawText);
+    if (!isObject(parsedManifest)) {
         throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
     }
-    const scripts = isObject(parsed['scripts']) ? parsed['scripts'] : {};
+    const scripts = isObject(parsedManifest['scripts']) ? parsedManifest['scripts'] : {};
     scripts['prepublishOnly'] = command;
-    parsed['scripts'] = scripts;
-    writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
+    parsedManifest['scripts'] = scripts;
+    writeFileSync(filePath, JSON.stringify(parsedManifest, null, 2) + '\n', 'utf8');
 }
-function countAction(publishable, action) {
-    return publishable.filter((pkg) => pkg.action === action).length;
+function countAction(publishablePackages, action) {
+    return publishablePackages.filter((packageStatus) => packageStatus.action === action).length;
 }
-function describeHookRun(publishable) {
-    const packages = publishable.length === 1 ? '1 publishable package' : `${publishable.length} publishable packages`;
-    const missing = countAction(publishable, 'missing');
-    if (missing > 0) {
-        return `${missing} of ${packages} ${missing === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
+function describeHookRun(publishablePackages) {
+    const packages = publishablePackages.length === 1 ? '1 publishable package' : `${publishablePackages.length} publishable packages`;
+    const missingCount = countAction(publishablePackages, 'missing');
+    if (missingCount > 0) {
+        return `${missingCount} of ${packages} ${missingCount === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
     }
-    const fixed = countAction(publishable, 'fixed');
-    if (fixed > 0) {
-        return `Added prepublishOnly to ${fixed} of ${packages}.`;
+    const fixedCount = countAction(publishablePackages, 'fixed');
+    if (fixedCount > 0) {
+        return `Added prepublishOnly to ${fixedCount} of ${packages}.`;
     }
-    const wouldFix = countAction(publishable, 'would-fix');
-    if (wouldFix > 0) {
-        return `Would add prepublishOnly to ${wouldFix} of ${packages}.`;
+    const wouldFixCount = countAction(publishablePackages, 'would-fix');
+    if (wouldFixCount > 0) {
+        return `Would add prepublishOnly to ${wouldFixCount} of ${packages}.`;
     }
-    return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
+    return `${packages} ${publishablePackages.length === 1 ? 'has' : 'have'} prepublishOnly.`;
 }
-function renderHookStatus(pkg, hookCommand, style) {
+function renderHookStatus(packageStatus, hookCommand, style) {
     const statuses = STATUS_GLYPHS[style];
-    switch (pkg.action) {
+    switch (packageStatus.action) {
         case 'ok':
-            return `${statuses.passed.text} ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: prepublishOnly = "${packageStatus.prepublishOnly}"`;
         case 'missing':
-            return `${statuses.failed.text} ${pkg.packageName}: missing prepublishOnly`;
+            return `${statuses.failed.text} ${packageStatus.packageName}: missing prepublishOnly`;
         case 'fixed':
-            return `${statuses.passed.text} ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: added prepublishOnly = "${hookCommand}"`;
         case 'would-fix':
-            return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
+            return `~ ${packageStatus.packageName}: would add prepublishOnly = "${hookCommand}"`;
     }
 }

package/dist/esm/commands/fmt.d.ts

@@ -13,7 +13,7 @@ export type ResolveTargetsResult = {
     error: string;
 };
 /**
- * Formats or checks the files git reports for `cwd`, and returns the exit code to report.
+ * Formats or checks the files that git reports for `cwd`, and returns the exit code to report.
  *
  * Trailing arguments are git pathspecs, not Prettier flags; an unrecognized option is rejected rather
  * than passed along, since git would read it as a pathspec matching nothing and the run would report
@@ -26,11 +26,11 @@ export declare function runFmt(argv: string[], cwd?: string): number;
  * pattern in `packages/<pkg>/.gitignore` is invisible to a root-level run; git knows the whole hierarchy,
  * along with `.git/info/exclude` and `core.excludesFile`, which Prettier cannot read under any flag.
  *
- * File selection is anchored at `cwd` and ignore discovery at the repository root. That split is the point:
- * scoping still follows where the caller stands, while the rules applied to a given file no longer do.
+ * Because file selection is anchored at `cwd` and ignore discovery at the repository root, scoping follows
+ * `cwd` while the ignore rules applied to a given file are the same from every directory.
  *
- * `pathspecs` narrow the selection and are passed to git verbatim, so they carry git pathspec semantics
- * rather than shell glob semantics.
+ * `pathspecs` narrow the selection and are passed to git verbatim: They have git pathspec semantics rather
+ * than shell glob semantics.
  */
 export declare function resolveFormatTargets(cwd: string, pathspecs?: string[]): ResolveTargetsResult;
 /** @internal */
@@ -40,15 +40,15 @@ export interface RunPrettierOptions {
     files: string[];
     ignorePaths: string[];
     cwd: string;
-    /** Overridable so the multi-batch path is reachable without a fixture that hits the real ceiling. */
+    /** Overridable so that the multi-batch path is reachable without a fixture that hits the real ceiling. */
     budgetBytes?: number;
 }
 /**
  * Runs Prettier over the selection, returning the first non-zero exit code. Every batch runs even after
  * one fails, so a check reports every offending file rather than only those in the first batch.
  *
- * The CLI runs under this process's own Node rather than through its shebang, so it does not depend on
- * the file's execute bit or on PATH holding a `node`.
+ * Because the CLI runs under this process's own Node rather than through its shebang, it does not depend
+ * on the file's execute bit or on PATH containing a `node`.
  *
  * @internal
  */