@jpillora/take 0.9.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpillora/take",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "A minimal CLI library for building TypeScript-based command-line tools",
   "type": "module",
   "main": "./take.mjs",

package/take.d.mts

@@ -1,4 +1,4 @@
-import { SpawnOptions as nodeSpawnOptions } from "node:child_process";
+import { type SpawnOptions as nodeSpawnOptions } from "node:child_process";
 export type Flag = {
     initial: number | string | boolean | Date;
     description: string;
@@ -20,6 +20,7 @@ export declare function newFlags<F extends Flags>(flags: F): F;
 export type NewCommand<F extends Flags = Flags> = TakeCommand<F> & {
     flagValues: FlagValues<F>;
     input: CommandInput<F>;
+    flagsInitial: FlagValues<F>;
 };
 export type CommandInput<F extends Flags> = {
     flags: FlagValues<F>;
@@ -34,6 +35,22 @@ export type SpawnOptions = {
     args?: string[];
 } & nodeSpawnOptions;
 export declare function spawn(options: SpawnOptions): Promise<number>;
+export type RunResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+    combined: string;
+    error?: string;
+    success: boolean;
+};
+export type ExecResult = {
+    pid: number;
+    error?: string;
+    wait: () => Promise<RunResult>;
+    kill: (signal: number) => void;
+};
+export declare function exec(options: SpawnOptions): ExecResult;
+export declare function run(options: SpawnOptions): Promise<RunResult>;
 export declare const $: (script: string) => Promise<void>;
 export declare const timer: () => () => string;
 export declare function Register(...commands: NewCommand<any>[]): Promise<void>;

package/take.mjs

@@ -1,6 +1,8 @@
-// Take is a mini-CLI library for building typescript-based command-line tools
-// Works with Deno, Node.js (with type stripping), and Bun
+// Take is a mini-CLI library for building typescript-based command-line tools.
+// Works with Deno, Node.js (with type stripping), and Bun.
+// IMPORTANT: All code must stay in 1 file.
 // deno-lint-ignore-file no-explicit-any
+import { Buffer } from "node:buffer";
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 import { spawn as nodeSpawn, } from "node:child_process";
@@ -51,6 +53,84 @@ export async function spawn(options) {
         });
     });
 }
+export function exec(options) {
+    let code = -1;
+    let error = "";
+    const datas = {
+        out: [],
+        err: [],
+        combined: [],
+    };
+    const result = {
+        get code() {
+            return code;
+        },
+        get stdout() {
+            return Buffer.concat(datas.out).toString();
+        },
+        get stderr() {
+            return Buffer.concat(datas.err).toString();
+        },
+        get combined() {
+            return Buffer.concat(datas.combined).toString();
+        },
+        get error() {
+            return error || undefined;
+        },
+        get success() {
+            return code === 0;
+        },
+    };
+    try {
+        const child = nodeSpawn(options.program, options.args ?? [], options);
+        child.stdout?.on("data", (data) => {
+            const buf = Buffer.from(data);
+            datas.out.push(buf);
+            datas.combined.push(buf);
+        });
+        child.stderr?.on("data", (data) => {
+            const buf = Buffer.from(data);
+            datas.err.push(buf);
+            datas.combined.push(buf);
+        });
+        let resolved = false;
+        const resultPromise = new Promise((resolve) => {
+            const done = (finalCode) => {
+                if (resolved) {
+                    return;
+                }
+                code = finalCode;
+                resolved = true;
+                resolve(result);
+            };
+            child.on("error", (err) => {
+                error = err.message;
+                done(1);
+            });
+            child.on("close", (c) => {
+                done(c ?? 1);
+            });
+        });
+        return {
+            pid: child.pid ?? 0,
+            wait: () => resultPromise,
+            kill: (signal) => child.kill(signal),
+        };
+    }
+    catch (err) {
+        code = 1;
+        error = err instanceof Error ? err.message : String(err);
+        return {
+            pid: 0,
+            error,
+            wait: () => Promise.resolve(result),
+            kill: () => { },
+        };
+    }
+}
+export function run(options) {
+    return exec(options).wait();
+}
 // helper for running bash scripts
 export const $ = async (script) => {
     await spawn({
@@ -372,7 +452,13 @@ export async function Register(...commands) {
     }
 }
 export function Command(command) {
-    return { ...command, flagValues: null, input: null };
+    const flagsInitial = Object.fromEntries(Object.entries(command.flags).map(([k, v]) => [k, v.initial]));
+    return {
+        ...command,
+        flagValues: null,
+        input: null,
+        flagsInitial,
+    };
 }
 // deno-lint-ignore no-constant-condition
 if (42 < 7) {