@ibrokethat/iter/lib/index.js

iteration

"use strict";

var _slicedToArray = (function () { function sliceIterator(arr, i) { 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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })();

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

const StopIteration = new Error();
const Sparse = {};

const GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
  yield 1;
});
const GeneratorFunction = GeneratorFunctionPrototype.constructor;

exports.GeneratorFunctionPrototype = GeneratorFunctionPrototype;
exports.GeneratorFunction = GeneratorFunction;

/**
  @description  returns true if a === b
  @param        {a} object
  @param        {b} function
  @return       {boolean}
*/
function eq(a, b) {

  return a === b;
}

function negate(fn, v, k) {

  return !fn(v, k);
}

function returns(o) {

  let genSet = function (v, k, type) {

    if (!r) {
      var _cache$get = cache.get(type || Array);

      var _cache$get2 = _slicedToArray(_cache$get, 2);

      r = _cache$get2[0];
      set = _cache$get2[1];
    }
    set(v, k);
  };

  let cache = new WeakMap();

  cache.set(Array, [[], function (v, k) {
    return r.push(v);
  }]);
  cache.set(Map, [new Map(), function (v, k) {
    return r.set(k, v);
  }]);
  cache.set(Set, [new Set(), function (v) {
    return r.add(v);
  }]);
  cache.set(Object, [{}, function (v, k) {
    return r[k] = v;
  }]);
  cache.set(GeneratorFunction, [null, genSet]);
  cache.set(GeneratorFunctionPrototype, [null, genSet]);

  var _cache$get3 = cache.get(o.constructor);

  var _cache$get4 = _slicedToArray(_cache$get3, 2);

  let r = _cache$get4[0];
  let set = _cache$get4[1];

  return {
    set: set,
    get: function () {
      return r;
    }
  };
}

function curry(fn) {

  //  ...args doesn't work for this return if we don't babel => as well
  return function () {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    switch (args.length) {

      case 0:

        throw new Error(fn.name + ': called with no arguments');

      case 1:

        let fn1 = args[0];

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

          return fn.apply(undefined, args.concat([fn1]));
        };

      default:

        return fn.apply(undefined, args);
    };
  };
}

function curry1(fn) {

  //  ...args doesn't work for this return if we don't babel => as well
  return function () {
    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      args[_key3] = arguments[_key3];
    }

    switch (args.length) {

      case 0:

        throw new Error(fn.name + ': called with no arguments');

      default:

        return fn.apply(undefined, args);
    };
  };
}

/**
  @description  creates an iterable object from another object
  @param        {object} object
  @return       {iterable}
*/
function iterator(object) {

  let o = typeof object === 'function' ? object() : object;

  switch (true) {

    case typeof o.entries === 'function':

      return o.entries();

    case typeof o[Symbol.iterator] === 'function':

      return o[Symbol.iterator]();

    case typeof o.next === 'function':

      return o;

    default:

      return (function* () {

        let i = 0;
        let keys = Object.keys(o);
        let len = keys.length;

        while (i < len) {

          yield [keys[i], o[keys[i++]], Object];
        }
      })();

  }
}
exports.iterator = iterator;

/**
  @descrption   applies a function to each item in an object
                after selecting most appropriate method to perform the iteration
  @param        {o} object
  @param        {fn} function
*/

function _forEach(o, fn) {

  try {
    //  fastpath
    if (typeof o !== 'function' && typeof o.length === 'number') {

      for (let i = 0, l = o.length; i < l; i++) {
        fn(o[i], i);
      }
    } else if (typeof o.entries === 'function') {

      for (let _ref of o.entries()) {
        var _ref2 = _slicedToArray(_ref, 2);

        let k = _ref2[0];
        let v = _ref2[1];

        fn(v, k);
      }
    } else if (typeof o[Symbol.iterator] === 'function') {

      for (let _ref3 of o) {
        var _ref4 = _slicedToArray(_ref3, 3);

        let k = _ref4[0];
        let v = _ref4[1];
        let type = _ref4[2];

        k = type === Set ? v : k;
        fn(v, k, type);
      }
    } else if (typeof o === 'function') {

      for (let _ref5 of o()) {
        var _ref6 = _slicedToArray(_ref5, 3);

        let k = _ref6[0];
        let v = _ref6[1];
        let type = _ref6[2];

        k = type === Set ? v : k;
        fn(v, k, type);
      }
    } else {

      let it = iterator(o);
      let data = it.next();

      while (!data.done) {
        var _data$value = _slicedToArray(data.value, 3);

        let k = _data$value[0];
        let v = _data$value[1];
        let type = _data$value[2];

        k = type === Set ? v : k;
        fn(v, k, type);
        data = it.next();
      }
    }
  } catch (e) {

    if (e !== StopIteration) {
      throw e;
    }
  }
}

