@williamthorsen/nmr 0.37.0 → 0.39.0

package/dist/esm/recording.js

@@ -1,14 +1,17 @@
+import { formatGlyphLine, STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 import { readCheckCacheEntry, readTranscript } from "./check-cache.js";
+import { NMR_GLYPHS } from "./glyphs.js";
 import { formatDuration } from "./helpers/duration.js";
 export function renderRecording(options) {
     const { entry } = options.recording;
     const age = formatDuration(Math.max(0, Date.now() - Date.parse(entry.recordedAt)));
-    const header = `📼 ${options.scope}: ${options.command} — recorded ${entry.recordedAt} (${age} ago), ` +
-        `ran in ${formatDuration(entry.durationMs)}\n$ ${entry.commandString}\n\n`;
+    const header = formatGlyphLine(NMR_GLYPHS, options.style, 'recording', `${options.scope}: ${options.command} — recorded ${entry.recordedAt} (${age} ago), ` +
+        `ran in ${formatDuration(entry.durationMs)}`) + `\n$ ${entry.commandString}\n\n`;
     return `${header}${appendNewline(renderBody(options.recording))}`;
 }
 export function renderRefusal(options) {
-    return `📭 ${options.scope}: ${options.command}: no recording; ${describeRefusal(options.command, options.refusal)}`;
+    const { text } = STATUS_GLYPHS[options.style].warning;
+    return `${text} ${options.scope}: ${options.command}: no recording; ${describeRefusal(options.command, options.refusal)}`;
 }
 export async function resolveRecording(options) {
     const { anchorDir, command, monorepoRoot } = options;
@@ -24,7 +27,10 @@ export async function resolveRecording(options) {
     }
     const ageMs = Math.max(0, Date.now() - Date.parse(entry.recordedAt));
     if (entry.key !== options.key) {
-        return { ok: false, refusal: { kind: 'mismatched', ageMs, difference: findKeyDifference(entry, options.current) } };
+        return {
+            ok: false,
+            refusal: { kind: 'mismatched', ageMs, difference: findKeyDifference(entry, options.currentIdentity) },
+        };
     }
     const transcript = await readTranscript({ anchorDir, command, monorepoRoot });
     if (transcript === undefined && (entry.retention?.replay.length ?? 0) === 0) {
@@ -42,14 +48,14 @@ function describeDifference(difference) {
         case 'command-string':
             return 'over a command chain this is not';
         case 'nmr-version':
-            return `under nmr ${difference.recorded}, not ${difference.current}`;
+            return `under nmr ${difference.recordedVersion}, not ${difference.currentVersion}`;
         case 'node-version':
-            return `under Node ${difference.recorded}, not ${difference.current}`;
+            return `under Node ${difference.recordedVersion}, not ${difference.currentVersion}`;
         case 'other':
             return 'under an install or environment this run does not share';
         default: {
-            const unhandled = difference;
-            throw new Error(`Unhandled key difference: ${JSON.stringify(unhandled)}`);
+            const unhandledDifference = difference;
+            throw new Error(`Unhandled key difference: ${JSON.stringify(unhandledDifference)}`);
         }
     }
 }
@@ -66,23 +72,27 @@ function describeRefusal(command, refusal) {
         case 'no-output':
             return `the pass ${formatDuration(refusal.ageMs)} ago retained none, as a run printing nothing or writing to a terminal does`;
         default: {
-            const unhandled = refusal;
-            throw new Error(`Unhandled refusal: ${JSON.stringify(unhandled)}`);
+            const unhandledRefusal = refusal;
+            throw new Error(`Unhandled refusal: ${JSON.stringify(unhandledRefusal)}`);
         }
     }
 }
-function findKeyDifference(entry, current) {
-    if (current.treeHash !== undefined && entry.treeHash !== current.treeHash) {
+function findKeyDifference(entry, currentIdentity) {
+    if (currentIdentity.treeHash !== undefined && entry.treeHash !== currentIdentity.treeHash) {
         return { ingredient: 'tree' };
     }
-    if (entry.commandString !== current.commandString) {
+    if (entry.commandString !== currentIdentity.commandString) {
         return { ingredient: 'command-string' };
     }
-    if (entry.nmrVersion !== current.nmrVersion) {
-        return { ingredient: 'nmr-version', current: current.nmrVersion, recorded: entry.nmrVersion };
+    if (entry.nmrVersion !== currentIdentity.nmrVersion) {
+        return { ingredient: 'nmr-version', currentVersion: currentIdentity.nmrVersion, recordedVersion: entry.nmrVersion };
     }
-    if (entry.nodeVersion !== current.nodeVersion) {
-        return { ingredient: 'node-version', current: current.nodeVersion, recorded: entry.nodeVersion };
+    if (entry.nodeVersion !== currentIdentity.nodeVersion) {
+        return {
+            ingredient: 'node-version',
+            currentVersion: currentIdentity.nodeVersion,
+            recordedVersion: entry.nodeVersion,
+        };
     }
     return { ingredient: 'other' };
 }

package/dist/esm/report-format.d.ts

@@ -47,5 +47,5 @@ export type ReportFormatRead = {
 export declare function resolveReportFormat(options: ResolveReportFormatOptions): ReportFormat;
 export interface ResolveReportFormatOptions {
     envFormat: ReportFormat | undefined;
-    jsonFlag: boolean;
+    hasJsonFlag: boolean;
 }

package/dist/esm/report-format.js

@@ -6,20 +6,20 @@ export function isReportFormat(value) {
     return names.includes(value);
 }
 export function readReportFormatEnv(env) {
-    const raw = env[REPORT_FORMAT_ENV_VAR];
-    if (raw === undefined || raw === '') {
+    const rawValue = env[REPORT_FORMAT_ENV_VAR];
+    if (rawValue === undefined || rawValue === '') {
         return { ok: true };
     }
-    if (!isReportFormat(raw)) {
-        return { ok: false, error: formatReportFormatRejection(REPORT_FORMAT_ENV_VAR, raw) };
+    if (!isReportFormat(rawValue)) {
+        return { ok: false, error: formatReportFormatRejection(REPORT_FORMAT_ENV_VAR, rawValue) };
     }
-    return { ok: true, format: raw };
+    return { ok: true, format: rawValue };
 }
 export const REPORT_FORMAT_ENV_VAR = 'NMR_REPORT_FORMAT';
 export const REPORT_FORMATS = ['text', 'json'];
 export function resolveReportFormat(options) {
-    const { envFormat, jsonFlag } = options;
-    if (jsonFlag)
+    const { envFormat, hasJsonFlag } = options;
+    if (hasJsonFlag)
         return 'json';
     return envFormat ?? 'text';
 }

package/dist/esm/resolveBinStyles.d.ts

@@ -0,0 +1,12 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
+/**
+ * Resolves the style of the running process's own output streams, and rejects a variable naming no style.
+ *
+ * What a standalone bin calls. A bin carries no `--output-style` of its own: the flag is `nmr`'s, and what
+ * reaches a bin is the variable that `nmr <command>` exports to it, so a bin run through nmr renders as nmr
+ * does and one run on its own detects its streams.
+ *
+ * Throws rather than exiting, so the bin's own boundary reports the message and sets the exit code, as it does
+ * for every other failure in what the caller declared.
+ */
+export declare function resolveBinStyles(): StreamStyles;

package/dist/esm/resolveBinStyles.js

@@ -0,0 +1,16 @@
+import process from 'node:process';
+import { describeInvalidOutputStyle } from '@williamthorsen/nmr-core';
+import { resolveOutputStyles } from "./output-style.js";
+import { UserError } from "./UserError.js";
+export function resolveBinStyles() {
+    const { invalid: invalidStyle, styles } = resolveOutputStyles({
+        env: process.env,
+        flagValue: undefined,
+        stderrIsTty: process.stderr.isTTY,
+        stdoutIsTty: process.stdout.isTTY,
+    });
+    if (invalidStyle !== undefined) {
+        throw new UserError(describeInvalidOutputStyle(invalidStyle));
+    }
+    return styles;
+}

package/dist/esm/resolver.d.ts

@@ -38,7 +38,7 @@ export interface ResolvedScript {
  * A bare string element and the `{ run }` spec compose the same step. The spec's only addition is the
  * declaration of what the step does with the invocation's trailing arguments, which position cannot carry.
  */
-export declare function expandScript(script: ScriptValue, workspaceRoot: boolean): readonly Step[];
+export declare function expandScript(script: ScriptValue, isWorkspaceRoot: boolean): readonly Step[];
 /**
  * Returns a description of a script for help output.
  */
@@ -87,4 +87,4 @@ export declare function isSelfReferential(script: string, commandName: string, p
  * Returns undefined if the command is not found in the registry. A package.json override of `""` (indicating
  * skip) resolves to a single opaque step carrying it, which renders back to the empty string.
  */
-export declare function resolveScript(commandName: string, registry: ScriptRegistry, packageDir: string | undefined, workspaceRoot: boolean): ResolvedScript | undefined;
+export declare function resolveScript(commandName: string, registry: ScriptRegistry, packageDir: string | undefined, isWorkspaceRoot: boolean): ResolvedScript | undefined;

package/dist/esm/resolver.js

@@ -12,13 +12,13 @@ export function applyDevBin(command, devBin, monorepoRoot) {
     }
     const spaceIndex = command.indexOf(' ');
     const firstToken = spaceIndex === -1 ? command : command.slice(0, spaceIndex);
-    const rest = spaceIndex === -1 ? '' : command.slice(spaceIndex);
+    const restOfCommand = spaceIndex === -1 ? '' : command.slice(spaceIndex);
     const replacement = devBin[firstToken];
     if (replacement === undefined) {
         return command;
     }
     const resolvedReplacement = resolveReplacementPaths(replacement, monorepoRoot);
-    return resolvedReplacement + rest;
+    return resolvedReplacement + restOfCommand;
 }
 export function applyDevBinToSteps(steps, devBin, monorepoRoot) {
     if (!devBin) {
@@ -40,13 +40,13 @@ function resolveReplacementPaths(replacement, monorepoRoot) {
     })
         .join(' ');
 }
-export function expandScript(script, workspaceRoot) {
+export function expandScript(script, isWorkspaceRoot) {
     if (typeof script === 'string') {
         return [{ kind: 'opaque', command: script }];
     }
     return script.map((element) => typeof element === 'string'
-        ? composeNmrStep(element, workspaceRoot)
-        : composeNmrStep(element.run, workspaceRoot, element.declinesArgs));
+        ? composeNmrStep(element, isWorkspaceRoot)
+        : composeNmrStep(element.run, isWorkspaceRoot, element.shouldDeclineArguments));
 }
 export function describeScript(script) {
     return typeof script === 'string' ? script : `[${script.map(describeElement).join(', ')}]`;
@@ -55,13 +55,13 @@ function describeElement(element) {
     if (typeof element === 'string') {
         return element;
     }
-    return element.declinesArgs === true ? `${element.run} (no args)` : element.run;
+    return element.shouldDeclineArguments === true ? `${element.run} (no args)` : element.run;
 }
 export function readPackageJsonScripts(packageDir) {
     const file = resolvePackageJsonPath(packageDir);
-    let raw;
+    let rawText;
     try {
-        raw = readFileSync(file, 'utf8');
+        rawText = readFileSync(file, 'utf8');
     }
     catch (error) {
         if (hasErrnoCode(error, 'ENOENT')) {
@@ -69,10 +69,10 @@ export function readPackageJsonScripts(packageDir) {
         }
         throw error;
     }
-    const parsed = parsePackageJson(raw, file);
-    if (!isObject(parsed))
+    const parsedManifest = parsePackageJson(rawText, file);
+    if (!isObject(parsedManifest))
         return undefined;
-    const scripts = parsed['scripts'];
+    const scripts = parsedManifest['scripts'];
     if (!isObject(scripts))
         return undefined;
     return readScriptRecord(packageDir, scripts);
@@ -108,15 +108,15 @@ export function findChainedSelfReference(packageDir, commandName) {
 export function isSelfReferential(script, commandName, packageDir) {
     return readSelfReference({ anchoredAtRoot: isMonorepoRoot(packageDir), commandName, script }) !== undefined;
 }
-export function resolveScript(commandName, registry, packageDir, workspaceRoot) {
+export function resolveScript(commandName, registry, packageDir, isWorkspaceRoot) {
     if (packageDir) {
         const pkgScripts = readPackageJsonScripts(packageDir);
         if (pkgScripts && Object.hasOwn(pkgScripts, commandName)) {
-            const override = pkgScripts[commandName];
-            if (override !== undefined && !isSelfReferential(override, commandName, packageDir)) {
+            const overrideCommand = pkgScripts[commandName];
+            if (overrideCommand !== undefined && !isSelfReferential(overrideCommand, commandName, packageDir)) {
                 return {
                     origin: { tier: 'package', file: resolvePackageJsonPath(packageDir), key: commandName },
-                    steps: [{ kind: 'opaque', command: override }],
+                    steps: [{ kind: 'opaque', command: overrideCommand }],
                 };
             }
         }
@@ -128,5 +128,5 @@ export function resolveScript(commandName, registry, packageDir, workspaceRoot)
     if (registryEntry === undefined) {
         return undefined;
     }
-    return { origin: { tier: 'registry', key: commandName }, steps: expandScript(registryEntry, workspaceRoot) };
+    return { origin: { tier: 'registry', key: commandName }, steps: expandScript(registryEntry, isWorkspaceRoot) };
 }