@atlaskit/teams-public 2.7.0 → 2.9.0

package/dist/es2019/common/ui/loom-avatar/hash.js

@@ -0,0 +1,6 @@
+import stringHash from 'string-hash';
+export const hash = str => {
+  let hash = stringHash(str);
+  hash = ~hash;
+  return Math.abs(Number(hash));
+};

package/dist/es2019/common/ui/loom-avatar/index.js

@@ -1 +1,5 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+/**
+ * @deprecated Use `import { LoomSpaceAvatar } from '@atlaskit/teams-public/loom-avatar/main'` instead.
+ */
 export { LoomSpaceAvatar } from './main';

package/dist/es2019/common/ui/loom-avatar/main.js

@@ -3,10 +3,12 @@ import "./main.compiled.css";
 import * as React from 'react';
 import { ax, ix } from "@compiled/react/runtime";
 import { cx } from '@atlaskit/css';
-import { fg } from '@atlaskit/platform-feature-flags';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { Box } from '@atlaskit/primitives/compiled';
-import Tile from '@atlaskit/tile';
-import { getAvatarText, pickContainerColor, pickTextColor } from './utils';
+import Tile from '@atlaskit/tile/tile';
+import { getAvatarText } from './getAvatarText';
+import { pickContainerColor } from './pickContainerColor';
+import { pickTextColor } from './pickTextColor';
 const typographyByAvatarSize = {
   small: "_11c81qyo",
   medium: "_11c81af2"

package/dist/es2019/common/ui/loom-avatar/pickContainerColor.js

@@ -0,0 +1,13 @@
+import { hash } from './hash';
+var SpaceColors = /*#__PURE__*/function (SpaceColors) {
+  SpaceColors["ORANGE_LIGHT"] = "#FFD5D2";
+  SpaceColors["BLUE_LIGHT"] = "#CFE1FD";
+  SpaceColors["YELLOW_LIGHT"] = "#FCE4A6";
+  SpaceColors["TEAL"] = "#BAF3DB";
+  return SpaceColors;
+}(SpaceColors || {});
+const AVATAR_CONTAINER_COLORS = [SpaceColors.ORANGE_LIGHT, SpaceColors.BLUE_LIGHT, SpaceColors.YELLOW_LIGHT, SpaceColors.TEAL];
+export const pickContainerColor = spaceName => {
+  const avatarHash = hash(spaceName);
+  return AVATAR_CONTAINER_COLORS[avatarHash % AVATAR_CONTAINER_COLORS.length];
+};

package/dist/es2019/common/ui/loom-avatar/pickTextColor.js

@@ -0,0 +1,13 @@
+import { hash } from './hash';
+var AvatarTextColors = /*#__PURE__*/function (AvatarTextColors) {
+  AvatarTextColors["ORANGE_DARK"] = "#AE2E24";
+  AvatarTextColors["BLUE_DARK"] = "#123263";
+  AvatarTextColors["YELLOW_DARK"] = "#9E4C00";
+  AvatarTextColors["TEAL_DARK"] = "#164B35";
+  return AvatarTextColors;
+}(AvatarTextColors || {});
+const AVATAR_TEXT_COLORS = [AvatarTextColors.ORANGE_DARK, AvatarTextColors.BLUE_DARK, AvatarTextColors.YELLOW_DARK, AvatarTextColors.TEAL_DARK];
+export const pickTextColor = spaceName => {
+  const avatarHash = hash(spaceName);
+  return AVATAR_TEXT_COLORS[avatarHash % AVATAR_TEXT_COLORS.length];
+};

package/dist/es2019/common/ui/team-link-card-actions/index.js

@@ -4,14 +4,16 @@ import "./index.compiled.css";
 import { ax, ix } from "@compiled/react/runtime";
 import React from 'react';
 import { defineMessages, useIntl } from 'react-intl';
-import { IconButton } from '@atlaskit/button/new';
+import IconButton from '@atlaskit/button/icon/button';
 import { cx } from '@atlaskit/css';
-import DropdownMenu, { DropdownItem, DropdownItemGroup } from '@atlaskit/dropdown-menu';
+import DropdownMenu from '@atlaskit/dropdown-menu/dropdown-menu';
+import DropdownItem from '@atlaskit/dropdown-menu/dropdown-menu-item';
+import DropdownItemGroup from '@atlaskit/dropdown-menu/dropdown-menu-item-group';
 import CrossIcon from '@atlaskit/icon/core/cross';
 import ShowMoreHorizontalIcon from '@atlaskit/icon/core/show-more-horizontal';
 import { Box } from '@atlaskit/primitives/compiled';
-import { useAnalyticsEvents } from '@atlaskit/teams-app-internal-analytics';
-import Tooltip from '@atlaskit/tooltip';
+import { useAnalyticsEvents } from '@atlaskit/teams-app-internal-analytics/use-analytics-events';
+import Tooltip from '@atlaskit/tooltip/Tooltip';
 const styles = {
   crossIconWrapper: "_1e0c1txw _4cvr1h6o _1bahesu3 _18u01wug",
   showMoreIconWrapper: "_1e0c1txw _4cvr1h6o _1bahesu3 _18u01wug",

package/dist/es2019/common/utils/analytics.js

@@ -1,4 +1,4 @@
-import { usePeopleTeamsAnalyticsSubcontext } from '@atlaskit/people-teams-ui-public/analytics';
+import { usePeopleTeamsAnalyticsSubcontext } from '@atlaskit/people-teams-ui-public/analytics-subcontext/store';
 const ANALYTICS_CHANNEL = 'peopleTeams';
 const runItLater = cb => {
   if (window.requestIdleCallback === 'function') {

package/dist/es2019/common/utils/container-to-new-web-link.js

@@ -0,0 +1,7 @@
+export const containerToNewWebLink = container => {
+  return {
+    contentTitle: container.name,
+    description: '',
+    linkUri: container.link || ''
+  };
+};

package/dist/es2019/common/utils/get-container-properties.js

@@ -7,9 +7,9 @@ import { cx } from '@atlaskit/css';
 import LinkIcon from '@atlaskit/icon/core/link';
 import LinkExternalIcon from '@atlaskit/icon/core/link-external';
 import Image from '@atlaskit/image';
-import { fg } from '@atlaskit/platform-feature-flags';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { Box, Flex, Text } from '@atlaskit/primitives/compiled';
-import Tile from '@atlaskit/tile';
+import Tile from '@atlaskit/tile/tile';
 import ConfluenceIcon from '../assets/ConfluenceIcon.svg';
 import JiraIcon from '../assets/JiraIcon.svg';
 import JiraProjectDiscovery from '../assets/JiraProjectDiscovery.svg';

package/dist/es2019/common/utils/{get-link-domain.js → get-domain-from-link-uri.js}

@@ -1,3 +1,5 @@
+import { unsafeGetDomainFromUrl } from './unsafe-get-domain-from-url';
+
 /**
  * Extract the domain from the URL. Strips "www" subdomains
  * e.g. http://dogs.animals.com/yellow/golden-retriever becomes "dogs.animals.com"
@@ -23,15 +25,4 @@ export const getDomainFromLinkUri = url => {
     return '';
   }
   return hostname.replace(/^www\./, '');
-};
-
-/**
- * Extract the domain from the URL.
- * Throws if url param is not a valid URL.
- * Marked as unsafe because the URL constructor throws Type Errors when it
- * receives invalid URLs. Feel free to use this method with adequate care.
- */
-export const unsafeGetDomainFromUrl = url => {
-  const urlObj = new URL(url);
-  return urlObj.hostname;
 };

package/dist/es2019/common/utils/get-is-experiment-enabled.js

@@ -1,4 +1,4 @@
-import FeatureGates from '@atlaskit/feature-gate-js-client';
+import FeatureGates from '@atlaskit/feature-gate-js-client/feature-gates';
 export const COHORT_PARAMETER = 'cohort';
 export const NOT_ENROLLED = 'not-enrolled';
 export const CONTROL = 'control';

package/dist/es2019/common/utils/is-new-team-web-link.js

@@ -0,0 +1,3 @@
+export const isNewTeamWebLink = input => {
+  return 'contentTitle' in input && 'linkUri' in input && !('type' in input) && !('id' in input);
+};

package/dist/es2019/common/utils/team-web-link-converters.js

@@ -1,25 +0,0 @@
-export const containerToNewWebLink = container => {
-  return {
-    contentTitle: container.name,
-    description: '',
-    linkUri: container.link || ''
-  };
-};
-export const webLinkToContainer = (link, iconData) => {
-  return {
-    id: link.linkId,
-    type: 'WebLink',
-    name: link.contentTitle,
-    icon: (iconData === null || iconData === void 0 ? void 0 : iconData.iconUrl) || null,
-    link: link.linkUri
-  };
-};
-export const webLinksToContainers = (links, linkIcons = []) => {
-  return links.map(link => {
-    const iconData = linkIcons.find(icon => icon.linkUrl === link.linkUri);
-    return webLinkToContainer(link, iconData);
-  });
-};
-export const isNewTeamWebLink = input => {
-  return 'contentTitle' in input && 'linkUri' in input && !('type' in input) && !('id' in input);
-};

package/dist/es2019/common/utils/unsafe-get-domain-from-url.js

@@ -0,0 +1,10 @@
+/**
+ * Extract the domain from the URL.
+ * Throws if url param is not a valid URL.
+ * Marked as unsafe because the URL constructor throws Type Errors when it
+ * receives invalid URLs. Feel free to use this method with adequate care.
+ */
+export const unsafeGetDomainFromUrl = url => {
+  const urlObj = new URL(url);
+  return urlObj.hostname;
+};

package/dist/es2019/common/utils/web-link-to-container.js

@@ -0,0 +1,9 @@
+export const webLinkToContainer = (link, iconData) => {
+  return {
+    id: link.linkId,
+    type: 'WebLink',
+    name: link.contentTitle,
+    icon: (iconData === null || iconData === void 0 ? void 0 : iconData.iconUrl) || null,
+    link: link.linkUri
+  };
+};

package/dist/es2019/common/utils/web-links-to-containers.js

@@ -0,0 +1,7 @@
+import { webLinkToContainer } from './web-link-to-container';
+export const webLinksToContainers = (links, linkIcons = []) => {
+  return links.map(link => {
+    const iconData = linkIcons.find(icon => icon.linkUrl === link.linkUri);
+    return webLinkToContainer(link, iconData);
+  });
+};

package/dist/es2019/controllers/hooks/use-refresh-containers-on-container-created/index.js

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from 'react';
 import { useCreateContainers } from '../use-create-containers';
-import { useTeamContainers } from '../use-team-containers';
+import { useTeamContainers } from '../use-team-containers/use-team-containers';
 const PRODUCT_TO_CONTAINER_TYPE = {
   Jira: 'JiraProject',
   Confluence: 'ConfluenceSpace',

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

@@ -0,0 +1,413 @@
+import { teamsClient } from '@atlaskit/teams-client';
+import { containersEqual } from './containers-equal';
+import { getErrorDetails } from './get-error-details';
+import { getInitialTeamState } from './get-initial-team-state';
+import { initialConnectedTeamsState } from './initial-connected-teams-state';
+import { normalizeError } from './normalize-error';
+export const actions = {
+  fetchTeamContainers: (teamId, fireAnalytics, fireAnalyticsNext) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    // Only skip if already loaded and not currently loading (prevents duplicate fetches)
+    if (currentTeamState !== null && currentTeamState !== void 0 && currentTeamState.hasLoaded && !currentTeamState.loading) {
+      return;
+    }
+    // Skip if currently loading to prevent concurrent fetches
+    if (currentTeamState !== null && currentTeamState !== void 0 && currentTeamState.loading) {
+      return;
+    }
+    setState({
+      teams: {
+        ...teams,
+        [teamId]: {
+          ...getInitialTeamState(),
+          teamContainers: [],
+          // Ensure empty containers for new fetch
+          loading: true,
+          hasLoaded: false
+        }
+      }
+    });
+    try {
+      const containers = await teamsClient.getTeamContainers(teamId);
+      fireAnalyticsNext('operational.fetchTeamContainers.succeeded', {
+        teamId
+      });
+
+      // Get fresh state after async operation
+      const currentState = getState();
+      const currentTeamState = currentState.teams[teamId];
+      if (!currentTeamState || currentTeamState.loading === false) {
+        // Team state was cleared or fetch was cancelled, don't update
+        return;
+      }
+      // Only update if we're still loading (prevents race conditions when teamId changes)
+      if (currentTeamState.loading) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...currentTeamState,
+              teamContainers: containers,
+              loading: false,
+              error: null,
+              hasLoaded: true,
+              teamId
+            }
+          }
+        });
+      }
+    } catch (err) {
+      fireAnalyticsNext('operational.fetchTeamContainers.failed', {
+        teamId,
+        error: getErrorDetails(err)
+      });
+
+      // Get fresh state after async operation
+      const currentState = getState();
+      if (!currentState.teams[teamId]) {
+        return;
+      }
+      setState({
+        teams: {
+          ...currentState.teams,
+          [teamId]: {
+            ...currentState.teams[teamId],
+            teamContainers: [],
+            error: normalizeError(err),
+            loading: false,
+            hasLoaded: true,
+            teamId
+          }
+        }
+      });
+    }
+  },
+  refetchTeamContainers: (teamId, fireAnalytics, fireAnalyticsNext) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    if (!currentTeamState) {
+      return;
+    }
+    try {
+      const containers = await teamsClient.getTeamContainers(teamId);
+      fireAnalyticsNext('operational.refetchTeamContainers.succeeded', {
+        teamId
+      });
+      if (!containersEqual(containers, currentTeamState.teamContainers)) {
+        setState({
+          teams: {
+            ...teams,
+            [teamId]: {
+              ...currentTeamState,
+              teamContainers: containers,
+              loading: false,
+              error: null,
+              hasLoaded: true,
+              teamId
+            }
+          }
+        });
+      }
+    } catch (err) {
+      fireAnalyticsNext('operational.refetchTeamContainers.failed', {
+        teamId,
+        error: getErrorDetails(err)
+      });
+      setState({
+        teams: {
+          ...teams,
+          [teamId]: {
+            ...currentTeamState,
+            error: normalizeError(err),
+            loading: false,
+            hasLoaded: true,
+            teamId
+          }
+        }
+      });
+    }
+  },
+  fetchNumberOfConnectedTeams: (teamId, containerId, fireAnalytics, fireAnalyticsNext) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    if (!currentTeamState) {
+      return;
+    }
+    const {
+      connectedTeams: {
+        containerId: currentContainerId
+      }
+    } = currentTeamState;
+    if (currentContainerId === containerId) {
+      return;
+    }
+    setState({
+      teams: {
+        ...teams,
+        [teamId]: {
+          ...currentTeamState,
+          connectedTeams: {
+            ...initialConnectedTeamsState,
+            containerId,
+            numberOfTeams: undefined
+          }
+        }
+      }
+    });
+    try {
+      const numberOfTeams = await teamsClient.getNumberOfConnectedTeams(containerId);
+      fireAnalyticsNext('operational.fetchNumberOfConnectedTeams.succeeded', {
+        numberOfTeams,
+        containerId
+      });
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (updatedTeamState) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              connectedTeams: {
+                ...initialConnectedTeamsState,
+                containerId,
+                numberOfTeams,
+                hasLoaded: true
+              }
+            }
+          }
+        });
+      }
+    } catch (e) {
+      fireAnalyticsNext('operational.fetchNumberOfConnectedTeams.failed', {
+        numberOfTeams: initialConnectedTeamsState.numberOfTeams || null,
+        containerId,
+        error: getErrorDetails(e)
+      });
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (updatedTeamState) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              connectedTeams: {
+                ...initialConnectedTeamsState,
+                containerId,
+                error: normalizeError(e)
+              }
+            }
+          }
+        });
+      }
+    }
+  },
+  fetchConnectedTeams: (teamId, containerId, fireAnalytics, fireAnalyticsNext) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    if (!currentTeamState) {
+      return;
+    }
+    const {
+      connectedTeams: {
+        containerId: currentContainerId,
+        numberOfTeams,
+        hasLoaded
+      }
+    } = currentTeamState;
+    if (currentContainerId === containerId && hasLoaded) {
+      return;
+    }
+    setState({
+      teams: {
+        ...teams,
+        [teamId]: {
+          ...currentTeamState,
+          connectedTeams: {
+            containerId,
+            isLoading: true,
+            hasLoaded: false,
+            teams: undefined,
+            error: null,
+            numberOfTeams
+          }
+        }
+      }
+    });
+    try {
+      const teamsResult = await teamsClient.getConnectedTeams(containerId);
+      fireAnalyticsNext('operational.fetchConnectedTeams.succeeded', {
+        numberOfTeams: numberOfTeams || null,
+        containerId
+      });
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (updatedTeamState) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              connectedTeams: {
+                containerId,
+                isLoading: false,
+                hasLoaded: true,
+                teams: teamsResult,
+                error: null,
+                numberOfTeams
+              }
+            }
+          }
+        });
+      }
+    } catch (e) {
+      fireAnalyticsNext('operational.fetchConnectedTeams.failed', {
+        numberOfTeams: numberOfTeams || null,
+        containerId,
+        error: getErrorDetails(e)
+      });
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (updatedTeamState) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              connectedTeams: {
+                containerId,
+                isLoading: false,
+                hasLoaded: false,
+                teams: [],
+                error: normalizeError(e),
+                numberOfTeams
+              }
+            }
+          }
+        });
+      }
+    }
+  },
+  unlinkTeamContainers: (teamId, containerId) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    if (currentTeamState) {
+      setState({
+        teams: {
+          ...teams,
+          [teamId]: {
+            ...currentTeamState,
+            unlinkError: null
+          }
+        }
+      });
+    }
+    try {
+      const mutationResult = await teamsClient.unlinkTeamContainer(teamId, containerId);
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (!updatedTeamState) {
+        return;
+      }
+      if (mutationResult.deleteTeamConnectedToContainer.errors.length) {
+        // Just handle 1 error at a time should be sufficient as we disconnect only 1 container at a time
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              unlinkError: mutationResult.deleteTeamConnectedToContainer.errors[0]
+            }
+          }
+        });
+      } else {
+        const newContainers = updatedTeamState.teamContainers.filter(container => container.id !== containerId);
+        const shouldResetConnectedTeams = updatedTeamState.connectedTeams.containerId === containerId;
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              teamContainers: newContainers,
+              ...(shouldResetConnectedTeams && {
+                connectedTeams: initialConnectedTeamsState
+              }),
+              unlinkError: null
+            }
+          }
+        });
+      }
+    } catch (err) {
+      const currentState = getState();
+      const updatedTeamState = currentState.teams[teamId];
+      if (updatedTeamState) {
+        setState({
+          teams: {
+            ...currentState.teams,
+            [teamId]: {
+              ...updatedTeamState,
+              unlinkError: normalizeError(err)
+            }
+          }
+        });
+      }
+    }
+  },
+  addTeamContainer: (teamId, teamContainer) => async ({
+    setState,
+    getState
+  }) => {
+    const {
+      teams
+    } = getState();
+    const currentTeamState = teams[teamId];
+    if (!currentTeamState) {
+      return;
+    }
+    const containerExists = currentTeamState.teamContainers.some(container => container.id === teamContainer.id);
+    if (containerExists) {
+      return;
+    }
+    const shouldResetConnectedTeams = currentTeamState.connectedTeams.containerId === teamContainer.id;
+    setState({
+      teams: {
+        ...teams,
+        [teamId]: {
+          ...currentTeamState,
+          teamContainers: [...currentTeamState.teamContainers, teamContainer],
+          ...(shouldResetConnectedTeams && {
+            connectedTeams: initialConnectedTeamsState
+          }),
+          teamId
+        }
+      }
+    });
+  }
+};