duce/lib/index.js

Thin wrapper around the transduce library adding helpers & experimental features

"use strict";

var _classCallCheck = require("babel-runtime/helpers/class-call-check")["default"];

var _inherits = require("babel-runtime/helpers/inherits")["default"];

var _interopRequireWildcard = require("babel-runtime/helpers/interop-require-wildcard")["default"];

var _defaults = require("babel-runtime/helpers/defaults")["default"];

exports.lazySeq = lazySeq;
exports.composeArr = composeArr;
exports.iterOnce = iterOnce;
exports.__esModule = true;
// A thin wrapper over "transduce"

var _transduce = require("transduce");

var transduce = _interopRequireWildcard(_transduce);

_defaults(exports, _interopRequireWildcard(_transduce));

var isIterator = transduce.isIterator;
var isIterable = transduce.isIterable;
var Transducer = transduce.Transducer;
var iterator = transduce.iterator;
var sequence = transduce.sequence;
var protocols = transduce.protocols;
var iterSymbol = protocols.iterator;

exports.iterSymbol = iterSymbol;
var _protocols$transducer = protocols.transducer;
var tStep = _protocols$transducer.step;
var tResult = _protocols$transducer.result;

function lazySeq(t, value) {
  return iterator(sequence(t, value));
}

function composeArr(arr) {
  return function (xf) {
    var i = arr.length;
    while (i--) {
      xf = arr[i](xf);
    }
    return xf;
  };
}

var buffered = function (n) {
  return function (xf) {
    return new Buffered(n, xf);
  };
};

var Buffered = (function (_Transducer) {
  function Buffered(n, xf) {
    _classCallCheck(this, Buffered);

    _Transducer.call(this, xf);
    this.n = n;
    this.buffer = [];
  }

  _inherits(Buffered, _Transducer);

  Buffered.prototype[tStep] = function (result, value) {
    this.buffer.push(value);
    if (this.buffer.length === 3) {
      return this.xfStep(result, this.buffer);
    }
    return result;
  };

  Buffered.prototype[tResult] = function (result) {
    while (this.buffer.length > 0) {
      result = this.xfStep(result, this.buffer);
    }
    return this.xfResult(result);
  };

  return Buffered;
})(Transducer);

var flatten = function (deep) {
  return function (xf) {
    return new Flatten(xf, deep);
  };
};

var Flatten = (function (_Transducer2) {
  function Flatten(xf) {
    var deep = arguments[1] === undefined ? false : arguments[1];

    _classCallCheck(this, Flatten);

    _Transducer2.call(this, xf);
    this.deep = deep;
  }

  _inherits(Flatten, _Transducer2);

  Flatten.prototype[tStep] = function (value, input) {
    var _this3 = this;

    if (Array.isArray(input)) {
      var reducer = this.deep ? function (value, input) {
        return _this3[tStep](value, input);
      } : function (value, input) {
        return _this3.xfStep(value, input);
      };
      return reduce(reducer, value, input);
    }
    return this.xfStep(value, input);
  };

  return Flatten;
})(Transducer);

function iterOnce(val) {
  var done;
  return {
    next: function next() {
      if (done) {
        return { done: true, value: undefined };
      }done = true;
      return { done: false, value: val };
    }
  };
}

var iterdone = (function () {
  var _iterdone = {};

  _iterdone.next = function next() {
    return { done: true, value: undefined };
  };

  _iterdone[iterSymbol] = function () {
    return this;
  };

  return _iterdone;
})();

exports.iterdone = iterdone;

var FlattenIterator = exports.FlattenIterator = (function () {
  function FlattenIterator(iterator, guard) {
    _classCallCheck(this, FlattenIterator);

    this.iterator = iterator;
    this.guard = guard;
    this.complete = false;
    this.buffer = [];
    this.stack = [];
  }

  FlattenIterator.prototype.next = function next() {
    while (!this.complete && this.buffer.length === 0) {
      this.__cycle();
    }
    return this.complete && this.buffer.length === 0 ? { done: true, value: undefined } : { done: false, value: this.buffer.shift() };
  };

  FlattenIterator.prototype.__cycle = function __cycle() {
    if (!isIterator(this.iterator)) {
      throw new TypeError("Invalid iterator value: " + this.iterator);
    }

    var _iterator$next = this.iterator.next();

    var done = _iterator$next.done;
    var value = _iterator$next.value;

    if (done) {
      if (this.stack.length === 0) {
        this.complete = true;
      } else {
        this.iterator = this.stack.pop();
      }
    }
    this.__next(value);
  };

  FlattenIterator.prototype.__next = function __next(value) {
    if (typeof value === "string" || !isIterable(value) && !isIterator(value)) {
      this.buffer.push(value);
    } else if (isIterable(value) || isIterator(value)) {
      if (this.guard && this.guard(value)) {
        this.buffer.push(value);
      } else {
        this.stack.push(this.iterator);
        this.iterator = isIterator(value) ? value : iterator(value);
      }
    }
  };

  FlattenIterator.prototype[iterSymbol] = function () {
    return this;
  };

  return FlattenIterator;
})();
//# sourceMappingURL=index.js.map