baro/dist/index.esm.js

import { roundD2, round, constraint } from '@aryth/math';
import { STR, OBJ } from '@typen/enum-data-types';
import { valid } from '@typen/nullish';
import readline from 'readline';

const trailZero = num => {
  if (!num) return '0';
  const tx = '' + roundD2(num);
  let i = tx.indexOf('.');

  if (!~i) {
    return tx + '.00';
  }

  let df = tx.length - i;

  if (df === 3) {
    return tx;
  }

  if (df === 2) {
    return tx + '0';
  }

  if (df === 1) {
    return tx + '00';
  }

  return tx;
};
const base3ToScale = (base3, dec) => {
  if (base3 === 0) return 'B'; //

  if (base3 === 1) return dec ? 'K' : 'KB'; // Kilo

  if (base3 === 2) return dec ? 'M' : 'MB'; // Mega

  if (base3 === 3) return dec ? 'G' : 'GB'; // Giga

  if (base3 === 4) return dec ? 'T' : 'TB'; // Tera

  if (base3 === 5) return dec ? 'P' : 'PB'; // Peta

  if (base3 === 6) return dec ? 'E' : 'EB'; // Exa

  if (base3 === 7) return dec ? 'Z' : 'ZB'; // Zetta

  if (base3 === 8) return dec ? 'Y' : 'YB'; // Yotta
};

const DEFAULT_SENTENCE = 'progress [{bar}] {progress}% | ETA: {eta}s | {value}/{total}';
class Layout {
  /**
   * @param {object}                        [options]
   * @param {number}                        [options.size]                size of the progressbar in chars
   * @param {string[]|string}               [options.char]
   * @param {string}                        [options.glue]
   * @param {string}                        [options.sentence]
   * @param {boolean}                       [options.autoZero = false]     autoZero - false
   * @param {function(State):string}        [options.bar]
   * @param {function(State):string}        [options.degree]
   * @param {function(State,object):string} [options.formatter]
   */
  constructor(options) {
    var _options$size, _options$glue, _options$autoZero, _options$sentence;

    const char = typeof options.char === STR ? [options.char, ' '] : Array.isArray(options.char) ? options.char : ['=', '-'];
    const [x, y] = char;
    this.size = (_options$size = options.size) !== null && _options$size !== void 0 ? _options$size : 24;
    this.chars = [x.repeat(this.size + 1), y.repeat(this.size + 1)];
    this.glue = (_options$glue = options.glue) !== null && _options$glue !== void 0 ? _options$glue : '';
    this.autoZero = (_options$autoZero = options.autoZero) !== null && _options$autoZero !== void 0 ? _options$autoZero : false; // autoZero - false

    this.sentence = (_options$sentence = options.sentence) !== null && _options$sentence !== void 0 ? _options$sentence : DEFAULT_SENTENCE;
    if (options.bar) this.bar = options.bar.bind(this);
    if (options.degree) this.degree = options.degree.bind(this);
    if (options.formatter) this.formatter = options.formatter.bind(this);
  }

  static build(options) {
    return new Layout(options);
  }

  loadFormatter(formatter) {
    this.formatter = formatter.bind(this);
    return this;
  }

  bar(state) {
    const {
      progress
    } = state;
    const {
      chars,
      glue,
      size
    } = this;
    const lenX = round(progress * size),
          lenY = size - lenX;
    const [x, y] = chars; // generate bar string by stripping the pre-rendered strings

    return x.slice(0, lenX) + glue + y.slice(0, lenY);
  }

  get fullBar() {
    return this.chars[0].slice(0, this.size);
  }

  get zeroBar() {
    return this.chars[1].slice(0, this.size);
  }

  degree(state) {
    let {
      value,
      total
    } = state;
    const {
      base3 = true,
      decimal = true
    } = this;
    if (!base3) return `${round(value)}/${total}`;
    const thousand = decimal ? 1000 : 1024;
    let base3Level = 0;

    while (total > thousand) {
      // base3Level <= base3
      total /= thousand;
      value /= thousand;
      base3Level++;
    }

    const totalText = trailZero(total);
    const valueText = trailZero(value).padStart(totalText.length); // return { value: valueText, total: totalText, scale: base3ToScale(base3, dec) }

    return `${valueText}/${totalText} ${base3ToScale(base3Level, decimal)}`;
  }
  /**
   *
   * @param {State|object} state
   * @returns {string}
   */


  formatter(state) {
    var _this$sentence;

    return (_this$sentence = this.sentence) === null || _this$sentence === void 0 ? void 0 : _this$sentence.replace(/\{(\w+)\}/g, (match, key) => {
      if (key === 'bar') return this.bar(state);
      if (key === 'degree') return this.degree(state);
      if (key in state) return state[key];
      const payload = state.payload;
      if (payload && key in payload) return payload[key];
      return match;
    });
  }

}

