@atlaskit/teams-public 2.7.0 → 2.9.0

package/dist/esm/controllers/hooks/use-team-containers/actions.js

@@ -0,0 +1,376 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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";
+import { teamsClient } from '@atlaskit/teams-client';
+import { containersDeepEqual } from './containers-deep-equal';
+import { initialConnectedTeamsState } from './initial-connected-teams-state';
+export var actions = {
+  fetchTeamContainers: function fetchTeamContainers(teamId, fireAnalytics) {
+    return /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+        var setState, getState, _getState, currentTeamId, containers, _t;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              setState = _ref.setState, getState = _ref.getState;
+              _getState = getState(), currentTeamId = _getState.teamId;
+              if (!(currentTeamId === teamId)) {
+                _context.next = 1;
+                break;
+              }
+              return _context.abrupt("return");
+            case 1:
+              setState({
+                loading: true,
+                error: null,
+                teamContainers: [],
+                teamId: teamId,
+                hasLoaded: false
+              });
+              _context.prev = 2;
+              _context.next = 3;
+              return teamsClient.getTeamContainers(teamId);
+            case 3:
+              containers = _context.sent;
+              fireAnalytics('operational.fetchTeamContainers.succeeded', {
+                teamId: teamId
+              });
+              setState({
+                teamContainers: containers,
+                loading: false,
+                error: null,
+                hasLoaded: true
+              });
+              _context.next = 5;
+              break;
+            case 4:
+              _context.prev = 4;
+              _t = _context["catch"](2);
+              fireAnalytics('operational.fetchTeamContainers.failed', {
+                teamId: teamId,
+                error: {
+                  message: _t.message || JSON.stringify(_t),
+                  stack: _t.stack
+                }
+              });
+              setState({
+                teamContainers: [],
+                error: _t,
+                loading: false,
+                hasLoaded: true
+              });
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[2, 4]]);
+      }));
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+  },
+  refetchTeamContainers: function refetchTeamContainers(fireAnalytics) {
+    return /*#__PURE__*/function () {
+      var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+        var setState, getState, _getState2, teamId, containers, _t2;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              setState = _ref3.setState, getState = _ref3.getState;
+              _getState2 = getState(), teamId = _getState2.teamId;
+              if (teamId) {
+                _context2.next = 1;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 1:
+              _context2.prev = 1;
+              _context2.next = 2;
+              return teamsClient.getTeamContainers(teamId);
+            case 2:
+              containers = _context2.sent;
+              fireAnalytics('operational.refetchTeamContainers.succeeded', {
+                teamId: teamId
+              });
+              // optimisation to avoid unnecessary state updates
+              if (!containersDeepEqual(containers, getState().teamContainers)) {
+                setState({
+                  teamContainers: containers,
+                  loading: false,
+                  error: null,
+                  hasLoaded: true
+                });
+              }
+              _context2.next = 4;
+              break;
+            case 3:
+              _context2.prev = 3;
+              _t2 = _context2["catch"](1);
+              fireAnalytics('operational.refetchTeamContainers.failed', {
+                teamId: teamId,
+                error: {
+                  message: _t2.message || JSON.stringify(_t2),
+                  stack: _t2.stack
+                }
+              });
+              setState({
+                teamContainers: getState().teamContainers,
+                error: _t2,
+                loading: false,
+                hasLoaded: true
+              });
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[1, 3]]);
+      }));
+      return function (_x2) {
+        return _ref4.apply(this, arguments);
+      };
+    }();
+  },
+  fetchNumberOfConnectedTeams: function fetchNumberOfConnectedTeams(containerId, fireAnalytics) {
+    return /*#__PURE__*/function () {
+      var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
+        var setState, getState, _getState3, currentContainerId, numberOfTeams, _t3;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              setState = _ref5.setState, getState = _ref5.getState;
+              _getState3 = getState(), currentContainerId = _getState3.connectedTeams.containerId;
+              if (!(currentContainerId === containerId)) {
+                _context3.next = 1;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 1:
+              setState({
+                connectedTeams: _objectSpread(_objectSpread({}, initialConnectedTeamsState), {}, {
+                  containerId: containerId,
+                  numberOfTeams: undefined
+                })
+              });
+              _context3.prev = 2;
+              _context3.next = 3;
+              return teamsClient.getNumberOfConnectedTeams(containerId);
+            case 3:
+              numberOfTeams = _context3.sent;
+              fireAnalytics('operational.fetchNumberOfConnectedTeams.succeeded', {
+                numberOfTeams: numberOfTeams,
+                containerId: containerId
+              });
+              setState({
+                connectedTeams: _objectSpread(_objectSpread({}, initialConnectedTeamsState), {}, {
+                  containerId: containerId,
+                  numberOfTeams: numberOfTeams
+                })
+              });
+              _context3.next = 5;
+              break;
+            case 4:
+              _context3.prev = 4;
+              _t3 = _context3["catch"](2);
+              fireAnalytics('operational.fetchNumberOfConnectedTeams.failed', {
+                numberOfTeams: initialConnectedTeamsState.numberOfTeams || null,
+                containerId: containerId,
+                error: {
+                  message: _t3.message || JSON.stringify(_t3),
+                  stack: _t3.stack
+                }
+              });
+              setState({
+                connectedTeams: _objectSpread(_objectSpread({}, initialConnectedTeamsState), {}, {
+                  containerId: containerId,
+                  error: _t3
+                })
+              });
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, null, [[2, 4]]);
+      }));
+      return function (_x3) {
+        return _ref6.apply(this, arguments);
+      };
+    }();
+  },
+  fetchConnectedTeams: function fetchConnectedTeams(containerId, fireAnalytics) {
+    return /*#__PURE__*/function () {
+      var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref7) {
+        var setState, getState, _getState4, _getState4$connectedT, currentContainerId, numberOfTeams, hasLoaded, teams, _t4;
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              setState = _ref7.setState, getState = _ref7.getState;
+              _getState4 = getState(), _getState4$connectedT = _getState4.connectedTeams, currentContainerId = _getState4$connectedT.containerId, numberOfTeams = _getState4$connectedT.numberOfTeams, hasLoaded = _getState4$connectedT.hasLoaded;
+              if (!(currentContainerId === containerId && hasLoaded)) {
+                _context4.next = 1;
+                break;
+              }
+              return _context4.abrupt("return");
+            case 1:
+              setState({
+                connectedTeams: {
+                  containerId: containerId,
+                  isLoading: true,
+                  hasLoaded: false,
+                  teams: undefined,
+                  error: null,
+                  numberOfTeams: numberOfTeams
+                }
+              });
+              _context4.prev = 2;
+              _context4.next = 3;
+              return teamsClient.getConnectedTeams(containerId);
+            case 3:
+              teams = _context4.sent;
+              fireAnalytics('operational.fetchConnectedTeams.succeeded', {
+                numberOfTeams: numberOfTeams || null,
+                containerId: containerId
+              });
+              setState({
+                connectedTeams: {
+                  containerId: containerId,
+                  isLoading: false,
+                  hasLoaded: true,
+                  teams: teams,
+                  error: null,
+                  numberOfTeams: numberOfTeams
+                }
+              });
+              _context4.next = 5;
+              break;
+            case 4:
+              _context4.prev = 4;
+              _t4 = _context4["catch"](2);
+              fireAnalytics('operational.fetchConnectedTeams.failed', {
+                numberOfTeams: numberOfTeams || null,
+                containerId: containerId,
+                error: {
+                  message: _t4.message || JSON.stringify(_t4),
+                  stack: _t4.stack
+                }
+              });
+              setState({
+                connectedTeams: {
+                  containerId: containerId,
+                  isLoading: false,
+                  hasLoaded: false,
+                  teams: [],
+                  error: _t4,
+                  numberOfTeams: numberOfTeams
+                }
+              });
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, null, [[2, 4]]);
+      }));
+      return function (_x4) {
+        return _ref8.apply(this, arguments);
+      };
+    }();
+  },
+  unlinkTeamContainers: function unlinkTeamContainers(teamId, containerId) {
+    return /*#__PURE__*/function () {
+      var _ref0 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref9) {
+        var setState, getState, mutationResult, _getState5, teamContainers, connectedTeams, newContainers, _t5;
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              setState = _ref9.setState, getState = _ref9.getState;
+              setState({
+                unlinkError: null
+              });
+              _context5.prev = 1;
+              _context5.next = 2;
+              return teamsClient.unlinkTeamContainer(teamId, containerId);
+            case 2:
+              mutationResult = _context5.sent;
+              if (mutationResult.deleteTeamConnectedToContainer.errors.length) {
+                // Just handle 1 error at a time should be suffcient as we disconenct only 1 container at a time
+                setState({
+                  unlinkError: mutationResult.deleteTeamConnectedToContainer.errors[0]
+                });
+              } else {
+                _getState5 = getState(), teamContainers = _getState5.teamContainers, connectedTeams = _getState5.connectedTeams;
+                newContainers = teamContainers.filter(function (container) {
+                  return container.id !== containerId;
+                });
+                if (connectedTeams.containerId === containerId) {
+                  setState({
+                    teamContainers: newContainers,
+                    connectedTeams: initialConnectedTeamsState
+                  });
+                } else {
+                  setState({
+                    teamContainers: newContainers
+                  });
+                }
+              }
+              _context5.next = 4;
+              break;
+            case 3:
+              _context5.prev = 3;
+              _t5 = _context5["catch"](1);
+              setState({
+                unlinkError: _t5
+              });
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, null, [[1, 3]]);
+      }));
+      return function (_x5) {
+        return _ref0.apply(this, arguments);
+      };
+    }();
+  },
+  addTeamContainer: function addTeamContainer(teamContainer) {
+    return /*#__PURE__*/function () {
+      var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref1) {
+        var setState, getState, _getState6, teamContainers, connectedTeams, containerExists;
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              setState = _ref1.setState, getState = _ref1.getState;
+              _getState6 = getState(), teamContainers = _getState6.teamContainers, connectedTeams = _getState6.connectedTeams;
+              containerExists = teamContainers.some(function (container) {
+                return container.id === teamContainer.id;
+              });
+              if (!containerExists) {
+                _context6.next = 1;
+                break;
+              }
+              return _context6.abrupt("return");
+            case 1:
+              if (connectedTeams.containerId === teamContainer.id) {
+                setState({
+                  teamContainers: [].concat(_toConsumableArray(teamContainers), [teamContainer]),
+                  connectedTeams: initialConnectedTeamsState
+                });
+              } else {
+                setState({
+                  teamContainers: [].concat(_toConsumableArray(teamContainers), [teamContainer])
+                });
+              }
+            case 2:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      return function (_x6) {
+        return _ref10.apply(this, arguments);
+      };
+    }();
+  }
+};

