@atlaskit/teams-client 4.0.0

package/dist/esm/services/rest-client/index.js

@@ -0,0 +1,373 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import once from 'lodash/once';
+import { HttpError, SLOIgnoreError } from '../../common/utils/error';
+import { fetchWithExponentialBackoff } from '../../common/utils/http';
+import { handleResponse } from '../../common/utils/status-code-handlers-provider';
+import { BaseClient } from '../base-client';
+import { clearCookie, getCookieAsInteger, REDIRECT_COUNT, setCookie } from './utils/cookie';
+import { parseErrorMessage } from './utils/parse-error-message';
+import { parseResponse } from './utils/parse-response';
+import { stripUUIDFromPath } from './utils/strip-uuid';
+var defaultFetchOptions = {
+  credentials: 'include',
+  headers: {
+    Accept: 'application/json'
+  },
+  mode: 'cors'
+};
+var incrementRedirectCount;
+var clearRedirectCount;
+resetRedirectCountOnceFlag();
+
+// Used by test to reset the once-ness of the functions above
+export function resetRedirectCountOnceFlag() {
+  incrementRedirectCount = once(function () {
+    return setCookie(REDIRECT_COUNT, getCookieAsInteger(REDIRECT_COUNT) + 1);
+  });
+  clearRedirectCount = once(function () {
+    return clearCookie(REDIRECT_COUNT);
+  });
+}
+export var RestClient = /*#__PURE__*/function (_BaseClient) {
+  function RestClient(_ref) {
+    var _this;
+    var _ref$serviceUrl = _ref.serviceUrl,
+      serviceUrl = _ref$serviceUrl === void 0 ? '' : _ref$serviceUrl,
+      _ref$config = _ref.config,
+      config = _ref$config === void 0 ? {
+        logException: function logException() {}
+      } : _ref$config;
+    _classCallCheck(this, RestClient);
+    _this = _callSuper(this, RestClient, [config]);
+    /**
+     * This function is necessary for if `statusCodeHandler` prescribes a login
+     * redirect upon a 401 response.
+     * While the default redirect behaviour may be overriden, this function has
+     * been kept separate to ensure it cannot be overriden, lest a host
+     * application supply embeddable-directory with a custom handler that suffers
+     * the infinite redirect bug.
+     */
+    _defineProperty(_this, "preventInfiniteRedirectLoop", function (response) {
+      if (!response.ok) {
+        var responseStatusCode = response.status;
+        if (responseStatusCode === 401) {
+          incrementRedirectCount();
+        }
+      } else {
+        clearRedirectCount();
+      }
+    });
+    _this.serviceUrl = serviceUrl;
+    return _this;
+  }
+  _inherits(RestClient, _BaseClient);
+  return _createClass(RestClient, [{
+    key: "setServiceUrl",
+    value: function setServiceUrl(serviceUrl) {
+      this.serviceUrl = serviceUrl;
+    }
+  }, {
+    key: "getResource",
+    value: function () {
+      var _getResource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(path) {
+        var fetchOptions,
+          _args = arguments;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              fetchOptions = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+              return _context.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getResource(_x) {
+        return _getResource.apply(this, arguments);
+      }
+      return getResource;
+    }()
+  }, {
+    key: "getResourceCached",
+    value: function () {
+      var _getResourceCached = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(path) {
+        var fetchOptions,
+          cacheOptions,
+          cacheKey,
+          cacheRecord,
+          response,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              fetchOptions = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+              cacheOptions = _args2.length > 2 ? _args2[2] : undefined;
+              cacheKey = path;
+              cacheRecord = this.getCachedValue(cacheKey);
+              if (!cacheRecord) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("return", cacheRecord);
+            case 6:
+              _context2.next = 8;
+              return this.getResource(path, fetchOptions);
+            case 8:
+              response = _context2.sent;
+              this.cacheValue(cacheKey, response, cacheOptions === null || cacheOptions === void 0 ? void 0 : cacheOptions.expiration);
+              return _context2.abrupt("return", response);
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getResourceCached(_x2) {
+        return _getResourceCached.apply(this, arguments);
+      }
+      return getResourceCached;
+    }()
+  }, {
+    key: "postResource",
+    value: function () {
+      var _postResource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(path, data) {
+        var fetchOptions,
+          _args3 = arguments;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              fetchOptions = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
+              return _context3.abrupt("return", this.postResourceRaw(path, JSON.stringify(data), fetchOptions));
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function postResource(_x3, _x4) {
+        return _postResource.apply(this, arguments);
+      }
+      return postResource;
+    }()
+  }, {
+    key: "postResourceRaw",
+    value: function () {
+      var _postResourceRaw = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(path, data) {
+        var fetchOptions,
+          _args4 = arguments;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              fetchOptions = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
+              fetchOptions = _objectSpread({
+                method: 'post',
+                headers: {}
+              }, fetchOptions);
+              if (data) {
+                fetchOptions = _objectSpread(_objectSpread({
+                  body: data
+                }, fetchOptions), {}, {
+                  headers: _objectSpread({
+                    'Content-Type': 'application/json'
+                  }, fetchOptions.headers)
+                });
+              }
+              return _context4.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function postResourceRaw(_x5, _x6) {
+        return _postResourceRaw.apply(this, arguments);
+      }
+      return postResourceRaw;
+    }()
+  }, {
+    key: "patchResource",
+    value: function () {
+      var _patchResource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(path, data) {
+        var fetchOptions;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              fetchOptions = {
+                /**
+                 * PATCH must be uppercase as per fetch spec only
+                 * DELETE, GET, HEAD, OPTIONS, POST, and PUT methods
+                 * are normalised to uppercase.
+                 *
+                 * https://github.com/github/fetch/issues/37
+                 * https://fetch.spec.whatwg.org/#methods
+                 */
+                method: 'PATCH'
+              };
+              if (data) {
+                fetchOptions = _objectSpread(_objectSpread({}, fetchOptions), {}, {
+                  body: JSON.stringify(data),
+                  headers: {
+                    'Content-Type': 'application/json'
+                  }
+                });
+              }
+              return _context5.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function patchResource(_x7, _x8) {
+        return _patchResource.apply(this, arguments);
+      }
+      return patchResource;
+    }()
+  }, {
+    key: "putResource",
+    value: function () {
+      var _putResource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(path, data) {
+        var additionalFetchOptions,
+          fetchOptions,
+          _args6 = arguments;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              additionalFetchOptions = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : {};
+              fetchOptions = {
+                method: 'put'
+              };
+              if (data) {
+                Object.assign(fetchOptions, {
+                  body: JSON.stringify(data),
+                  headers: {
+                    'Content-Type': 'application/json'
+                  }
+                });
+              }
+              return _context6.abrupt("return", this.makeRequest(path, _objectSpread(_objectSpread({}, fetchOptions), additionalFetchOptions)));
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function putResource(_x9, _x10) {
+        return _putResource.apply(this, arguments);
+      }
+      return putResource;
+    }()
+  }, {
+    key: "deleteResource",
+    value: function () {
+      var _deleteResource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(path) {
+        var options,
+          fetchOptions,
+          _args7 = arguments;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              options = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : {};
+              fetchOptions = _objectSpread(_objectSpread({}, options), {}, {
+                method: 'delete'
+              });
+              return _context7.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 3:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function deleteResource(_x11) {
+        return _deleteResource.apply(this, arguments);
+      }
+      return deleteResource;
+    }()
+  }, {
+    key: "makeRequest",
+    value: function () {
+      var _makeRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(path) {
+        var additionalFetchOptions,
+          url,
+          options,
+          response,
+          responseStatusCode,
+          traceId,
+          message,
+          httpError,
+          _args8 = arguments;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              additionalFetchOptions = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {
+                shouldLogError: function shouldLogError(e) {
+                  return e.status !== 429;
+                }
+              };
+              url = this.serviceUrl + path;
+              options = _objectSpread(_objectSpread({}, defaultFetchOptions), additionalFetchOptions);
+              _context8.next = 5;
+              return fetchWithExponentialBackoff(url, options);
+            case 5:
+              response = _context8.sent;
+              this.preventInfiniteRedirectLoop(response);
+              handleResponse(response);
+              responseStatusCode = response.status;
+              traceId = response.headers.get('atl-traceid');
+              if (response.ok) {
+                _context8.next = 21;
+                break;
+              }
+              if (!(responseStatusCode === 401)) {
+                _context8.next = 15;
+                break;
+              }
+              throw new SLOIgnoreError({
+                message: 'Unauthorized Request - incrementing redirect count'
+              });
+            case 15:
+              _context8.next = 17;
+              return parseErrorMessage(response);
+            case 17:
+              message = _context8.sent;
+              httpError = new HttpError({
+                message: message,
+                status: responseStatusCode,
+                traceId: traceId !== null && traceId !== void 0 ? traceId : undefined,
+                path: path
+              });
+              if (options.shouldLogError && options.shouldLogError(httpError)) {
+                this.logException(httpError, stripUUIDFromPath(path), {
+                  method: options.method || 'GET',
+                  url: url,
+                  status: responseStatusCode
+                });
+              }
+              throw httpError;
+            case 21:
+              return _context8.abrupt("return", additionalFetchOptions.ignoreResponse ? null : parseResponse(response));
+            case 22:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function makeRequest(_x12) {
+        return _makeRequest.apply(this, arguments);
+      }
+      return makeRequest;
+    }()
+  }]);
+}(BaseClient);

package/dist/esm/services/rest-client/utils/cookie.js

@@ -0,0 +1,14 @@
+export var REDIRECT_COUNT = 'redirectCount';
+export var IDENTITY_CSRF_TOKEN = 'avatar.csrf.token';
+export function setCookie(key, value) {
+  document.cookie = "".concat(key, "=").concat(value, ";path=/;max-age=30");
+}
+export function getCookieAsInteger(key) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var regex = new RegExp("".concat(key, "=(\\d+)"));
+  var result = document.cookie.match(regex);
+  return result ? parseInt(result[1], 10) : defaultValue;
+}
+export function clearCookie(key) {
+  document.cookie = "".concat(key, "=doesntmatter;path=/;expires=Thu, 01 Jan 1970 00:00:01 GMT");
+}

package/dist/esm/services/rest-client/utils/parse-error-message.js

@@ -0,0 +1,55 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export function parseErrorMessage(_x) {
+  return _parseErrorMessage.apply(this, arguments);
+}
+function _parseErrorMessage() {
+  _parseErrorMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(response) {
+    var json, text, errs;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return response.text();
+        case 2:
+          text = _context.sent;
+          _context.prev = 3;
+          json = JSON.parse(text);
+          _context.next = 10;
+          break;
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](3);
+          return _context.abrupt("return", text);
+        case 10:
+          delete json.timestamp; // to dedupe sentry, scrub non-unique 'timestamp' field from the error body
+          if (!json.error) {
+            _context.next = 15;
+            break;
+          }
+          return _context.abrupt("return", "".concat(json.status || 'UNKNOWN_STATUS', " ").concat(json.error || 'MISSING_ERROR_MESSAGE'));
+        case 15:
+          if (!json.status) {
+            _context.next = 19;
+            break;
+          }
+          return _context.abrupt("return", "".concat(json.status, " MISSING_ERROR_MESSAGE"));
+        case 19:
+          if (!json.errors) {
+            _context.next = 22;
+            break;
+          }
+          errs = json.errors.map(function (error) {
+            return typeof error === 'string' ? error : error.code || error.message || 'MISSING_ERROR_MESSAGE';
+          });
+          return _context.abrupt("return", errs.join('\n - '));
+        case 22:
+          return _context.abrupt("return", JSON.stringify(json));
+        case 23:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[3, 7]]);
+  }));
+  return _parseErrorMessage.apply(this, arguments);
+}

package/dist/esm/services/rest-client/utils/parse-response.js

@@ -0,0 +1,14 @@
+export function parseResponse(response) {
+  var responseStatusCode = response.status;
+  if (responseStatusCode === 204 || responseStatusCode === 202) {
+    return null;
+  }
+  var contentType = response.headers.get('content-type');
+  if (!contentType || contentType.includes('text/html') || contentType.includes('text/plain')) {
+    return response.text();
+  }
+  if (contentType.includes('application/json')) {
+    return response.json();
+  }
+  return null;
+}

package/dist/esm/services/rest-client/utils/strip-uuid.js

@@ -0,0 +1,4 @@
+var UUID_REGEX = new RegExp(/((\w{4,12}-?)){5}/g);
+export var stripUUIDFromPath = function stripUUIDFromPath(path) {
+  return path.replace(UUID_REGEX, '<UUID>');
+};

package/dist/esm/services/sentry/constants.js

@@ -0,0 +1,10 @@
+import { isFedRamp } from '@atlaskit/atlassian-context';
+
+// https://sentry.io/settings/atlassian-2y/projects/people-and-teams-directory/keys/
+export var SENTRY_PUBLIC_KEY = '1dc056d49dfe4df8961dc1b810e4620d';
+export var SENTRY_PROJECT_ID = '5988845';
+export var SENTRY_FEDRAMP_PUBLIC_KEY = '067abcc494be9a87b3cdf9416f2b97d5';
+export var SENTRY_FEDRAMP_PROJECT_ID = '47';
+var SENTRY_COMMERCIAL_DSN = "https://".concat(SENTRY_PUBLIC_KEY, "@o55978.ingest.sentry.io/").concat(SENTRY_PROJECT_ID);
+var SENTRY_FEDRAMP_DSN = "https://".concat(SENTRY_FEDRAMP_PUBLIC_KEY, "@sentry.atlassian-us-gov-mod.com/").concat(SENTRY_FEDRAMP_PROJECT_ID);
+export var SENTRY_DSN = isFedRamp() ? SENTRY_FEDRAMP_DSN : SENTRY_COMMERCIAL_DSN;

package/dist/esm/services/sentry/index.js

@@ -0,0 +1,2 @@
+export { addBreadcrumb, logException, logErrorMessage, logInfoMessage, createErrorHandler, logExceptionWithPackageContext, logErrorMessageWithPackageContext, logInfoMessageWithPackageContext, createErrorHandlerWithPackageContext } from './main';
+export { useTeamsSentryClientSetup } from './utils/use-teams-sentry-client-setup';

package/dist/esm/services/sentry/main.js

@@ -0,0 +1,186 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["tags"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// See Sentry accepted options in here https://docs.sentry.io/error-reporting/configuration/?platform=javascript
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+import { getSentryClient } from './utils/sentry-client';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+function decorateScope(scope, context) {
+  var tags = context.tags,
+    otherContext = _objectWithoutProperties(context, _excluded);
+  if (tags) {
+    scope.setTags(tags);
+  }
+  if (Object.keys(otherContext).length) {
+    scope.setExtras(otherContext);
+  }
+  return scope;
+}
+export function logException(_x, _x2) {
+  return _logException.apply(this, arguments);
+}
+function _logException() {
+  _logException = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(ex, name) {
+    var context,
+      sentryClient,
+      _args = arguments;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          context = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+          _context.prev = 1;
+          _context.next = 4;
+          return getSentryClient();
+        case 4:
+          sentryClient = _context.sent;
+          if (!(!sentryClient || typeof sentryClient.captureException !== 'function')) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return");
+        case 7:
+          sentryClient.withScope(function (scope) {
+            var _context$packageName, _context$packageVersi;
+            decorateScope(scope, context);
+            scope.setTag('name', name);
+            scope.setTag('packageName', (_context$packageName = context.packageName) !== null && _context$packageName !== void 0 ? _context$packageName : 'unknown');
+            scope.setTag('packageVersion', (_context$packageVersi = context.packageVersion) !== null && _context$packageVersi !== void 0 ? _context$packageVersi : 'unknown');
+            sentryClient.captureException(ex, scope);
+          });
+          _context.next = 12;
+          break;
+        case 10:
+          _context.prev = 10;
+          _context.t0 = _context["catch"](1);
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1, 10]]);
+  }));
+  return _logException.apply(this, arguments);
+}
+function logMessage(_x3, _x4) {
+  return _logMessage.apply(this, arguments);
+}
+function _logMessage() {
+  _logMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(severity, message) {
+    var context,
+      sentryClient,
+      _args2 = arguments;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          context = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+          _context2.next = 3;
+          return getSentryClient();
+        case 3:
+          sentryClient = _context2.sent;
+          if (!(!sentryClient || typeof sentryClient.captureException !== 'function')) {
+            _context2.next = 6;
+            break;
+          }
+          return _context2.abrupt("return");
+        case 6:
+          sentryClient.withScope(function (scope) {
+            var _context$packageName2, _context$packageVersi2;
+            decorateScope(scope, context);
+            // The Severity enum is being replaced by SeverityLevel type in v7 anyway
+            scope.setLevel(severity);
+            scope.setTag('packageName', (_context$packageName2 = context.packageName) !== null && _context$packageName2 !== void 0 ? _context$packageName2 : 'unknown');
+            scope.setTag('packageVersion', (_context$packageVersi2 = context.packageVersion) !== null && _context$packageVersi2 !== void 0 ? _context$packageVersi2 : 'unknown');
+            sentryClient.captureMessage(message, scope);
+          });
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _logMessage.apply(this, arguments);
+}
+export function logErrorMessage(message) {
+  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  logMessage('error', message, context).catch(function () {});
+}
+export function logInfoMessage(message) {
+  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  logMessage('info', message, context).catch(function () {});
+}
+export var createErrorHandler = function createErrorHandler(details) {
+  return function (error, message) {
+    var tags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    logException(error, message, {
+      tags: _objectSpread(_objectSpread({}, details), tags)
+    });
+  };
+};
+export var logExceptionWithPackageContext = function logExceptionWithPackageContext(packageContext) {
+  return function () {
+    // Intentionally not awaiting the promise here as we don't need the result
+    logException(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], _objectSpread(_objectSpread({}, arguments.length <= 2 ? undefined : arguments[2]), {}, {
+      packageName: packageContext.packageName,
+      packageVersion: packageContext.packageVersion
+    }));
+  };
+};
+export var logErrorMessageWithPackageContext = function logErrorMessageWithPackageContext(packageContext) {
+  return function () {
+    // Intentionally not awaiting the promise here as we don't need the result
+    logErrorMessage(arguments.length <= 0 ? undefined : arguments[0], _objectSpread(_objectSpread({}, arguments.length <= 1 ? undefined : arguments[1]), {}, {
+      packageName: packageContext.packageName,
+      packageVersion: packageContext.packageVersion
+    }));
+  };
+};
+export var logInfoMessageWithPackageContext = function logInfoMessageWithPackageContext(packageContext) {
+  return function () {
+    // Intentionally not awaiting the promise here as we don't need the result
+    logInfoMessage(arguments.length <= 0 ? undefined : arguments[0], _objectSpread(_objectSpread({}, arguments.length <= 1 ? undefined : arguments[1]), {}, {
+      packageName: packageContext.packageName,
+      packageVersion: packageContext.packageVersion
+    }));
+  };
+};
+export var createErrorHandlerWithPackageContext = function createErrorHandlerWithPackageContext(packageContext) {
+  return function () {
+    return createErrorHandler(_objectSpread(_objectSpread({}, arguments.length <= 0 ? undefined : arguments[0]), {}, {
+      packageName: packageContext.packageName,
+      packageVersion: packageContext.packageVersion
+    }));
+  };
+};
+export function addBreadcrumb(_x5) {
+  return _addBreadcrumb.apply(this, arguments);
+}
+function _addBreadcrumb() {
+  _addBreadcrumb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(crumb) {
+    var sentryClient;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return getSentryClient();
+        case 2:
+          sentryClient = _context3.sent;
+          sentryClient.withScope(function (scope) {
+            scope.addBreadcrumb(typeof crumb === 'string' ? {
+              message: crumb
+            } : crumb);
+          });
+        case 4:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _addBreadcrumb.apply(this, arguments);
+}

package/dist/esm/services/sentry/types.js

@@ -0,0 +1 @@
+export {};