awv3/plugins/sketcher/statements.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _symbol = require('babel-runtime/core-js/symbol');

var _symbol2 = _interopRequireDefault(_symbol);

var _execute = function () {
    var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(socket, tasks, factory) {
        var commands, response;
        return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
                switch (_context.prev = _context.next) {
                    case 0:
                        commands = tasks.map(function (task) {
                            return { command: 'Execute', task: task };
                        });
                        _context.next = 3;
                        return socket.request(commands, factory);

                    case 3:
                        response = _context.sent;

                        if (!response.errors.length) {
                            _context.next = 6;
                            break;
                        }

                        throw response.errors[0];

                    case 6:
                        if (!(response.results.length !== tasks.length)) {
                            _context.next = 8;
                            break;
                        }

                        throw new Error('Server returned ' + response.results.length + ' results, expected ' + tasks.length);

                    case 8:
                        return _context.abrupt('return', response.results.map(function (r, i) {
                            if (r.hint !== tasks[i]) throw new Error('Server returned result for "' + r.hint + '", expected "' + tasks[i] + '"');
                            return r.result;
                        }));

                    case 9:
                    case 'end':
                        return _context.stop();
                }
            }
        }, _callee, this);
    }));

    return function _execute(_x, _x2, _x3) {
        return _ref2.apply(this, arguments);
    };
}();

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

// Unique symbol to guarantee that external code can't resolve Statements
var resolve = (0, _symbol2.default)('resolve');

var StatementsBase = function () {
    function StatementsBase(commands, promise, res) {
        (0, _classCallCheck3.default)(this, StatementsBase);

        this.commands = commands;
        this.promise = promise;
        this[resolve] = res;
    }

    (0, _createClass3.default)(StatementsBase, [{
        key: 'then',
        value: function then(onFulfilled, onRejected) {
            return new StatementsThen(this, onFulfilled, onRejected);
        }
    }, {
        key: 'and',
        value: function and() {
            for (var _len = arguments.length, statements = Array(_len), _key = 0; _key < _len; _key++) {
                statements[_key] = arguments[_key];
            }

            return Statements.all([this].concat(statements));
        }
    }, {
        key: 'execute',
        value: function execute(socket, factory) {
            this[resolve](_execute(socket, this.commands, factory));
            return this.promise;
        }
    }], [{
        key: 'all',
        value: function all(statements) {
            return statements.length === 1 ? statements[0] : new StatementsAll(statements);
        }
    }]);
    return StatementsBase;
}();

var Statements = function (_StatementsBase) {
    (0, _inherits3.default)(Statements, _StatementsBase);

    function Statements(commands) {
        (0, _classCallCheck3.default)(this, Statements);

        var res = void 0,
            promise = new _promise2.default(function (r) {
            return res = r;
        });
        return (0, _possibleConstructorReturn3.default)(this, (Statements.__proto__ || (0, _getPrototypeOf2.default)(Statements)).call(this, commands, promise, res));
    }

    return Statements;
}(StatementsBase);

exports.default = Statements;

var StatementsAll = function (_StatementsBase2) {
    (0, _inherits3.default)(StatementsAll, _StatementsBase2);

    function StatementsAll(statements) {
        var _ref;

        (0, _classCallCheck3.default)(this, StatementsAll);
        return (0, _possibleConstructorReturn3.default)(this, (StatementsAll.__proto__ || (0, _getPrototypeOf2.default)(StatementsAll)).call(this, (_ref = []).concat.apply(_ref, (0, _toConsumableArray3.default)(statements.map(function (s) {
            return s.commands;
        }))), _promise2.default.all(statements.map(function (s) {
            return s.promise;
        })), function (promise) {
            promise.then(function (value) {
                var nresults = 0;
                // fulfill each substatement with its slice of results
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = (0, _getIterator3.default)(statements), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var s = _step.value;

                        s[resolve](_promise2.default.resolve(value.slice(nresults, nresults + s.commands.length)));
                        nresults += s.commands.length;
                    }
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }
            }, function () {
                // reject each substatement with the same rejection reason
                var _iteratorNormalCompletion2 = true;
                var _didIteratorError2 = false;
                var _iteratorError2 = undefined;

                try {
                    for (var _iterator2 = (0, _getIterator3.default)(statements), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                        var s = _step2.value;

                        s[resolve](promise);
                    }
                } catch (err) {
                    _didIteratorError2 = true;
                    _iteratorError2 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion2 && _iterator2.return) {
                            _iterator2.return();
                        }
                    } finally {
                        if (_didIteratorError2) {
                            throw _iteratorError2;
                        }
                    }
                }
            });
        }));
    }

    return StatementsAll;
}(StatementsBase);

var StatementsThen = function (_StatementsBase3) {
    (0, _inherits3.default)(StatementsThen, _StatementsBase3);

    function StatementsThen(before, onFulfilled, onRejected) {
        (0, _classCallCheck3.default)(this, StatementsThen);
        return (0, _possibleConstructorReturn3.default)(this, (StatementsThen.__proto__ || (0, _getPrototypeOf2.default)(StatementsThen)).call(this, before.commands, before.promise.then(onFulfilled, onRejected), before[resolve]));
    }

    return StatementsThen;
}(StatementsBase);