trezor-link/lib/parallel.js

'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _desc, _value, _class;

var _debugDecorator = require('./debug-decorator');

Function.prototype.$asyncbind = function $asyncbind(self, catcher) {
  'use strict';

  if (!Function.prototype.$asyncbind) {
    Object.defineProperty(Function.prototype, '$asyncbind', {
      value: $asyncbind,
      enumerable: false,
      configurable: true,
      writable: true
    });
  }

  if (!$asyncbind.trampoline) {
    $asyncbind.trampoline = function trampoline(t, x, s, e) {
      return function b(q) {
        while (q) {
          if (q.then) return q.then(b, e);

          try {
            if (q.pop) {
              if (q.length) return q.pop() ? x.call(t) : q;
              q = s;
            } else q = q.call(t);
          } catch (r) {
            return e(r);
          }
        }
      };
    };
  }

  if (!$asyncbind.LazyThenable) {
    $asyncbind.LazyThenable = function () {
      function isThenable(obj) {
        return obj && obj instanceof Object && typeof obj.then === 'function';
      }

      function resolution(p, r, how) {
        try {
          var x = how ? how(r) : r;
          if (p === x) return p.reject(new TypeError('Promise resolution loop'));

          if (isThenable(x)) {
            x.then(function (y) {
              resolution(p, y);
            }, function (e) {
              p.reject(e);
            });
          } else {
            p.resolve(x);
          }
        } catch (ex) {
          p.reject(ex);
        }
      }

      function Chained() {}

      ;
      Chained.prototype = {
        resolve: _unchained,
        reject: _unchained,
        then: thenChain
      };

      function _unchained(v) {}

      function thenChain(res, rej) {
        this.resolve = res;
        this.reject = rej;
      }

      function then(res, rej) {
        var chain = new Chained();

        try {
          this._resolver(function (value) {
            return isThenable(value) ? value.then(res, rej) : resolution(chain, value, res);
          }, function (ex) {
            resolution(chain, ex, rej);
          });
        } catch (ex) {
          resolution(chain, ex, rej);
        }

        return chain;
      }

      function Thenable(resolver) {
        this._resolver = resolver;
        this.then = then;
      }

      ;

      Thenable.resolve = function (v) {
        return Thenable.isThenable(v) ? v : {
          then: function then(resolve) {
            return resolve(v);
          }
        };
      };

      Thenable.isThenable = isThenable;
      return Thenable;
    }();

    $asyncbind.EagerThenable = $asyncbind.Thenable = ($asyncbind.EagerThenableFactory = function (tick) {
      tick = tick || (typeof process === 'undefined' ? 'undefined' : _typeof(process)) === 'object' && process.nextTick || typeof setImmediate === 'function' && setImmediate || function (f) {
        setTimeout(f, 0);
      };

      var soon = function () {
        var fq = [],
            fqStart = 0,
            bufferSize = 1024;

        function callQueue() {
          while (fq.length - fqStart) {
            fq[fqStart]();
            fq[fqStart++] = undefined;

            if (fqStart === bufferSize) {
              fq.splice(0, bufferSize);
              fqStart = 0;
            }
          }
        }

        return function (fn) {
          fq.push(fn);
          if (fq.length - fqStart === 1) tick(callQueue);
        };
      }();

      function Zousan(func) {
        if (func) {
          var me = this;
          func(function (arg) {
            me.resolve(arg);
          }, function (arg) {
            me.reject(arg);
          });
        }
      }

      Zousan.prototype = {
        resolve: function resolve(value) {
          if (this.state !== undefined) return;
          if (value === this) return this.reject(new TypeError('Attempt to resolve promise with self'));
          var me = this;

          if (value && (typeof value === 'function' || (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object')) {
            try {
              var first = 0;
              var then = value.then;

              if (typeof then === 'function') {
                then.call(value, function (ra) {
                  if (!first++) {
                    me.resolve(ra);
                  }
                }, function (rr) {
                  if (!first++) {
                    me.reject(rr);
                  }
                });
                return;
              }
            } catch (e) {
              if (!first) this.reject(e);
              return;
            }
          }

          this.state = STATE_FULFILLED;
          this.v = value;
          if (me.c) soon(function () {
            for (var n = 0, l = me.c.length; n < l; n++) {
              STATE_FULFILLED(me.c[n], value);
            }
          });
        },
        reject: function reject(reason) {
          if (this.state !== undefined) return;
          this.state = STATE_REJECTED;
          this.v = reason;
          var clients = this.c;
          if (clients) soon(function () {
            for (var n = 0, l = clients.length; n < l; n++) {
              STATE_REJECTED(clients[n], reason);
            }
          });
        },
        then: function then(onF, onR) {
          var p = new Zousan();
          var client = {
            y: onF,
            n: onR,
            p: p
          };

          if (this.state === undefined) {
            if (this.c) this.c.push(client);else this.c = [client];
          } else {
            var s = this.state,
                a = this.v;
            soon(function () {
              s(client, a);
            });
          }

          return p;
        }
      };

      function STATE_FULFILLED(c, arg) {
        if (typeof c.y === 'function') {
          try {
            var yret = c.y.call(undefined, arg);
            c.p.resolve(yret);
          } catch (err) {
            c.p.reject(err);
          }
        } else c.p.resolve(arg);
      }

      function STATE_REJECTED(c, reason) {
        if (typeof c.n === 'function') {
          try {
            var yret = c.n.call(undefined, reason);
            c.p.resolve(yret);
          } catch (err) {
            c.p.reject(err);
          }
        } else c.p.reject(reason);
      }

      Zousan.resolve = function (val) {
        if (val && val instanceof Zousan) return val;
        var z = new Zousan();
        z.resolve(val);
        return z;
      };

      Zousan.reject = function (err) {
        if (err && err instanceof Zousan) return err;
        var z = new Zousan();
        z.reject(err);
        return z;
      };

      Zousan.version = '2.3.2-nodent';
      return Zousan;
    })();
  }

  var resolver = this;

  switch (catcher) {
    case true:
      return new $asyncbind.Thenable(boundThen);

    case 0:
      return new $asyncbind.LazyThenable(boundThen);

    case undefined:
      boundThen.then = boundThen;
      return boundThen;

    default:
      return function () {
        try {
          return resolver.apply(self, arguments);
        } catch (ex) {
          return catcher(ex);
        }
      };
  }

  function boundThen() {
    return resolver.apply(self, arguments);
  }
};

function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
  var desc = {};
  Object['ke' + 'ys'](descriptor).forEach(function (key) {
    desc[key] = descriptor[key];
  });
  desc.enumerable = !!desc.enumerable;
  desc.configurable = !!desc.configurable;

  if ('value' in desc || desc.initializer) {
    desc.writable = true;
  }

  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
    return decorator(target, property, desc) || desc;
  }, desc);

  if (context && desc.initializer !== void 0) {
    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
    desc.initializer = undefined;
  }

  if (desc.initializer === void 0) {
    Object['define' + 'Property'](target, property, desc);
    desc = null;
  }

  return desc;
}

