@commercetools-frontend/application-shell 27.10.0 → 27.11.1

package/dist/user-settings-menu-498c4581.esm.js

@@ -0,0 +1,320 @@
+import _Object$keys from '@babel/runtime-corejs3/core-js-stable/object/keys';
+import _Object$getOwnPropertySymbols from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols';
+import _filterInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/filter';
+import _Object$getOwnPropertyDescriptor from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor';
+import _forEachInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/for-each';
+import _Object$getOwnPropertyDescriptors from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors';
+import _Object$defineProperties from '@babel/runtime-corejs3/core-js-stable/object/define-properties';
+import _Object$defineProperty from '@babel/runtime-corejs3/core-js-stable/object/define-property';
+import _defineProperty from '@babel/runtime-corejs3/helpers/esm/defineProperty';
+import _slicedToArray from '@babel/runtime-corejs3/helpers/esm/slicedToArray';
+import _styled from '@emotion/styled/base';
+import _findInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/find';
+import _startsWithInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/starts-with';
+import _trimInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/trim';
+import _mapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/map';
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { css } from '@emotion/react';
+import { useFlagVariation } from '@flopflip/react-broadcast';
+import Downshift from 'downshift';
+import { defineMessages, useIntl, FormattedMessage } from 'react-intl';
+import { Link } from 'react-router-dom';
+import { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';
+import { STATIC_URL_PATHS, SUPPORT_PORTAL_URL, LOGOUT_REASONS, NO_VALUE_FALLBACK } from '@commercetools-frontend/constants';
+import AccessibleHidden from '@commercetools-uikit/accessible-hidden';
+import Avatar from '@commercetools-uikit/avatar';
+import { designTokens } from '@commercetools-uikit/design-system';
+import Spacings from '@commercetools-uikit/spacings';
+import Text from '@commercetools-uikit/text';
+import { D as DIMENSIONS } from './oidc-cb344fae.esm.js';
+import { u as useApplicationsMenu } from './use-applications-menu-85ab6542.esm.js';
+import { jsx, jsxs, Fragment } from '@emotion/react/jsx-runtime';
+import '@apollo/client';
+import '@commercetools-frontend/l10n';
+
+var messages = defineMessages({
+  support: {
+    id: 'UserSettingsMenu.support',
+    description: 'The label for Support',
+    defaultMessage: 'Support'
+  },
+  logout: {
+    id: 'UserSettingsMenu.logout',
+    description: 'The label for logout option',
+    defaultMessage: 'Logout'
+  },
+  privacyPolicy: {
+    id: 'UserSettingsMenu.privacyPolicy',
+    description: 'The label for privacy policy option',
+    defaultMessage: 'Privacy Policy'
+  },
+  menuLabel: {
+    id: 'UserSettingsMenu.menuLabel',
+    description: 'The label describing the menu',
+    defaultMessage: 'User settings menu'
+  },
+  openMenuLabel: {
+    id: 'UserSettingsMenu.openMenuLabel',
+    description: 'The label when menu is closed and would be opened by a click',
+    defaultMessage: 'Open user settings menu'
+  },
+  closeMenuLabel: {
+    id: 'UserSettingsMenu.closeMenuLabel',
+    description: 'The label when menu is open and would be closed by a click',
+    defaultMessage: 'Close user settings menu'
+  }
+});
+
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, 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 _context3, _context4; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context3 = ownKeys(Object(t), !0)).call(_context3, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context4 = ownKeys(Object(t))).call(_context4, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+const MENU_LABEL_ID = 'user-menu-setting-menu-label';
+const UserAvatar = props => {
+  const _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isMouseOver = _useState2[0],
+    setIsMouseOver = _useState2[1];
+  const handleMouseOver = useCallback(() => {
+    setIsMouseOver(true);
+  }, []);
+  const handleMouseOut = useCallback(() => {
+    setIsMouseOver(false);
+  }, []);
+  return jsx("div", {
+    onMouseOver: handleMouseOver,
+    onMouseOut: handleMouseOut,
+    children: jsx(Spacings.Inline, {
+      alignItems: "center",
+      children: jsx(Avatar, {
+        size: "m",
+        gravatarHash: props.gravatarHash,
+        firstName: props.firstName,
+        lastName: props.lastName,
+        isHighlighted: isMouseOver,
+        color: "purple"
+      })
+    })
+  });
+};
+UserAvatar.displayName = 'UserAvatar';
+function getIsFocusedElementInMenu() {
+  return Boolean(document.activeElement?.getAttribute('data-user-settings-menu'));
+}
+const stateReducer = (state, changes) => {
+  switch (changes.type) {
+    // So in case the user wants to navigate with the tab button
+    // we need to make sure that the menu does not close
+    case Downshift.stateChangeTypes.blurButton:
+      return _objectSpread(_objectSpread({}, changes), {}, {
+        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false
+      });
+    default:
+      return changes;
+  }
+};
+function isLongLivedFlag(flag) {
+  return typeof flag?.value === 'boolean';
+}
+const OptionalFeatureToggle = props => {
+  const flagVariation = useFlagVariation(props.featureToggle);
+  if (props.featureToggle) {
+    if (flagVariation === true) return jsx(Fragment, {
+      children: props.children
+    });
+    if (isLongLivedFlag(flagVariation) && flagVariation.value === true) return jsx(Fragment, {
+      children: props.children
+    });
+    return null;
+  }
+  return jsx(Fragment, {
+    children: props.children
+  });
+};
+const renderLabel = (menu, applicationLanguage) => {
+  var _context;
+  const localizedLabel = _findInstanceProperty(_context = menu.labelAllLocales).call(_context, loc => _startsWithInstanceProperty(applicationLanguage).call(applicationLanguage, loc.locale));
+  if (localizedLabel) return localizedLabel.value;
+  return NO_VALUE_FALLBACK;
+};
+const MenuItem = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1al5ftg0"
+} : {
+  target: "e1al5ftg0",
+  label: "MenuItem"
+})("width:100%;cursor:pointer;color:", designTokens.colorSolid, ";:hover{background-color:", designTokens.colorNeutral95, ";}", props => props.hasDivider === true ? /*#__PURE__*/css("border-bottom:1px solid ", designTokens.colorNeutral, ";margin:", designTokens.spacing10, " 0;" + (process.env.NODE_ENV === "production" ? "" : ";label:MenuItem;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AAiJW","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */") : '', ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AAsI0C","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */"));
+const MenuItemLabel = props => jsx("div", {
+  css: /*#__PURE__*/css("padding:", designTokens.spacing20, " ", designTokens.spacing50, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:MenuItemLabel;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AA0JY","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */"),
+  children: props.children
+});
+const UserSettingsAvatarContainer = props => jsx("div", {
+  css: /*#__PURE__*/css("padding:", designTokens.spacing30, " ", designTokens.spacing50, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:UserSettingsAvatarContainer;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AAsKY","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */"),
+  children: props.children
+});
+const getUserSettingsMenuStyles = () => {
+  return /*#__PURE__*/css("position:absolute;background:", designTokens.colorSurface, ";border-radius:", designTokens.borderRadius2, ";box-shadow:0px 2px 5px 0px rgba(0, 0, 0, 0.15);width:", designTokens.constraint9, ";right:40px;top:calc(", DIMENSIONS.header, " + ", designTokens.spacing20, ");padding:0 0 ", designTokens.spacing10, " 0;overflow:hidden;" + (process.env.NODE_ENV === "production" ? "" : ";label:getUserSettingsMenuStyles;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AA+KY","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */");
+};
+var _ref2 = process.env.NODE_ENV === "production" ? {
+  name: "4zleql",
+  styles: "display:block"
+} : {
+  name: "1h437nn-getUserSettingsMenuItemLinkStyles",
+  styles: "display:block;label:getUserSettingsMenuItemLinkStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AA4LmD","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const getUserSettingsMenuItemLinkStyles = () => _ref2;
+const UserSettingsMenuBody = props => {
+  var _context2;
+  // Focus on a menu item when it's opened through keyboard
+  const menuElementRef = useRef(null);
+  useEffect(() => {
+    menuElementRef.current?.focus();
+  }, []);
+  const environment = useApplicationContext(context => context.environment);
+  const applicationsAppBarMenu = useApplicationsMenu('appBar', {
+    environment
+  });
+  const accountMenuItems = applicationsAppBarMenu ?? [];
+  return jsx("div", {
+    onKeyDown: event => {
+      if (event.key === 'Esc' || event.key === 'Tab' && !getIsFocusedElementInMenu()) {
+        props.downshiftProps.closeMenu();
+      }
+    },
+    css: getUserSettingsMenuStyles(),
+    children: jsxs("div", _objectSpread(_objectSpread({}, props.downshiftProps.getMenuProps()), {}, {
+      children: [jsx(UserSettingsAvatarContainer, {
+        children: jsxs(Spacings.Inline, {
+          scale: "m",
+          alignItems: "center",
+          children: [jsx(Avatar, {
+            size: "m",
+            firstName: props.firstName,
+            lastName: props.lastName,
+            gravatarHash: props.gravatarHash,
+            color: "purple"
+          }), jsxs("div", {
+            children: [jsx(Text.Subheadline, {
+              as: "h4",
+              children: _trimInstanceProperty(_context2 = [props.firstName, props.lastName].join(' ')).call(_context2)
+            }), jsx(Text.Detail, {
+              truncate: true,
+              tone: "secondary",
+              children: props.email
+            })]
+          })]
+        })
+      }), accountMenuItems.length > 0 ? jsx(MenuItem, {
+        hasDivider: true
+      }) : null, _mapInstanceProperty(accountMenuItems).call(accountMenuItems, menu => jsx(OptionalFeatureToggle, {
+        featureToggle: menu.featureToggle ?? undefined,
+        children: jsx(Link, {
+          css: getUserSettingsMenuItemLinkStyles(),
+          to: `/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`,
+          onClick: () => props.downshiftProps.toggleMenu(),
+          "data-user-settings-menu": true,
+          ref: menuElementRef,
+          children: jsx(MenuItem, {
+            children: jsx(MenuItemLabel, {
+              children: jsx(Text.Body, {
+                children: renderLabel(menu, props.language)
+              })
+            })
+          })
+        })
+      }, menu.key)), jsx(MenuItem, {
+        hasDivider: true
+      }), jsx("a", {
+        css: getUserSettingsMenuItemLinkStyles(),
+        href: `https://commercetools.com/privacy#suppliers`,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        onClick: () => props.downshiftProps.toggleMenu(),
+        "data-user-settings-menu": true,
+        ref: !applicationsAppBarMenu ? menuElementRef : undefined,
+        children: jsx(MenuItem, {
+          children: jsx(MenuItemLabel, {
+            children: jsx(Text.Body, {
+              intlMessage: messages.privacyPolicy
+            })
+          })
+        })
+      }), jsx("a", {
+        css: getUserSettingsMenuItemLinkStyles(),
+        href: SUPPORT_PORTAL_URL,
+        rel: "noopener noreferrer",
+        target: "_blank",
+        onClick: () => props.downshiftProps.toggleMenu(),
+        "data-user-settings-menu": true,
+        children: jsx(MenuItem, {
+          children: jsx(MenuItemLabel, {
+            children: jsx(Text.Body, {
+              intlMessage: messages.support
+            })
+          })
+        })
+      }), jsx(MenuItem, {
+        hasDivider: true
+      }), jsxs("a", {
+        css: getUserSettingsMenuItemLinkStyles()
+        // NOTE: we want to redirect to a new page so that the
+        // server can remove things like cookie for access token.
+        ,
+        href: `/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`,
+        "data-test": "logout-button",
+        "data-user-settings-menu": true,
+        children: [jsx(MenuItem, {
+          children: jsx(MenuItemLabel, {
+            children: jsx(Text.Body, {
+              intlMessage: messages.logout
+            })
+          })
+        }), jsx("div", {
+          tabIndex: 0,
+          onFocus: () => props.downshiftProps.closeMenu()
+        })]
+      })]
+    }))
+  });
+};
+UserSettingsMenuBody.displayName = 'UserSettingsMenuBody';
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "18rc9yp",
+  styles: "cursor:pointer;border:none;padding:0;display:flex;background:transparent"
+} : {
+  name: "pod1xb-UserSettingsMenu",
+  styles: "cursor:pointer;border:none;padding:0;display:flex;background:transparent;label:UserSettingsMenu;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["user-settings-menu.tsx"],"names":[],"mappings":"AAqUsB","file":"user-settings-menu.tsx","sourcesContent":["import { ReactNode, useCallback, useEffect, useRef, useState } from 'react';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { useFlagVariation } from '@flopflip/react-broadcast';\nimport type { TFlagVariation } from '@flopflip/types';\nimport Downshift, {\n  type ControllerStateAndHelpers,\n  type DownshiftProps,\n} from 'downshift';\nimport { useIntl, FormattedMessage } from 'react-intl';\nimport { Link } from 'react-router-dom';\nimport { useApplicationContext } from '@commercetools-frontend/application-shell-connectors';\nimport {\n  LOGOUT_REASONS,\n  NO_VALUE_FALLBACK,\n  STATIC_URL_PATHS,\n  SUPPORT_PORTAL_URL,\n} from '@commercetools-frontend/constants';\nimport AccessibleHidden from '@commercetools-uikit/accessible-hidden';\nimport Avatar from '@commercetools-uikit/avatar';\nimport { designTokens as uikitDesignTokens } from '@commercetools-uikit/design-system';\nimport Spacings from '@commercetools-uikit/spacings';\nimport Text from '@commercetools-uikit/text';\nimport { DIMENSIONS } from '../../constants';\nimport useApplicationsMenu from '../../hooks/use-applications-menu';\nimport type { TUser } from '../../types/generated/mc';\nimport type { TFetchApplicationsMenuQuery } from '../../types/generated/proxy';\nimport messages from './messages';\n\ntype Props = Pick<\n  TUser,\n  'language' | 'firstName' | 'lastName' | 'email' | 'gravatarHash'\n>;\ntype MenuBodyProps = Props & {\n  downshiftProps: ControllerStateAndHelpers<{}>;\n};\ntype OptionalFeatureToggleProps = {\n  featureToggle?: string;\n  children: ReactNode;\n};\ntype MenuItemProps = {\n  hasDivider?: boolean;\n};\ntype MenuItemLabelProps = {\n  children: ReactNode;\n};\ntype UserSettingsAvatarContainerProps = {\n  children: ReactNode;\n};\ntype MenuConfig = TFetchApplicationsMenuQuery['applicationsMenu']['appBar'][0];\n\nconst MENU_LABEL_ID = 'user-menu-setting-menu-label';\n\nconst UserAvatar = (\n  props: Pick<Props, 'firstName' | 'lastName' | 'gravatarHash'>\n) => {\n  const [isMouseOver, setIsMouseOver] = useState(false);\n  const handleMouseOver = useCallback(() => {\n    setIsMouseOver(true);\n  }, []);\n  const handleMouseOut = useCallback(() => {\n    setIsMouseOver(false);\n  }, []);\n  return (\n    <div onMouseOver={handleMouseOver} onMouseOut={handleMouseOut}>\n      <Spacings.Inline alignItems=\"center\">\n        <Avatar\n          size=\"m\"\n          gravatarHash={props.gravatarHash}\n          firstName={props.firstName}\n          lastName={props.lastName}\n          isHighlighted={isMouseOver}\n          color=\"purple\"\n        />\n      </Spacings.Inline>\n    </div>\n  );\n};\nUserAvatar.displayName = 'UserAvatar';\n\nfunction getIsFocusedElementInMenu() {\n  return Boolean(\n    document.activeElement?.getAttribute('data-user-settings-menu')\n  );\n}\n\nconst stateReducer: DownshiftProps<{}>['stateReducer'] = (state, changes) => {\n  switch (changes.type) {\n    // So in case the user wants to navigate with the tab button\n    // we need to make sure that the menu does not close\n    case Downshift.stateChangeTypes.blurButton:\n      return {\n        ...changes,\n        isOpen: (state.isOpen && getIsFocusedElementInMenu()) ?? false,\n      };\n    default:\n      return changes;\n  }\n};\n\ntype TLongLivedFlag = {\n  value: boolean;\n  reason?: string;\n};\n\nfunction isLongLivedFlag(\n  flag: TFlagVariation | TLongLivedFlag\n): flag is TLongLivedFlag {\n  return typeof (flag as TLongLivedFlag)?.value === 'boolean';\n}\n\nconst OptionalFeatureToggle = (props: OptionalFeatureToggleProps) => {\n  const flagVariation = useFlagVariation(props.featureToggle);\n\n  if (props.featureToggle) {\n    if (flagVariation === true) return <>{props.children}</>;\n    if (isLongLivedFlag(flagVariation) && flagVariation.value === true)\n      return <>{props.children}</>;\n    return null;\n  }\n  return <>{props.children}</>;\n};\n\nconst renderLabel = (\n  menu: MenuConfig,\n  applicationLanguage: Props['language']\n) => {\n  const localizedLabel = menu.labelAllLocales.find((loc) =>\n    applicationLanguage.startsWith(loc.locale)\n  );\n  if (localizedLabel) return localizedLabel.value;\n  return NO_VALUE_FALLBACK;\n};\n\nconst MenuItem = styled.div<MenuItemProps>`\n  width: 100%;\n  cursor: pointer;\n  color: ${uikitDesignTokens.colorSolid};\n\n  :hover {\n    background-color: ${uikitDesignTokens.colorNeutral95};\n  }\n\n  ${(props) =>\n    props.hasDivider === true\n      ? css`\n          border-bottom: 1px solid ${uikitDesignTokens.colorNeutral};\n          margin: ${uikitDesignTokens.spacing10} 0;\n        `\n      : ''};\n`;\n\nconst MenuItemLabel = (props: MenuItemLabelProps) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing20} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst UserSettingsAvatarContainer = (\n  props: UserSettingsAvatarContainerProps\n) => (\n  <div\n    css={css`\n      padding: ${uikitDesignTokens.spacing30} ${uikitDesignTokens.spacing50};\n    `}\n  >\n    {props.children}\n  </div>\n);\n\nconst getUserSettingsMenuStyles = () => {\n  return css`\n    position: absolute;\n    background: ${uikitDesignTokens.colorSurface};\n    border-radius: ${uikitDesignTokens.borderRadius2};\n    box-shadow: 0px 2px 5px 0px rgba(0, 0, 0, 0.15);\n    width: ${uikitDesignTokens.constraint9};\n    right: 40px;\n    top: calc(${DIMENSIONS.header} + ${uikitDesignTokens.spacing20});\n    padding: 0 0 ${uikitDesignTokens.spacing10} 0;\n    overflow: hidden;\n  `;\n};\n\nconst getUserSettingsMenuItemLinkStyles = () => css`\n  display: block;\n`;\n\nconst UserSettingsMenuBody = (props: MenuBodyProps) => {\n  // Focus on a menu item when it's opened through keyboard\n  const menuElementRef = useRef<HTMLAnchorElement>(null);\n  useEffect(() => {\n    menuElementRef.current?.focus();\n  }, []);\n\n  const environment = useApplicationContext((context) => context.environment);\n\n  const applicationsAppBarMenu = useApplicationsMenu<'appBar'>('appBar', {\n    environment,\n  });\n  const accountMenuItems = applicationsAppBarMenu ?? [];\n\n  return (\n    <div\n      onKeyDown={(event) => {\n        if (\n          event.key === 'Esc' ||\n          (event.key === 'Tab' && !getIsFocusedElementInMenu())\n        ) {\n          props.downshiftProps.closeMenu();\n        }\n      }}\n      css={getUserSettingsMenuStyles()}\n    >\n      <div {...props.downshiftProps.getMenuProps()}>\n        <UserSettingsAvatarContainer>\n          <Spacings.Inline scale=\"m\" alignItems=\"center\">\n            <Avatar\n              size=\"m\"\n              firstName={props.firstName}\n              lastName={props.lastName}\n              gravatarHash={props.gravatarHash}\n              color=\"purple\"\n            />\n            <div>\n              <Text.Subheadline as=\"h4\">\n                {[props.firstName, props.lastName].join(' ').trim()}\n              </Text.Subheadline>\n              <Text.Detail truncate tone=\"secondary\">\n                {props.email}\n              </Text.Detail>\n            </div>\n          </Spacings.Inline>\n        </UserSettingsAvatarContainer>\n        {accountMenuItems.length > 0 ? <MenuItem hasDivider={true} /> : null}\n        {accountMenuItems.map((menu) => (\n          <OptionalFeatureToggle\n            key={menu.key}\n            featureToggle={menu.featureToggle ?? undefined}\n          >\n            <Link\n              css={getUserSettingsMenuItemLinkStyles()}\n              to={`/${STATIC_URL_PATHS.ACCOUNT}/${menu.uriPath}`}\n              onClick={() => props.downshiftProps.toggleMenu()}\n              data-user-settings-menu\n              ref={menuElementRef}\n            >\n              <MenuItem>\n                <MenuItemLabel>\n                  <Text.Body>{renderLabel(menu, props.language)}</Text.Body>\n                </MenuItemLabel>\n              </MenuItem>\n            </Link>\n          </OptionalFeatureToggle>\n        ))}\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={`https://commercetools.com/privacy#suppliers`}\n          target=\"_blank\"\n          rel=\"noopener noreferrer\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n          ref={!applicationsAppBarMenu ? menuElementRef : undefined}\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.privacyPolicy} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          href={SUPPORT_PORTAL_URL}\n          rel=\"noopener noreferrer\"\n          target=\"_blank\"\n          onClick={() => props.downshiftProps.toggleMenu()}\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.support} />\n            </MenuItemLabel>\n          </MenuItem>\n        </a>\n        <MenuItem hasDivider={true} />\n        <a\n          css={getUserSettingsMenuItemLinkStyles()}\n          // NOTE: we want to redirect to a new page so that the\n          // server can remove things like cookie for access token.\n          href={`/${STATIC_URL_PATHS.LOGOUT}?reason=${LOGOUT_REASONS.USER}`}\n          data-test=\"logout-button\"\n          data-user-settings-menu\n        >\n          <MenuItem>\n            <MenuItemLabel>\n              <Text.Body intlMessage={messages.logout} />\n            </MenuItemLabel>\n          </MenuItem>\n          <div tabIndex={0} onFocus={() => props.downshiftProps.closeMenu()} />\n        </a>\n      </div>\n    </div>\n  );\n};\nUserSettingsMenuBody.displayName = 'UserSettingsMenuBody';\n\nconst UserSettingsMenu = (props: Props) => {\n  const intl = useIntl();\n\n  return (\n    <div data-test=\"user-settings-menu\">\n      <AccessibleHidden>\n        <span id={MENU_LABEL_ID}>\n          <FormattedMessage {...messages.menuLabel} />\n        </span>\n      </AccessibleHidden>\n      <Downshift stateReducer={stateReducer} labelId={MENU_LABEL_ID}>\n        {(downshiftProps) => (\n          <div>\n            <button\n              css={css`\n                cursor: pointer;\n                border: none;\n                padding: 0;\n                display: flex;\n                background: transparent;\n              `}\n              {...downshiftProps.getToggleButtonProps({\n                'aria-label': intl.formatMessage(\n                  downshiftProps.isOpen\n                    ? messages.closeMenuLabel\n                    : messages.openMenuLabel\n                ),\n              })}\n            >\n              <UserAvatar\n                firstName={props.firstName}\n                lastName={props.lastName}\n                gravatarHash={props.gravatarHash}\n              />\n            </button>\n            {downshiftProps.isOpen && (\n              <UserSettingsMenuBody\n                {...props}\n                downshiftProps={downshiftProps}\n              />\n            )}\n          </div>\n        )}\n      </Downshift>\n    </div>\n  );\n};\nUserSettingsMenu.displayName = 'UserSettingsMenu';\n\nexport default UserSettingsMenu;\n\n// For testing\nexport { UserAvatar, UserSettingsMenuBody };\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const UserSettingsMenu = props => {
+  const intl = useIntl();
+  return jsxs("div", {
+    "data-test": "user-settings-menu",
+    children: [jsx(AccessibleHidden, {
+      children: jsx("span", {
+        id: MENU_LABEL_ID,
+        children: jsx(FormattedMessage, _objectSpread({}, messages.menuLabel))
+      })
+    }), jsx(Downshift, {
+      stateReducer: stateReducer,
+      labelId: MENU_LABEL_ID,
+      children: downshiftProps => jsxs("div", {
+        children: [jsx("button", _objectSpread(_objectSpread({
+          css: _ref
+        }, downshiftProps.getToggleButtonProps({
+          'aria-label': intl.formatMessage(downshiftProps.isOpen ? messages.closeMenuLabel : messages.openMenuLabel)
+        })), {}, {
+          children: jsx(UserAvatar, {
+            firstName: props.firstName,
+            lastName: props.lastName,
+            gravatarHash: props.gravatarHash
+          })
+        })), downshiftProps.isOpen && jsx(UserSettingsMenuBody, _objectSpread(_objectSpread({}, props), {}, {
+          downshiftProps: downshiftProps
+        }))]
+      })
+    })]
+  });
+};
+UserSettingsMenu.displayName = 'UserSettingsMenu';
+
+export { UserAvatar, UserSettingsMenuBody, UserSettingsMenu as default };