@equinor/echo-framework 0.7.4 → 0.7.7

package/dist/node_modules/@microsoft/signalr/dist/esm/LongPollingTransport.js

@@ -0,0 +1,444 @@
+'use strict';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var AbortController = require('./AbortController.js');
+
+var Errors = require('./Errors.js');
+
+var HeaderNames = require('./HeaderNames.js');
+
+var ILogger = require('./ILogger.js');
+
+var ITransport = require('./ITransport.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+// Not exported from 'index', this type is internal.
+
+/** @private */
+
+
+var LongPollingTransport = /*#__PURE__*/function () {
+  function LongPollingTransport(httpClient, accessTokenFactory, logger, options) {
+    _classCallCheck(this, LongPollingTransport);
+
+    this._httpClient = httpClient;
+    this._accessTokenFactory = accessTokenFactory;
+    this._logger = logger;
+    this._pollAbort = new AbortController.AbortController();
+    this._options = options;
+    this._running = false;
+    this.onreceive = null;
+    this.onclose = null;
+  } // This is an internal type, not exported from 'index' so this is really just internal.
+
+
+  _createClass(LongPollingTransport, [{
+    key: "pollAborted",
+    get: function get() {
+      return this._pollAbort.aborted;
+    }
+  }, {
+    key: "connect",
+    value: function () {
+      var _connect = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(url, transferFormat) {
+        var _Utils$getUserAgentHe, _Utils$getUserAgentHe2, name, value, headers, pollOptions, token, pollUrl, response;
+
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                Utils.Arg.isRequired(url, "url");
+                Utils.Arg.isRequired(transferFormat, "transferFormat");
+                Utils.Arg.isIn(transferFormat, ITransport.TransferFormat, "transferFormat");
+                this._url = url;
+
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Connecting."); // Allow binary format on Node and Browsers that support binary content (indicated by the presence of responseType property)
+
+
+                if (!(transferFormat === ITransport.TransferFormat.Binary && typeof XMLHttpRequest !== "undefined" && typeof new XMLHttpRequest().responseType !== "string")) {
+                  _context.next = 7;
+                  break;
+                }
+
+                throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
+
+              case 7:
+                _Utils$getUserAgentHe = Utils.getUserAgentHeader(), _Utils$getUserAgentHe2 = _slicedToArray(_Utils$getUserAgentHe, 2), name = _Utils$getUserAgentHe2[0], value = _Utils$getUserAgentHe2[1];
+                headers = _objectSpread(_defineProperty({}, name, value), this._options.headers);
+                pollOptions = {
+                  abortSignal: this._pollAbort.signal,
+                  headers: headers,
+                  timeout: 100000,
+                  withCredentials: this._options.withCredentials
+                };
+
+                if (transferFormat === ITransport.TransferFormat.Binary) {
+                  pollOptions.responseType = "arraybuffer";
+                }
+
+                _context.next = 13;
+                return this._getAccessToken();
+
+              case 13:
+                token = _context.sent;
+
+                this._updateHeaderToken(pollOptions, token); // Make initial long polling request
+                // Server uses first long polling request to finish initializing connection and it returns without data
+
+
+                pollUrl = "".concat(url, "&_=").concat(Date.now());
+
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) polling: ".concat(pollUrl, "."));
+
+                _context.next = 19;
+                return this._httpClient.get(pollUrl, pollOptions);
+
+              case 19:
+                response = _context.sent;
+
+                if (response.statusCode !== 200) {
+                  this._logger.log(ILogger.LogLevel.Error, "(LongPolling transport) Unexpected response code: ".concat(response.statusCode, ".")); // Mark running as false so that the poll immediately ends and runs the close logic
+
+
+                  this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
+                  this._running = false;
+                } else {
+                  this._running = true;
+                }
+
+                this._receiving = this._poll(this._url, pollOptions);
+
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function connect(_x, _x2) {
+        return _connect.apply(this, arguments);
+      }
+
+      return connect;
+    }()
+  }, {
+    key: "_getAccessToken",
+    value: function () {
+      var _getAccessToken2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+        return regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this._accessTokenFactory) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                _context2.next = 3;
+                return this._accessTokenFactory();
+
+              case 3:
+                return _context2.abrupt("return", _context2.sent);
+
+              case 4:
+                return _context2.abrupt("return", null);
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function _getAccessToken() {
+        return _getAccessToken2.apply(this, arguments);
+      }
+
+      return _getAccessToken;
+    }()
+  }, {
+    key: "_updateHeaderToken",
+    value: function _updateHeaderToken(request, token) {
+      if (!request.headers) {
+        request.headers = {};
+      }
+
+      if (token) {
+        request.headers[HeaderNames.HeaderNames.Authorization] = "Bearer ".concat(token);
+        return;
+      }
+
+      if (request.headers[HeaderNames.HeaderNames.Authorization]) {
+        delete request.headers[HeaderNames.HeaderNames.Authorization];
+      }
+    }
+  }, {
+    key: "_poll",
+    value: function () {
+      var _poll2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(url, pollOptions) {
+        var token, pollUrl, response;
+        return regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.prev = 0;
+
+              case 1:
+                if (!this._running) {
+                  _context3.next = 20;
+                  break;
+                }
+
+                _context3.next = 4;
+                return this._getAccessToken();
+
+              case 4:
+                token = _context3.sent;
+
+                this._updateHeaderToken(pollOptions, token);
+
+                _context3.prev = 6;
+                pollUrl = "".concat(url, "&_=").concat(Date.now());
+
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) polling: ".concat(pollUrl, "."));
+
+                _context3.next = 11;
+                return this._httpClient.get(pollUrl, pollOptions);
+
+              case 11:
+                response = _context3.sent;
+
+                if (response.statusCode === 204) {
+                  this._logger.log(ILogger.LogLevel.Information, "(LongPolling transport) Poll terminated by server.");
+
+                  this._running = false;
+                } else if (response.statusCode !== 200) {
+                  this._logger.log(ILogger.LogLevel.Error, "(LongPolling transport) Unexpected response code: ".concat(response.statusCode, ".")); // Unexpected status code
+
+
+                  this._closeError = new Errors.HttpError(response.statusText || "", response.statusCode);
+                  this._running = false;
+                } else {
+                  // Process the response
+                  if (response.content) {
+                    this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) data received. ".concat(Utils.getDataDetail(response.content, this._options.logMessageContent), "."));
+
+                    if (this.onreceive) {
+                      this.onreceive(response.content);
+                    }
+                  } else {
+                    // This is another way timeout manifest.
+                    this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+                  }
+                }
+
+                _context3.next = 18;
+                break;
+
+              case 15:
+                _context3.prev = 15;
+                _context3.t0 = _context3["catch"](6);
+
+                if (!this._running) {
+                  // Log but disregard errors that occur after stopping
+                  this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll errored after shutdown: ".concat(_context3.t0.message));
+                } else {
+                  if (_context3.t0 instanceof Errors.TimeoutError) {
+                    // Ignore timeouts and reissue the poll.
+                    this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+                  } else {
+                    // Close the connection with the error as the result.
+                    this._closeError = _context3.t0;
+                    this._running = false;
+                  }
+                }
+
+              case 18:
+                _context3.next = 1;
+                break;
+
+              case 20:
+                _context3.prev = 20;
+
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Polling complete."); // We will reach here with pollAborted==false when the server returned a response causing the transport to stop.
+                // If pollAborted==true then client initiated the stop and the stop method will raise the close event after DELETE is sent.
+
+
+                if (!this.pollAborted) {
+                  this._raiseOnClose();
+                }
+
+                return _context3.finish(20);
+
+              case 24:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[0,, 20, 24], [6, 15]]);
+      }));
+
+      function _poll(_x3, _x4) {
+        return _poll2.apply(this, arguments);
+      }
+
+      return _poll;
+    }()
+  }, {
+    key: "send",
+    value: function () {
+      var _send = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(data) {
+        return regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (this._running) {
+                  _context4.next = 2;
+                  break;
+                }
+
+                return _context4.abrupt("return", Promise.reject(new Error("Cannot send until the transport is connected")));
+
+              case 2:
+                return _context4.abrupt("return", Utils.sendMessage(this._logger, "LongPolling", this._httpClient, this._url, this._accessTokenFactory, data, this._options));
+
+              case 3:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function send(_x5) {
+        return _send.apply(this, arguments);
+      }
+
+      return send;
+    }()
+  }, {
+    key: "stop",
+    value: function () {
+      var _stop = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5() {
+        var headers, _Utils$getUserAgentHe3, _Utils$getUserAgentHe4, name, value, deleteOptions, token;
+
+        return regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stopping polling."); // Tell receiving loop to stop, abort any current request, and then wait for it to finish
+
+
+                this._running = false;
+
+                this._pollAbort.abort();
+
+                _context5.prev = 3;
+                _context5.next = 6;
+                return this._receiving;
+
+              case 6:
+                // Send DELETE to clean up long polling on the server
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) sending DELETE request to ".concat(this._url, "."));
+
+                headers = {};
+                _Utils$getUserAgentHe3 = Utils.getUserAgentHeader(), _Utils$getUserAgentHe4 = _slicedToArray(_Utils$getUserAgentHe3, 2), name = _Utils$getUserAgentHe4[0], value = _Utils$getUserAgentHe4[1];
+                headers[name] = value;
+                deleteOptions = {
+                  headers: _objectSpread(_objectSpread({}, headers), this._options.headers),
+                  timeout: this._options.timeout,
+                  withCredentials: this._options.withCredentials
+                };
+                _context5.next = 13;
+                return this._getAccessToken();
+
+              case 13:
+                token = _context5.sent;
+
+                this._updateHeaderToken(deleteOptions, token);
+
+                _context5.next = 17;
+                return this._httpClient["delete"](this._url, deleteOptions);
+
+              case 17:
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) DELETE request sent.");
+
+              case 18:
+                _context5.prev = 18;
+
+                this._logger.log(ILogger.LogLevel.Trace, "(LongPolling transport) Stop finished."); // Raise close event here instead of in polling
+                // It needs to happen after the DELETE request is sent
+
+
+                this._raiseOnClose();
+
+                return _context5.finish(18);
+
+              case 22:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this, [[3,, 18, 22]]);
+      }));
+
+      function stop() {
+        return _stop.apply(this, arguments);
+      }
+
+      return stop;
+    }()
+  }, {
+    key: "_raiseOnClose",
+    value: function _raiseOnClose() {
+      if (this.onclose) {
+        var logMessage = "(LongPolling transport) Firing onclose event.";
+
+        if (this._closeError) {
+          logMessage += " Error: " + this._closeError;
+        }
+
+        this._logger.log(ILogger.LogLevel.Trace, logMessage);
+
+        this.onclose(this._closeError);
+      }
+    }
+  }]);
+
+  return LongPollingTransport;
+}();
+
+exports.LongPollingTransport = LongPollingTransport;

