@atlaskit/teams-client 4.0.0

package/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

package/README.md

@@ -0,0 +1,9 @@
+# TeamsClient
+
+A client to retrieve team related data
+
+**Note:** This component is designed for internal Atlassian development. External contributors will
+be able to use this component but will not be able to submit issues.
+
+# Usage
+`import { teamsClient } from '@atlaskit/teams-client';`

package/client/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlaskit/teams-client/client",
+  "main": "../dist/cjs/services/index.js",
+  "module": "../dist/esm/services/index.js",
+  "module:es2019": "../dist/es2019/services/index.js",
+  "sideEffects": false,
+  "types": "../dist/types/services/index.d.ts",
+  "typesVersions": {
+    ">=4.5 <5.4": {
+      "*": [
+        "../dist/types-ts4.5/services/index.d.ts"
+      ]
+    }
+  }
+}

package/dist/cjs/common/types.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.USER_ARI_PREFIX = exports.TEAM_ARI_PREFIX = void 0;
+var USER_ARI_PREFIX = exports.USER_ARI_PREFIX = 'ari:cloud:identity::user/';
+var TEAM_ARI_PREFIX = exports.TEAM_ARI_PREFIX = 'ari:cloud:identity::team/';

package/dist/cjs/common/utils/ari.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toUserId = exports.toUserARI = exports.toTeamId = exports.toTeamARI = exports.isUserARI = exports.isTeamARI = void 0;
+var _types = require("../types");
+var isUserARI = exports.isUserARI = function isUserARI(ari) {
+  return ari.startsWith(_types.USER_ARI_PREFIX);
+};
+var toUserId = exports.toUserId = function toUserId(ari) {
+  if (isUserARI(ari)) {
+    return ari.replace(_types.USER_ARI_PREFIX, '');
+  }
+  throw new Error('Invalid UserARI');
+};
+var toUserARI = exports.toUserARI = function toUserARI(userId) {
+  return isUserARI(userId) ? userId : "".concat(_types.USER_ARI_PREFIX).concat(userId);
+};
+var isTeamARI = exports.isTeamARI = function isTeamARI(ari) {
+  return ari.startsWith(_types.TEAM_ARI_PREFIX);
+};
+var toTeamId = exports.toTeamId = function toTeamId(ari) {
+  if (isTeamARI(ari)) {
+    return ari.replace(_types.TEAM_ARI_PREFIX, '');
+  }
+  throw new Error('Invalid TeamARI');
+};
+var toTeamARI = exports.toTeamARI = function toTeamARI(teamId) {
+  return isTeamARI(teamId) ? teamId : "".concat(_types.TEAM_ARI_PREFIX).concat(teamId);
+};

