json-rpc-peer/dist/index.js

JSON-RPC 2 transport-agnostic library

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

exports.__esModule = true;
var _exportNames = {
  Peer: true
};
exports.Peer = exports.default = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));

var _map2 = _interopRequireDefault(require("lodash/map"));

var _isArray2 = _interopRequireDefault(require("lodash/isArray"));

var _forEach2 = _interopRequireDefault(require("lodash/forEach"));

var _events = require("events");

var _jsonRpcProtocol = require("json-rpc-protocol");

Object.keys(_jsonRpcProtocol).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  exports[key] = _jsonRpcProtocol[key];
});

function makeAsync(fn) {
  return function () {
    var _arguments = arguments,
        _this = this;

    return new Promise(function (resolve) {
      return resolve(fn.apply(_this, _arguments));
    });
  };
}

var parseMessage = function parseMessage(message) {
  try {
    return (0, _jsonRpcProtocol.parse)(message);
  } catch (error) {
    throw _jsonRpcProtocol.format.error(null, error);
  }
};

function defaultOnMessage(message) {
  if (message.type === "request") {
    throw new _jsonRpcProtocol.MethodNotFound(message.method);
  }
}

function noop() {}

var nextRequestId = -9007199254740991;

var Peer = function (_EventEmitter) {
  (0, _inheritsLoose2.default)(Peer, _EventEmitter);

  function Peer(onMessage) {
    var _this2;

    if (onMessage === void 0) {
      onMessage = defaultOnMessage;
    }

    _this2 = _EventEmitter.call(this) || this;
    _this2._asyncEmitError = process.nextTick.bind(process, _this2.emit.bind((0, _assertThisInitialized2.default)(_this2)), "error");
    _this2._handle = makeAsync(onMessage);
    _this2._deferreds = Object.create(null);
    return _this2;
  }

  var _proto = Peer.prototype;

  _proto._getDeferred = function _getDeferred(id) {
    var deferred = this._deferreds[id];
    delete this._deferreds[id];
    return deferred;
  };

  _proto.exec = function () {
    var _exec = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(message, data) {
      var _this3 = this;

      var results, _message, type, _message2, id, _message3, error;

      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              message = parseMessage(message);

              if (!(0, _isArray2.default)(message)) {
                _context.next = 6;
                break;
              }

              results = [];
              _context.next = 5;
              return Promise.all((0, _map2.default)(message, function (message) {
                return _this3.exec(message, data).then(function (result) {
                  if (result !== undefined) {
                    results.push(result);
                  }
                });
              }));

            case 5:
              return _context.abrupt("return", results);

            case 6:
              _message = message, type = _message.type;

              if (!(type === "error")) {
                _context.next = 15;
                break;
              }

              _message2 = message, id = _message2.id;

              if (!(id === null)) {
                _context.next = 11;
                break;
              }

              return _context.abrupt("return");

            case 11:
              _message3 = message, error = _message3.error;

              this._getDeferred(id).reject(new _jsonRpcProtocol.JsonRpcError(error.message, error.code, error.data));

              _context.next = 24;
              break;

            case 15:
              if (!(type === "response")) {
                _context.next = 19;
                break;
              }

              this._getDeferred(message.id).resolve(message.result);

              _context.next = 24;
              break;

            case 19:
              if (!(type === "notification")) {
                _context.next = 23;
                break;
              }

              this._handle(message, data).catch(noop);

              _context.next = 24;
              break;

            case 23:
              return _context.abrupt("return", this._handle(message, data).then(function (result) {
                return _jsonRpcProtocol.format.response(message.id, result === undefined ? null : result);
              }).catch(function (error) {
                return _jsonRpcProtocol.format.error(message.id, error instanceof _jsonRpcProtocol.MethodNotFound && !error.data ? new _jsonRpcProtocol.MethodNotFound(message.method) : error);
              }));

            case 24:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this);
    }));

    function exec(_x, _x2) {
      return _exec.apply(this, arguments);
    }

    return exec;
  }();

  _proto.failPendingRequests = function failPendingRequests(reason) {
    var deferreds = this._deferreds;
    (0, _forEach2.default)(deferreds, function (_ref, id) {
      var reject = _ref.reject;
      reject(reason);
      delete deferreds[id];
    });
  };

  _proto.request = function request(method, params) {
    var _this4 = this;

    return new Promise(function (resolve, reject) {
      var requestId = nextRequestId++;

      _this4.push(_jsonRpcProtocol.format.request(requestId, method, params));

      _this4._deferreds[requestId] = {
        resolve,
        reject
      };
    });
  };

  _proto.notify = function () {
    var _notify = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(method, params) {
      return _regenerator.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              this.push(_jsonRpcProtocol.format.notification(method, params));

            case 1:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

    function notify(_x3, _x4) {
      return _notify.apply(this, arguments);
    }

    return notify;
  }();

  _proto.end = function end(data, encoding, cb) {
    if (typeof data === "function") {
      process.nextTick(data);
    } else {
      if (typeof encoding === "function") {
        process.nextTick(encoding);
      } else if (typeof cb === "function") {
        process.nextTick(cb);
      }

      if (data !== undefined) {
        this.write(data);
      }
    }
  };

  _proto.pipe = function pipe(writable) {
    var _this5 = this;

    var listeners = {
      data: function data(_data) {
        return writable.write(_data);
      },
      end: function end() {
        writable.end();
        clean();
      }
    };

    var clean = function clean() {
      return (0, _forEach2.default)(listeners, function (listener, event) {
        _this5.removeListener(event, listener);
      });
    };

    (0, _forEach2.default)(listeners, function (listener, event) {
      _this5.on(event, listener);
    });
    return writable;
  };

  _proto.push = function push(data) {
    return data === null ? this.emit("end") : this.emit("data", data);
  };

  _proto.write = function write(message) {
    var _this6 = this;

    var cb;
    var n = arguments.length;

    if (n > 1 && typeof (cb = arguments[n - 1]) === "function") {
      process.nextTick(cb);
    }

    this.exec(String(message)).then(function (response) {
      if (response !== undefined) {
        _this6.push(response);
      }
    }, this._asyncEmitError);
    return true;
  };

  return Peer;
}(_events.EventEmitter);

exports.Peer = exports.default = Peer;
//# sourceMappingURL=index.js.map