elliptical/lib-browser/phrases/map.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 _utils = require('../utils');

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

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

function visit(option, _ref, traverse) {
  var props = _ref.props;
  var children = _ref.children;

  var newOption, iterator, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, output, mapped;

  return _regenerator2.default.wrap(function visit$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          // preprocess with inbound
          newOption = option;

          if (props.inbound) {
            newOption = props.inbound(option);
          }

          iterator = traverse(children[0], newOption);

          if (props.outbound) {
            _context.next = 6;
            break;
          }

          return _context.delegateYield(iterator, 't0', 5);

        case 5:
          return _context.abrupt('return');

        case 6:
          _iteratorNormalCompletion = true;
          _didIteratorError = false;
          _iteratorError = undefined;
          _context.prev = 9;
          _iterator = iterator[Symbol.iterator]();

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

          output = _step.value;

          if (!(props.skipIncomplete && !(0, _utils.isComplete)(output))) {
            _context.next = 18;
            break;
          }

          _context.next = 16;
          return output;

        case 16:
          _context.next = 25;
          break;

        case 18:
          mapped = props.outbound(output);

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

          return _context.delegateYield((0, _utils.limitIterator)(mapped, props.limit), 't1', 21);

        case 21:
          _context.next = 25;
          break;

        case 23:
          _context.next = 25;
          return mapped;

        case 25:
          _iteratorNormalCompletion = true;
          _context.next = 11;
          break;

        case 28:
          _context.next = 34;
          break;

        case 30:
          _context.prev = 30;
          _context.t2 = _context['catch'](9);
          _didIteratorError = true;
          _iteratorError = _context.t2;

        case 34:
          _context.prev = 34;
          _context.prev = 35;

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

        case 37:
          _context.prev = 37;

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

          throw _iteratorError;

        case 40:
          return _context.finish(37);

        case 41:
          return _context.finish(34);

        case 42:
        case 'end':
          return _context.stop();
      }
    }
  }, _marked[0], this, [[9, 30, 34, 42], [35,, 37, 41]]);
}

exports.default = { visit: visit };