package/dist/node_modules/@microsoft/signalr/dist/esm/ServerSentEventsTransport.js

@@ -0,0 +1,235 @@
+'use strict';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var ILogger = require('./ILogger.js');
+
+var ITransport = require('./ITransport.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+/** @private */
+
+
+var ServerSentEventsTransport = /*#__PURE__*/function () {
+  function ServerSentEventsTransport(httpClient, accessTokenFactory, logger, options) {
+    _classCallCheck(this, ServerSentEventsTransport);
+
+    this._httpClient = httpClient;
+    this._accessTokenFactory = accessTokenFactory;
+    this._logger = logger;
+    this._options = options;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+
+  _createClass(ServerSentEventsTransport, [{
+    key: "connect",
+    value: function () {
+      var _connect = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(url, transferFormat) {
+        var _this = this;
+
+        var token;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                Utils.Arg.isRequired(url, "url");
+                Utils.Arg.isRequired(transferFormat, "transferFormat");
+                Utils.Arg.isIn(transferFormat, ITransport.TransferFormat, "transferFormat");
+
+                this._logger.log(ILogger.LogLevel.Trace, "(SSE transport) Connecting."); // set url before accessTokenFactory because this.url is only for send and we set the auth header instead of the query string for send
+
+
+                this._url = url;
+
+                if (!this._accessTokenFactory) {
+                  _context.next = 10;
+                  break;
+                }
+
+                _context.next = 8;
+                return this._accessTokenFactory();
+
+              case 8:
+                token = _context.sent;
+
+                if (token) {
+                  url += (url.indexOf("?") < 0 ? "?" : "&") + "access_token=".concat(encodeURIComponent(token));
+                }
+
+              case 10:
+                return _context.abrupt("return", new Promise(function (resolve, reject) {
+                  var opened = false;
+
+                  if (transferFormat !== ITransport.TransferFormat.Text) {
+                    reject(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
+                    return;
+                  }
+
+                  var eventSource;
+
+                  if (Utils.Platform.isBrowser || Utils.Platform.isWebWorker) {
+                    eventSource = new _this._options.EventSource(url, {
+                      withCredentials: _this._options.withCredentials
+                    });
+                  } else {
+                    // Non-browser passes cookies via the dictionary
+                    var cookies = _this._httpClient.getCookieString(url);
+
+                    var headers = {};
+                    headers.Cookie = cookies;
+
+                    var _Utils$getUserAgentHe = Utils.getUserAgentHeader(),
+                        _Utils$getUserAgentHe2 = _slicedToArray(_Utils$getUserAgentHe, 2),
+                        name = _Utils$getUserAgentHe2[0],
+                        value = _Utils$getUserAgentHe2[1];
+
+                    headers[name] = value;
+                    eventSource = new _this._options.EventSource(url, {
+                      withCredentials: _this._options.withCredentials,
+                      headers: _objectSpread(_objectSpread({}, headers), _this._options.headers)
+                    });
+                  }
+
+                  try {
+                    eventSource.onmessage = function (e) {
+                      if (_this.onreceive) {
+                        try {
+                          _this._logger.log(ILogger.LogLevel.Trace, "(SSE transport) data received. ".concat(Utils.getDataDetail(e.data, _this._options.logMessageContent), "."));
+
+                          _this.onreceive(e.data);
+                        } catch (error) {
+                          _this._close(error);
+
+                          return;
+                        }
+                      }
+                    }; // @ts-ignore: not using event on purpose
+
+
+                    // @ts-ignore: not using event on purpose
+                    eventSource.onerror = function (e) {
+                      // EventSource doesn't give any useful information about server side closes.
+                      if (opened) {
+                        _this._close();
+                      } else {
+                        reject(new Error("EventSource failed to connect. The connection could not be found on the server," + " either the connection ID is not present on the server, or a proxy is refusing/buffering the connection." + " If you have multiple servers check that sticky sessions are enabled."));
+                      }
+                    };
+
+                    eventSource.onopen = function () {
+                      _this._logger.log(ILogger.LogLevel.Information, "SSE connected to ".concat(_this._url));
+
+                      _this._eventSource = eventSource;
+                      opened = true;
+                      resolve();
+                    };
+                  } catch (e) {
+                    reject(e);
+                    return;
+                  }
+                }));
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function connect(_x, _x2) {
+        return _connect.apply(this, arguments);
+      }
+
+      return connect;
+    }()
+  }, {
+    key: "send",
+    value: function () {
+      var _send = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(data) {
+        return regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (this._eventSource) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                return _context2.abrupt("return", Promise.reject(new Error("Cannot send until the transport is connected")));
+
+              case 2:
+                return _context2.abrupt("return", Utils.sendMessage(this._logger, "SSE", this._httpClient, this._url, this._accessTokenFactory, data, this._options));
+
+              case 3:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function send(_x3) {
+        return _send.apply(this, arguments);
+      }
+
+      return send;
+    }()
+  }, {
+    key: "stop",
+    value: function stop() {
+      this._close();
+
+      return Promise.resolve();
+    }
+  }, {
+    key: "_close",
+    value: function _close(e) {
+      if (this._eventSource) {
+        this._eventSource.close();
+
+        this._eventSource = undefined;
+
+        if (this.onclose) {
+          this.onclose(e);
+        }
+      }
+    }
+  }]);
+
+  return ServerSentEventsTransport;
+}();
+
+exports.ServerSentEventsTransport = ServerSentEventsTransport;