@equinor/echo-framework 0.7.4 → 0.7.5

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

@@ -0,0 +1,281 @@
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+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 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; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var Errors = require('./Errors.js');
+
+var HttpClient = require('./HttpClient.js');
+
+var ILogger = require('./ILogger.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+
+var FetchHttpClient = /*#__PURE__*/function (_HttpClient$HttpClien) {
+  _inherits(FetchHttpClient, _HttpClient$HttpClien);
+
+  var _super = _createSuper(FetchHttpClient);
+
+  function FetchHttpClient(logger) {
+    var _this;
+
+    _classCallCheck(this, FetchHttpClient);
+
+    _this = _super.call(this);
+    _this._logger = logger;
+
+    if (typeof fetch === "undefined") {
+      // In order to ignore the dynamic require in webpack builds we need to do this magic
+      // @ts-ignore: TS doesn't know about these names
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require; // Cookies aren't automatically handled in Node so we need to add a CookieJar to preserve cookies across requests
+
+      _this._jar = new (requireFunc("tough-cookie").CookieJar)();
+      _this._fetchType = requireFunc("node-fetch"); // node-fetch doesn't have a nice API for getting and setting cookies
+      // fetch-cookie will wrap a fetch implementation with a default CookieJar or a provided one
+
+      _this._fetchType = requireFunc("fetch-cookie")(_this._fetchType, _this._jar);
+    } else {
+      _this._fetchType = fetch.bind(Utils.getGlobalThis());
+    }
+
+    if (typeof AbortController === "undefined") {
+      // In order to ignore the dynamic require in webpack builds we need to do this magic
+      // @ts-ignore: TS doesn't know about these names
+      var _requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require; // Node needs EventListener methods on AbortController which our custom polyfill doesn't provide
+
+
+      _this._abortControllerType = _requireFunc("abort-controller");
+    } else {
+      _this._abortControllerType = AbortController;
+    }
+
+    return _this;
+  }
+  /** @inheritDoc */
+
+
+  _createClass(FetchHttpClient, [{
+    key: "send",
+    value: function () {
+      var _send = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(request) {
+        var _this2 = this;
+
+        var abortController, error, timeoutId, msTimeout, response, errorMessage, content, payload;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(request.abortSignal && request.abortSignal.aborted)) {
+                  _context.next = 2;
+                  break;
+                }
+
+                throw new Errors.AbortError();
+
+              case 2:
+                if (request.method) {
+                  _context.next = 4;
+                  break;
+                }
+
+                throw new Error("No method defined.");
+
+              case 4:
+                if (request.url) {
+                  _context.next = 6;
+                  break;
+                }
+
+                throw new Error("No url defined.");
+
+              case 6:
+                abortController = new this._abortControllerType();
+
+                // Hook our abortSignal into the abort controller
+                if (request.abortSignal) {
+                  request.abortSignal.onabort = function () {
+                    abortController.abort();
+                    error = new Errors.AbortError();
+                  };
+                } // If a timeout has been passed in, setup a timeout to call abort
+                // Type needs to be any to fit window.setTimeout and NodeJS.setTimeout
+
+
+                timeoutId = null;
+
+                if (request.timeout) {
+                  msTimeout = request.timeout;
+                  timeoutId = setTimeout(function () {
+                    abortController.abort();
+
+                    _this2._logger.log(ILogger.LogLevel.Warning, "Timeout from HTTP request.");
+
+                    error = new Errors.TimeoutError();
+                  }, msTimeout);
+                }
+
+                _context.prev = 10;
+                _context.next = 13;
+                return this._fetchType(request.url, {
+                  body: request.content,
+                  cache: "no-cache",
+                  credentials: request.withCredentials === true ? "include" : "same-origin",
+                  headers: _objectSpread({
+                    "Content-Type": "text/plain;charset=UTF-8",
+                    "X-Requested-With": "XMLHttpRequest"
+                  }, request.headers),
+                  method: request.method,
+                  mode: "cors",
+                  redirect: "follow",
+                  signal: abortController.signal
+                });
+
+              case 13:
+                response = _context.sent;
+                _context.next = 22;
+                break;
+
+              case 16:
+                _context.prev = 16;
+                _context.t0 = _context["catch"](10);
+
+                if (!error) {
+                  _context.next = 20;
+                  break;
+                }
+
+                throw error;
+
+              case 20:
+                this._logger.log(ILogger.LogLevel.Warning, "Error from HTTP request. ".concat(_context.t0, "."));
+
+                throw _context.t0;
+
+              case 22:
+                _context.prev = 22;
+
+                if (timeoutId) {
+                  clearTimeout(timeoutId);
+                }
+
+                if (request.abortSignal) {
+                  request.abortSignal.onabort = null;
+                }
+
+                return _context.finish(22);
+
+              case 26:
+                if (response.ok) {
+                  _context.next = 31;
+                  break;
+                }
+
+                _context.next = 29;
+                return deserializeContent(response, "text");
+
+              case 29:
+                errorMessage = _context.sent;
+                throw new Errors.HttpError(errorMessage || response.statusText, response.status);
+
+              case 31:
+                content = deserializeContent(response, request.responseType);
+                _context.next = 34;
+                return content;
+
+              case 34:
+                payload = _context.sent;
+                return _context.abrupt("return", new HttpClient.HttpResponse(response.status, response.statusText, payload));
+
+              case 36:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[10, 16, 22, 26]]);
+      }));
+
+      function send(_x) {
+        return _send.apply(this, arguments);
+      }
+
+      return send;
+    }()
+  }, {
+    key: "getCookieString",
+    value: function getCookieString(url) {
+      var cookies = "";
+
+      if (Utils.Platform.isNode && this._jar) {
+        // @ts-ignore: unused variable
+        this._jar.getCookies(url, function (e, c) {
+          return cookies = c.join("; ");
+        });
+      }
+
+      return cookies;
+    }
+  }]);
+
+  return FetchHttpClient;
+}(HttpClient.HttpClient);
+
+function deserializeContent(response, responseType) {
+  var content;
+
+  switch (responseType) {
+    case "arraybuffer":
+      content = response.arrayBuffer();
+      break;
+
+    case "text":
+      content = response.text();
+      break;
+
+    case "blob":
+    case "document":
+    case "json":
+      throw new Error("".concat(responseType, " is not supported."));
+
+    default:
+      content = response.text();
+      break;
+  }
+
+  return content;
+}
+
+exports.FetchHttpClient = FetchHttpClient;

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