function compare(a, b) {
  if (!isNaN(parseInt(a.path))) {
    return parseInt(a.path) - parseInt(b.path);
  } else {
    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
  }
}

var ParallelTransport = (_class = function () {
  function ParallelTransport(transports) {
    _classCallCheck(this, ParallelTransport);

    this.name = 'ParallelTransport';
    this.debug = false;

    this.transports = transports;
  }

  _createClass(ParallelTransport, [{
    key: '_prepend',
    value: function _prepend(name, devices) {
      return devices.map(function (device) {
        return {
          path: name + '-' + device.path,
          session: device.session == null ? null : name + '-' + device.session
        };
      });
    }
  }, {
    key: '_filter',
    value: function _filter(name, devices) {
      var _this = this;

      return devices.filter(function (device) {
        return _this._parseName(device.path).name === name;
      }).map(function (device) {
        return _extends({}, device, {
          path: _this._parseName(device.path).rest,
          session: device.session == null ? device.session : _this._parseName(device.session).rest
        });
      });
    }
  }, {
    key: '_antiFilter',
    value: function _antiFilter(name, devices) {
      var _this2 = this;

      return devices.filter(function (device) {
        return _this2._parseName(device.path).name !== name;
      }).map(function (device) {
        return _extends({}, device, {
          path: _this2._parseName(device.path).rest,
          session: device.session == null ? device.session : _this2._parseName(device.session).rest
        });
      });
    }
  }, {
    key: 'enumerate',
    value: function enumerate() {
      return new Promise(function ($return, $error) {
        var $Try_1_Finally = function ($Try_1_Exit) {
          return function ($Try_1_Value) {
            try {
              if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
              }
            } catch ($exception_3) {
              return $Try_2_Finally($error)($exception_3);
            } finally {
              if (_didIteratorError) {
                return $error(_iteratorError);
              }
            }

            return $Try_1_Exit && $Try_1_Exit.call(this, $Try_1_Value);
          }.$asyncbind(this, $error);
        }.$asyncbind(this);
        var res, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, name, devices;

        res = [];
        _iteratorNormalCompletion = true;
        _didIteratorError = false;
        _iteratorError = undefined;

        function $Try_1_Post() {
          return $return(res.sort(compare));
        }

        var $Try_1_Catch = function (err) {
          _didIteratorError = true;
          _iteratorError = err;
          return $Try_1_Finally($Try_1_Post).call(this);
        }.$asyncbind(this, $Try_1_Finally($error));

        try {
          _iterator = Object.keys(this.transports)[Symbol.iterator]();
          return Function.$asyncbind.trampoline(this, $Loop_12_exit, $Loop_12_step, $Try_1_Catch)($Loop_12);
          function $Loop_12() {
            if (!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) {
              name = _step.value;
              return this.transports[name].enumerate().then(function ($await_18) {
                devices = $await_18;
                res.push.apply(res, _toConsumableArray(this._prepend(name, devices)));
                return $Loop_12_step;
              }.$asyncbind(this, $Try_1_Catch), $Try_1_Catch);
            } else return [1];
          }

          function $Loop_12_step() {
            _iteratorNormalCompletion = true;
            return $Loop_12;
          }

          function $Loop_12_exit() {
            return $Try_1_Finally($Try_1_Post).call(this);
          }
        } catch (err) {
          $Try_1_Catch(err)
        }
      }.$asyncbind(this));
    }
  }, {
    key: 'listen',
    value: function listen(old) {
      return new Promise(function ($return, $error) {
        var _this3, promises, _ref, name, devices, antiFiltered, prepended;

        _this3 = this;

        promises = Object.keys(this.transports).map(function (name) {
          return new Promise(function ($return, $error) {
            var oldFiltered, devices;

            oldFiltered = old == null ? null : _this3._filter(name, old);
            return _this3.transports[name].listen(oldFiltered).then(function ($await_19) {
              devices = $await_19;
              return $return({ name: name, devices: devices });
            }.$asyncbind(this, $error), $error);
          }.$asyncbind(this));
        });

        return Promise.race(promises).then(function ($await_20) {
          _ref = $await_20;
          name = _ref.name;
          devices = _ref.devices;


          antiFiltered = old == null ? [] : this._antiFilter(name, old);
          prepended = this._prepend(name, devices);

          return $return(antiFiltered.concat(prepended).sort(compare));
        }.$asyncbind(this, $error), $error);
      }.$asyncbind(this));
    }
  }, {
    key: '_parseName',
    value: function _parseName(input) {
      if (input == null) {
        throw new Error('Wrong input');
      }

      var _input$split = input.split('-');

      var _input$split2 = _toArray(_input$split);

      var name = _input$split2[0];

      var restArray = _input$split2.slice(1);

      if (restArray.length === 0) {
        throw new Error('Input has to contain transport name.');
      }
      var transport = this.transports[name];
      if (transport == null) {
        throw new Error('Input has to contain valid transport name.');
      }
      var rest = restArray.join('-');

      return {
        transport: transport,
        name: name,
        rest: rest
      };
    }
  }, {
    key: 'acquire',
    value: function acquire(input) {
      return new Promise(function ($return, $error) {
        var path, previous, newInput, res;

        path = this._parseName(input.path);
        previous = input.previous == null ? null : this._parseName(input.previous);
        if (previous != null && path.name !== previous.name) {
          return $error(new Error('Session transport has to equal path transport.'));
        }
        newInput = {
          path: path.rest,
          previous: previous == null ? null : previous.rest,
          checkPrevious: input.checkPrevious
        };
        return path.transport.acquire(newInput).then(function ($await_21) {
          res = $await_21;
          return $return(path.name + '-' + res);
        }.$asyncbind(this, $error), $error);
      }.$asyncbind(this));
    }
  }, {
    key: 'release',
    value: function release(session) {
      return new Promise(function ($return, $error) {
        var sessionP = this._parseName(session);
        return $return(sessionP.transport.release(sessionP.rest));
      }.$asyncbind(this));
    }
  }, {
    key: '_checkConfigured',
    value: function _checkConfigured() {
      // configured is true if all of the transports are configured
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = Object.keys(this.transports)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var name = _step2.value;

          var transport = this.transports[name];
          if (!transport.configured) {
            return false;
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

      return true;
    }
  }, {
    key: 'configure',
    value: function configure(signedData) {
      return new Promise(function ($return, $error) {
        var $Try_6_Finally = function ($Try_6_Exit) {
          return function ($Try_6_Value) {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3.return) {
                _iterator3.return();
              }
            } catch ($exception_8) {
              return $Try_7_Finally($error)($exception_8);
            } finally {
              if (_didIteratorError3) {
                return $error(_iteratorError3);
              }
            }

            return $Try_6_Exit && $Try_6_Exit.call(this, $Try_6_Value);
          }.$asyncbind(this, $error);
        }.$asyncbind(this);
        var _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, name, transport;

        _iteratorNormalCompletion3 = true;
        _didIteratorError3 = false;
        _iteratorError3 = undefined;

        function $Try_6_Post() {
          this.configured = this._checkConfigured();
          return $return();
        }

        var $Try_6_Catch = function (err) {
          _didIteratorError3 = true;
          _iteratorError3 = err;
          return $Try_6_Finally($Try_6_Post).call(this);
        }.$asyncbind(this, $Try_6_Finally($error));
        try {
          _iterator3 = Object.keys(this.transports)[Symbol.iterator]();
          return Function.$asyncbind.trampoline(this, $Loop_14_exit, $Loop_14_step, $Try_6_Catch)($Loop_14);
          function $Loop_14() {
            if (!(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done)) {
              name = _step3.value;

              transport = this.transports[name];
              return transport.configure(signedData).then(function ($await_22) {
                return $Loop_14_step;
              }.$asyncbind(this, $Try_6_Catch), $Try_6_Catch);
            } else return [1];
          }

          function $Loop_14_step() {
            _iteratorNormalCompletion3 = true;
            return $Loop_14;
          }

          function $Loop_14_exit() {
            return $Try_6_Finally($Try_6_Post).call(this);
          }
        } catch (err) {
          $Try_6_Catch(err)
        }
      }.$asyncbind(this));
    }
  }, {
    key: 'call',
    value: function call(session, name, data) {
      return new Promise(function ($return, $error) {
        var sessionP = this._parseName(session);
        return $return(sessionP.transport.call(sessionP.rest, name, data));
      }.$asyncbind(this));
    }

    // resolves when the transport can be used; rejects when it cannot

  }, {
    key: 'init',
    value: function init(debug) {
      return new Promise(function ($return, $error) {
        var $Try_9_Finally = function ($Try_9_Exit) {
          return function ($Try_9_Value) {
            try {
              if (!_iteratorNormalCompletion4 && _iterator4.return) {
                _iterator4.return();
              }
            } catch ($exception_11) {
              return $Try_10_Finally($error)($exception_11);
            } finally {
              if (_didIteratorError4) {
                return $error(_iteratorError4);
              }
            }

            return $Try_9_Exit && $Try_9_Exit.call(this, $Try_9_Value);
          }.$asyncbind(this, $error);
        }.$asyncbind(this);
        var version, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, name, transport;

        this.debug = !!debug;
        version = '';
        _iteratorNormalCompletion4 = true;
        _didIteratorError4 = false;
        _iteratorError4 = undefined;

        function $Try_9_Post() {
          this.version = version;
          this.configured = this._checkConfigured();
          return $return();
        }

        var $Try_9_Catch = function (err) {
          _didIteratorError4 = true;
          _iteratorError4 = err;
          return $Try_9_Finally($Try_9_Post).call(this);
        }.$asyncbind(this, $Try_9_Finally($error));
        try {
          _iterator4 = Object.keys(this.transports)[Symbol.iterator]();
          return Function.$asyncbind.trampoline(this, $Loop_16_exit, $Loop_16_step, $Try_9_Catch)($Loop_16);
          function $Loop_16() {
            if (!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done)) {
              name = _step4.value;

              transport = this.transports[name];
              return transport.init(debug).then(function ($await_23) {
                version = version + (name + ':' + transport.version + ';');
                return $Loop_16_step;
              }.$asyncbind(this, $Try_9_Catch), $Try_9_Catch);
            } else return [1];
          }

          function $Loop_16_step() {
            _iteratorNormalCompletion4 = true;
            return $Loop_16;
          }

          function $Loop_16_exit() {
            return $Try_9_Finally($Try_9_Post).call(this);
          }
        } catch (err) {
          $Try_9_Catch(err)
        }
      }.$asyncbind(this));
    }
  }]);

  return ParallelTransport;
}(), (_applyDecoratedDescriptor(_class.prototype, 'enumerate', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'enumerate'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'listen', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'listen'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'acquire', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'acquire'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'release', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'release'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'configure', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'configure'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'call', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'call'), _class.prototype), _applyDecoratedDescriptor(_class.prototype, 'init', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'init'), _class.prototype)), _class);
exports.default = ParallelTransport;
module.exports = exports['default'];