radashi-helper/dist/chunk-ST3J6QTN.cjs

Help with managing your own Radashi

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }




var _chunk5R2KEZLQcjs = require('./chunk-5R2KEZLQ.cjs');

// src/exec/exec.ts
var _stream = require('stream');
var _tinyspawn = require('tinyspawn'); var _tinyspawn2 = _interopRequireDefault(_tinyspawn);
function exec(command, args, options) {
  let stdoutSink;
  let stderrSink;
  const stdio = _optionalChain([options, 'optionalAccess', _ => _.stdio]);
  if (_chunk5R2KEZLQcjs.isArray.call(void 0, stdio)) {
    let [stdin, stdout, stderr] = stdio;
    if (_chunk5R2KEZLQcjs.isFunction.call(void 0, stdout)) {
      stdoutSink = createAsyncGeneratorStream(stdout, process.stdout);
      stdout = "pipe";
    }
    if (_chunk5R2KEZLQcjs.isFunction.call(void 0, stderr)) {
      stderrSink = createAsyncGeneratorStream(stderr, process.stderr);
      stderr = "pipe";
    }
    if (stdio[1] !== stdout || stdio[2] !== stderr) {
      options = { ...options, stdio: [stdin, stdout, stderr] };
    }
  }
  const proc = _tinyspawn2.default.call(void 0, command, args, options);
  if (stdoutSink) {
    proc.stdout.pipe(stdoutSink);
  }
  if (stderrSink) {
    proc.stderr.pipe(stderrSink);
  }
  if (_optionalChain([options, 'optionalAccess', _2 => _2.reject]) === false) {
    return Object.assign(
      proc.catch((error) => error),
      proc
    );
  }
  return proc;
}
function createAsyncGeneratorStream(init, sink) {
  let generator;
  return new (0, _stream.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 _optionalChain([generator, 'optionalAccess', _3 => _3.return, 'call', _4 => _4()]);
        callback();
      } catch (error) {
        callback(error);
      }
    }
  });
}

// src/util/log.ts
var log;
function setLogHandler(handler) {
  log = exports.log = (msg, ...args) => handler("info", msg, ...args);
  log.warn = (msg, ...args) => handler("warn", msg, ...args);
  log.error = (msg, ...args) => handler("error", msg, ...args);
}
setLogHandler(_chunk5R2KEZLQcjs.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 (_chunk5R2KEZLQcjs.isError.call(void 0, error) && "stderr" in error) {
    if ("stdout" in error) {
      log(error.stdout);
    }
    log.error(error.stderr);
  }
  throw error;
}








exports.exec = exec; exports.log = log; exports.setLogHandler = setLogHandler; exports.RadashiError = RadashiError; exports.EarlyExitError = EarlyExitError; exports.forwardStderrAndRethrow = forwardStderrAndRethrow;