class Config {
  /**
   *
   * @param {object} config
   *
   * @param {WriteStream}  [config.stream = process.stderr] the output stream to write on
   * @param {number}       [config.fps = 12]                the max update rate in fps (redraw will only triggered on value change)
   * @param {Terminal|any} [config.terminal = null]         external terminal provided ?
   * @param {boolean}      [config.autoClear = false]       clear on finish ?
   * @param {boolean}      [config.autoStop = false]        stop on finish ?
   * @param {boolean}      [config.hideCursor = false]      hide the cursor ?
   * @param {boolean}      [config.lineWrap = false]        allow or disable setLineWrap ?
   * @param {string}       [config.sentence = DEFAULT_FORMAT] the bar sentence
   * @param {function}     [config.formatTime = null]       external time-sentence provided ?
   * @param {function}     [config.formatValue = null]      external value-sentence provided ?
   * @param {function}     [config.formatBar = null]        external bar-sentence provided ?
   * @param {boolean}      [config.syncUpdate = true]       allow synchronous updates ?
   * @param {boolean}      [config.noTTYOutput = false]     noTTY mode
   * @param {number}       [config.notTTYSchedule = 2000]   schedule - 2s
   * @param {boolean}      [config.forceRedraw = false]     force bar redraw even if progress did not change
   *
   * @param {object}       [config.eta]                     eta config
   * @param {boolean}      [config.eta.on = false]          switch to turn on eta
   * @param {number}       [config.eta.capacity = 10]       the number of results to average ETA over
   * @param {boolean}      [config.eta.autoUpdate = false]  automatic eta updates based on fps
   * @returns {Config}
   */
  constructor(config) {
    var _config$fps, _config$stream, _config$eta$capacity, _config$eta, _config$eta$autoUpdat, _config$eta2, _config$terminal, _config$autoClear, _config$autoStop, _config$hideCursor, _config$lineWrap, _config$syncUpdate, _config$noTTYOutput, _config$notTTYSchedul, _config$forceRedraw;

    // merge layout
    // the max update rate in fps (redraw will only triggered on value change)
    this.throttle = 1000 / ((_config$fps = config.fps) !== null && _config$fps !== void 0 ? _config$fps : 10); // the output stream to write on

    this.stream = (_config$stream = config.stream) !== null && _config$stream !== void 0 ? _config$stream : process.stderr;
    this.eta = config.eta ? {
      capacity: (_config$eta$capacity = (_config$eta = config.eta) === null || _config$eta === void 0 ? void 0 : _config$eta.capacity) !== null && _config$eta$capacity !== void 0 ? _config$eta$capacity : 10,
      // the number of results to average ETA over
      autoUpdate: (_config$eta$autoUpdat = (_config$eta2 = config.eta) === null || _config$eta2 === void 0 ? void 0 : _config$eta2.autoUpdate) !== null && _config$eta$autoUpdat !== void 0 ? _config$eta$autoUpdat : false // automatic eta updates based on fps

    } : null;
    this.terminal = (_config$terminal = config.terminal) !== null && _config$terminal !== void 0 ? _config$terminal : null; // external terminal provided ?

    this.autoClear = (_config$autoClear = config.autoClear) !== null && _config$autoClear !== void 0 ? _config$autoClear : false; // clear on finish ?

    this.autoStop = (_config$autoStop = config.autoStop) !== null && _config$autoStop !== void 0 ? _config$autoStop : false; // stop on finish ?

    this.hideCursor = (_config$hideCursor = config.hideCursor) !== null && _config$hideCursor !== void 0 ? _config$hideCursor : false; // hide the cursor ?

    this.lineWrap = (_config$lineWrap = config.lineWrap) !== null && _config$lineWrap !== void 0 ? _config$lineWrap : false; // disable setLineWrap ?

    this.syncUpdate = (_config$syncUpdate = config.syncUpdate) !== null && _config$syncUpdate !== void 0 ? _config$syncUpdate : true; // allow synchronous updates ?

    this.noTTYOutput = (_config$noTTYOutput = config.noTTYOutput) !== null && _config$noTTYOutput !== void 0 ? _config$noTTYOutput : false; // noTTY mode

    this.notTTYSchedule = (_config$notTTYSchedul = config.notTTYSchedule) !== null && _config$notTTYSchedul !== void 0 ? _config$notTTYSchedul : 2000; // schedule - 2s

    this.forceRedraw = (_config$forceRedraw = config.forceRedraw) !== null && _config$forceRedraw !== void 0 ? _config$forceRedraw : false; // force bar redraw even if progress did not change

    return this;
  }

