@williamthorsen/nmr 0.15.0 → 0.17.0

package/dist/esm/runCli.js

@@ -1,169 +1,159 @@
-import path from "node:path";
-import { readPackageVersion } from "@williamthorsen/nmr-core";
+import path from 'node:path';
+import { readPackageVersion, reportError } from '@williamthorsen/nmr-core';
 import { resolveContext } from "./context.js";
 import { generateHelp } from "./help.js";
 import { isHookName } from "./helpers/hook-name.js";
-import { applyDevBin, buildRootRegistry, buildWorkspaceRegistry, resolveScript } from "./resolver.js";
+import { applyDevBin, buildRootRegistry, buildWorkspaceRegistry, hasIntegrationTestConfig, resolveScript, } from "./resolver.js";
 import { runCommand } from "./runner.js";
 const VERSION = readPackageVersion(import.meta.url);
-async function runCli(options) {
-  const { args, cwd, env, stdout, stderr } = options;
-  const parseResult = parseArgs(args);
-  if (!parseResult.ok) {
-    stderr.write(`${parseResult.error}
-`);
-    return { exitCode: 1 };
-  }
-  const { parsed } = parseResult;
-  if (parsed.version) {
-    stdout.write(`${VERSION}
-`);
-    return { exitCode: 0 };
-  }
-  const context = await resolveContext(cwd);
-  const useRoot = parsed.workspaceRoot || context.isRoot;
-  const packageDir = useRoot ? context.monorepoRoot : context.packageDir ?? context.monorepoRoot;
-  if (parsed.help || !parsed.command) {
-    stdout.write(`${generateHelp(context.config, packageDir, useRoot)}
-`);
-    return { exitCode: 0 };
-  }
-  const { command } = parsed;
-  const passthrough = parsed.passthrough.length > 0 ? " " + parsed.passthrough.map(shellQuote).join(" ") : "";
-  const runOptions = { quiet: parsed.quiet, stdout, stderr, env };
-  if (parsed.filter) {
-    const delegateCmd = `pnpm --filter ${shellQuote(parsed.filter)} exec nmr ${command}${passthrough}`;
-    const exitCode2 = runCommand(delegateCmd, context.monorepoRoot, runOptions);
-    return { exitCode: exitCode2 };
-  }
-  if (parsed.recursive) {
-    const childEnv = { ...env, NMR_RUN_IF_PRESENT: "1" };
-    const delegateCmd = `pnpm --recursive exec nmr ${command}${passthrough}`;
-    const exitCode2 = runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: childEnv });
-    return { exitCode: exitCode2 };
-  }
-  const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config, parsed.intTest);
-  const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
-  if (!resolved) {
-    if (env.NMR_RUN_IF_PRESENT === "1") {
-      return { exitCode: 0 };
+export async function runCli(options) {
+    const { args, cwd, env, stdout, stderr } = options;
+    const parseResult = parseArgs(args);
+    if (!parseResult.ok) {
+        reportError(parseResult.error, stderr);
+        return { exitCode: 1 };
     }
-    stderr.write(`Unknown command: ${command}
-`);
-    return { exitCode: 1 };
-  }
-  const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet, stdout);
-  if (skipExitCode !== void 0) {
-    return { exitCode: skipExitCode };
-  }
-  if (resolved.source === "package" && !parsed.quiet && registry[command] !== void 0) {
-    stdout.write(`\u{1F4E6} ${path.basename(packageDir)}: Using override script: ${resolved.command}
-`);
-  }
-  const substitutedCommand = applyDevBin(resolved.command, context.config.devBin, context.monorepoRoot);
-  const mainCommand = substitutedCommand + passthrough;
-  const isHookInvocation = isHookName(command);
-  const fullCommand = isHookInvocation ? mainCommand : wrapWithHooks(command, mainCommand, registry, packageDir, parsed.workspaceRoot);
-  const exitCode = runCommand(fullCommand, cwd, runOptions);
-  return { exitCode };
-}
-function parseArgs(args) {
-  const parsed = {
-    quiet: false,
-    recursive: false,
-    workspaceRoot: false,
-    help: false,
-    version: false,
-    intTest: false,
-    passthrough: []
-  };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg === void 0) break;
-    if (arg === "-F" || arg === "--filter") {
-      i++;
-      const filterValue = args[i];
-      if (filterValue === void 0) {
-        return { ok: false, error: "Error: -F/--filter requires a pattern argument" };
-      }
-      parsed.filter = filterValue;
-      i++;
-      continue;
+    const { parsed } = parseResult;
+    if (parsed.version) {
+        stdout.write(`${VERSION}\n`);
+        return { exitCode: 0 };
     }
-    if (arg === "-R" || arg === "--recursive") {
-      parsed.recursive = true;
-      i++;
-      continue;
+    const context = await resolveContext(cwd);
+    const useRoot = parsed.workspaceRoot || context.isRoot;
+    const packageDir = useRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
+    if (parsed.help || !parsed.command) {
+        stdout.write(`${generateHelp(context.config, packageDir, useRoot)}\n`);
+        return { exitCode: 0 };
     }
-    if (arg === "-w" || arg === "--workspace-root") {
-      parsed.workspaceRoot = true;
-      i++;
-      continue;
+    const { command } = parsed;
+    const passthrough = parsed.passthrough.length > 0 ? ' ' + parsed.passthrough.map(shellQuote).join(' ') : '';
+    const runOptions = { quiet: parsed.quiet, stdout, stderr, env };
+    if (parsed.filter) {
+        const delegateCmd = `pnpm --filter ${shellQuote(parsed.filter)} exec nmr ${command}${passthrough}`;
+        const exitCode = runCommand(delegateCmd, context.monorepoRoot, runOptions);
+        return { exitCode };
     }
-    if (arg === "-?" || arg === "--help") {
-      parsed.help = true;
-      i++;
-      continue;
+    if (parsed.recursive) {
+        const childEnv = { ...env, NMR_RUN_IF_PRESENT: '1' };
+        const delegateCmd = `pnpm --recursive exec nmr ${command}${passthrough}`;
+        const exitCode = runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: childEnv });
+        return { exitCode };
     }
-    if (arg === "-V" || arg === "--version") {
-      parsed.version = true;
-      i++;
-      continue;
+    const registry = useRoot
+        ? buildRootRegistry(context.config)
+        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(packageDir));
+    const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
+    if (!resolved) {
+        if (env.NMR_RUN_IF_PRESENT === '1') {
+            return { exitCode: 0 };
+        }
+        reportError(`Unknown command: ${command}`, stderr);
+        return { exitCode: 1 };
     }
-    if (arg === "-q" || arg === "--quiet") {
-      parsed.quiet = true;
-      i++;
-      continue;
+    const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet, stdout);
+    if (skipExitCode !== undefined) {
+        return { exitCode: skipExitCode };
     }
-    if (arg === "--int-test") {
-      parsed.intTest = true;
-      i++;
-      continue;
+    if (resolved.source === 'package' && !parsed.quiet && registry[command] !== undefined) {
+        stdout.write(`📦 ${path.basename(packageDir)}: Using override script: ${resolved.command}\n`);
     }
-    parsed.command = arg;
-    parsed.passthrough = args.slice(i + 1);
-    break;
-  }
-  return { ok: true, parsed };
+    const substitutedCommand = applyDevBin(resolved.command, context.config.devBin, context.monorepoRoot);
+    const mainCommand = substitutedCommand + passthrough;
+    const isHookInvocation = isHookName(command);
+    const fullCommand = isHookInvocation
+        ? mainCommand
+        : wrapWithHooks(command, mainCommand, registry, packageDir, parsed.workspaceRoot);
+    const exitCode = runCommand(fullCommand, cwd, runOptions);
+    return { exitCode };
+}
+function parseArgs(args) {
+    const parsed = {
+        quiet: false,
+        recursive: false,
+        workspaceRoot: false,
+        help: false,
+        version: false,
+        passthrough: [],
+    };
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === undefined)
+            break;
+        if (arg === '-F' || arg === '--filter') {
+            i++;
+            const filterValue = args[i];
+            if (filterValue === undefined) {
+                return { ok: false, error: '-F/--filter requires a pattern argument' };
+            }
+            parsed.filter = filterValue;
+            i++;
+            continue;
+        }
+        if (arg === '-R' || arg === '--recursive') {
+            parsed.recursive = true;
+            i++;
+            continue;
+        }
+        if (arg === '-w' || arg === '--workspace-root') {
+            parsed.workspaceRoot = true;
+            i++;
+            continue;
+        }
+        if (arg === '-?' || arg === '--help') {
+            parsed.help = true;
+            i++;
+            continue;
+        }
+        if (arg === '-V' || arg === '--version') {
+            parsed.version = true;
+            i++;
+            continue;
+        }
+        if (arg === '-q' || arg === '--quiet') {
+            parsed.quiet = true;
+            i++;
+            continue;
+        }
+        parsed.command = arg;
+        parsed.passthrough = args.slice(i + 1);
+        break;
+    }
+    return { ok: true, parsed };
 }
 function handleSkipMessage(resolvedCommand, packageDir, quiet, stdout) {
-  if (resolvedCommand === "") {
-    if (!quiet) {
-      stdout.write(`\u26D4 ${path.basename(packageDir)}: Override script is defined but empty. Skipping.
-`);
+    if (resolvedCommand === '') {
+        if (!quiet) {
+            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is defined but empty. Skipping.\n`);
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (resolvedCommand === ":") {
-    if (!quiet) {
-      stdout.write(`\u26D4 ${path.basename(packageDir)}: Override script is a no-op. Skipping.
-`);
+    if (resolvedCommand === ':') {
+        if (!quiet) {
+            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is a no-op. Skipping.\n`);
+        }
+        return 0;
     }
-    return 0;
-  }
-  return void 0;
+    return undefined;
 }
 function wrapWithHooks(command, mainCommand, registry, packageDir, workspaceRoot) {
-  const segments = [];
-  const flag = workspaceRoot ? "-w " : "";
-  if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
-    segments.push(`nmr ${flag}${command}:pre`);
-  }
-  segments.push(mainCommand);
-  if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
-    segments.push(`nmr ${flag}${command}:post`);
-  }
-  return segments.join(" && ");
+    const segments = [];
+    const flag = workspaceRoot ? '-w ' : '';
+    if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
+        segments.push(`nmr ${flag}${command}:pre`);
+    }
+    segments.push(mainCommand);
+    if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
+        segments.push(`nmr ${flag}${command}:post`);
+    }
+    return segments.join(' && ');
 }
 function hasRunnableHook(hookName, registry, packageDir, workspaceRoot) {
-  const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
-  if (!resolved) return false;
-  return resolved.command !== "" && resolved.command !== ":";
+    const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
+    if (!resolved)
+        return false;
+    return resolved.command !== '' && resolved.command !== ':';
 }
 function shellQuote(arg) {
-  return "'" + arg.replace(/'/g, String.raw`'\''`) + "'";
+    return "'" + arg.replace(/'/g, String.raw `'\''`) + "'";
 }
-export {
-  runCli
-};

package/dist/esm/runner.js

@@ -1,40 +1,41 @@
-import { spawnSync } from "node:child_process";
-import process from "node:process";
-function runCommand(command, cwd, options) {
-  const quiet = options?.quiet === true;
-  const stdout = options?.stdout ?? process.stdout;
-  const stderr = options?.stderr ?? process.stderr;
-  const env = options?.env ?? process.env;
-  const stdoutChannel = quiet ? "pipe" : streamFdOrPipe(stdout);
-  const stderrChannel = quiet ? "pipe" : streamFdOrPipe(stderr);
-  const result = spawnSync(command, [], {
-    shell: true,
-    stdio: ["inherit", stdoutChannel, stderrChannel],
-    cwd,
-    env
-  });
-  if (result.error) {
-    stderr.write(`${result.error.message}
-`);
-    return 1;
-  }
-  if (quiet) {
-    if (result.status !== 0) {
-      writeBuffer(result.stdout, stderr);
-      writeBuffer(result.stderr, stderr);
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+import { reportError } from '@williamthorsen/nmr-core';
+export function runCommand(command, cwd, options) {
+    const quiet = options?.quiet === true;
+    const stdout = options?.stdout ?? process.stdout;
+    const stderr = options?.stderr ?? process.stderr;
+    const env = options?.env ?? process.env;
+    const stdoutChannel = quiet ? 'pipe' : streamFdOrPipe(stdout);
+    const stderrChannel = quiet ? 'pipe' : streamFdOrPipe(stderr);
+    const result = spawnSync(command, [], {
+        shell: true,
+        stdio: ['inherit', stdoutChannel, stderrChannel],
+        cwd,
+        env,
+    });
+    if (result.error) {
+        reportError(result.error.message, stderr);
+        return 1;
     }
-  } else {
-    if (stdoutChannel === "pipe") writeBuffer(result.stdout, stdout);
-    if (stderrChannel === "pipe") writeBuffer(result.stderr, stderr);
-  }
-  return result.status ?? 1;
+    if (quiet) {
+        if (result.status !== 0) {
+            writeBuffer(result.stdout, stderr);
+            writeBuffer(result.stderr, stderr);
+        }
+    }
+    else {
+        if (stdoutChannel === 'pipe')
+            writeBuffer(result.stdout, stdout);
+        if (stderrChannel === 'pipe')
+            writeBuffer(result.stderr, stderr);
+    }
+    return result.status ?? 1;
 }
 function streamFdOrPipe(stream) {
-  return "fd" in stream && typeof stream.fd === "number" ? stream.fd : "pipe";
+    return 'fd' in stream && typeof stream.fd === 'number' ? stream.fd : 'pipe';
 }
 function writeBuffer(buffer, dest) {
-  if (buffer.length > 0) dest.write(buffer);
+    if (buffer.length > 0)
+        dest.write(buffer);
 }
-export {
-  runCommand
-};

package/dist/esm/scripts.d.ts

@@ -1,2 +1,2 @@
-export type { ScriptRegistry, ScriptValue } from './default-scripts.ts';
-export { getDefaultRootScripts, getDefaultWorkspaceScripts } from './resolve-scripts.ts';
+export type { ScriptRegistry, ScriptValue } from './default-scripts.js';
+export { getDefaultRootScripts, getDefaultWorkspaceScripts } from './resolve-scripts.js';

package/dist/esm/scripts.js

@@ -1,5 +1 @@
-import { getDefaultRootScripts, getDefaultWorkspaceScripts } from "./resolve-scripts.js";
-export {
-  getDefaultRootScripts,
-  getDefaultWorkspaceScripts
-};
+export { getDefaultRootScripts, getDefaultWorkspaceScripts } from "./resolve-scripts.js";

package/dist/esm/tests/consistency.d.ts

@@ -1,4 +1,4 @@
-export { findMonorepoRoot } from '../context.ts';
+export { findMonorepoRoot } from '../context.js';
 export declare function checkPnpmVersionConsistency(monorepoRoot: string): void;
 export declare function checkNodeVersionConsistency(monorepoRoot: string): void;
 export declare function getPnpmVersionFromAction(monorepoRoot: string): Promise<string>;

package/dist/esm/tests/consistency.js

@@ -1,66 +1,57 @@
-import fs from "node:fs";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
 import { findMonorepoRoot } from "../context.js";
-import { findMonorepoRoot as findMonorepoRoot2 } from "../context.js";
+export { findMonorepoRoot } from "../context.js";
 import { getRuntimeVersionFromAsdf } from "./helpers/get-runtime-version-from-asdf.js";
 import { getStringFromYamlFile } from "./helpers/get-string-from-yaml-file.js";
 import { getValueAtPathOrThrow } from "./helpers/get-value-at-path.js";
-const GITHUB_ACTION_FILE_PATH = ".github/workflows/code-quality.yaml";
-function checkPnpmVersionConsistency(monorepoRoot) {
-  describe("pnpm version consistency", () => {
-    it("pnpm version is the same in GitHub action and package.json", async () => {
-      const actionVersion = await getPnpmVersionFromAction(monorepoRoot);
-      const packageJsonVersion = getPnpmVersionFromPackageJson(monorepoRoot);
-      expect(actionVersion).toBe(packageJsonVersion);
+const GITHUB_ACTION_FILE_PATH = '.github/workflows/code-quality.yaml';
+export function checkPnpmVersionConsistency(monorepoRoot) {
+    describe('pnpm version consistency', () => {
+        it('pnpm version is the same in GitHub action and package.json', async () => {
+            const actionVersion = await getPnpmVersionFromAction(monorepoRoot);
+            const packageJsonVersion = getPnpmVersionFromPackageJson(monorepoRoot);
+            expect(actionVersion).toBe(packageJsonVersion);
+        });
     });
-  });
 }
-function checkNodeVersionConsistency(monorepoRoot) {
-  describe("Node.js version consistency", () => {
-    it("version is the same in GitHub action and .tool-versions", async () => {
-      const toolVersion = await getRuntimeVersionFromAsdf("nodejs", monorepoRoot);
-      const actionVersion = await getNodeVersionFromAction(monorepoRoot);
-      expect(toolVersion).toBe(actionVersion);
+export function checkNodeVersionConsistency(monorepoRoot) {
+    describe('Node.js version consistency', () => {
+        it('version is the same in GitHub action and .tool-versions', async () => {
+            const toolVersion = await getRuntimeVersionFromAsdf('nodejs', monorepoRoot);
+            const actionVersion = await getNodeVersionFromAction(monorepoRoot);
+            expect(toolVersion).toBe(actionVersion);
+        });
     });
-  });
 }
-async function getPnpmVersionFromAction(monorepoRoot) {
-  const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-  return getStringFromYamlFile(actionPath, "jobs.code-quality.with.pnpm-version", "pnpm version");
+export async function getPnpmVersionFromAction(monorepoRoot) {
+    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
+    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.pnpm-version', 'pnpm version');
 }
-function getPnpmVersionFromPackageJson(monorepoRoot) {
-  const pkgPath = path.join(monorepoRoot, "package.json");
-  const raw = fs.readFileSync(pkgPath, "utf8");
-  const pkg = JSON.parse(raw);
-  const pm = getValueAtPathOrThrow(pkg, "packageManager");
-  if (typeof pm !== "string") {
-    throw new TypeError('"packageManager" field missing or not a string in package.json.');
-  }
-  const [name, version] = pm.split("@");
-  if (name !== "pnpm") {
-    throw new Error("packageManager is not pnpm.");
-  }
-  if (!version) {
-    throw new Error("pnpm version missing in package.json.");
-  }
-  return version;
+export function getPnpmVersionFromPackageJson(monorepoRoot) {
+    const pkgPath = path.join(monorepoRoot, 'package.json');
+    const raw = fs.readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const pm = getValueAtPathOrThrow(pkg, 'packageManager');
+    if (typeof pm !== 'string') {
+        throw new TypeError('"packageManager" field missing or not a string in package.json.');
+    }
+    const [name, version] = pm.split('@');
+    if (name !== 'pnpm') {
+        throw new Error('packageManager is not pnpm.');
+    }
+    if (!version) {
+        throw new Error('pnpm version missing in package.json.');
+    }
+    return version;
 }
-async function getNodeVersionFromAction(monorepoRoot) {
-  const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-  return getStringFromYamlFile(actionPath, "jobs.code-quality.with.node-version", "Node.js version");
+export async function getNodeVersionFromAction(monorepoRoot) {
+    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
+    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.node-version', 'Node.js version');
 }
-function runConsistencyChecks() {
-  const monorepoRoot = findMonorepoRoot();
-  checkPnpmVersionConsistency(monorepoRoot);
-  checkNodeVersionConsistency(monorepoRoot);
+export function runConsistencyChecks() {
+    const monorepoRoot = findMonorepoRoot();
+    checkPnpmVersionConsistency(monorepoRoot);
+    checkNodeVersionConsistency(monorepoRoot);
 }
-export {
-  checkNodeVersionConsistency,
-  checkPnpmVersionConsistency,
-  findMonorepoRoot2 as findMonorepoRoot,
-  getNodeVersionFromAction,
-  getPnpmVersionFromAction,
-  getPnpmVersionFromPackageJson,
-  runConsistencyChecks
-};

package/dist/esm/tests/helpers/get-runtime-version-from-asdf.js

@@ -1,15 +1,12 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-async function getRuntimeVersionFromAsdf(runtime, monorepoRoot) {
-  const toolVersionsPath = path.join(monorepoRoot, ".tool-versions");
-  const toolVersions = await fs.promises.readFile(toolVersionsPath, { encoding: "utf8" });
-  const versionLine = toolVersions.split("\n").find((line) => line.trim().startsWith(runtime));
-  assert.ok(versionLine, `${runtime} not found in .tool-versions`);
-  const [, version] = versionLine.trim().split(/\s+/);
-  assert.ok(version, `${runtime} version missing in .tool-versions`);
-  return version;
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+export async function getRuntimeVersionFromAsdf(runtime, monorepoRoot) {
+    const toolVersionsPath = path.join(monorepoRoot, '.tool-versions');
+    const toolVersions = await fs.promises.readFile(toolVersionsPath, { encoding: 'utf8' });
+    const versionLine = toolVersions.split('\n').find((line) => line.trim().startsWith(runtime));
+    assert.ok(versionLine, `${runtime} not found in .tool-versions`);
+    const [, version] = versionLine.trim().split(/\s+/);
+    assert.ok(version, `${runtime} version missing in .tool-versions`);
+    return version;
 }
-export {
-  getRuntimeVersionFromAsdf
-};

package/dist/esm/tests/helpers/get-string-from-yaml-file.js

@@ -1,15 +1,12 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import { parse } from "yaml";
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { parse } from 'yaml';
 import { getValueAtPathOrThrow } from "./get-value-at-path.js";
-async function getStringFromYamlFile(filePath, keyPath, label) {
-  const raw = await fs.promises.readFile(filePath, { encoding: "utf8" });
-  const parsed = parse(raw);
-  assert.ok(parsed, `YAML content not found in ${filePath}`);
-  const value = getValueAtPathOrThrow(parsed, keyPath);
-  assert.ok(typeof value === "string" && value.length > 0, `${label} not found at ${keyPath}`);
-  return value;
+export async function getStringFromYamlFile(filePath, keyPath, label) {
+    const raw = await fs.promises.readFile(filePath, { encoding: 'utf8' });
+    const parsed = parse(raw);
+    assert.ok(parsed, `YAML content not found in ${filePath}`);
+    const value = getValueAtPathOrThrow(parsed, keyPath);
+    assert.ok(typeof value === 'string' && value.length > 0, `${label} not found at ${keyPath}`);
+    return value;
 }
-export {
-  getStringFromYamlFile
-};

package/dist/esm/tests/helpers/get-value-at-path.js

@@ -1,34 +1,34 @@
 function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function getValueAtPathOrThrow(obj, objPath) {
-  if (!isObject(obj)) {
-    throw new Error("Expected an object as root value.");
-  }
-  const keys = objPath.split(".");
-  let current = obj;
-  for (const key of keys) {
-    if (Array.isArray(current)) {
-      const index = Number(key);
-      if (Number.isNaN(index)) {
-        throw new TypeError(`Expected array index at segment "${key}" in path "${objPath}"`);
-      }
-      if (index >= 0 && index < current.length) {
-        current = current[index];
-      } else {
-        throw new Error(`Array index out of bounds: "${key}" in path "${objPath}"`);
-      }
-    } else if (isObject(current)) {
-      if (!(key in current)) {
-        throw new Error(`Missing key "${key}" in path "${objPath}"`);
-      }
-      current = current[key];
-    } else {
-      throw new Error(`Unexpected non-object/non-array at segment "${key}" in path "${objPath}"`);
+export function getValueAtPathOrThrow(obj, objPath) {
+    if (!isObject(obj)) {
+        throw new Error('Expected an object as root value.');
     }
-  }
-  return current;
+    const keys = objPath.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (Array.isArray(current)) {
+            const index = Number(key);
+            if (Number.isNaN(index)) {
+                throw new TypeError(`Expected array index at segment "${key}" in path "${objPath}"`);
+            }
+            if (index >= 0 && index < current.length) {
+                current = current[index];
+            }
+            else {
+                throw new Error(`Array index out of bounds: "${key}" in path "${objPath}"`);
+            }
+        }
+        else if (isObject(current)) {
+            if (!(key in current)) {
+                throw new Error(`Missing key "${key}" in path "${objPath}"`);
+            }
+            current = current[key];
+        }
+        else {
+            throw new Error(`Unexpected non-object/non-array at segment "${key}" in path "${objPath}"`);
+        }
+    }
+    return current;
 }
-export {
-  getValueAtPathOrThrow
-};