@nekobird/piko/build/esm/piko.js

A general utility library for dealing with numbers, strings, and other things.

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}

function _iterableToArrayLimit(arr, i) {
  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

  return arr2;
}

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function getRandomInteger(min, max) {
  var ceilMin = Math.ceil(min);
  var floorMax = Math.floor(max);
  return Math.floor(Math.random() * (floorMax - ceilMin + 1)) + ceilMin;
}
function getMaxArraysLength() {
  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
    arrays[_key] = arguments[_key];
  }

  return Math.max.apply(Math, _toConsumableArray(arrays.map(function (array) {
    return array.length;
  })));
}
function isNumber(value) {
  return typeof value === 'number' && !isNaN(value);
}
function isNullOrUndefined(value) {
  return typeof value === 'undefined' || value === null;
}
function toArray(value) {
  return Array.isArray(value) ? value : [value];
}

function snapToInterval(value, interval) {
  var origin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  var sign = Math.sign(value) || 1;

  var _interval = Math.abs(interval);

  var _value = Math.abs(value);

  var remainder = Math.abs(value - origin) % _interval;

  var result = remainder >= _interval / 2 ? _value - remainder + _interval : _value - remainder;
  return result * sign;
}
function average() {
  return arguments.length === 1 ? arguments.length <= 0 ? undefined : arguments[0] : sum.apply(void 0, arguments) / arguments.length;
}
function clamp(value, a, b) {
  var range = isNumber(a) && isNumber(b) ? orderRangeArray([a, b]) : isNumberOrRange(a) && typeof b === 'undefined' ? orderRangeArray(getRangeFromNumberOrRange(a)) : null;
  return range ? Math.max(range[0], Math.min(value, range[1])) : value;
}
function countDigits(value) {
  var matches = value.toString().match(/([\d])/g);
  return matches ? matches.length : 0;
}
function cubicBezier(t, p1, cp1, cp2, p2) {
  return Math.pow(1 - t, 3) * p1 + 3 * t * Math.pow(1 - t, 2) * cp1 + 3 * t * t * (1 - t) * cp2 + t * t * t * p2;
}
function cycleNumber(value, range) {
  var _range = getRangeFromNumberOrRange(range);

  var _orderRangeArray = orderRangeArray(_range),
      _orderRangeArray2 = _slicedToArray(_orderRangeArray, 2),
      min = _orderRangeArray2[0],
      max = _orderRangeArray2[1];

  if (min === 0 && max === 0) {
    return 0;
  }

  var da = getEuclideanDistance(min, max);

  if (value > max) {
    var db = getEuclideanDistance(value, max);
    var c = db % da + min;
    return c === min ? max : c;
  } else if (value < min) {
    var _db = getEuclideanDistance(value, min);

    var _c = max - _db % da;

    return _c === max ? min : _c;
  }

  return value;
}
function getEuclideanDistance(a, b) {
  return a === b ? 0 : Math.sqrt(Math.abs((a - b) * (b - a)));
}
function hypotenuse(x, y) {
  if (Math.hypot) {
    return Math.hypot(x, y);
  }

  var max = Math.max(Math.abs(x), Math.abs(y)) || 1;
  var min = Math.min(Math.abs(x), Math.abs(y));
  var n = min / max;
  return max * Math.sqrt(1 + n * n);
}
function lerp(t, from, to) {
  return (1 - t) * from + t * to;
}
function randomNumber(range) {
  var integerOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var fixed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;

  var _range = getRangeFromNumberOrRange(range);

  var _range2 = _slicedToArray(_range, 2),
      min = _range2[0],
      max = _range2[1];

  return min === 0 && max === 1 ? integerOnly ? Math.floor(Math.random() * 2) : parseFloat(Math.random().toFixed(fixed)) : parseInt(transform(Math.random(), 1, _range, false).toFixed(0), 10);
}
function roundTo(value) {
  var to = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  return parseFloat(value.toFixed(to));
}
function sum() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  return values.reduce(function (previous, current) {
    return previous + current;
  });
}
function transform(value, from, to) {
  var clampResult = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

  var _from = getRangeFromNumberOrRange(from);

  var _to = getRangeFromNumberOrRange(to);

  var result = (value - _from[0]) * ((_to[1] - _to[0]) / (_from[1] - _from[0])) + _to[0];
  return clampResult ? clamp(result, _to) : result;
}
function numberIsWithin(value, a, b, c) {
  var range;
  var isExclusive = false;

  if (isNumber(a) && isNumber(b) && (typeof c === 'boolean' || typeof c === 'undefined')) {
    if (typeof c === 'boolean') {
      isExclusive = c;
    }

    range = orderRangeArray([a, b]);
  } else if (isNumberOrRange(a) && (typeof b === 'boolean' || typeof b === 'undefined')) {
    if (typeof b === 'boolean') {
      isExclusive = b;
    }

    range = getRangeFromNumberOrRange(a);
  } else {
    return false;
  }

  var _range3 = range,
      _range4 = _slicedToArray(_range3, 2),
      min = _range4[0],
      max = _range4[1];

  return isExclusive ? value > min && value < max : value >= min && value <= max;
}
function createArrayOfConsecutiveNumbers(a, b) {
  var range = isNumberOrRange(a) && typeof b === 'undefined' ? getRangeFromNumberOrRange(a) : isNumber(a) && isNumber(b) ? [a, b] : null;
  return range ? range[0] !== range[1] ? _toConsumableArray(Array(getEuclideanDistance.apply(void 0, _toConsumableArray(range)) + 1).keys()).map(function (n) {
    return range[0] > range[1] ? range[0] - n : n + range[0];
  }) : [] : [];
}
function getRangeFromNumberOrRange(range) {
  return isNumber(range) ? [0, range] : [range[0], range[1]];
}
function isNumberOrRange(thing) {
  return isNumber(thing) || isRangeArray(thing);
}
function isRangeArray(thing) {
  return Array.isArray(thing) && thing.length === 2 && thing.every(isNumber);
}
function orderRangeArray(range) {
  return [Math.min.apply(Math, _toConsumableArray(range)), Math.max.apply(Math, _toConsumableArray(range))];
}
function isInteger(n) {
  return isNumber(n) && n % 1 === 0;
}
function isValidArrayIndex(n) {
  return isInteger(n) && n >= 0;
}
function toNumber(thing) {
  return isNumber(thing) ? thing : parseFloat(thing);
}

