trezor-link/lib/fallback.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 _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, u) {
      return function b(q) {
        while (q) {
          if (q.then) {
            q = q.then(b, e);
            return u ? undefined : q;
          }

          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 _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;
}

var FallbackTransport = (_class = function () {

  // note: activeTransport is actually "?Transport", but
  // everywhere I am using it is in `async`, so error gets returned as Promise.reject
  function FallbackTransport(transports) {
    _classCallCheck(this, FallbackTransport);

    this.name = 'FallbackTransport';
    this.activeName = '';
    this.debug = false;
    this.requestNeeded = false;

    this.transports = transports;
  }

  // first one that inits successfuly is the final one; others won't even start initing


  _createClass(FallbackTransport, [{
    key: '_tryInitTransports',
    value: function _tryInitTransports() {
      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_4) {
              return $Try_3_Finally($error)($exception_4);
            } 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, lastError, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, transport;

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

        function $Try_1_Post() {
          if (res.length === 0) {
            return $error(lastError || new Error('No transport could be initialized.'));
          }
          return $return(res);
        }

        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 = this.transports[Symbol.iterator]();
          return Function.$asyncbind.trampoline(this, $Loop_9_exit, $Loop_9_step, $Try_1_Catch, true)($Loop_9);

          function $Loop_9() {
            if (!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) {
              transport = _step.value;

              function $Try_2_Post() {
                return $Loop_9_step;
              }

              var $Try_2_Catch = function (e) {
                lastError = e;
                return $Try_2_Post.call(this);
              }.$asyncbind(this, $Try_1_Catch);
              try {
                return transport.init(this.debug).then(function ($await_13) {
                  res.push(transport);
                  return $Try_2_Post.call(this);
                }.$asyncbind(this, $Try_2_Catch), $Try_2_Catch);
              } catch (e) {
                $Try_2_Catch(e)
              }
            } else return [1];
          }

          function $Loop_9_step() {
            _iteratorNormalCompletion = true;
            return $Loop_9;
          }

          function $Loop_9_exit() {
            return $Try_1_Finally($Try_1_Post).call(this);
          }
        } catch (err) {
          $Try_1_Catch(err)
        }
      }.$asyncbind(this));
    }

    // first one that inits successfuly is the final one; others won't even start initing

  }, {
    key: '_tryConfigureTransports',
    value: function _tryConfigureTransports(data) {
      return new Promise(function ($return, $error) {
        var $Try_5_Finally = function ($Try_5_Exit) {
          return function ($Try_5_Value) {
            try {
              if (!_iteratorNormalCompletion2 && _iterator2.return) {
                _iterator2.return();
              }
            } catch ($exception_8) {
              return $Try_7_Finally($error)($exception_8);
            } finally {
              if (_didIteratorError2) {
                return $error(_iteratorError2);
              }
            }

            return $Try_5_Exit && $Try_5_Exit.call(this, $Try_5_Value);
          }.$asyncbind(this, $error);
        }.$asyncbind(this);

        var lastError, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, transport;

        lastError = null;
        _iteratorNormalCompletion2 = true;
        _didIteratorError2 = false;
        _iteratorError2 = undefined;

        function $Try_5_Post() {
          return $error(lastError || new Error('No transport could be initialized.'));
        }

        var $Try_5_Catch = function (err) {
          _didIteratorError2 = true;
          _iteratorError2 = err;
          return $Try_5_Finally($Try_5_Post).call(this);
        }.$asyncbind(this, $Try_5_Finally($error));
        try {
          _iterator2 = this._availableTransports[Symbol.iterator]();
          return Function.$asyncbind.trampoline(this, $Loop_11_exit, $Loop_11_step, $Try_5_Catch, true)($Loop_11);

          function $Loop_11() {
            if (!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) {
              transport = _step2.value;
              var $Try_6_Catch = function (e) {
                lastError = e;
                return $Loop_11_step;
              }.$asyncbind(this, $Try_5_Catch);
              try {
                return transport.configure(data).then(function ($await_14) {
                  return $Try_5_Finally($return)(transport);
                }.$asyncbind(this, $Try_6_Catch), $Try_6_Catch);
              } catch (e) {
                $Try_6_Catch(e)
              }
            } else return [1];
          }

          function $Loop_11_step() {
            _iteratorNormalCompletion2 = true;
            return $Loop_11;
          }

          function $Loop_11_exit() {
            return $Try_5_Finally($Try_5_Post).call(this);
          }
        } catch (err) {
          $Try_5_Catch(err)
        }
      }.$asyncbind(this));
    }
  }, {
    key: 'init',
    value: function init(debug) {
      return new Promise(function ($return, $error) {
        var transports;

        this.debug = !!debug;

        // init ALL OF THEM
        return this._tryInitTransports().then(function ($await_15) {
          transports = $await_15;
          this._availableTransports = transports;

          // a slight hack - configured is always false, so we force caller to call configure()
          // to find out the actual working transport (bridge falls on configure, not on info)
          this.version = transports[0].version;
          this.configured = false;
          return $return();
        }.$asyncbind(this, $error), $error);
      }.$asyncbind(this));
    }
  }, {
    key: 'configure',
    value: function configure(signedData) {
      return new Promise(function ($return, $error) {
        return this._tryConfigureTransports(signedData).then(function ($await_16) {
          this.activeTransport = $await_16;
          this.configured = this.activeTransport.configured;
          this.version = this.activeTransport.version;
          this.activeName = this.activeTransport.name;
          this.requestNeeded = this.activeTransport.requestNeeded;
          return $return();
        }.$asyncbind(this, $error), $error);
      }.$asyncbind(this));
    }

    // using async so I get Promise.recect on this.activeTransport == null (or other error), not Error

  }, {
    key: 'enumerate',
    value: function enumerate() {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.enumerate());
      }.$asyncbind(this));
    }
  }, {
    key: 'listen',
    value: function listen(old) {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.listen(old));
      }.$asyncbind(this));
    }
  }, {
    key: 'acquire',
    value: function acquire(input) {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.acquire(input));
      }.$asyncbind(this));
    }
  }, {
    key: 'release',
    value: function release(session) {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.release(session));
      }.$asyncbind(this));
    }
  }, {
    key: 'call',
    value: function call(session, name, data) {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.call(session, name, data));
      }.$asyncbind(this));
    }
  }, {
    key: 'requestDevice',
    value: function requestDevice() {
      return new Promise(function ($return, $error) {
        return $return(this.activeTransport.requestDevice());
      }.$asyncbind(this));
    }
  }]);

  return FallbackTransport;
}(), (_applyDecoratedDescriptor(_class.prototype, 'init', [_debugDecorator.debugInOut], Object.getOwnPropertyDescriptor(_class.prototype, 'init'), _class.prototype)), _class);
exports.default = FallbackTransport;
module.exports = exports['default'];