@@ -0,0 +1,86 @@
+'use strict';
+
+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 TextMessageFormat = require('./TextMessageFormat.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+/** @private */
+
+
+var HandshakeProtocol = /*#__PURE__*/function () {
+  function HandshakeProtocol() {
+    _classCallCheck(this, HandshakeProtocol);
+  }
+
+  _createClass(HandshakeProtocol, [{
+    key: "writeHandshakeRequest",
+    value: // Handshake request is always JSON
+    function writeHandshakeRequest(handshakeRequest) {
+      return TextMessageFormat.TextMessageFormat.write(JSON.stringify(handshakeRequest));
+    }
+  }, {
+    key: "parseHandshakeResponse",
+    value: function parseHandshakeResponse(data) {
+      var messageData;
+      var remainingData;
+
+      if (Utils.isArrayBuffer(data)) {
+        // Format is binary but still need to read JSON text from handshake response
+        var binaryData = new Uint8Array(data);
+        var separatorIndex = binaryData.indexOf(TextMessageFormat.TextMessageFormat.RecordSeparatorCode);
+
+        if (separatorIndex === -1) {
+          throw new Error("Message is incomplete.");
+        } // content before separator is handshake response
+        // optional content after is additional messages
+
+
+        var responseLength = separatorIndex + 1;
+        messageData = String.fromCharCode.apply(null, Array.prototype.slice.call(binaryData.slice(0, responseLength)));
+        remainingData = binaryData.byteLength > responseLength ? binaryData.slice(responseLength).buffer : null;
+      } else {
+        var textData = data;
+
+        var _separatorIndex = textData.indexOf(TextMessageFormat.TextMessageFormat.RecordSeparator);
+
+        if (_separatorIndex === -1) {
+          throw new Error("Message is incomplete.");
+        } // content before separator is handshake response
+        // optional content after is additional messages
+
+
+        var _responseLength = _separatorIndex + 1;
+
+        messageData = textData.substring(0, _responseLength);
+        remainingData = textData.length > _responseLength ? textData.substring(_responseLength) : null;
+      } // At this point we should have just the single handshake message
+
+
+      var messages = TextMessageFormat.TextMessageFormat.parse(messageData);
+      var response = JSON.parse(messages[0]);
+
+      if (response.type) {
+        throw new Error("Expected a handshake response from the server.");
+      }
+
+      var responseMessage = response; // multiple messages could have arrived with handshake
+      // return additional data to be parsed as usual, or null if all parsed
+
+      return [remainingData, responseMessage];
+    }
+  }]);
+
+  return HandshakeProtocol;
+}();
+
+exports.HandshakeProtocol = HandshakeProtocol;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+var HeaderNames = /*#__PURE__*/_createClass(function HeaderNames() {
+  _classCallCheck(this, HeaderNames);
+});
+
+HeaderNames.Authorization = "Authorization";
+HeaderNames.Cookie = "Cookie";
+exports.HeaderNames = HeaderNames;

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

@@ -0,0 +1,82 @@
+'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 _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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/** Represents an HTTP response. */
+
+var HttpResponse = /*#__PURE__*/_createClass(function HttpResponse(statusCode, statusText, content) {
+  _classCallCheck(this, HttpResponse);
+
+  this.statusCode = statusCode;
+  this.statusText = statusText;
+  this.content = content;
+});
+/** Abstraction over an HTTP client.
+ *
+ * This class provides an abstraction over an HTTP client so that a different implementation can be provided on different platforms.
+ */
+
+
+var HttpClient = /*#__PURE__*/function () {
+  function HttpClient() {
+    _classCallCheck(this, HttpClient);
+  }
+
+  _createClass(HttpClient, [{
+    key: "get",
+    value: function get(url, options) {
+      return this.send(_objectSpread(_objectSpread({}, options), {}, {
+        method: "GET",
+        url: url
+      }));
+    }
+  }, {
+    key: "post",
+    value: function post(url, options) {
+      return this.send(_objectSpread(_objectSpread({}, options), {}, {
+        method: "POST",
+        url: url
+      }));
+    }
+  }, {
+    key: "delete",
+    value: function _delete(url, options) {
+      return this.send(_objectSpread(_objectSpread({}, options), {}, {
+        method: "DELETE",
+        url: url
+      }));
+    }
+    /** Gets all cookies that apply to the specified URL.
+     *
+     * @param url The URL that the cookies are valid for.
+     * @returns {string} A string containing all the key-value cookie pairs for the specified URL.
+     */
+    // @ts-ignore
+
+  }, {
+    key: "getCookieString",
+    value: function getCookieString(url) {
+      return "";
+    }
+  }]);
+
+  return HttpClient;
+}();
+
+exports.HttpClient = HttpClient;
+exports.HttpResponse = HttpResponse;