package/dist/cjs/common/utils/error/index.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TeamErrorType = exports.StatusCode = exports.SLOIgnoreHttpError = exports.SLOIgnoreError = exports.HttpError = exports.GraphQLError = exports.ErrorCategory = exports.DefaultError = void 0;
+exports.doesErrorContainStatus = doesErrorContainStatus;
+exports.isAuthError = isAuthError;
+exports.isErrorStatusCode = isErrorStatusCode;
+exports.isNetworkError = isNetworkError;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _GraphQLError;
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(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; })(); }
+var ErrorCategory = exports.ErrorCategory = /*#__PURE__*/function (ErrorCategory) {
+  ErrorCategory["NotFound"] = "NotFound";
+  ErrorCategory["NotPermitted"] = "NotPermitted";
+  ErrorCategory["MalformedInput"] = "MalformedInput";
+  ErrorCategory["Internal"] = "Internal";
+  return ErrorCategory;
+}({});
+var StatusCode = exports.StatusCode = /*#__PURE__*/function (StatusCode) {
+  StatusCode[StatusCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  StatusCode[StatusCode["FORBIDDEN"] = 403] = "FORBIDDEN";
+  StatusCode[StatusCode["TIMEOUT"] = 408] = "TIMEOUT";
+  StatusCode[StatusCode["GONE"] = 410] = "GONE";
+  StatusCode[StatusCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  return StatusCode;
+}({});
+function isAuthError(error) {
+  return isErrorStatusCode(StatusCode.UNAUTHORIZED, error) || isErrorStatusCode(StatusCode.FORBIDDEN, error);
+}
+function isErrorStatusCode(statusCode, error) {
+  var _error$message;
+  if (!error) {
+    return false;
+  }
+  if (error['status'] === statusCode ||
+  // error can be `ProperNetworkError` from `packages/graphql-client/src/links/error.ts`
+  error['statusCode'] === statusCode) {
+    return true;
+  }
+  var reg = new RegExp("status (code)?.*(".concat(statusCode, ")"));
+  return !!(error !== null && error !== void 0 && (_error$message = error.message) !== null && _error$message !== void 0 && _error$message.match(reg));
+}
+function doesErrorContainStatus(statusCode, message) {
+  var reg = new RegExp("status .*(".concat(statusCode, ")"));
+  return reg.test(message);
+}
+var TeamErrorType = exports.TeamErrorType = /*#__PURE__*/function (TeamErrorType) {
+  TeamErrorType["TEAM_NOT_ACTIVE"] = "Team must be active";
+  return TeamErrorType;
+}({});
+// Extending new custom Error types with `Object.setPrototypeOf`
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+var CommonError = /*#__PURE__*/function (_Error) {
+  function CommonError(message) {
+    var _this;
+    (0, _classCallCheck2.default)(this, CommonError);
+    _this = _callSuper(this, CommonError, [message]);
+    _this.name = _this.constructor.name;
+    _this.message = message || 'UnknownError';
+    _this.stack = new Error(message).stack || '';
+    return _this;
+  }
+  (0, _inherits2.default)(CommonError, _Error);
+  return (0, _createClass2.default)(CommonError);
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+var DefaultError = exports.DefaultError = /*#__PURE__*/function (_CommonError) {
+  function DefaultError(_ref) {
+    var _this2;
+    var message = _ref.message;
+    (0, _classCallCheck2.default)(this, DefaultError);
+    _this2 = _callSuper(this, DefaultError, [message || 'UnknownError']);
+    Object.setPrototypeOf(_this2, DefaultError.prototype);
+    return _this2;
+  }
+  (0, _inherits2.default)(DefaultError, _CommonError);
+  return (0, _createClass2.default)(DefaultError);
+}(CommonError);
+/**
+ * These errors will not fail UFO experiences
+ */
+var SLOIgnoreError = exports.SLOIgnoreError = /*#__PURE__*/function (_CommonError2) {
+  function SLOIgnoreError(_ref2) {
+    var _this3;
+    var message = _ref2.message;
+    (0, _classCallCheck2.default)(this, SLOIgnoreError);
+    _this3 = _callSuper(this, SLOIgnoreError, ["SentryIgnore: ".concat(message || 'UnknownError')]);
+    Object.setPrototypeOf(_this3, SLOIgnoreError.prototype);
+    return _this3;
+  }
+  (0, _inherits2.default)(SLOIgnoreError, _CommonError2);
+  return (0, _createClass2.default)(SLOIgnoreError);
+}(CommonError);
+// Http Errors
+var HttpError = exports.HttpError = /*#__PURE__*/function (_CommonError3) {
+  function HttpError(_ref3) {
+    var _this4;
+    var message = _ref3.message,
+      status = _ref3.status,
+      traceId = _ref3.traceId,
+      path = _ref3.path;
+    (0, _classCallCheck2.default)(this, HttpError);
+    _this4 = _callSuper(this, HttpError, [message]);
+    Object.setPrototypeOf(_this4, HttpError.prototype);
+    _this4.status = status;
+    _this4.traceId = traceId;
+    _this4.path = path;
+    return _this4;
+  }
+  (0, _inherits2.default)(HttpError, _CommonError3);
+  return (0, _createClass2.default)(HttpError);
+}(CommonError);
+/**
+ * These errors will not fail UFO experiences
+ */
+var SLOIgnoreHttpError = exports.SLOIgnoreHttpError = /*#__PURE__*/function (_HttpError) {
+  function SLOIgnoreHttpError(props) {
+    var _this5;
+    (0, _classCallCheck2.default)(this, SLOIgnoreHttpError);
+    _this5 = _callSuper(this, SLOIgnoreHttpError, [props]);
+    Object.setPrototypeOf(_this5, SLOIgnoreHttpError.prototype);
+    return _this5;
+  }
+  (0, _inherits2.default)(SLOIgnoreHttpError, _HttpError);
+  return (0, _createClass2.default)(SLOIgnoreHttpError);
+}(HttpError); // Graphql Errors
+var GraphQLError = exports.GraphQLError = /*#__PURE__*/function (_CommonError4) {
+  // tslint:disable-line no-any
+
+  function GraphQLError(_ref4) {
+    var _this6;
+    var message = _ref4.message,
+      _ref4$category = _ref4.category,
+      category = _ref4$category === void 0 ? 'default' : _ref4$category,
+      fields = _ref4.fields;
+    (0, _classCallCheck2.default)(this, GraphQLError);
+    _this6 = _callSuper(this, GraphQLError, [message]);
+    Object.setPrototypeOf(_this6, GraphQLError.prototype);
+    _this6.category = category;
+    if (fields) {
+      _this6.fields = fields;
+    }
+    return _this6;
+  }
+  (0, _inherits2.default)(GraphQLError, _CommonError4);
+  return (0, _createClass2.default)(GraphQLError);
+}(CommonError);
+_GraphQLError = GraphQLError;
+(0, _defineProperty2.default)(GraphQLError, "from", function (rawErrors) {
+  var firstError = rawErrors[0];
+  var errorData = {
+    category: firstError.category,
+    message: firstError.message
+  };
+  if (firstError.fields) {
+    errorData.fields = firstError.fields.reduce(function (obj, item) {
+      obj[item.field] = item.message;
+      return obj;
+    }, {});
+  }
+  return new _GraphQLError(errorData);
+});
+function isNetworkError(error) {
+  return error && !!error.message && (
+  // Firefox
+  error.message.includes('NetworkError') ||
+  // Chrome
+  error.message.startsWith('Failed to fetch') || error.message.includes('GraphQL error: Failed to fetch') ||
+  // cancel by users or unknown reason
+  error.message.includes('GraphQL error: The operation was aborted') || error.message.includes('GraphQL error: cancelled') || error.message.includes('Abgebrochen') || error.message.includes('отменено') || error.message.includes('Сетевое соединение потеряно.') || error.message.includes('anulowane') || error.message.includes('annulé') || error.message.includes('已取消') || error.message.includes('cancelado') || error.message.includes('キャンセルしました') || error.message.includes('cancelled') || error.message.includes('Network error') ||
+  // GraphQL-wrapping network error
+  !!(error['graphQLErrors'] && error['networkError']));
+}

package/dist/cjs/common/utils/filter-null.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterNull = filterNull;
+function filterNull(x) {
+  return !!x;
+}

package/dist/cjs/common/utils/http.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchWithExponentialBackoff = exports.EXPONENTIAL_BACKOFF_RETRY_POLICY = void 0;
+exports.is5xx = is5xx;
+exports.isFetchResponse = isFetchResponse;
+exports.withExponentialBackoff = withExponentialBackoff;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var EXPONENTIAL_BACKOFF_RETRY_POLICY = exports.EXPONENTIAL_BACKOFF_RETRY_POLICY = {
+  INITIAL_DELAY: 200,
+  MAX_RETRIES: 5,
+  JITTER: true
+};
+
+/**
+ * Checks whether a status code is a 5xx HTTP code.
+ * @param {number} status HTTP status code
+ */
+function is5xx(status) {
+  return 500 <= status && status <= 599;
+}
+function isFetchResponse(data) {
+  if (!data || !data.hasOwnProperty('response')) {
+    return false;
+  }
+  return data.response instanceof Response;
+}
+
+// tslint:disable-next-line no-any
+
+// tslint:disable-next-line no-any
+var defaultRetryIfCallback = function defaultRetryIfCallback(a) {
+  return !a;
+};
+var defaultOptions = {
+  initial: 200,
+  jitter: false,
+  max: 5,
+  retryIf: defaultRetryIfCallback
+};
+/**
+ * Transparently wrap a function so that it is retried until it succeeds or reaches a max retry limit.
+ * The returned function has the same signature as the wrapped function.
+ *
+ * Modified from https://jsfiddle.net/pajtai/pLka0ow9/
+ */
+function withExponentialBackoff(toTry) {
+  var hofOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+  var initial = hofOptions.initial,
+    jitter = hofOptions.jitter,
+    max = hofOptions.max,
+    retryIf = hofOptions.retryIf;
+
+  // Initialize max retry decrementing counter (range of max...0)
+  var attemptsRemaining = max;
+
+  // Initialize delay. This will exponentially increase each retry (delay = intial * 2^n)
+  var delay = initial;
+
+  /**
+   * This function calls itself recursively until `retryIf` evaluates false or the retry limit is reached.
+   * The functioned-to-be-retried is called on each recursion.
+   */
+  return /*#__PURE__*/function () {
+    var _tryWithExponentialBackoff = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var result,
+        _args = arguments;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return toTry.apply(void 0, _args);
+          case 2:
+            result = _context.sent;
+            --attemptsRemaining;
+
+            // If tried function was unsuccessful and there are still retries remaining, retry!
+            if (!(retryIf && retryIf(result) && attemptsRemaining > 0)) {
+              _context.next = 9;
+              break;
+            }
+            _context.next = 7;
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, jitter ? Math.random() * delay : delay);
+            });
+          case 7:
+            // Exponentially increase delay
+            delay *= 2;
+
+            // Initiate retry
+            return _context.abrupt("return", tryWithExponentialBackoff.apply(void 0, _args));
+          case 9:
+            return _context.abrupt("return", result);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function tryWithExponentialBackoff() {
+      return _tryWithExponentialBackoff.apply(this, arguments);
+    }
+    return tryWithExponentialBackoff;
+  }();
+}
+var fetchWithExponentialBackoff = exports.fetchWithExponentialBackoff = withExponentialBackoff(function (url, init) {
+  return fetch(url, init);
+}, {
+  initial: EXPONENTIAL_BACKOFF_RETRY_POLICY.INITIAL_DELAY,
+  jitter: EXPONENTIAL_BACKOFF_RETRY_POLICY.JITTER,
+  max: EXPONENTIAL_BACKOFF_RETRY_POLICY.MAX_RETRIES,
+  retryIf: function retryIf(response) {
+    return is5xx(response.status);
+  }
+});

