elprimero/dist/index.cjs.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var xbrief = require('xbrief');
var veho = require('veho');
var crostab = require('crostab');
var borel = require('borel');
var hatsuMatrix = require('hatsu-matrix');

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

const _d_2 = '2-digit',
      _num = 'numeric';
const confDate = {
  year: _d_2,
  month: _d_2,
  day: _d_2
},
      confTime = {
  hour: _num,
  minute: _num,
  second: _num,
  hour12: false
};
class Fm {}

_defineProperty(Fm, "Day", new Intl.DateTimeFormat(undefined, confDate));

_defineProperty(Fm, "Time", new Intl.DateTimeFormat(undefined, confTime));

_defineProperty(Fm, "DayTime", new Intl.DateTimeFormat(undefined, { ...confDate,
  ...confTime
}));

const padMilli = ms => {
  ms = '' + ms;
  return ms.length > 2 ? ms : ('00' + ms).slice(-3);
};

const {
  Time
} = Fm;
const format = Time.format.bind(Time);
class ETA {
  constructor() {
    this.t = new Date();
  }

  ini(msg = '') {
    return `[${format(this.t)}] [Ini 0ms] ${msg}`;
  }

  split() {
    const cur = new Date(),
          df = cur - this.t;
    this.t = cur;
    return df;
  }

  lap(msg = '') {
    return `[${format(this.t)}] [Lap ${this.split()}ms] ${msg}`;
  }

  end(msg = '') {
    return `[${format(this.t)}] [End ${this.split()}ms] ${msg}`;
  }

} // split: another approach
// ([this.f, this.t] = [new Date(), this.f])
// return this.f - this.t

class GP {
  /**
   * hh:mm:ss
   * @param {Date} [date=new Date()]
   * @returns {string}
   */
  static roughly(date = new Date()) {
    return Fm.Time.format(date);
  }
  /**
   * hh:mm:ss.mmm
   * @param {Date} date
   * @returns {string}
   */


  static time(date = new Date()) {
    return `${Fm.Time.format(date)}.${padMilli(date.getMilliseconds())}`;
  }

  static vec(date = new Date()) {
    return [date.getFullYear(), date.getMonth() + 1, date.getDate()];
  }

  static y4md(date = new Date(), de = '-') {
    return [String(date.getFullYear()).padStart(4, '0'), String(date.getMonth() + 1).padStart(2, '0'), //Months are zero based
    String(date.getDate()).padStart(2, '0')].join(de);
  }

  static mdy(date = new Date()) {
    return Fm.Day.format(date);
  }

  static dateTime(date = new Date()) {
    return Fm.DayTime.format(date);
  }
  /**
   * Return string of current time.
   * Format: hh:mm:ss
   * @return {string}
   */


  static roughlyNow() {
    return Fm.Time.format(new Date());
  }
  /**
   * Return string of current time with 3-digit milliseconds.
   * Format: hh:mm:ss.mmm
   * @return {string}
   */


  static now() {
    let d = new Date();
    return `${Fm.Time.format(d)}.${padMilli(d.getMilliseconds())}`;
  }
  /**
   *
   * @returns {number}
   */


  static year() {
    return new Date().getFullYear();
  }
  /**
   * Return current date array in [Y,M,D] order.
   * @returns {*[]}
   */


  static todayVec() {
    const td = new Date(); //Months are zero based

    return [td.getFullYear(), td.getMonth() + 1, td.getDate()];
  }
  /**
   * Return current date in YYYY-MM-DD format, the delimiter '-' can be replaced by setting parameter 'de'
   * @param {string} [de='-'] - delimiter
   * @returns {string}
   */


  static today(de = '-') {
    const td = new Date();
    return [String(td.getFullYear()).padStart(4, '0'), String(td.getMonth() + 1).padStart(2, '0'), //Months are zero based
    String(td.getDate()).padStart(2, '0')].join(de);
  }
  /**
   * Return current date in MM/DD/YY format.
   * Format: mm/dd/yy
   * @return {string}
   */


  static todayMDY() {
    return Fm.Day.format(new Date());
  }
  /**
   * Return string of current date with time.
   * Format: mm/dd/yy, hh:mm:ss
   * @return {string}
   */


  static present() {
    return Fm.DayTime.format(new Date());
  }

}

const _reh = (r, func, params) => {
  for (--r; r > 0; r--) func.apply(null, params);

  return func.apply(null, params);
}; // const _rehRest = (repeat, func, ...params) => {
//   for (let i = --repeat; !!i; --i) func.call(null, ...params)
//   return func.call(null, ...params)
// }