function hasUppercaseLetter() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  return values.every(function (value) {
    return /[A-Z]+/g.test(value);
  });
}
function isKebabCase() {
  for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    values[_key2] = arguments[_key2];
  }

  return values.every(function (value) {
    return hasUppercaseLetter(value) === false && /^([a-z]+|[a-z][a-z\-]+[a-z])$/g.test(value);
  });
}
function isSnakeCase() {
  for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    values[_key3] = arguments[_key3];
  }

  return values.every(function (value) {
    return hasUppercaseLetter(value) === false && /^([a-z]+|[a-z][a-z\_]+[a-z])$/g.test(value);
  });
}
function kebabCaseToCamelCase(from) {
  if (isKebabCase(from)) {
    return from.replace(/(\-[a-z]{1})/g, function (match) {
      return match.replace(/[\-]/g, '').toUpperCase();
    });
  }

  return from;
}
function lowercaseFirstLetter(value) {
  return value.charAt(0).toLowerCase() + value.slice(1);
}
function match(string, regex) {
  var value = string.match(regex);

  if (!value) {
    return null;
  }

  if (value.length === 1) {
    return value[0];
  }

  return value;
}
function removeExtraWhitespaces(value) {
  return value.replace(/[\s]+/g, ' ');
}
function removeNewLines(value) {
  return value.replace(/[\r\n]+/g, '');
}
function removeTabs(value) {
  return value.replace(/[\t]+/g, '');
}
function replace(value, patterns) {
  var replacement = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
  var result = value;

  if (isStringOrRegExpArray(patterns)) {
    patterns.forEach(function (pattern) {
      result = value.replace(pattern, replacement);
    });
  } else if (isStringOrRegExp(patterns)) {
    result = value.replace(patterns, replacement);
  }

  return result;
}
function uppercaseFirstLetter(value) {
  return value.charAt(0).toUpperCase() + value.slice(1);
}
function isStringOrRegExp(value) {
  return typeof value === 'string' || value instanceof RegExp;
}
function isStringOrRegExpArray(value) {
  return Array.isArray(value) && value.every(isStringOrRegExp);
}
function toString(value) {
  return isNumber(value) ? value.toString() : value;
}
function repeatString(string, count) {
  var between = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
  return count > 0 ? (string + between).repeat(count - 1) + string : '';
}

