elliptical/lib-browser/phrases/repeat.js

Interactive natural-language interfaces

'use strict';

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _unique = require('../unique');

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

var _marked = [visit, parseChild, callParseChild].map(_regenerator2.default.mark);

var defaultProps = {
  max: Number.MAX_SAFE_INTEGER,
  min: 1,
  unique: false
};

function visit(option, _ref, traverse) {
  var props = _ref.props;
  var children = _ref.children;
  var child, modifications, trueOption;
  return _regenerator2.default.wrap(function visit$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          props = _lodash2.default.defaults({}, props, defaultProps);
          child = children[0];
          modifications = {
            result: [],
            score: 1
          };
          trueOption = _lodash2.default.assign({}, option, modifications);
          return _context.delegateYield(parseChild(0, trueOption, child, props, traverse), 't0', 5);

        case 5:
        case 'end':
          return _context.stop();
      }
    }
  }, _marked[0], this);
}

function parseChild(index, option, child, props, traverse) {
  var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, sepOutput, trueOutput;

  return _regenerator2.default.wrap(function parseChild$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          if (!(index > props.max)) {
            _context2.next = 2;
            break;
          }

          return _context2.abrupt('return');

        case 2:
          if (!(index >= props.min)) {
            _context2.next = 5;
            break;
          }

          _context2.next = 5;
          return option;

        case 5:
          if (!(index >= props.min && option.text == null)) {
            _context2.next = 7;
            break;
          }

          return _context2.abrupt('return');

        case 7:
          if (!(index > 0 && props.separator)) {
            _context2.next = 36;
            break;
          }

          _iteratorNormalCompletion = true;
          _didIteratorError = false;
          _iteratorError = undefined;
          _context2.prev = 11;
          _iterator = traverse(props.separator, option)[Symbol.iterator]();

        case 13:
          if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
            _context2.next = 20;
            break;
          }

          sepOutput = _step.value;
          trueOutput = _lodash2.default.assign({}, sepOutput, { result: option.result });
          return _context2.delegateYield(callParseChild(index, trueOutput, child, props, traverse), 't0', 17);

        case 17:
          _iteratorNormalCompletion = true;
          _context2.next = 13;
          break;

        case 20:
          _context2.next = 26;
          break;

        case 22:
          _context2.prev = 22;
          _context2.t1 = _context2['catch'](11);
          _didIteratorError = true;
          _iteratorError = _context2.t1;

        case 26:
          _context2.prev = 26;
          _context2.prev = 27;

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

        case 29:
          _context2.prev = 29;

          if (!_didIteratorError) {
            _context2.next = 32;
            break;
          }

          throw _iteratorError;

        case 32:
          return _context2.finish(29);

        case 33:
          return _context2.finish(26);

        case 34:
          _context2.next = 37;
          break;

        case 36:
          return _context2.delegateYield(callParseChild(index, option, child, props, traverse), 't2', 37);

        case 37:
        case 'end':
          return _context2.stop();
      }
    }
  }, _marked[1], this, [[11, 22, 26, 34], [27,, 29, 33]]);
}

function callParseChild(index, option, child, props, traverse) {
  var mods, trueOption, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, output, outputModifications, trueOutput;

  return _regenerator2.default.wrap(function callParseChild$(_context3) {
    while (1) {
      switch (_context3.prev = _context3.next) {
        case 0:
          mods = {
            qualifiers: [],
            arguments: [],
            categories: [],
            annotations: []
          };
          trueOption = _lodash2.default.assign({}, option, mods);
          _iteratorNormalCompletion2 = true;
          _didIteratorError2 = false;
          _iteratorError2 = undefined;
          _context3.prev = 5;
          _iterator2 = traverse(child, trueOption)[Symbol.iterator]();

        case 7:
          if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) {
            _context3.next = 17;
            break;
          }

          output = _step2.value;

          if (!(props.unique && !(0, _unique.checkAgainstResultList)(option.result, output.result))) {
            _context3.next = 11;
            break;
          }

          return _context3.abrupt('return');

        case 11:
          outputModifications = {
            result: option.result.concat(output.result),
            qualifiers: option.qualifiers.concat(output.qualifiers),
            arguments: option.arguments.concat(output.arguments),
            categories: option.categories.concat(output.categories),
            annotations: option.annotations.concat(output.annotations)
          };
          trueOutput = _lodash2.default.assign({}, output, outputModifications);
          return _context3.delegateYield(parseChild(index + 1, trueOutput, child, props, traverse), 't0', 14);

        case 14:
          _iteratorNormalCompletion2 = true;
          _context3.next = 7;
          break;

        case 17:
          _context3.next = 23;
          break;

        case 19:
          _context3.prev = 19;
          _context3.t1 = _context3['catch'](5);
          _didIteratorError2 = true;
          _iteratorError2 = _context3.t1;

        case 23:
          _context3.prev = 23;
          _context3.prev = 24;

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

        case 26:
          _context3.prev = 26;

          if (!_didIteratorError2) {
            _context3.next = 29;
            break;
          }

          throw _iteratorError2;

        case 29:
          return _context3.finish(26);

        case 30:
          return _context3.finish(23);

        case 31:
        case 'end':
          return _context3.stop();
      }
    }
  }, _marked[2], this, [[5, 19, 23, 31], [24,, 26, 30]]);
}

exports.default = { visit: visit };