class Chrono {
  /**
   *
   * @param {number} repeat
   * @param {function} func
   * @param {...*[]} [params]
   * @return {*}
   */
  static rehearsalRest(repeat, func, ...params) {
    for (--repeat; repeat > 0; repeat--) func.call(null, ...params);

    return func.call(null, ...params);
  }
  /**
   *
   * @param {number} repeat
   * @param {function} func
   * @param {...*[]} [params]
   * @return {*}
   */


  static rehearsalArgs(repeat, func, params) {
    for (--repeat; repeat > 0; repeat--) func.call(null, params);

    return func.call(null, params);
  }
  /**
   * Cross by repeatList and functions.
   * Each function contains no parameter.
   * @param {number[]} repeatList
   * @param {Object<string,function>} funcList
   * @param {*[]} [params]
   * @returns {CrosTab}
   */


  static crossByRepeatsAndFuncs({
    repeatList,
    funcList,
    params = []
  }) {
    const eta = new ETA();
    const [side, banner] = [repeatList, Object.keys(funcList)];
    const [ht, wd] = [side.length, banner.length];
    const [lapseX, valueRow] = [veho.Mx.ini(ht, wd, (i, j) => 0), veho.Ar.ini(wd, () => null)];
    eta.ini();

    for (let [x, repeat] of Object.entries(repeatList)) {
      var _ref, _Object$keys;

      _ref = `[${GP.now()}] [${x}] (${repeat}): repeat for each of [${(_Object$keys = Object.keys(funcList), xbrief.ArrX.hBrief(_Object$keys))}]`, console.log(_ref);
      eta.split();

      for (let [y, func] of Object.values(funcList).entries()) {
        valueRow[y] = _reh(repeat, func, params);
        lapseX[x][y] = eta.split();
      }
    }

    return new crostab.CrosTab(side, banner, lapseX, 'repeat #').unshiftRow('result', valueRow);
  }
  /**
   * Cross by paramsList and functions, under certain repeat.
   * Each function receives the same list of paramsList.
   * @param {number} repeat
   * @param {Object<string,*[]>} paramsList - each value is an array of parameters.
   * @param {Object<string,function>} funcList
   * @param {{showAverage:boolean,showParamsValues:boolean}} [config]
   * @returns {{lapse:CrosTab,result:CrosTab}}
   */


  static strategies({
    repeat,
    paramsList,
    funcList,
    config = {
      showAverage: true,
      showParamsValues: false
    }
  }) {
    var _lapse$columns$map$ma;

    const eta = new ETA(),
          [side, banner] = [Object.keys(paramsList), Object.keys(funcList)],
          [ht, wd] = [side.length, banner.length],
          [lapseX, valueX] = [veho.Mx.ini(ht, wd, (i, j) => 0), veho.Mx.ini(ht, wd, (i, j) => null)];
    eta.ini();

    for (let [x, [label, params]] of Object.entries(paramsList).entries()) {
      var _ref2;

      _ref2 = `[${GP.now()}] [${x}] (${label}) tested by each of funcs [${banner}], each repeated * ${repeat}.`, console.log(_ref2);
      eta.split();

      for (let [y, func] of Object.values(funcList).entries()) {
        valueX[x][y] = _reh(repeat, func, params);
        lapseX[x][y] = eta.split();
      }
    }

    let [lapse, result] = [crostab.CrosTab.from({
      side,
      banner,
      matrix: lapseX,
      title: 'parameter'
    }).clone(), crostab.CrosTab.from({
      side,
      banner,
      matrix: valueX,
      title: 'parameter'
    }).clone()];
    if (config.showAverage) lapse.unshiftRow('avg', (_lapse$columns$map$ma = lapse.columns.map(borel.Stat.avg).map(it => it.toFixed()), hatsuMatrix.Visual.vector(_lapse$columns$map$ma)));
    if (config.showParamsValues) result.unshiftCol('input', Object.values(paramsList));
    return {
      lapse,
      result
    };
  }

}

class Dawdle {
  static linger(ms, fn, ...args) {
    return new Promise((pass, veto) => {
      let st = false,
          rs;
      Promise.resolve(fn.apply(null, args)).then(x => st++ ? pass(x) : rs = x, veto);
      Promise.resolve(Dawdle.timeout(ms)).then(_ => {
        if (st++) pass(rs);
      }, veto);
    });
  }

  static timeout(ms) {
    return new Promise(pass => setTimeout(pass, ms));
  }

}

const monthCap = (m, lp) => m !== 0b10 ? 30 + m % 0b10 ^ m >= 0x8 : 28 + lp;

const leapYear = y => y % 4 ? false : y % 100 ? true : !(y % 400);