function compose() {
  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
    funcs[_key] = arguments[_key];
  }

  return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return funcs.reduceRight(function (a, f) {
      return f(a);
    }, args);
  };
}
function composeRight() {
  for (var _len3 = arguments.length, funcs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    funcs[_key3] = arguments[_key3];
  }

  return function () {
    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      args[_key4] = arguments[_key4];
    }

    return funcs.reduce(function (a, f) {
      return f(a);
    }, args);
  };
}
function pipe() {
  for (var _len5 = arguments.length, funcs = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
    funcs[_key5] = arguments[_key5];
  }

  return function () {
    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
      args[_key6] = arguments[_key6];
    }

    return funcs.reduce(function (a, f) {
      return f(a);
    }, args);
  };
}
function curry(func) {
  return function currify() {
    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
      args[_key7] = arguments[_key7];
    }

    return args.length >= func.length ? func.apply(null, args) : currify.bind.apply(currify, [null].concat(args));
  };
}
function unary(func) {
  return function () {
    return func.call(null, arguments.length <= 0 ? undefined : arguments[0]);
  };
}
function cycleArray(array, offset) {
  var index = offset % array.length;

  if (offset < 0) {
    var remainder = Math.abs(offset) % array.length;
    index = remainder === 0 ? 0 : array.length + remainder * -1;
  }

  return array[index];
}
function cycleArrayNext(array) {
  var index = -1;
  return function () {
    index++;

    if (index > array.length - 1) {
      index = 0;
    }

    return array[index];
  };
}
function debounce(func, delayInSeconds) {
  var _arguments = arguments,
      _this = this;

  var timeout;
  return function () {
    clearTimeout(timeout);
    timeout = setTimeout(function () {
      return func.apply(_this, _arguments);
    }, delayInSeconds * 1000);
  };
}
function delay(callback, delayInSeconds) {
  return new Promise(function (resolve) {
    setTimeout(function () {
      return resolve(callback());
    }, delayInSeconds * 1000);
  });
}
function fillArraysToLargestLength(filler) {
  for (var _len8 = arguments.length, arrays = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
    arrays[_key8 - 1] = arguments[_key8];
  }

  var maxLength = getMaxArraysLength.apply(void 0, arrays);
  arrays.forEach(function (array) {
    while (array.length < maxLength) {
      array.push(filler);
    }
  });
  return maxLength;
}
function getMinArraysLength() {
  for (var _len9 = arguments.length, arrays = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
    arrays[_key9] = arguments[_key9];
  }

  return Math.min.apply(Math, _toConsumableArray(arrays.map(function (array) {
    return array.length;
  })));
}
function isEmptyObject(object) {
  return isObject(object) && Object.keys(object).length < 1;
}
function isObject(object) {
  return _typeof(object) === 'object' && object !== null;
}
function isPromise() {
  for (var _len10 = arguments.length, things = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
    things[_key10] = arguments[_key10];
  }

  if (things.length === 0) {
    return false;
  }

  var isPromise = function isPromise(thing) {
    return isObject(thing) && 'then' in thing && typeof thing.then === 'function' && thing instanceof Promise && Promise.resolve(thing) === thing;
  };

  return things.every(isPromise);
}
function memo(func, cache) {
  return function () {
    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
      args[_key11] = arguments[_key11];
    }

    var key = JSON.stringify(args);

    if (cache.has(key)) {
      return cache.get(key);
    }

    var value = func.apply(void 0, args);
    cache.set(key, value);
    return value;
  };
}
function once(fn) {
  var isCalled = false;
  var returnValue = null;
  return function () {
    if (!isCalled) {
      returnValue = fn.apply(void 0, arguments);
      isCalled = true;
    }

    return returnValue;
  };
}
function promiseChain() {
  for (var _len12 = arguments.length, funcs = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
    funcs[_key12] = arguments[_key12];
  }

  return new Promise(function (resolve, reject) {
    var currentIndex = -1;

    var loop = function loop() {
      currentIndex++;
      typeof funcs[currentIndex] === 'function' ? funcs[currentIndex]().then(function () {
        return loop();
      })["catch"](function (error) {
        return reject(error);
      }) : resolve();
    };

    loop();
  });
}
function promiseEach(array, func) {
  return array.length === 0 ? Promise.resolve() : array.reduce(function (previous, current) {
    return previous.then(function () {
      return func(current);
    });
  }, Promise.resolve());
}
function randomChoice() {
  for (var _len13 = arguments.length, choices = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
    choices[_key13] = arguments[_key13];
  }

  return choices[getRandomInteger(0, choices.length - 1)];
}
function sleep(timeInSeconds) {
  return new Promise(function (resolve) {
    return setTimeout(function () {
      return resolve();
    }, timeInSeconds * 1000);
  });
}
function throttle(func, thresholdInSeconds) {
  var timeout;
  var last;
  var threshold = thresholdInSeconds * 1000;
  return function () {
    var _arguments2 = arguments,
        _this2 = this;

    var now = Date.now();

    if (isNumber(last) && now < last + threshold) {
      clearTimeout(timeout);
      timeout = setTimeout(function () {
        last = now;
        func.apply(_this2, _arguments2);
      }, threshold);
    } else {
      last = now;
      func.apply(this, arguments);
    }
  };
}
function truthChain() {
  for (var _len14 = arguments.length, funcs = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
    funcs[_key14] = arguments[_key14];
  }

  return funcs.every(function (func) {
    return func();
  });
}