let forEach = exports.forEach = curry(_forEach);

/**
  @description  pulls all the data from an iterable object into the correct data structure
  @param        {object} o
  @param        {function} fn
  @return       {iterable}
*/
function collect(o, type) {

  let r = returns(o);

  forEach(o, function (v, k, type) {
    return r.set(v, k, type);
  });

  return r.get() || returns(type).get();
}

/**
  @description  creates an iterator filter
  @param        {object} o
  @param        {function} fn
  @return       {iterable}
*/
function* _ifilter(o, fn) {

  let type = o.constructor;
  let iterable = iterator(o);
  let data = iterable.next();

  while (!data.done) {
    var _data$value2 = _slicedToArray(data.value, 3);

    let k = _data$value2[0];
    let v = _data$value2[1];
    let t = _data$value2[2];

    if (fn(v, k)) {

      yield [k, v, t || type];
    }

    data = iterable.next();
  }
}

let filter = exports.ifilter = curry(_ifilter);

/**
  @descrption   calls a function on each item in an object and returns the item if 'true'
  @param        {o} object
  @param        {fn} function
*/
function _filter(o, fn) {

  return collect(_ifilter(o, fn), o);
}

exports.filter = curry(_filter);

/**
  @description  creates an iterator map
  @param        {object} o
  @param        {function} fn
  @return       {iterable}
*/
function* _imap() {
  for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
    args[_key4] = arguments[_key4];
  }

  if (args.length === 2) {
    let o = args[0];
    let fn = args[1];

    let iterable = iterator(o);
    let data = iterable.next();
    let type = o.constructor;

    while (!data.done) {
      var _data$value3 = _slicedToArray(data.value, 3);

      let k = _data$value3[0];
      let v = _data$value3[1];
      let t = _data$value3[2];

      yield [k, fn(v, k), t || type];

      data = iterable.next();
    }
  } else {

    let fn = args.pop();
    let type = args[0].constructor;
    let iterables = map(args, iterator);
    let data = invoke(iterables, 'next');

    while (_filter(data, function (v) {
      return v.done;
    }).length === 0) {
      var _data$0$value = _slicedToArray(data[0].value, 3);

      let k = _data$0$value[0];
      let t = _data$0$value[2];

      let v = fn.apply(undefined, _toConsumableArray(pluck(data, 'value.1')));

      yield [k, v, t || type];

      data = invoke(iterables, 'next');
    }
  }
}

exports.imap = curry(_imap);

/**
  @descrption   calls a function on each item in an object and returns the result
  @param        {o} object
  @param        {fn} function
  @return       {object|array}
*/
function _map() {
  for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
    args[_key5] = arguments[_key5];
  }

  if (args.length === 2) {
    let o = args[0];
    let fn = args[1];

    if (typeof o !== 'function' && typeof o.length === 'number') {

      let r = Array(o.length);
      _forEach(o, function (v, k) {
        return r[k] = fn(v, k);
      });
      return r;
    }
  }

  return collect(_imap.apply(undefined, args), args[0]);
}

let map = exports.map = curry(_map);

/*
  @description  adds the value of each index from each object into an array
  @param        {object} o
  @param        {any} [ret]
  @return       {number}
*/
function izip() {
  for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
    args[_key6] = arguments[_key6];
  }

  if (args.length === 1) {
    return args[0];
  }
  //  => doesn't work here - weird
  return _imap.apply(undefined, args.concat([function () {
    for (var _len7 = arguments.length, args = Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
      args[_key7] = arguments[_key7];
    }

    return args;
  }]));
}
exports.izip = izip;

/*
  @description  adds the value of each index from each object into an array
  @param        {object} o
  @param        {any} [ret]
  @return       {number}
*/
function zip() {

  return collect(izip.apply(undefined, arguments), arguments[0]);
}
exports.zip = zip;

/**
  @description  take while the predicate is true
  @param        {o} object
  @param        {fn} funtion
  @return       {int|string}
*/
function* _itakeWhile(o, fn) {

  let iterable = iterator(o);
  let data = iterable.next();

  while (!data.done) {
    var _data$value4 = _slicedToArray(data.value, 3);

    let k = _data$value4[0];
    let v = _data$value4[1];
    let type = _data$value4[2];

    if (fn(v, k)) {
      yield [k, v, type];
    } else {
      break;
    }

    data = iterable.next();
  }
}