const nextMonth = dt => {
  dt.m += 1;

  if (dt.m > 12) {
    dt.y += 1;
    dt.m = 1;
    dt.lp = leapYear(dt.y);
  }

  dt.cap = monthCap(dt.m, dt.lp);
  return dt;
};
const prevMonth = dt => {
  dt.m -= 1;

  if (dt.m < 1) {
    dt.y -= 1;
    dt.m = 12;
    dt.lp = leapYear(dt.y);
  }

  dt.cap = monthCap(dt.m, dt.lp);
  return dt;
};
const yearForth = dt => {
  let {
    y,
    m,
    d
  } = dt;

  while (d >= 365) {
    d -= 365;
    if (m <= 2 && leapYear(y++) || m > 2 && leapYear(++y)) d--;
  }

  const lp = leapYear(y);
  return {
    y,
    m,
    d,
    lp,
    cap: monthCap(m, lp)
  };
};
const yearBack = dt => {
  let {
    y,
    m,
    d
  } = dt;

  while (d <= -365) {
    d += 365;
    if (m <= 2 && leapYear(--y) || m > 2 && leapYear(y--)) d++;
  }

  const lp = leapYear(y);
  return {
    y,
    m,
    d,
    lp,
    cap: monthCap(m, lp)
  };
};
const daysForth = dt => {
  while (dt.d > dt.cap) {
    var _dt;

    dt.d -= dt.cap;
    _dt = dt, nextMonth(_dt);
  }

  return dt;
};
const daysBack = dt => {
  dt.cap = 0;

  while (dt.d < dt.cap) {
    var _dt2;

    _dt2 = dt, prevMonth(_dt2);
    dt.d += dt.cap;
  }

  return daysForth(dt);
};

const endOfMonth = (y, m) => monthCap(m, leapYear(y));
const calibre = (y, m, d, hi) => {
  if (d >= hi) return [y, m, endOfMonth(y, m)];
  if (d >= 28) return [y, m, Math.min(d, endOfMonth(y, m))];
  return [y, m, d];
};

const pad0 = (n, l) => {
  n = '' + n;

  while (n.length < l) n = '0' + n;

  return n;
};

const joinY4MD = (y, m, d, l = '-') => `${+y < 1000 ? pad0(+y, 4) : +y}${l}${+m < 10 ? pad0(+m, 2) : +m}${l}${+d < 10 ? pad0(+d, 2) : +d}`;

const ymdToInt = ([y, m, d]) => ((y & 0xffff) << 9) + ((m & 0xf) << 5) + ((d & 0x1f) << 0);

class Y4MD {
  static now() {
    return Y4MD.fromDate(new Date());
  }

  static fromDate(date = new Date()) {
    return [date.getFullYear(), date.getMonth() + 1, date.getDate()];
  }

  static toDate(ymd) {
    return new Date(ymd[0], ymd[1] - 1, ymd[2]);
  }

  static fromTx(tx) {
    return [+tx.slice(0, 4), +tx.slice(5, 7), +tx.slice(8, 10)];
  }

  static toTx(ymd, de = '-') {
    return joinY4MD(ymd[0], ymd[1], ymd[2], de);
  }

  static belongTo(ymd, lo, hi) {
    const int = ymdToInt(ymd);
    return ymdToInt(lo) <= int && int <= ymdToInt(hi);
  }

  static addD([y, m, d], days) {
    let lp = leapYear(y),

    /**
     *
     * @type {{y: number, m: number,d: number, lp: boolean, cap: number }}
     */
    dt = {
      y,
      m,
      d: d + days,
      lp,
      cap: monthCap(m, lp)
    };
    if (dt.d - 365 > 0) dt = yearForth(dt);
    if (dt.d + 365 < 0) dt = yearBack(dt);
    dt = dt.d >= 0 ? daysForth(dt) : daysBack(dt);
    return [dt.y, dt.m, dt.d];
  }

  static addM([y, m, d], months) {
    let eom = endOfMonth(y, m);
    let ym = y * 12 + m + months;
    y = ~~(ym / 12);
    m = ym % 12;

    if (m < 1) {
      y--;
      m = 12;
    }

    return calibre(y, m, d, eom);
  }

  static addQ([y, m, d], quarters) {
    return Y4MD.addM([y, m, d], quarters * 3);
  }

  static addY([y, m, d], years) {
    return calibre(y + years, m, d, endOfMonth(y, m));
  }

  static seasonLoHi([y, m]) {
    let hi = ~~((m - 1) / 3 + 1) * 3;
    return [[y, hi - 2, 1], [y, hi, endOfMonth(y, hi)]];
  }

  static monthLoHi([y, m]) {
    return [[y, m, 1], [y, m, endOfMonth(y, m)]];
  }

}

exports.Chrono = Chrono;
exports.Dawdle = Dawdle;
exports.ETA = ETA;
exports.GP = GP;
exports.Y4MD = Y4MD;