@atlaskit/teams-public 2.7.0 → 2.9.0

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

@@ -0,0 +1,260 @@
+import { teamsClient } from '@atlaskit/teams-client';
+import { containersDeepEqual } from './containers-deep-equal';
+import { initialConnectedTeamsState } from './initial-connected-teams-state';
+export const actions = {
+  fetchTeamContainers: (teamId, fireAnalytics) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teamId: currentTeamId
+    } = getState();
+    if (currentTeamId === teamId) {
+      return;
+    }
+    setState({
+      loading: true,
+      error: null,
+      teamContainers: [],
+      teamId,
+      hasLoaded: false
+    });
+    try {
+      const containers = await teamsClient.getTeamContainers(teamId);
+      fireAnalytics('operational.fetchTeamContainers.succeeded', {
+        teamId
+      });
+      setState({
+        teamContainers: containers,
+        loading: false,
+        error: null,
+        hasLoaded: true
+      });
+    } catch (err) {
+      fireAnalytics('operational.fetchTeamContainers.failed', {
+        teamId,
+        error: {
+          message: err.message || JSON.stringify(err),
+          stack: err.stack
+        }
+      });
+      setState({
+        teamContainers: [],
+        error: err,
+        loading: false,
+        hasLoaded: true
+      });
+    }
+  },
+  refetchTeamContainers: fireAnalytics => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teamId
+    } = getState();
+    if (!teamId) {
+      return;
+    }
+    try {
+      const containers = await teamsClient.getTeamContainers(teamId);
+      fireAnalytics('operational.refetchTeamContainers.succeeded', {
+        teamId
+      });
+      // optimisation to avoid unnecessary state updates
+      if (!containersDeepEqual(containers, getState().teamContainers)) {
+        setState({
+          teamContainers: containers,
+          loading: false,
+          error: null,
+          hasLoaded: true
+        });
+      }
+    } catch (err) {
+      fireAnalytics('operational.refetchTeamContainers.failed', {
+        teamId,
+        error: {
+          message: err.message || JSON.stringify(err),
+          stack: err.stack
+        }
+      });
+      setState({
+        teamContainers: getState().teamContainers,
+        error: err,
+        loading: false,
+        hasLoaded: true
+      });
+    }
+  },
+  fetchNumberOfConnectedTeams: (containerId, fireAnalytics) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      connectedTeams: {
+        containerId: currentContainerId
+      }
+    } = getState();
+    if (currentContainerId === containerId) {
+      return;
+    }
+    setState({
+      connectedTeams: {
+        ...initialConnectedTeamsState,
+        containerId,
+        numberOfTeams: undefined
+      }
+    });
+    try {
+      const numberOfTeams = await teamsClient.getNumberOfConnectedTeams(containerId);
+      fireAnalytics('operational.fetchNumberOfConnectedTeams.succeeded', {
+        numberOfTeams,
+        containerId
+      });
+      setState({
+        connectedTeams: {
+          ...initialConnectedTeamsState,
+          containerId,
+          numberOfTeams
+        }
+      });
+    } catch (e) {
+      fireAnalytics('operational.fetchNumberOfConnectedTeams.failed', {
+        numberOfTeams: initialConnectedTeamsState.numberOfTeams || null,
+        containerId,
+        error: {
+          message: e.message || JSON.stringify(e),
+          stack: e.stack
+        }
+      });
+      setState({
+        connectedTeams: {
+          ...initialConnectedTeamsState,
+          containerId,
+          error: e
+        }
+      });
+    }
+  },
+  fetchConnectedTeams: (containerId, fireAnalytics) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      connectedTeams: {
+        containerId: currentContainerId,
+        numberOfTeams,
+        hasLoaded
+      }
+    } = getState();
+    if (currentContainerId === containerId && hasLoaded) {
+      return;
+    }
+    setState({
+      connectedTeams: {
+        containerId,
+        isLoading: true,
+        hasLoaded: false,
+        teams: undefined,
+        error: null,
+        numberOfTeams
+      }
+    });
+    try {
+      const teams = await teamsClient.getConnectedTeams(containerId);
+      fireAnalytics('operational.fetchConnectedTeams.succeeded', {
+        numberOfTeams: numberOfTeams || null,
+        containerId
+      });
+      setState({
+        connectedTeams: {
+          containerId,
+          isLoading: false,
+          hasLoaded: true,
+          teams,
+          error: null,
+          numberOfTeams
+        }
+      });
+    } catch (e) {
+      fireAnalytics('operational.fetchConnectedTeams.failed', {
+        numberOfTeams: numberOfTeams || null,
+        containerId,
+        error: {
+          message: e.message || JSON.stringify(e),
+          stack: e.stack
+        }
+      });
+      setState({
+        connectedTeams: {
+          containerId,
+          isLoading: false,
+          hasLoaded: false,
+          teams: [],
+          error: e,
+          numberOfTeams
+        }
+      });
+    }
+  },
+  unlinkTeamContainers: (teamId, containerId) => async ({
+    setState,
+    getState
+  }) => {
+    setState({
+      unlinkError: null
+    });
+    try {
+      const mutationResult = await teamsClient.unlinkTeamContainer(teamId, containerId);
+      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 {
+        const {
+          teamContainers,
+          connectedTeams
+        } = getState();
+        const newContainers = teamContainers.filter(container => container.id !== containerId);
+        if (connectedTeams.containerId === containerId) {
+          setState({
+            teamContainers: newContainers,
+            connectedTeams: initialConnectedTeamsState
+          });
+        } else {
+          setState({
+            teamContainers: newContainers
+          });
+        }
+      }
+    } catch (err) {
+      setState({
+        unlinkError: err
+      });
+    }
+  },
+  addTeamContainer: teamContainer => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teamContainers,
+      connectedTeams
+    } = getState();
+    const containerExists = teamContainers.some(container => container.id === teamContainer.id);
+    if (containerExists) {
+      return;
+    }
+    if (connectedTeams.containerId === teamContainer.id) {
+      setState({
+        teamContainers: [...teamContainers, teamContainer],
+        connectedTeams: initialConnectedTeamsState
+      });
+    } else {
+      setState({
+        teamContainers: [...teamContainers, teamContainer]
+      });
+    }
+  }
+};

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * 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) {
+  const sortById = (a, b) => a.id.localeCompare(b.id);
+  return JSON.stringify([...arr1].sort(sortById)) === JSON.stringify([...arr2].sort(sortById));
+}

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

