@augment-vir/node 31.73.3 → 31.73.4

package/src/augments/fs/read-dir.ts

@@ -2,20 +2,14 @@ import {readdir, stat} from 'node:fs/promises';
 import {join, relative} from 'node:path';
 import {type RequireExactlyOne} from 'type-fest';
 
-async function internalReadDirPathsRecursive({
-    dirPath,
-    basePath,
-}: Readonly<{dirPath: string; basePath: string}>): Promise<string[]> {
+async function internalReadDirPathsRecursive(dirPath: string, basePath: string): Promise<string[]> {
     const dirContents = await readdir(dirPath);
     const recursiveContents: string[] = (
         await Promise.all(
             dirContents.map(async (fileName): Promise<string | ReadonlyArray<string>> => {
                 const filePath = join(dirPath, fileName);
                 if ((await stat(filePath)).isDirectory()) {
-                    return internalReadDirPathsRecursive({
-                        dirPath: filePath,
-                        basePath,
-                    });
+                    return internalReadDirPathsRecursive(filePath, basePath);
                 } else {
                     return relative(basePath, filePath);
                 }
@@ -35,10 +29,7 @@ async function internalReadDirPathsRecursive({
  * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
  */
 export async function readDirRecursive(dirPath: string): Promise<string[]> {
-    return await internalReadDirPathsRecursive({
-        dirPath,
-        basePath: dirPath,
-    });
+    return await internalReadDirPathsRecursive(dirPath, dirPath);
 }
 
 /**

package/src/augments/path/contains.ts

@@ -9,22 +9,18 @@ import {isOperatingSystem, OperatingSystem} from '../os/operating-system.js';
  * @category Package : @augment-vir/node
  * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
  */
-export function doesPathContain({
-    potentialParentPath,
-    potentialChildPath,
-    options = {},
-}: Readonly<{
-    potentialParentPath: string;
-    potentialChildPath: string;
-    options?: PartialWithUndefined<{
+export function doesPathContain(
+    potentialParentPath: string,
+    potentialChildPath: string,
+    options: PartialWithUndefined<{
         /**
          * Set this to `true` to return `true` if the paths are exactly equal.
          *
          * @default false
          */
         allowSelf: boolean;
-    }>;
-}>): boolean {
+    }> = {},
+): boolean {
     if (!potentialParentPath || !potentialChildPath) {
         return false;
     }

package/src/augments/path/resolve-import.ts

@@ -17,18 +17,14 @@ import {replaceWithWindowsPathIfNeeded} from './os-path.js';
  * @returns `undefined` if no matches are found.
  * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
  */
-export function resolveImportPath({
-    importerFilePath,
-    importPath,
-}: Readonly<{importerFilePath: string; importPath: string}>): string | undefined {
+export function resolveImportPath(
+    importerFilePath: string,
+    importPath: string,
+): string | undefined {
     const foundTsconfig = readTsconfig(importerFilePath);
 
     const mappedImportPath = foundTsconfig
-        ? mapImportPath({
-              importPath,
-              tsconfig: foundTsconfig.tsconfig,
-              tsconfigPath: foundTsconfig.path,
-          })
+        ? mapImportPath(importPath, foundTsconfig.tsconfig, foundTsconfig.path)
         : importPath;
 
     if (mappedImportPath.startsWith(sep) || mappedImportPath.startsWith('/')) {
@@ -85,11 +81,11 @@ function mapFilePath(path: string): string {
     return path;
 }
 
-function mapImportPath({
-    importPath,
-    tsconfig,
-    tsconfigPath,
-}: Readonly<{importPath: string; tsconfig: ParsedCommandLine; tsconfigPath: string}>): string {
+function mapImportPath(
+    importPath: string,
+    tsconfig: ParsedCommandLine,
+    tsconfigPath: string,
+): string {
     const paths = tsconfig.options.paths;
     if (!paths) {
         return importPath;

package/src/augments/terminal/run-cli-script.ts

@@ -30,11 +30,16 @@ export const ExtensionToRunner: Record<string, string | {npx: string}> = {
  * @category Package : @augment-vir/node
  * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
  */
-export async function runCliScript({
-    scriptPath,
-    cliScriptFilePath,
-    binName,
-}: Readonly<{scriptPath: string; cliScriptFilePath: string; binName: string | undefined}>) {
+export async function runCliScript(
+    scriptPath: string,
+    /** This should just be `__filename` (for CJS) or `import.meta.filename` (for ESM). */
+    cliScriptFilePath: string,
+    /**
+     * This should be the bin name of the package that is calling this function. Set to `undefined`
+     * if there isn't one.
+     */
+    binName: string | undefined,
+) {
     const args = extractRelevantArgs({
         rawArgs: process.argv,
         binName,

package/src/augments/terminal/shell.ts

@@ -75,21 +75,6 @@ export class ShellTarget extends ListenTarget<
     }
 }
 
-/**
- * Options for {@link streamShellCommand}.
- *
- * @category Node : Terminal : Util
- * @category Package : @augment-vir/node
- * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
- */
-export type StreamShellCommandOptions = PartialWithUndefined<{
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    shell: string;
-    /** Automatically hook up stdout and stderr printing to the caller's console methods. */
-    hookUpToConsole: boolean;
-}>;
-
 /**
  * Runs a shell command and returns a {@link ShellTarget} instance for directly hooking into shell
  * events. This allows instant reactions to shell events but in a less convenient API compared to
@@ -103,12 +88,10 @@ export type StreamShellCommandOptions = PartialWithUndefined<{
  */
 export function streamShellCommand(
     command: string,
-    {
-        cwd,
-        env = process.env,
-        shell = 'bash',
-        hookUpToConsole = false,
-    }: StreamShellCommandOptions = {},
+    cwd?: string,
+    shell = 'bash',
+    env: NodeJS.ProcessEnv = process.env,
+    hookUpToConsole = false,
 ): ShellTarget {
     const stdio = hookUpToConsole ? [process.stdin] : undefined;
 
@@ -164,11 +147,8 @@ export function streamShellCommand(
         const exitSignal: NodeJS.Signals | undefined = inputExitSignal ?? undefined;
 
         if ((exitCode !== undefined && exitCode !== 0) || exitSignal !== undefined) {
-            const execException: ExecException & {cwd?: string | undefined} = Object.assign(
-                new Error(`Command failed: ${command}`),
-                {
-                    cmd: command,
-                },
+            const execException: ExecException & {cwd?: string | undefined} = new Error(
+                `Command failed: ${command}`,
             );
             if (exitCode != undefined) {
                 execException.code = exitCode;
@@ -177,6 +157,7 @@ export function streamShellCommand(
             if (exitSignal != undefined) {
                 execException.signal = exitSignal;
             }
+            execException.cmd = command;
             execException.killed = childProcess.killed;
             execException.cwd = cwd;
             shellTarget.dispatch(
@@ -205,21 +186,19 @@ export function streamShellCommand(
  * @category Package : @augment-vir/node
  * @package [`@augment-vir/node`](https://www.npmjs.com/package/@augment-vir/node)
  */
-export type RunShellCommandOptions = StreamShellCommandOptions &
-    PartialWithUndefined<{
-        /** @default false */
-        rejectOnError: boolean;
-        /** Callback to call whenever the shell logs to stdout. */
-        stdoutCallback: (
-            stdout: string,
-            childProcess: ChildProcess,
-        ) => MaybePromise<void> | undefined;
-        /** Callback to call whenever the shell logs to stderr. */
-        stderrCallback: (
-            stderr: string,
-            childProcess: ChildProcess,
-        ) => MaybePromise<void> | undefined;
-    }>;
+export type RunShellCommandOptions = {
+    cwd?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    shell?: string | undefined;
+    /** Automatically hook up stdout and stderr printing to the caller's console methods. */
+    hookUpToConsole?: boolean | undefined;
+    /** @default false */
+    rejectOnError?: boolean | undefined;
+    /** Callback to call whenever the shell logs to stdout. */
+    stdoutCallback?: (stdout: string, childProcess: ChildProcess) => MaybePromise<void> | undefined;
+    /** Callback to call whenever the shell logs to stderr. */
+    stderrCallback?: (stderr: string, childProcess: ChildProcess) => MaybePromise<void> | undefined;
+};
 
 /**
  * Runs a shell command and returns its output.
@@ -239,12 +218,13 @@ export async function runShellCommand(
         let stderr = '';
         const errors: Error[] = [];
 
-        const shellTarget = streamShellCommand(command, {
-            cwd: options.cwd,
-            shell: options.shell,
-            env: options.env,
-            hookUpToConsole: options.hookUpToConsole,
-        });
+        const shellTarget = streamShellCommand(
+            command,
+            options.cwd,
+            options.shell,
+            options.env,
+            options.hookUpToConsole,
+        );
 
         shellTarget.listen(ShellStdoutEvent, ({detail: chunk}) => {
             if (options.stdoutCallback) {