exports.itakeWhile = curry(_itakeWhile);

/**
  @description  take while the predicate is true
  @param        {o} object
  @param        {fn} funtion
  @return       {int|string}
*/
function _takeWhile(o, fn) {

  return collect(_itakeWhile(o, fn), o);
}

exports.takeWhile = curry(_takeWhile);

/**
  @description  take while the predicate is true
  @param        {o} object
  @param        {fn} funtion
  @return       {int|string}
*/
function _itake(o) {
  let n = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];

  return _itakeWhile(o, function (v, k) {
    return k < n;
  });
}

exports.itake = curry1(_itake);

function _take(o) {
  let n = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];

  return collect(_itake(o, n), o);
}

exports.take = curry1(_take);

/**
  @description  drop while the predicate is true
  @param        {o} object
  @param        {fn} funtion
  @return       {int|string}
*/
function* _idropWhile(o, fn) {

  let iterable = iterator(o);
  let take = false;
  let data = iterable.next();

  while (!data.done) {
    var _data$value5 = _slicedToArray(data.value, 3);

    let k = _data$value5[0];
    let v = _data$value5[1];
    let type = _data$value5[2];

    take = take || !fn(v, k);

    if (take) {
      yield [k, v, type];
    }

    data = iterable.next();
  }
}

exports.idropWhile = curry(_idropWhile);

/**
  @description  ignore while the predicate is true
  @param        {o} object
  @param        {fn} function
  @return       {int|string}
*/
function _dropWhile(o, fn) {

  return collect(_idropWhile(o, fn), o);
}

exports.dropWhile = curry(_dropWhile);

function _idrop(o) {
  let n = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];

  return _idropWhile(o, function (v, k) {
    return k < n;
  });
}

exports.idrop = curry1(_idrop);

function _drop(o) {
  let n = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];

  return collect(_idrop(o, n), o);
}

exports.drop = curry1(_drop);

function _groupBy(o, fn) {

  let type = o.constructor;

  let iterable = iterator(o);
  let data = iterable.next();

  var _data$value6 = _slicedToArray(data.value, 3);

  let k = _data$value6[0];
  let v = _data$value6[1];
  let t = _data$value6[2];

  let key = fn(v, k);
  let r = typeof key === 'number' ? [] : typeof key === 'string' ? {} : new Map();

  while (!data.done) {
    var _data$value7 = _slicedToArray(data.value, 3);

    let k = _data$value7[0];
    let v = _data$value7[1];
    let t = _data$value7[2];

    let key = fn(v, k);

    if (r.constructor === Map) {

      if (!r.has(key)) {

        r.set(key, returns(o));
      }
      r.get(key).set(v, k, t || type);
    } else {

      if (!r[key]) {

        r[key] = returns(o);
      }
      r[key].set(v, k, t || type);
    }

    data = iterable.next();
  }

  return map(r, function (v) {
    return v ? v.get() : null;
  });
}

exports.groupBy = curry(_groupBy);

function _indexBy(o, fn) {

  return _map(_igroupBy(o, fn), function (v, k, type) {
    return v;
  });
}

exports.indexBy = curry(_indexBy);

function _part(o, fn) {

  let iterable = iterator(o);
  let data = iterable.next();
  let t = returns(o);
  let f = returns(o);

  while (!data.done) {
    var _data$value8 = _slicedToArray(data.value, 3);

    let k = _data$value8[0];
    let v = _data$value8[1];
    let type = _data$value8[2];

    if (fn(v, k)) {
      t.set(v, k, type);
    } else {
      f.set(v, k, type);
    }

    data = iterable.next();
  }

  return [t.get(), f.get()];
}

exports.part = curry(_part);

/**
  @description  invokes the passed method on a collection of Objects and returns an Array of the values returned by each Object
  @param        {object} items
  @param        {string} method
  @param        {any} [arg1, arg2, ..., argN]
  @return       {array}
*/
function invoke(items, method) {

  let args = Array.prototype.slice.call(arguments, 2);
  let i = -1;
  let l = Array.isArray(items) ? items.length : 0;
  let res = [];

  while (++i < l) {
    res.push(items[i][method].apply(items[i], args));
  }

  return res;
}
exports.invoke = invoke;

