@tstdl/base 0.92.41 → 0.92.42

package/file/mime-type.js

@@ -10,9 +10,12 @@ export function getMimeTypeExtensions(mimeType) {
     return mimeTypesMap.get(mimeType) ?? [];
 }
 async function spawnFileCommand(args, file) {
-    const process = await spawnCommand('file', args, { stdinPipeOptions: { preventCancel: true } });
+    const process = await spawnCommand('file', args);
     if (isDefined(file)) {
-        await process.write(file);
+        try {
+            await process.write(file);
+        }
+        catch { /* ignore as file command closes stdin early */ }
     }
     const { code } = await process.wait();
     if (code != 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.41",
+  "version": "0.92.42",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/process/spawn.d.ts

@@ -2,7 +2,7 @@ import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     process: ChildProcessWithoutNullStreams;
     stderr: ReadableStream<Uint8Array>;
-    write(chunk: ReadableStream<Uint8Array> | Uint8Array | string): Promise<void>;
+    write(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): Promise<void>;
     readOutputBytes(): Promise<Uint8Array>;
     readOutput(): Promise<string>;
     readErrorBytes(): Promise<Uint8Array>;
@@ -12,6 +12,4 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
         signal: string | null;
     }>;
 };
-export declare function spawnCommand(command: string, args?: string[], options?: {
-    stdinPipeOptions?: StreamPipeOptions;
-}): Promise<SpawnCommandResult>;
+export declare function spawnCommand(command: string, args?: string[]): Promise<SpawnCommandResult>;

package/process/spawn.js

@@ -3,7 +3,7 @@ import { decodeTextStream, encodeUtf8Stream } from '../utils/encoding.js';
 import { readBinaryStream, readTextStream } from '../utils/stream/stream-reader.js';
 import { toReadableStream } from '../utils/stream/to-readable-stream.js';
 import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
-export async function spawnCommand(command, args, options) {
+export async function spawnCommand(command, args) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
     const process = spawn(command, args, { stdio: 'pipe' });
@@ -14,15 +14,15 @@ export async function spawnCommand(command, args, options) {
     const readable = Readable.toWeb(process.stdout);
     const writable = Writable.toWeb(process.stdin);
     const stderr = Readable.toWeb(process.stderr);
-    async function write(data) {
+    async function write(data, options) {
         if (isReadableStream(data)) {
-            await data.pipeTo(writable, options?.stdinPipeOptions);
+            await data.pipeTo(writable, options);
         }
         else if (isUint8Array(data)) {
-            await toReadableStream(data).pipeTo(writable, options?.stdinPipeOptions);
+            await toReadableStream(data).pipeTo(writable, options);
         }
         else if (isString(data)) {
-            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable, options?.stdinPipeOptions);
+            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable, options);
         }
     }
     async function readOutputBytes() {
@@ -31,10 +31,10 @@ export async function spawnCommand(command, args, options) {
     async function readOutput() {
         return readTextStream(readable.pipeThrough(decodeTextStream()));
     }
-    async function readErrBytes() {
+    async function readErrorBytes() {
         return readBinaryStream(stderr);
     }
-    async function readErr() {
+    async function readError() {
         return readTextStream(stderr.pipeThrough(decodeTextStream()));
     }
     const signalPromise = new Promise((resolve) => process.on('close', (code, signal) => resolve({ code, signal })));
@@ -46,8 +46,8 @@ export async function spawnCommand(command, args, options) {
         write,
         readOutputBytes,
         readOutput,
-        readErrorBytes: readErrBytes,
-        readError: readErr,
+        readErrorBytes,
+        readError,
         async wait() {
             return signalPromise;
         }