function getNumberOfDaysInMonth(year, month) {
  return new Date(year, month, 0).getDate();
}
function getPreviousMonthNumberOfDays(year, month) {
  return new Date(month < 0 ? year - 1 : year, month < 0 ? 11 : month, 0).getDate();
}
function getNextMonthNumberOfDays(year, month) {
  return new Date(month > 11 ? year + 1 : year, month > 11 ? 0 : month, 0).getDate();
}
function getDay(year, month, day) {
  return new Date(year, month, day).getDay();
}

export { average, clamp, compose, composeRight, countDigits, createArrayOfConsecutiveNumbers, cubicBezier, curry, cycleArray, cycleArrayNext, cycleNumber, debounce, delay, fillArraysToLargestLength, getDay, getEuclideanDistance, getMaxArraysLength, getMinArraysLength, getNextMonthNumberOfDays, getNumberOfDaysInMonth, getPreviousMonthNumberOfDays, getRandomInteger, getRangeFromNumberOrRange, hasUppercaseLetter, hypotenuse, isEmptyObject, isInteger, isKebabCase, isNullOrUndefined, isNumber, isNumberOrRange, isObject, isPromise, isRangeArray, isSnakeCase, isStringOrRegExp, isStringOrRegExpArray, isValidArrayIndex, kebabCaseToCamelCase, lerp, lowercaseFirstLetter, match, memo, numberIsWithin, once, orderRangeArray, pipe, promiseChain, promiseEach, randomChoice, randomNumber, removeExtraWhitespaces, removeNewLines, removeTabs, repeatString, replace, roundTo, sleep, snapToInterval, sum, throttle, toArray, toNumber, toString, transform, truthChain, unary, uppercaseFirstLetter };
//# sourceMappingURL=piko.js.map