radashi-helper/dist/chunk-JLKIE3A2.js

Help with managing your own Radashi

import {
  isArray,
  isError,
  isFunction,
  noop
} from "./chunk-VOEQFXI5.js";

// src/exec/exec.ts
import { Writable } from "node:stream";
import spawn from "tinyspawn";
function exec(command, args, options) {
  let stdoutSink;
  let stderrSink;
  const stdio = options?.stdio;
  if (isArray(stdio)) {
    let [stdin, stdout, stderr] = stdio;
    if (isFunction(stdout)) {
      stdoutSink = createAsyncGeneratorStream(stdout, process.stdout);
      stdout = "pipe";
    }
    if (isFunction(stderr)) {
      stderrSink = createAsyncGeneratorStream(stderr, process.stderr);
      stderr = "pipe";
    }
    if (stdio[1] !== stdout || stdio[2] !== stderr) {
      options = { ...options, stdio: [stdin, stdout, stderr] };
    }
  }
  const proc = spawn(command, args, options);
  if (stdoutSink) {
    proc.stdout.pipe(stdoutSink);
  }
  if (stderrSink) {
    proc.stderr.pipe(stderrSink);
  }
  if (options?.reject === false) {
    return Object.assign(
      proc.catch((error) => error),
      proc
    );
  }
  return proc;
}
function createAsyncGeneratorStream(init, sink) {
  let generator;
  return new Writable({
    async write(chunk, encoding, callback) {
      try {
        const data = chunk.toString("utf8");
        const result = await (generator ??= init(data)).next(data);
        if (!result.done && result.value !== void 0) {
          sink.write(result.value);
        }
        callback();
      } catch (error) {
        callback(error);
      }
    },
    async final(callback) {
      try {
        await generator?.return();
        callback();
      } catch (error) {
        callback(error);
      }
    }
  });
}

// src/util/log.ts
var log;
function setLogHandler(handler) {
  log = (msg, ...args) => handler("info", msg, ...args);
  log.warn = (msg, ...args) => handler("warn", msg, ...args);
  log.error = (msg, ...args) => handler("error", msg, ...args);
}
setLogHandler(noop);

// src/util/error.ts
var RadashiError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "RadashiError";
  }
};
var EarlyExitError = class extends RadashiError {
  constructor(message = "Cannot continue. Exiting...") {
    super(message);
    this.name = "EarlyExitError";
  }
};
function forwardStderrAndRethrow(error) {
  if (isError(error) && "stderr" in error) {
    if ("stdout" in error) {
      log(error.stdout);
    }
    log.error(error.stderr);
  }
  throw error;
}

export {
  exec,
  log,
  setLogHandler,
  RadashiError,
  EarlyExitError,
  forwardStderrAndRethrow
};