package/dist/cjs/common/utils/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isInvited", {
+  enumerable: true,
+  get: function get() {
+    return _team.isInvited;
+  }
+});
+Object.defineProperty(exports, "isMember", {
+  enumerable: true,
+  get: function get() {
+    return _team.isMember;
+  }
+});
+Object.defineProperty(exports, "isNonMember", {
+  enumerable: true,
+  get: function get() {
+    return _team.isNonMember;
+  }
+});
+Object.defineProperty(exports, "isRequestingJoin", {
+  enumerable: true,
+  get: function get() {
+    return _team.isRequestingJoin;
+  }
+});
+Object.defineProperty(exports, "sortMembersByType", {
+  enumerable: true,
+  get: function get() {
+    return _sortTeams.sortMembersByType;
+  }
+});
+var _sortTeams = require("./sort-teams");
+var _team = require("./team");

package/dist/cjs/common/utils/permissions/constants.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.vanityActions = exports.openPermissions = exports.inviteOnlyPermissions = exports.getPermissionMap = exports.allPermissions = exports.SCIMSyncTeamPermissions = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+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) { (0, _defineProperty2.default)(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; }
+var allPermissions = exports.allPermissions = function allPermissions(defaultPermission, isMember) {
+  return {
+    ADD_MEMBER_TO_TEAM: defaultPermission,
+    JOIN_TEAM: defaultPermission,
+    REQUEST_TO_JOIN: defaultPermission,
+    CANCEL_JOIN_REQUEST: defaultPermission,
+    APPROVE_JOIN_REQUEST: defaultPermission,
+    REJECT_JOIN_REQUEST: defaultPermission,
+    REMOVE_MEMBER_FROM_TEAM: defaultPermission,
+    CANCEL_INVITE: defaultPermission,
+    LEAVE_TEAM: defaultPermission && isMember,
+    EDIT_DESCRIPTION: defaultPermission,
+    EDIT_TEAM_NAME: defaultPermission,
+    EDIT_PROFILE_HEADER: defaultPermission,
+    EDIT_TEAM_LINK: defaultPermission,
+    DELETE_TEAM: defaultPermission,
+    EDIT_TEAM_SETTINGS: defaultPermission,
+    EDIT_TEAM_MEMBERSHIP: defaultPermission,
+    REMOVE_AGENT_FROM_TEAM: defaultPermission,
+    ADD_AGENT_TO_TEAM: defaultPermission
+  };
+};
+var vanityActions = exports.vanityActions = ['EDIT_DESCRIPTION', 'EDIT_TEAM_NAME', 'EDIT_PROFILE_HEADER', 'EDIT_TEAM_LINK'];
+var openPermissions = exports.openPermissions = function openPermissions(permission) {
+  return {
+    JOIN_TEAM: permission === 'FULL_READ' || permission === 'FULL_WRITE',
+    REQUEST_TO_JOIN: false,
+    CANCEL_JOIN_REQUEST: false,
+    APPROVE_JOIN_REQUEST: false,
+    REJECT_JOIN_REQUEST: false
+  };
+};
+var inviteOnlyPermissions = exports.inviteOnlyPermissions = function inviteOnlyPermissions(permission) {
+  return {
+    REQUEST_TO_JOIN: permission === 'FULL_READ',
+    CANCEL_JOIN_REQUEST: permission === 'FULL_READ'
+  };
+};
+var SCIMSyncTeamPermissions = exports.SCIMSyncTeamPermissions = function SCIMSyncTeamPermissions(isMember, isOrgAdmin) {
+  return {
+    EDIT_DESCRIPTION: isMember || isOrgAdmin,
+    EDIT_TEAM_SETTINGS: isMember || isOrgAdmin,
+    EDIT_TEAM_LINK: isMember || isOrgAdmin,
+    EDIT_TEAM_NAME: (isMember || isOrgAdmin) && (0, _platformFeatureFlags.fg)('enable_edit_team_name_external_type_teams')
+  };
+};
+var getPermissionMap = exports.getPermissionMap = function getPermissionMap(settings, permission, isMember, isOrgAdmin) {
+  if (settings === 'OPEN') {
+    return _objectSpread(_objectSpread({}, allPermissions(permission === 'FULL_WRITE', isMember)), openPermissions(permission));
+  }
+  if (settings === 'MEMBER_INVITE') {
+    return _objectSpread(_objectSpread({}, allPermissions(permission === 'FULL_WRITE', isMember)), inviteOnlyPermissions(permission));
+  } else if (settings === 'EXTERNAL') {
+    return _objectSpread(_objectSpread({}, allPermissions(false, isMember)), SCIMSyncTeamPermissions(isMember, isOrgAdmin));
+  }
+  return allPermissions(false, false);
+};

package/dist/cjs/common/utils/permissions/has-permission.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasPermission = hasPermission;
+exports.hasPermissionForAction = hasPermissionForAction;
+exports.userCan = userCan;
+var _team = require("../team");
+var _constants = require("./constants");
+function hasPermission(action, settings, permission, isPeopleBrowseEnabled, currentUserMembership, teamVisibilityPermissions) {
+  if (!isPeopleBrowseEnabled && !_constants.vanityActions.includes(action)) {
+    return false;
+  }
+  var isMemberOfTeam = (0, _team.isMember)(currentUserMembership);
+  var isOrgAdmin = Boolean(teamVisibilityPermissions === null || teamVisibilityPermissions === void 0 ? void 0 : teamVisibilityPermissions.canAdminTeams);
+  return userCan(action, {
+    membershipSettings: settings,
+    teamPermission: permission,
+    isMemberOfTeam: isMemberOfTeam,
+    isOrgAdmin: isOrgAdmin
+  });
+}
+/**
+ * Determines if a user has permission perform a given action on a team
+ */
+function userCan(action, options) {
+  return (0, _constants.getPermissionMap)(options.membershipSettings, options.teamPermission, options.isMemberOfTeam, options.isOrgAdmin)[action];
+}
+
+/**
+ * @deprecated Use `userCan` instead, it gives better visibility into the option mappings
+ */
+function hasPermissionForAction(action, settings, permission, isMemberOfTeam) {
+  var isOrgAdmin = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  return userCan(action, {
+    membershipSettings: settings,
+    teamPermission: permission,
+    isMemberOfTeam: isMemberOfTeam,
+    isOrgAdmin: isOrgAdmin
+  });
+}

package/dist/cjs/common/utils/permissions/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AllTeamActions", {
+  enumerable: true,
+  get: function get() {
+    return _types.AllTeamActions;
+  }
+});
+Object.defineProperty(exports, "hasPermission", {
+  enumerable: true,
+  get: function get() {
+    return _hasPermission.hasPermission;
+  }
+});
+Object.defineProperty(exports, "hasPermissionForAction", {
+  enumerable: true,
+  get: function get() {
+    return _hasPermission.hasPermissionForAction;
+  }
+});
+Object.defineProperty(exports, "userCan", {
+  enumerable: true,
+  get: function get() {
+    return _hasPermission.userCan;
+  }
+});
+var _hasPermission = require("./has-permission");
+var _types = require("./types");