  static build(config) {
    return new Config(config);
  }

}

// ETA calculation
class ETA {
  constructor(capacity, initTime, initValue) {
    // size of eta buffer
    this.capacity = capacity || 100; // eta buffer with initial values

    this.valueSeries = [initValue];
    this.timeSeries = [initTime]; // eta time value

    this.eta = '0';
  } // add new values to calculation buffer


  update(time, {
    value,
    total
  }) {
    this.valueSeries.push(value);
    this.timeSeries.push(time); // trigger recalculation

    this.calculate(total - value);
  } // fetch estimated time


  get value() {
    return this.eta;
  } // eta calculation - request number of remaining events


  calculate(remaining) {
    // get number of samples in eta buffer
    const consumed = this.valueSeries.length;
    const gap = Math.min(this.capacity, consumed);
    const dValue = this.valueSeries[consumed - 1] - this.valueSeries[consumed - gap];
    const dTime = this.timeSeries[consumed - 1] - this.timeSeries[consumed - gap]; // get progress per ms

    const marginalRate = dValue / dTime; // strip past elements

    this.valueSeries = this.valueSeries.slice(-this.capacity);
    this.timeSeries = this.timeSeries.slice(-this.capacity); // eq: vt_rate *x = total

    const eta = Math.ceil(remaining / marginalRate / 1000); // check values

    return this.eta = isNaN(eta) ? 'NULL' : !isFinite(eta) ? 'INF' // +/- Infinity --- NaN already handled
    : eta > 1e7 ? 'INF' // > 10M s ? - set upper display limit ~115days (1e7/60/60/24)
    : eta < 0 ? 0 // negative ?
    : eta; // assign
  }

}

class State {
  constructor(total, value, payload, eta) {
    var _eta$capacity;

    this.value = value !== null && value !== void 0 ? value : 0;
    this.total = total !== null && total !== void 0 ? total : 100;
    this.start = Date.now(); // store start time for duration+eta calculation

    this.end = null; // reset stop time for 're-start' scenario (used for duration calculation)

    this.calETA = eta ? new ETA((_eta$capacity = eta.capacity) !== null && _eta$capacity !== void 0 ? _eta$capacity : 64, this.start, this.value) : null; // initialize eta buffer

    this.payload = payload !== null && payload !== void 0 ? payload : {};
    return this;
  }

  static build(values) {
    const {
      total,
      value,
      payload,
      eta
    } = values;
    return new State(total, value, payload, eta);
  }

  initialize(total, value, payload, eta) {
    return Object.assign(this, new State(total, value, payload, eta));
  }

  get eta() {
    return this.calETA.eta;
  }

  get reachLimit() {
    return this.value >= this.total;
  }

  get progress() {
    const progress = this.value / this.total;
    return isNaN(progress) ? 0 // this.preset?.autoZero ? 0.0 : 1.0
    : constraint(progress, 0, 1);
  }

  update(value, payload) {
    var _this$calETA;

    // if (payload) for (let key in payload) this[key] = payload[key]
    this.value = value;
    if (payload) this.payload = payload;
    (_this$calETA = this.calETA) === null || _this$calETA === void 0 ? void 0 : _this$calETA.update(Date.now(), this); // add new value; recalculate eta

    if (this.reachLimit) this.end = Date.now();
    return this;
  }

  stop(value, payload) {
    this.end = Date.now();
    if (valid(value)) this.value = value;
    if (payload) this.payload = payload;
  }

  get elapsed() {
    var _this$end;

    return round((((_this$end = this.end) !== null && _this$end !== void 0 ? _this$end : Date.now()) - this.start) / 1000);
  }

  get percent() {
    return ~~(this.progress * 100);
  }

}

class Escape {
  constructor(conf) {
    var _conf$ctx, _conf$arg, _conf$instant;

    this.ctx = (_conf$ctx = conf.ctx) !== null && _conf$ctx !== void 0 ? _conf$ctx : {};
    this.arg = (_conf$arg = conf.arg) !== null && _conf$arg !== void 0 ? _conf$arg : null;
    this.fn = conf.fn.bind(this.ctx, this.arg);
    this.instant = (_conf$instant = conf.instant) !== null && _conf$instant !== void 0 ? _conf$instant : true;
    this.timer = null;
    this.logs = [];
  }

  static build(conf) {
    return new Escape(conf);
  }

  get active() {
    return valid(this.timer);
  }