package/dist/esm/controllers/hooks/use-team-containers/connected-teams.js

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

package/dist/esm/controllers/hooks/use-team-containers/containers-deep-equal.js

@@ -0,0 +1,16 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/**
+ * Compares two container lists for deep equality, ignoring order.
+ *
+ * 1. Sorts both lists by `id`.
+ * 2. Serialises each and compares the results, so a change to any field counts as a difference.
+ *
+ * Contrast with `containersEqual` in `./containers-equal`, which compares `id` alone and so
+ * treats two lists of the same containers as equal even when their contents differ.
+ */
+export function containersDeepEqual(arr1, arr2) {
+  var sortById = function sortById(a, b) {
+    return a.id.localeCompare(b.id);
+  };
+  return JSON.stringify(_toConsumableArray(arr1).sort(sortById)) === JSON.stringify(_toConsumableArray(arr2).sort(sortById));
+}

package/dist/esm/controllers/hooks/use-team-containers/containers-equal.js

@@ -0,0 +1,22 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/**
+ * Compares two container lists by id, ignoring order.
+ *
+ * 1. Returns false immediately if the lengths differ.
+ * 2. Sorts both lists by `id` and compares ids pairwise, so field-level changes are ignored.
+ *
+ * Contrast with `containersDeepEqual` in `./containers-deep-equal`, which also compares contents.
+ */
+export function containersEqual(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  var sortById = function sortById(a, b) {
+    return a.id.localeCompare(b.id);
+  };
+  var sorted1 = _toConsumableArray(arr1).sort(sortById);
+  var sorted2 = _toConsumableArray(arr2).sort(sortById);
+  return sorted1.every(function (item, index) {
+    return item.id === sorted2[index].id;
+  });
+}

package/dist/esm/controllers/hooks/use-team-containers/get-error-details.js

@@ -0,0 +1,8 @@
+import { normalizeError } from './normalize-error';
+export function getErrorDetails(err) {
+  var error = normalizeError(err);
+  return {
+    message: error.message,
+    stack: error.stack
+  };
+}

package/dist/esm/controllers/hooks/use-team-containers/get-initial-team-state.js

@@ -0,0 +1,12 @@
+import { initialConnectedTeamsState } from './initial-connected-teams-state';
+export var getInitialTeamState = function getInitialTeamState() {
+  return {
+    teamContainers: [],
+    loading: false,
+    hasLoaded: false,
+    error: null,
+    unlinkError: null,
+    teamId: null,
+    connectedTeams: initialConnectedTeamsState
+  };
+};