package/dist/cjs/common/utils/permissions/types.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AllTeamActions = void 0;
+var AllTeamActions = exports.AllTeamActions = ['ADD_MEMBER_TO_TEAM', 'JOIN_TEAM', 'REQUEST_TO_JOIN', 'CANCEL_JOIN_REQUEST', 'APPROVE_JOIN_REQUEST', 'REJECT_JOIN_REQUEST', 'REMOVE_MEMBER_FROM_TEAM', 'CANCEL_INVITE', 'LEAVE_TEAM', 'REMOVE_AGENT_FROM_TEAM', 'ADD_AGENT_TO_TEAM',
+// Visual
+'EDIT_TEAM_NAME', 'EDIT_DESCRIPTION', 'EDIT_PROFILE_HEADER', 'EDIT_TEAM_LINK', 'EDIT_TEAM_SETTINGS', 'EDIT_TEAM_MEMBERSHIP',
+// Serious
+'DELETE_TEAM'];

package/dist/cjs/common/utils/sort-teams.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortMembersByType = void 0;
+var MemberType = /*#__PURE__*/function (MemberType) {
+  MemberType[MemberType["CURRENT_USER"] = 0] = "CURRENT_USER";
+  MemberType[MemberType["MEMBER"] = 1] = "MEMBER";
+  MemberType[MemberType["INVITED"] = 2] = "INVITED";
+  MemberType[MemberType["INACTIVE"] = 3] = "INACTIVE";
+  MemberType[MemberType["DELETED"] = 4] = "DELETED";
+  return MemberType;
+}(MemberType || {});
+var checkType = function checkType(member, currentAccountId) {
+  var _member$user, _member$user2;
+  if (member.membershipId.memberId === currentAccountId) {
+    return MemberType.CURRENT_USER;
+  } else if (member && member.state === 'INVITED') {
+    return MemberType.INVITED;
+  } else if (((_member$user = member.user) === null || _member$user === void 0 ? void 0 : _member$user.status) === 'inactive') {
+    return MemberType.INACTIVE;
+  } else if (((_member$user2 = member.user) === null || _member$user2 === void 0 ? void 0 : _member$user2.status) === 'closed') {
+    return MemberType.DELETED;
+  } else {
+    return MemberType.MEMBER;
+  }
+};
+var sortMembersByType = exports.sortMembersByType = function sortMembersByType(members, currentAccountId) {
+  var newMembers = members.map(function (member) {
+    return {
+      member: member,
+      type: checkType(member, currentAccountId)
+    };
+  });
+  newMembers.sort(function (_ref, _ref2) {
+    var memberA = _ref.member,
+      typeA = _ref.type;
+    var memberB = _ref2.member,
+      typeB = _ref2.type;
+    if (typeA === typeB) {
+      var _memberA$user, _memberB$user;
+      return ((_memberA$user = memberA.user) === null || _memberA$user === void 0 ? void 0 : _memberA$user.fullName.localeCompare(((_memberB$user = memberB.user) === null || _memberB$user === void 0 ? void 0 : _memberB$user.fullName) || '')) || 0;
+    } else {
+      return typeA - typeB;
+    }
+  });
+  return newMembers.map(function (_ref3) {
+    var member = _ref3.member;
+    return member;
+  });
+};

package/dist/cjs/common/utils/status-code-handlers-provider.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleResponse = handleResponse;
+exports.statusCodeHandlersProvider = void 0;
+/**
+ * Our REST clients are initialised when their module loads which makes it tricky for them to consume the `statusCodeHandlers` prop passed to App from the host application.
+ * This is a temporary measure to enable the clients to consume `statusCodeHandlers`.
+ * The long term solution is to replace our REST clients with Apollo client custom resolvers
+ * This will unify all remote data handling under the apollo-client module which is able to easily receive `statusCodeHandlers` as it is initialised within the React portion of our app.
+ */
+
+var statusCodeHandlersProvider = exports.statusCodeHandlersProvider = {
+  handlers: {},
+  get: function get() {
+    return statusCodeHandlersProvider.handlers;
+  },
+  setHandlers: function setHandlers(handlers) {
+    statusCodeHandlersProvider.handlers = handlers;
+  }
+};
+function handleResponse(response) {
+  var status = response.status;
+  var handler = statusCodeHandlersProvider.get()[status];
+  if (typeof handler === 'function') {
+    handler(response);
+  }
+}