elliptical/lib-browser/utils.js

Interactive natural-language interfaces

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

exports.isComplete = isComplete;
exports.limitIterator = limitIterator;
exports.substrings = substrings;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _smartSplit = require('smart-split');

var _smartSplit2 = _interopRequireDefault(_smartSplit);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _marked = [limitIterator, substrings].map(_regenerator2.default.mark);

function isComplete(option) {
  return !_lodash2.default.some(option.words, 'placeholder');
}

// Accepts either an iterator of Options, or an iterator of iterators of Options
function limitIterator(iterator, limit) {
  var successes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, success, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, option, mods, _mods, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, _item;

  return _regenerator2.default.wrap(function limitIterator$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!limit) {
            _context.next = 65;
            break;
          }

          successes = 0;
          _iteratorNormalCompletion = true;
          _didIteratorError = false;
          _iteratorError = undefined;
          _context.prev = 5;
          _iterator = iterator[Symbol.iterator]();

        case 7:
          if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
            _context.next = 49;
            break;
          }

          item = _step.value;
          success = false;

          if (!item[Symbol.iterator]) {
            _context.next = 40;
            break;
          }

          _iteratorNormalCompletion2 = true;
          _didIteratorError2 = false;
          _iteratorError2 = undefined;
          _context.prev = 14;
          _iterator2 = item[Symbol.iterator]();

        case 16:
          if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) {
            _context.next = 24;
            break;
          }

          option = _step2.value;
          mods = {
            callbacks: option.callbacks.concat(function () {
              success = true;
            })
          };
          _context.next = 21;
          return _lodash2.default.assign({}, option, mods);

        case 21:
          _iteratorNormalCompletion2 = true;
          _context.next = 16;
          break;

        case 24:
          _context.next = 30;
          break;

        case 26:
          _context.prev = 26;
          _context.t0 = _context['catch'](14);
          _didIteratorError2 = true;
          _iteratorError2 = _context.t0;

        case 30:
          _context.prev = 30;
          _context.prev = 31;

          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }

        case 33:
          _context.prev = 33;

          if (!_didIteratorError2) {
            _context.next = 36;
            break;
          }

          throw _iteratorError2;

        case 36:
          return _context.finish(33);

        case 37:
          return _context.finish(30);

        case 38:
          _context.next = 43;
          break;

        case 40:
          _mods = {
            callbacks: item.callbacks.concat(function () {
              success = true;
            })
          };
          _context.next = 43;
          return _lodash2.default.assign({}, item, _mods);

        case 43:

          if (success) successes++;

          if (!(limit <= successes)) {
            _context.next = 46;
            break;
          }

          return _context.abrupt('break', 49);

        case 46:
          _iteratorNormalCompletion = true;
          _context.next = 7;
          break;

        case 49:
          _context.next = 55;
          break;

        case 51:
          _context.prev = 51;
          _context.t1 = _context['catch'](5);
          _didIteratorError = true;
          _iteratorError = _context.t1;

        case 55:
          _context.prev = 55;
          _context.prev = 56;

          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }

        case 58:
          _context.prev = 58;

          if (!_didIteratorError) {
            _context.next = 61;
            break;
          }

          throw _iteratorError;

        case 61:
          return _context.finish(58);

        case 62:
          return _context.finish(55);

        case 63:
          _context.next = 95;
          break;

        case 65:
          _iteratorNormalCompletion3 = true;
          _didIteratorError3 = false;
          _iteratorError3 = undefined;
          _context.prev = 68;
          _iterator3 = iterator[Symbol.iterator]();

        case 70:
          if (_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done) {
            _context.next = 81;
            break;
          }

          _item = _step3.value;

          if (!_item[Symbol.iterator]) {
            _context.next = 76;
            break;
          }

          return _context.delegateYield(_item, 't2', 74);

        case 74:
          _context.next = 78;
          break;

        case 76:
          _context.next = 78;
          return _item;

        case 78:
          _iteratorNormalCompletion3 = true;
          _context.next = 70;
          break;

        case 81:
          _context.next = 87;
          break;

        case 83:
          _context.prev = 83;
          _context.t3 = _context['catch'](68);
          _didIteratorError3 = true;
          _iteratorError3 = _context.t3;

        case 87:
          _context.prev = 87;
          _context.prev = 88;

          if (!_iteratorNormalCompletion3 && _iterator3.return) {
            _iterator3.return();
          }

        case 90:
          _context.prev = 90;

          if (!_didIteratorError3) {
            _context.next = 93;
            break;
          }

          throw _iteratorError3;

        case 93:
          return _context.finish(90);

        case 94:
          return _context.finish(87);

        case 95:
        case 'end':
          return _context.stop();
      }
    }
  }, _marked[0], this, [[5, 51, 55, 63], [14, 26, 30, 38], [31,, 33, 37], [56,, 58, 62], [68, 83, 87, 95], [88,, 90, 94]]);
}

function substrings(input, _ref) {
  var _ref$splitOn = _ref.splitOn;
  var splitOn = _ref$splitOn === undefined ? '' : _ref$splitOn;
  var _ref$consumeAll = _ref.consumeAll;
  var consumeAll = _ref$consumeAll === undefined ? false : _ref$consumeAll;
  var _ref$greedy = _ref.greedy;
  var greedy = _ref$greedy === undefined ? false : _ref$greedy;
  var inputs, i;
  return _regenerator2.default.wrap(function substrings$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          if (!consumeAll) {
            _context2.next = 4;
            break;
          }

          _context2.next = 3;
          return input;

        case 3:
          return _context2.abrupt('return');

        case 4:
          inputs = (0, _smartSplit2.default)(input, splitOn);
          i = 0;

        case 6:
          if (!(i < inputs.length)) {
            _context2.next = 17;
            break;
          }

          if (!greedy) {
            _context2.next = 12;
            break;
          }

          _context2.next = 10;
          return inputs.slice(0, inputs.length - i).join('');

        case 10:
          _context2.next = 14;
          break;

        case 12:
          _context2.next = 14;
          return inputs.slice(0, i + 1).join('');

        case 14:
          i += 2;
          _context2.next = 6;
          break;

        case 17:
        case 'end':
          return _context2.stop();
      }
    }
  }, _marked[1], this);
}