@@ -0,0 +1,17 @@
+/**
+ * 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;
+  }
+  const sortById = (a, b) => a.id.localeCompare(b.id);
+  const sorted1 = [...arr1].sort(sortById);
+  const sorted2 = [...arr2].sort(sortById);
+  return sorted1.every((item, index) => item.id === sorted2[index].id);
+}

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

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

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

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

package/dist/es2019/controllers/hooks/use-team-containers/index.js

@@ -1,329 +1,13 @@
-import { useCallback, useEffect } from 'react';
-import { createHook, createStore } from 'react-sweet-state';
-import { fg } from '@atlaskit/platform-feature-flags';
-import { useAnalyticsEvents } from '@atlaskit/teams-app-internal-analytics';
-import { teamsClient } from '@atlaskit/teams-client';
-import { useConnectedTeams as useConnectedTeamsMulti, useTeamContainers as useTeamContainersMulti } from './multi-team';
-const initialConnectedTeamsState = {
-  containerId: undefined,
-  isLoading: false,
-  hasLoaded: false,
-  teams: undefined,
-  error: null,
-  numberOfTeams: undefined
-};
-const initialState = {
-  teamContainers: [],
-  loading: true,
-  hasLoaded: false,
-  error: null,
-  unlinkError: null,
-  teamId: null,
-  connectedTeams: initialConnectedTeamsState
-};
-function containersEqual(arr1, arr2) {
-  const sortById = (a, b) => a.id.localeCompare(b.id);
-  return JSON.stringify([...arr1].sort(sortById)) === JSON.stringify([...arr2].sort(sortById));
-}
-const actions = {
-  fetchTeamContainers: (teamId, fireAnalytics) => async ({
-    setState,
-    getState
-  }) => {
-    const {
-      teamId: currentTeamId
-    } = getState();
-    if (currentTeamId === teamId) {
-      return;
-    }
-    setState({
-      loading: true,
-      error: null,
-      teamContainers: [],
-      teamId,
-      hasLoaded: false
-    });
-    try {
-      const containers = await teamsClient.getTeamContainers(teamId);
-      fireAnalytics('operational.fetchTeamContainers.succeeded', {
-        teamId
-      });
-      setState({
-        teamContainers: containers,
-        loading: false,
-        error: null,
-        hasLoaded: true
-      });
-    } catch (err) {
-      fireAnalytics('operational.fetchTeamContainers.failed', {
-        teamId,
-        error: {
-          message: err.message || JSON.stringify(err),
-          stack: err.stack
-        }
-      });
-      setState({
-        teamContainers: [],
-        error: err,
-        loading: false,
-        hasLoaded: true
-      });
-    }
-  },
-  refetchTeamContainers: fireAnalytics => async ({
-    setState,
-    getState
-  }) => {
-    const {
-      teamId
-    } = getState();
-    if (!teamId) {
-      return;
-    }
-    try {
-      const containers = await teamsClient.getTeamContainers(teamId);
-      fireAnalytics('operational.refetchTeamContainers.succeeded', {
-        teamId
-      });
-      // optimisation to avoid unnecessary state updates
-      if (!containersEqual(containers, getState().teamContainers)) {
-        setState({
-          teamContainers: containers,
-          loading: false,
-          error: null,
-          hasLoaded: true
-        });
-      }
-    } catch (err) {
-      fireAnalytics('operational.refetchTeamContainers.failed', {
-        teamId,
-        error: {
-          message: err.message || JSON.stringify(err),
-          stack: err.stack
-        }
-      });
-      setState({
-        teamContainers: getState().teamContainers,
-        error: err,
-        loading: false,
-        hasLoaded: true
-      });
-    }
-  },
-  fetchNumberOfConnectedTeams: (containerId, fireAnalytics) => async ({
-    setState,
-    getState
-  }) => {
-    const {
-      connectedTeams: {
-        containerId: currentContainerId
-      }
-    } = getState();
-    if (currentContainerId === containerId) {
-      return;
-    }
-    setState({
-      connectedTeams: {
-        ...initialConnectedTeamsState,
-        containerId,
-        numberOfTeams: undefined
-      }
-    });
-    try {
-      const numberOfTeams = await teamsClient.getNumberOfConnectedTeams(containerId);
-      fireAnalytics('operational.fetchNumberOfConnectedTeams.succeeded', {
-        numberOfTeams,
-        containerId
-      });
-      setState({
-        connectedTeams: {
-          ...initialConnectedTeamsState,
-          containerId,
-          numberOfTeams
-        }
-      });
-    } catch (e) {
-      fireAnalytics('operational.fetchNumberOfConnectedTeams.failed', {
-        numberOfTeams: initialConnectedTeamsState.numberOfTeams || null,
-        containerId,
-        error: {
-          message: e.message || JSON.stringify(e),
-          stack: e.stack
-        }
-      });
-      setState({
-        connectedTeams: {
-          ...initialConnectedTeamsState,
-          containerId,
-          error: e
-        }
-      });
-    }
-  },
-  fetchConnectedTeams: (containerId, fireAnalytics) => async ({
-    setState,
-    getState
-  }) => {
-    const {
-      connectedTeams: {
-        containerId: currentContainerId,
-        numberOfTeams,
-        hasLoaded
-      }
-    } = getState();
-    if (currentContainerId === containerId && hasLoaded) {
-      return;
-    }
-    setState({
-      connectedTeams: {
-        containerId,
-        isLoading: true,
-        hasLoaded: false,
-        teams: undefined,
-        error: null,
-        numberOfTeams
-      }
-    });
-    try {
-      const teams = await teamsClient.getConnectedTeams(containerId);
-      fireAnalytics('operational.fetchConnectedTeams.succeeded', {
-        numberOfTeams: numberOfTeams || null,
-        containerId
-      });
-      setState({
-        connectedTeams: {
-          containerId,
-          isLoading: false,
-          hasLoaded: true,
-          teams,
-          error: null,
-          numberOfTeams
-        }
-      });
-    } catch (e) {
-      fireAnalytics('operational.fetchConnectedTeams.failed', {
-        numberOfTeams: numberOfTeams || null,
-        containerId,
-        error: {
-          message: e.message || JSON.stringify(e),
-          stack: e.stack
-        }
-      });
-      setState({
-        connectedTeams: {
-          containerId,
-          isLoading: false,
-          hasLoaded: false,
-          teams: [],
-          error: e,
-          numberOfTeams
-        }
-      });
-    }
-  },
-  unlinkTeamContainers: (teamId, containerId) => async ({
-    setState,
-    getState
-  }) => {
-    setState({
-      unlinkError: null
-    });
-    try {
-      const mutationResult = await teamsClient.unlinkTeamContainer(teamId, containerId);
-      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 {
-        const {
-          teamContainers,
-          connectedTeams
-        } = getState();
-        const newContainers = teamContainers.filter(container => container.id !== containerId);
-        if (connectedTeams.containerId === containerId) {
-          setState({
-            teamContainers: newContainers,
-            connectedTeams: initialConnectedTeamsState
-          });
-        } else {
-          setState({
-            teamContainers: newContainers
-          });
-        }
-      }
-    } catch (err) {
-      setState({
-        unlinkError: err
-      });
-    }
-  },
-  addTeamContainer: teamContainer => async ({
-    setState,
-    getState
-  }) => {
-    const {
-      teamContainers,
-      connectedTeams
-    } = getState();
-    const containerExists = teamContainers.some(container => container.id === teamContainer.id);
-    if (containerExists) {
-      return;
-    }
-    if (connectedTeams.containerId === teamContainer.id) {
-      setState({
-        teamContainers: [...teamContainers, teamContainer],
-        connectedTeams: initialConnectedTeamsState
-      });
-    } else {
-      setState({
-        teamContainers: [...teamContainers, teamContainer]
-      });
-    }
-  }
-};
-const Store = createStore({
-  initialState,
-  actions,
-  name: 'teamContainersStore'
-});
-export const useTeamContainersHook = createHook(Store);
-export const useTeamContainers = (teamId, enable = true) => {
-  const [state, actions] = useTeamContainersHook();
-  const useMultiTeam = fg('enable_multi_team_containers_state');
-  const multiTeamResult = useTeamContainersMulti(teamId, useMultiTeam ? enable : false);
-  const {
-    fireEvent
-  } = useAnalyticsEvents();
-  useEffect(() => {
-    if (enable && !useMultiTeam) {
-      actions.fetchTeamContainers(teamId, fireEvent);
-    }
-  }, [teamId, actions, enable, fireEvent, useMultiTeam]);
-  const refetchTeamContainers = useCallback(async () => actions.refetchTeamContainers(fireEvent), [actions, fireEvent]);
-  if (useMultiTeam) {
-    return multiTeamResult;
-  }
-  return {
-    ...state,
-    addTeamContainer: actions.addTeamContainer,
-    unlinkTeamContainers: containerId => actions.unlinkTeamContainers(teamId, containerId),
-    refetchTeamContainers
-  };
-};
-export const useConnectedTeams = teamId => {
-  const [state, actions] = useTeamContainersHook();
-  const useMultiTeam = fg('enable_multi_team_containers_state');
-  const multiTeamResult = useConnectedTeamsMulti(useMultiTeam ? teamId || '' : '');
-  const {
-    fireEvent
-  } = useAnalyticsEvents();
-  if (useMultiTeam) {
-    return multiTeamResult;
-  }
-  return {
-    ...state.connectedTeams,
-    fetchNumberOfConnectedTeams: containerId => actions.fetchNumberOfConnectedTeams(containerId, fireEvent),
-    fetchConnectedTeams: containerId => actions.fetchConnectedTeams(containerId, fireEvent)
-  };
-};
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+/**
+ * @deprecated Use `import { useTeamContainersHook } from '@atlaskit/teams-public/use-team-containers/use-team-containers-hook'` instead.
+ */
+export { useTeamContainersHook } from './use-team-containers-hook';
+/**
+ * @deprecated Use `import { useTeamContainers } from '@atlaskit/teams-public/use-team-containers/use-team-containers'` instead.
+ */
+export { useTeamContainers } from './use-team-containers';
+/**
+ * @deprecated Use `import { useConnectedTeams } from '@atlaskit/teams-public/use-connected-teams'` instead.
+ */
+export { useConnectedTeams } from './use-connected-teams';

package/dist/es2019/controllers/hooks/use-team-containers/initial-connected-teams-state.js

@@ -0,0 +1,8 @@
+export const initialConnectedTeamsState = {
+  containerId: undefined,
+  isLoading: false,
+  hasLoaded: false,
+  teams: undefined,
+  error: null,
+  numberOfTeams: undefined
+};