/**
  @description  pluck values from a collection of Objects
  @param        {object} items
  @param        {string} key
  @param        {boolean} [only_existing]
  @return       {array}
*/
function pluck(items, key, only_existing) {

  only_existing = only_existing === true;

  let U;
  let i = -1;
  let l = Array.isArray(items) ? items.length : 0;
  let res = [];
  let val;

  if (key.indexOf('.') > -1) {

    return reduce(key.split('.'), function (v, k) {
      return pluck(v, k, only_existing);
    }, items);
  }

  while (++i < l) {

    val = key in Object(items[i]) ? items[i][key] : U;

    if (only_existing !== true || val !== null && val !== U) {

      res.push(val);
    }
  }

  return res;
}

exports.pluck = pluck;

function _first(o, fn) {

  let r;
  forEach(o, function (v, k) {
    if (fn(v, k)) {
      r = [v, k];
      throw StopIteration;
    }
  });
  return r;
}

let first = exports.first = curry(_first);

function _last(o, fn) {

  let r;
  forEach(o, function (v, k) {
    if (fn(v, k)) {
      r = [v, k];
    }
  });

  return r;
}

let last = exports.last = curry(_last);

/**
  @description  returns true if any of the items evaluate to true
                else returns false
  @param        {o} object
  @param        {fn} function
  @param        {object} [scope]
  @return       {boolean}
*/
function _some(o, fn) {

  return !!first(o, fn);
}

exports.some = curry(_some);

/**
  @description  returns true if all of the items evaluate to true
                else returns false
  @param        {o} object
  @param        {fn} function
  @param        {object} [scope]
  @return       {boolean}
*/
function _every(o, fn) {

  return !!!first(o, negate.bind(null, fn));
}

exports.every = curry(_every);

/**
  @description  returns the index of the first match
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _indexOf(o, el) {

  let r = first(o, eq.bind(null, el));
  return r ? r[1] : -1;
}

exports.indexOf = curry(_indexOf);

/**
  @description  returns the index|key of the first item to match the predicate function
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _findIndex(o, fn) {

  let r = first(o, fn);
  return r ? r[1] : -1;
}

exports.findIndex = curry(_findIndex);

/**
  @description  returns the value of the first item to match the predicate function
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _find(o, fn) {

  let r = first(o, fn);
  return r ? r[0] : undefined;
}

exports.find = curry(_find);

/**
  @description  returns the index of the last match
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _lastIndexOf(o, el) {

  let r = last(o, eq.bind(null, el));
  return r ? r[1] : -1;
}

exports.lastIndexOf = curry(_lastIndexOf);

/**
  @description  returns the index|key of the last item to match the predicate function
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _findLastIndex(o, fn) {

  let r = last(o, fn);
  return r ? r[1] : -1;
}

exports.findLastIndex = curry(_findLastIndex);

/**
  @description  returns the value of the first last to match the predicate function
  @param        {o} object
  @param        {any} val
  @return       {int|string}
*/
function _findLast(o, fn) {

  let r = last(o, fn);
  return r ? r[0] : undefined;
}

exports.findLast = curry(_findLast);

/**
  @description  reduces the value of the object down to a single value
  @param        {any} acc
  @param        {object} o
  @param        {function} fn
  @return       {any}
*/
function reduce(o, fn, acc) {

  let noAcc = typeof acc === 'undefined';
  let iterable;

  if (noAcc) {

    iterable = iterator(o);
    let data = iterable.next();

    if (data.done) {
      throw new TypeError("reduce() of sequence with no initial value");
    } else {
      acc = data.value[1];
    }
  } else {
    iterable = o;
  }

  forEach(iterable, function (value, key) {
    acc = fn(acc, value, key);
  });

  return acc;
}

exports.reduce = reduce;

/**
  @description  adds the values of the object
  @param        {object} o
  @param        {any} [ret]
  @return       {number}
*/
function sum(o, acc) {
  return reduce(o, function (acc, a) {
    return acc + a;
  }, acc);
}

exports.sum = sum;

function* chain() {
  for (var _len8 = arguments.length, args = Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
    args[_key8] = arguments[_key8];
  }

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

  let iterables = map(args, iterator);
  let data = iterables[0].next();

  while (true) {

    if (!data.done) {
      yield data.value;
    } else {

      if (iterables.length === 1) {
        break;
      }
      iterables.shift();
    }

    data = iterables[0].next();
  }
}

exports.chain = chain;

/**
  @description  creates a range iterable
  @param        {number} start
  @param        {number} stop
  @param        {number} [step]
  @return       {iterable}
*/
function* irange(start, stop) {
  let step = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];

  let i = 0;

  while (start <= stop) {

    yield [i++, start];
    start = start + step;
  }
}

exports.irange = irange;
//# sourceMappingURL=index.js.map