  loop(ms) {
    if (typeof this.timer === OBJ) this.stop();
    if (!this.fn) return void 0;
    if (this.instant) this.fn();
    this.timer = setInterval(this.fn, ms);
  }

  stop() {
    clearTimeout(this.timer);
    return this.timer = null;
  }

}

class Terminal {
  stream = null;
  /** @type {boolean} line wrapping enabled */

  lineWrap = true;
  /** @type {number} current, relative y position */

  dy = 0;
  /**
   *
   * @param {Config|object} configs
   * @param {node::WriteStream} configs.stream
   * @param {boolean} [configs.lineWrap]
   * @param {number} [configs.dy]
   *
   */

  constructor(configs) {
    var _configs$lineWrap, _configs$dy;

    this.stream = configs.stream;
    this.lineWrap = (_configs$lineWrap = configs.lineWrap) !== null && _configs$lineWrap !== void 0 ? _configs$lineWrap : true;
    this.dy = (_configs$dy = configs.dy) !== null && _configs$dy !== void 0 ? _configs$dy : 0;
  } // tty environment ?


  get isTTY() {
    return this.stream.isTTY;
  } // get terminal width


  get width() {
    var _this$stream$columns;

    return (_this$stream$columns = this.stream.columns) !== null && _this$stream$columns !== void 0 ? _this$stream$columns : this.stream.isTTY ? 80 : 200; // set max width to 80 in tty-mode and 200 in noTTY-mode
  } // write content to output stream
  // @TODO use string-width to strip length


  write(tx) {
    this.stream.write(tx); // this.stream.write(this.lineWrap ? tx.slice(0, this.width) : tx)
  }

  cleanWrite(tx) {
    this.cursorTo(0, null); // set cursor to start of line

    this.stream.write(tx); // write output

    this.clearRight(); // clear to the right from cursor
  } // save cursor position + settings


  saveCursor() {
    if (!this.isTTY) return void 0;
    this.stream.write('\x1B7'); // save position
  } // restore last cursor position + settings


  restoreCursor() {
    if (!this.isTTY) return void 0;
    this.stream.write('\x1B8'); // restore cursor
  } // show/hide cursor


  showCursor(enabled) {
    if (!this.isTTY) return void 0;
    enabled ? this.stream.write('\x1B[?25h') : this.stream.write('\x1B[?25l');
  } // change cursor position


  cursorTo(x, y) {
    if (!this.isTTY) return void 0;
    readline.cursorTo(this.stream, x, y); // move cursor absolute
  } // change relative cursor position


  moveCursor(dx, dy) {
    if (!this.isTTY) return void 0;
    if (dy) this.dy += dy; // store current position

    if (dx || dy) readline.moveCursor(this.stream, dx, dy); // move cursor relative
  } // reset relative cursor


  resetCursor() {
    if (!this.isTTY) return void 0;
    readline.moveCursor(this.stream, 0, -this.dy); // move cursor to initial line

    readline.cursorTo(this.stream, 0, null); // first char

    this.dy = 0; // reset counter
  } // clear to the right from cursor


  clearRight() {
    if (!this.isTTY) return void 0;
    readline.clearLine(this.stream, 1);
  } // clear the full line


  clearLine() {
    if (!this.isTTY) return void 0;
    readline.clearLine(this.stream, 0);
  } // clear everything beyond the current line


  clearDown() {
    if (!this.isTTY) return void 0;
    readline.clearScreenDown(this.stream);
  } // add new line; increment counter


  newline() {
    this.stream.write('\n');
    this.dy++;
  } // control line wrapping


  setLineWrap(enabled) {
    if (!this.isTTY) return void 0;
    this.lineWrap = enabled; // store state

    enabled ? this.stream.write('\x1B[?7h') : this.stream.write('\x1B[?7l');
  }

}

class Baro {
  /** @type {Config|object} store config */
  config;
  /** @type {Terminal|object} store terminal instance */

  terminal;
  /** @type {boolean} progress bar active ? */

  active = false;
  /** @type {function} use default formatter or custom one ? */

  formatter;
  /** @type {[State]}  */

  states;
  /**
   *
   * @param {Config} config
   * @param {Layout} layout
   */

  constructor(config, layout) {
    var _this$config$terminal;

    this.config = config;
    this.layout = layout;
    this.states = [];
    this.escape = Escape.build({
      fn: this.#renderStates,
      ctx: this,
      arg: this.states
    });
    this.terminal = (_this$config$terminal = this.config.terminal) !== null && _this$config$terminal !== void 0 ? _this$config$terminal : new Terminal(this.config);
  }

  static build(config, layout) {
    config = Config.build(config);
    layout = Layout.build(layout);
    return new Baro(config, layout);
  }

  get active() {
    return !!this.escape.timer;
  }

  get forceRedraw() {
    return this.config.forceRedraw || this.config.noTTYOutput && !this.terminal.isTTY; // force redraw in noTTY-mode!
  }

  get noTTY() {
    return this.config.noTTYOutput && !this.terminal.isTTY;
  }

  boot() {
    if (this.config.hideCursor) this.terminal.showCursor(false); // hide the cursor ?

    if (!this.config.lineWrap) this.terminal.setLineWrap(false); // disable line wrapping ?

    this.escape.loop(this.config.throttle); // initialize update timer
  }
  /**
   * add a new bar to the stack
   * @param total
   * @param value
   * @param payload
   * @returns {State}
   */


  create(total, value, payload) {
    // progress updates are only visible in TTY mode!
    if (this.noTTY) return void 0;
    const state = new State(total, value, payload, true);
    state.last = Number.NEGATIVE_INFINITY;
    this.states.push(state);
    if (!this.escape.active && this.states.length) this.boot();
    return state;
  } // remove a bar from the stack


  remove(state) {
    const index = this.states.indexOf(state); // find element

    if (index < 0) {
      return false;
    } // element found ?


    this.states.splice(index, 1); // remove element

    this.terminal.newline();
    this.terminal.clearDown();
    return true;
  }

  stop() {
    this.escape.stop(); // stop timer

    if (this.config.hideCursor) {
      this.terminal.showCursor(true);
    } // cursor hidden ?


    if (!this.config.lineWrap) {
      this.terminal.setLineWrap(true);
    } // re-enable line wrapping ?


    if (this.config.autoClear) {
      this.terminal.resetCursor(); // reset cursor

      this.terminal.clearDown();
    } // clear all bars or show final progress
    else {
      for (let state of this.states) {
        state.stop();
      }

      this.#renderStates(this.states);
    }
  }

  #renderStates(states) {
    this.terminal.resetCursor(); // reset cursor

    for (let i = 0, hi = states.length; i < hi; i++) {
      const state = states[i]; // update each bar

      if (this.forceRedraw || state.value !== state.last) {
        this.terminal.cleanWrite(this.layout.formatter(state));
      } // string updated, only trigger redraw on change


      this.terminal.newline();
      state.last = state.value;
    }

    if (this.noTTY) {
      this.terminal.newline();
      this.terminal.newline();
    } // add new line in noTTY mode


    if (this.config.autoStop && states.every(state => state.reachLimit)) {
      this.stop();
    } // stop if autoStop and all bars stopped

  }

}

class Spin {
  max;
  value;
  width;
  step;

  constructor(max, width, step) {
    this.max = max;
    this.width = width;
    this.step = step;
    this.value = 0;
  }

  static build(max, width, step) {
    return new Spin(max, width, step);
  }

  next() {
    this.value += this.step;
    if (this.value >= this.max) this.value -= this.max;
    return this;
  }

  get sequel() {
    let next = this.value + this.width;
    if (next > this.max) next -= this.max;
    return next;
  }

  get record() {
    const {
      value,
      sequel
    } = this;

    if (value <= 0 || value >= this.max) {
      const x = this.width;
      const y = this.max - this.width;
      return [0, 0, x, y];
    } else {
      if (value < sequel) {
        const x = value - 1;
        const y = this.width;
        const z = this.max - this.width - value + 1;
        return [0, x, y, z];
      } else {
        const x = sequel;
        const y = value - sequel - 1;
        const z = this.max - value + 1;
        return [x, y, z, 0];
      }
    }
  }

  renderBar([bar, spc]) {
    const {
      value,
      sequel
    } = this;

    if (value <= 0 || value >= this.max) {
      const x = this.width;
      const y = this.max - this.width;
      return bar.slice(0, x) + spc.slice(0, y);
    } else {
      if (value < sequel) {
        const x = value;
        const y = this.width;
        const z = this.max - this.width - value;
        return spc.slice(0, x) + bar.slice(0, y) + spc.slice(0, z);
      } else {
        const x = sequel;
        const y = value - sequel;
        const z = this.max - value;
        return bar.slice(0, x) + spc.slice(0, y) + bar.slice(0, z);
      }
    }
  }

}

const CHARSET_SHADE = [`█`, `░`]; // \u2588 \u2591

const CHARSET_RECT = [`■`, ` `]; // \u25A0

const CHARSET_LEGACY = [`=`, `-`];

export { Baro, CHARSET_LEGACY, CHARSET_RECT, CHARSET_SHADE, Config, ETA, Escape, Layout, Spin, State };