@codecademy/brand 3.25.0 → 3.26.0-alpha.193077b42d.0

package/dist/AppHeader/Search/hooks/useSearchTracking.d.ts

@@ -0,0 +1,5 @@
+interface SearchTracking {
+    onSearchAsYouType?: (query: string, searchId: string, resultsCount: number, queryLoadTime: number) => void;
+}
+export declare const useSearchTracking: ({ onSearchAsYouType }: SearchTracking) => void;
+export {};

package/dist/AppHeader/Search/hooks/useSearchTracking.js

@@ -0,0 +1,46 @@
+import { useEffect, useRef } from 'react';
+import { usePrevious } from 'react-use';
+import { isSimilarSetOfStrings } from '../../utils/string-similarity';
+import { useSearchTrackingContext } from '../SearchTrackingProvider';
+export const useSearchTracking = ({
+  onSearchAsYouType
+}) => {
+  const {
+    onSearchAsYouTypeParams
+  } = useSearchTrackingContext();
+
+  // store the previous search event params
+  const prevSearchEventParams = usePrevious(onSearchAsYouTypeParams);
+  const lastTrackedQueryRef = useRef('');
+  useEffect(() => {
+    // skip search tracking entirely if tracking function is not provided
+    if (!onSearchAsYouType) {
+      return;
+    }
+
+    // skip empty queries
+    if (onSearchAsYouTypeParams?.query.length === 0) {
+      return;
+    }
+    let searchEventDelay;
+
+    // scenario 1: track when user's search has no results
+    if (onSearchAsYouTypeParams?.resultsCount === 0) {
+      searchEventDelay = setTimeout(() => {
+        onSearchAsYouType(onSearchAsYouTypeParams.query, onSearchAsYouTypeParams.searchId, 0, onSearchAsYouTypeParams.queryLoadTime);
+        lastTrackedQueryRef.current = onSearchAsYouTypeParams.query;
+      }, 1500);
+    }
+
+    // scenario 2: track when user's search has meaningful edits
+    if (prevSearchEventParams && onSearchAsYouTypeParams?.query !== prevSearchEventParams.query && prevSearchEventParams.query !== '' && prevSearchEventParams.resultsCount > 0 && prevSearchEventParams.query !== lastTrackedQueryRef.current && !isSimilarSetOfStrings(onSearchAsYouTypeParams?.query ?? '', prevSearchEventParams.query)) {
+      searchEventDelay = setTimeout(() => {
+        onSearchAsYouType(prevSearchEventParams.query, prevSearchEventParams.searchId, prevSearchEventParams.resultsCount, prevSearchEventParams.queryLoadTime);
+        lastTrackedQueryRef.current = prevSearchEventParams.query;
+      }, 1500);
+    }
+    return () => {
+      clearTimeout(searchEventDelay);
+    };
+  }, [onSearchAsYouType, onSearchAsYouTypeParams, prevSearchEventParams]);
+};

package/dist/AppHeader/utils/string-similarity.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Determines whether two sets of words are similar based on the Jaccard index and
+ * a specified similarity threshold.
+ *
+ * @param a - A set of strings to compare against the second set of strings.
+ * @param b - A set of strings to compare against the first set of strings.
+ * @param threshold - A float between 0 and 1, where 1 means the strings are
+ * identical and 0 means the strings are completely different.
+ *
+ * The threshold is used to determine if the strings are similar.
+ * By default, if the threshold is 0.8, then the strings are considered similar
+ * if at least 80% of the words in the first set of strings are also in the
+ * second set of strings.
+ *
+ * @returns - It returns true if the strings are similar, false otherwise.
+ */
+export declare const isSimilarSetOfStrings: (a: string, b: string, threshold?: number) => boolean;

package/dist/AppHeader/utils/string-similarity.js

@@ -0,0 +1,30 @@
+const transformSanitizedStringToArray = s => s.trim().toLowerCase().split(/\s+/);
+
+/**
+ * Determines whether two sets of words are similar based on the Jaccard index and
+ * a specified similarity threshold.
+ *
+ * @param a - A set of strings to compare against the second set of strings.
+ * @param b - A set of strings to compare against the first set of strings.
+ * @param threshold - A float between 0 and 1, where 1 means the strings are
+ * identical and 0 means the strings are completely different.
+ *
+ * The threshold is used to determine if the strings are similar.
+ * By default, if the threshold is 0.8, then the strings are considered similar
+ * if at least 80% of the words in the first set of strings are also in the
+ * second set of strings.
+ *
+ * @returns - It returns true if the strings are similar, false otherwise.
+ */
+export const isSimilarSetOfStrings = (a, b, threshold = 0.8) => {
+  const setA = Array.from(new Set(transformSanitizedStringToArray(a)));
+  const setB = Array.from(new Set(transformSanitizedStringToArray(b)));
+
+  // manually calculating intersection and union to support older browsers that may not have
+  // the Set.intersection and Set.union methods
+  const intersection = new Set([...setA].filter(s => setB.includes(s)));
+  const union = new Set([...setA, ...setB]);
+
+  // the Jaccard similarity is the ratio between the intersection and union of the two sets of words
+  return threshold <= intersection.size / union.size;
+};

package/dist/AppHeaderMobile/index.js

@@ -5,6 +5,7 @@ import { Background, css, states, theme } from '@codecademy/gamut-styles';
 import { useEffect, useRef, useState } from 'react';
 import * as React from 'react';
 import { AppHeaderListItem } from '../AppHeader/AppHeaderElements/AppHeaderListItem';
+import { SearchTrackingProvider } from '../AppHeader/Search/SearchTrackingProvider';
 import { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';
 import { appHeaderMobileBreakpoint, StyledAppBar } from '../AppHeader/shared';
 import { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';
@@ -29,7 +30,7 @@ const StyledOverlay = /*#__PURE__*/_styled(Overlay, {
   left: 0,
   top: 0,
   overflowX: `hidden`
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AppHeaderMobile/index.tsx"],"names":[],"mappings":"AA6CsB","file":"../../src/AppHeaderMobile/index.tsx","sourcesContent":["import {\n  Box,\n  ButtonBaseElements,\n  IconButton,\n  Overlay,\n} from '@codecademy/gamut';\nimport { MenuIcon } from '@codecademy/gamut-icons';\nimport { Background, css, states, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useRef, useState } from 'react';\nimport * as React from 'react';\n\nimport { AppHeaderSearch } from '..';\nimport { AppHeaderListItem } from '../AppHeader/AppHeaderElements/AppHeaderListItem';\nimport { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';\nimport {\n  AppHeaderAction,\n  AppHeaderItem,\n  appHeaderMobileBreakpoint,\n  FormattedMobileAppHeaderItems,\n  StyledAppBar,\n} from '../AppHeader/shared';\nimport { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';\nimport { AppHeaderMainMenuMobile } from '../AppHeaderMobile/AppHeaderMainMenuMobile';\nimport { NavigationMenuFormattedLabel } from '../GlobalHeader';\nimport { HeaderHeightArea } from '../HeaderHeightArea';\nimport { NotificationsContents } from '../Notifications/NotificationsContents';\nimport { AppHeaderNotificationSettings } from '../Notifications/types';\nimport { useHeaderNotifications } from '../Notifications/useHeaderNotifications';\n\nexport type AppHeaderMobileProps = AppHeaderAction & {\n  items: FormattedMobileAppHeaderItems;\n  notifications?: AppHeaderNotificationSettings;\n  redirectParam?: string;\n  search: AppHeaderSearch;\n  isAnon: boolean;\n  /**\n   * used to conditonally hide the default search icon and notification bell\n   */\n  isEnterprise?: boolean;\n  isSimple?: boolean;\n  hideRightMenuButton?: boolean;\n  navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;\n};\n\nconst StyledOverlay = styled(Overlay)(\n  css({\n    display: { _: `block`, [appHeaderMobileBreakpoint]: `none` },\n    width: `100vw`,\n    height: `100vh`,\n    opacity: 1,\n    bg: `beige`,\n    position: `fixed`,\n    left: 0,\n    top: 0,\n    overflowX: `hidden`,\n  })\n);\n\nconst StyledNavBar = styled.ul<{ center?: boolean }>(\n  css({\n    display: `flex`,\n    padding: 0,\n    listStyle: `none`,\n    margin: 0,\n    width: `100%`,\n    alignItems: 'center',\n  }),\n  states({\n    center: {\n      justifyContent: {\n        _: 'center',\n        sm: 'flex-start',\n      },\n    },\n  })\n);\n\nexport const AppHeaderMobile: React.FC<AppHeaderMobileProps> = ({\n  action,\n  items,\n  notifications,\n  search,\n  redirectParam,\n  isAnon,\n  isEnterprise,\n  isSimple,\n  hideRightMenuButton,\n  navigationMenuFormattedLabel,\n}) => {\n  const [mobileMenuOpen, setMobileMenuOpen] = useState<boolean | undefined>(\n    undefined\n  );\n  const [allowScroll, setAllowScroll] = useState<boolean>(false);\n  const openButtonRef = useRef<ButtonBaseElements>(null);\n  const closeButtonRef = useRef<ButtonBaseElements>(null);\n\n  const [notificationsBell, notificationsView] = useHeaderNotifications({\n    settings: notifications,\n    Renderer: NotificationsContents,\n  });\n\n  const [searchButton, searchPane] = useHeaderSearch({\n    ...search,\n  });\n\n  const openMobileMenu = () => {\n    setMobileMenuOpen(true);\n\n    if (closeButtonRef.current) {\n      closeButtonRef.current.focus();\n    }\n  };\n\n  useEffect(() => {\n    if (mobileMenuOpen === false && openButtonRef.current) {\n      setTimeout(() => {\n        if (openButtonRef.current) openButtonRef.current.focus();\n      }, 0);\n    }\n  }, [mobileMenuOpen]);\n\n  const mapItemsToElement = <T extends AppHeaderItem[]>(\n    items: T,\n    side: 'left' | 'right',\n    hideExtraItems?: boolean\n  ) => {\n    const shouldHideItems = hideExtraItems === true && items.length > 1;\n    return items.map((item, index) => {\n      const isLastItem = index + 1 === items.length;\n      const isHidable = !isLastItem && shouldHideItems;\n      return (\n        <AppHeaderListItem\n          key={item.id}\n          ml={side === 'right' && index === 0 ? 'auto' : 0}\n          display={{\n            _: isHidable ? 'none' : 'flex',\n            xs: 'flex',\n          }}\n        >\n          {mapAppHeaderItemToElement({\n            action,\n            isStandalone: undefined,\n            isTeams: undefined,\n            item,\n            mobile: true,\n            onKeyDown: undefined,\n            redirectParam,\n          })}\n        </AppHeaderListItem>\n      );\n    });\n  };\n\n  const right = [\n    ...(!isEnterprise ? [searchButton] : []),\n    ...(notificationsBell && !isEnterprise ? [notificationsBell] : []),\n    ...items.right,\n  ];\n\n  const onItemType = (type: string | undefined) => {\n    if (\n      type &&\n      (type === 'catalog-dropdown' || type === 'resources-dropdown')\n    ) {\n      setAllowScroll(true);\n    } else {\n      setAllowScroll(false);\n    }\n  };\n\n  return (\n    <>\n      {!mobileMenuOpen && ( // need this bc AppBar has a hardcoded z-Index of 15\n        <HeaderHeightArea\n          display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n        >\n          <StyledAppBar as=\"nav\" aria-label=\"Main\">\n            <StyledNavBar center={!!isSimple}>\n              {mapItemsToElement(items.left, 'left')}\n              {mapItemsToElement(right, 'right', true)}\n              {!hideRightMenuButton && (\n                <AppHeaderListItem ml={right.length === 0 ? 'auto' : 0}>\n                  <IconButton\n                    aria-expanded={mobileMenuOpen}\n                    aria-label={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tip={'Site\\nnavigation'}\n                    tipProps={{\n                      alignment: 'bottom-center',\n                      placement: 'floating',\n                    }}\n                    data-testid=\"header-mobile-menu\"\n                    onClick={() => {\n                      openMobileMenu();\n                    }}\n                    icon={MenuIcon}\n                    variant=\"interface\"\n                    ref={openButtonRef}\n                  />\n                </AppHeaderListItem>\n              )}\n            </StyledNavBar>\n          </StyledAppBar>\n        </HeaderHeightArea>\n      )}\n      <StyledOverlay\n        clickOutsideCloses\n        escapeCloses\n        isOpen={mobileMenuOpen}\n        onRequestClose={() => setMobileMenuOpen(false)}\n        allowScroll={allowScroll}\n      >\n        <Background bg=\"beige\">\n          <HeaderHeightArea\n            display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n            as=\"nav\"\n            ariaLabel=\"Main\"\n            data-testid=\"header-mobile-menu-dropdown\"\n          >\n            <StyledAppBar>\n              <StyledNavBar>\n                {mapItemsToElement(items.left, 'left')}\n                <AppHeaderListItem ml=\"auto\">\n                  <IconButton\n                    aria-expanded={mobileMenuOpen}\n                    onClick={() => {\n                      setMobileMenuOpen(false);\n                    }}\n                    icon={MenuIcon}\n                    aria-label={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tip={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tipProps={{\n                      alignment: 'bottom-center',\n                      placement: 'floating',\n                    }}\n                    ref={closeButtonRef}\n                  />\n                </AppHeaderListItem>\n              </StyledNavBar>\n            </StyledAppBar>\n            <Box background={theme.colors.beige} height=\"auto\">\n              <AppHeaderMainMenuMobile\n                action={action}\n                items={items.mainMenu}\n                getItemType={onItemType}\n                isAnon={isAnon}\n              />\n            </Box>\n          </HeaderHeightArea>\n        </Background>\n      </StyledOverlay>\n      {!isEnterprise && (\n        <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n          {searchPane}\n        </Box>\n      )}\n      <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n        {notificationsView}\n      </Box>\n    </>\n  );\n};\n"]} */");
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AppHeaderMobile/index.tsx"],"names":[],"mappings":"AA8CsB","file":"../../src/AppHeaderMobile/index.tsx","sourcesContent":["import {\n  Box,\n  ButtonBaseElements,\n  IconButton,\n  Overlay,\n} from '@codecademy/gamut';\nimport { MenuIcon } from '@codecademy/gamut-icons';\nimport { Background, css, states, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useRef, useState } from 'react';\nimport * as React from 'react';\n\nimport { AppHeaderSearch } from '..';\nimport { AppHeaderListItem } from '../AppHeader/AppHeaderElements/AppHeaderListItem';\nimport { SearchTrackingProvider } from '../AppHeader/Search/SearchTrackingProvider';\nimport { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';\nimport {\n  AppHeaderAction,\n  AppHeaderItem,\n  appHeaderMobileBreakpoint,\n  FormattedMobileAppHeaderItems,\n  StyledAppBar,\n} from '../AppHeader/shared';\nimport { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';\nimport { AppHeaderMainMenuMobile } from '../AppHeaderMobile/AppHeaderMainMenuMobile';\nimport { NavigationMenuFormattedLabel } from '../GlobalHeader';\nimport { HeaderHeightArea } from '../HeaderHeightArea';\nimport { NotificationsContents } from '../Notifications/NotificationsContents';\nimport { AppHeaderNotificationSettings } from '../Notifications/types';\nimport { useHeaderNotifications } from '../Notifications/useHeaderNotifications';\n\nexport type AppHeaderMobileProps = AppHeaderAction & {\n  items: FormattedMobileAppHeaderItems;\n  notifications?: AppHeaderNotificationSettings;\n  redirectParam?: string;\n  search: AppHeaderSearch;\n  isAnon: boolean;\n  /**\n   * used to conditonally hide the default search icon and notification bell\n   */\n  isEnterprise?: boolean;\n  isSimple?: boolean;\n  hideRightMenuButton?: boolean;\n  navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;\n};\n\nconst StyledOverlay = styled(Overlay)(\n  css({\n    display: { _: `block`, [appHeaderMobileBreakpoint]: `none` },\n    width: `100vw`,\n    height: `100vh`,\n    opacity: 1,\n    bg: `beige`,\n    position: `fixed`,\n    left: 0,\n    top: 0,\n    overflowX: `hidden`,\n  })\n);\n\nconst StyledNavBar = styled.ul<{ center?: boolean }>(\n  css({\n    display: `flex`,\n    padding: 0,\n    listStyle: `none`,\n    margin: 0,\n    width: `100%`,\n    alignItems: 'center',\n  }),\n  states({\n    center: {\n      justifyContent: {\n        _: 'center',\n        sm: 'flex-start',\n      },\n    },\n  })\n);\n\nexport const AppHeaderMobile: React.FC<AppHeaderMobileProps> = ({\n  action,\n  items,\n  notifications,\n  search,\n  redirectParam,\n  isAnon,\n  isEnterprise,\n  isSimple,\n  hideRightMenuButton,\n  navigationMenuFormattedLabel,\n}) => {\n  const [mobileMenuOpen, setMobileMenuOpen] = useState<boolean | undefined>(\n    undefined\n  );\n  const [allowScroll, setAllowScroll] = useState<boolean>(false);\n  const openButtonRef = useRef<ButtonBaseElements>(null);\n  const closeButtonRef = useRef<ButtonBaseElements>(null);\n\n  const [notificationsBell, notificationsView] = useHeaderNotifications({\n    settings: notifications,\n    Renderer: NotificationsContents,\n  });\n\n  const [searchButton, searchPane] = useHeaderSearch({\n    ...search,\n  });\n\n  const openMobileMenu = () => {\n    setMobileMenuOpen(true);\n\n    if (closeButtonRef.current) {\n      closeButtonRef.current.focus();\n    }\n  };\n\n  useEffect(() => {\n    if (mobileMenuOpen === false && openButtonRef.current) {\n      setTimeout(() => {\n        if (openButtonRef.current) openButtonRef.current.focus();\n      }, 0);\n    }\n  }, [mobileMenuOpen]);\n\n  const mapItemsToElement = <T extends AppHeaderItem[]>(\n    items: T,\n    side: 'left' | 'right',\n    hideExtraItems?: boolean\n  ) => {\n    const shouldHideItems = hideExtraItems === true && items.length > 1;\n    return items.map((item, index) => {\n      const isLastItem = index + 1 === items.length;\n      const isHidable = !isLastItem && shouldHideItems;\n      return (\n        <AppHeaderListItem\n          key={item.id}\n          ml={side === 'right' && index === 0 ? 'auto' : 0}\n          display={{\n            _: isHidable ? 'none' : 'flex',\n            xs: 'flex',\n          }}\n        >\n          {mapAppHeaderItemToElement({\n            action,\n            isStandalone: undefined,\n            isTeams: undefined,\n            item,\n            mobile: true,\n            onKeyDown: undefined,\n            redirectParam,\n          })}\n        </AppHeaderListItem>\n      );\n    });\n  };\n\n  const right = [\n    ...(!isEnterprise ? [searchButton] : []),\n    ...(notificationsBell && !isEnterprise ? [notificationsBell] : []),\n    ...items.right,\n  ];\n\n  const onItemType = (type: string | undefined) => {\n    if (\n      type &&\n      (type === 'catalog-dropdown' || type === 'resources-dropdown')\n    ) {\n      setAllowScroll(true);\n    } else {\n      setAllowScroll(false);\n    }\n  };\n\n  return (\n    <>\n      <SearchTrackingProvider>\n        {!mobileMenuOpen && ( // need this bc AppBar has a hardcoded z-Index of 15\n          <HeaderHeightArea\n            display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n          >\n            <StyledAppBar as=\"nav\" aria-label=\"Main\">\n              <StyledNavBar center={!!isSimple}>\n                {mapItemsToElement(items.left, 'left')}\n                {mapItemsToElement(right, 'right', true)}\n                {!hideRightMenuButton && (\n                  <AppHeaderListItem ml={right.length === 0 ? 'auto' : 0}>\n                    <IconButton\n                      aria-expanded={mobileMenuOpen}\n                      aria-label={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tip={'Site\\nnavigation'}\n                      tipProps={{\n                        alignment: 'bottom-center',\n                        placement: 'floating',\n                      }}\n                      data-testid=\"header-mobile-menu\"\n                      onClick={() => {\n                        openMobileMenu();\n                      }}\n                      icon={MenuIcon}\n                      variant=\"interface\"\n                      ref={openButtonRef}\n                    />\n                  </AppHeaderListItem>\n                )}\n              </StyledNavBar>\n            </StyledAppBar>\n          </HeaderHeightArea>\n        )}\n        <StyledOverlay\n          clickOutsideCloses\n          escapeCloses\n          isOpen={mobileMenuOpen}\n          onRequestClose={() => setMobileMenuOpen(false)}\n          allowScroll={allowScroll}\n        >\n          <Background bg=\"beige\">\n            <HeaderHeightArea\n              display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n              as=\"nav\"\n              ariaLabel=\"Main\"\n              data-testid=\"header-mobile-menu-dropdown\"\n            >\n              <StyledAppBar>\n                <StyledNavBar>\n                  {mapItemsToElement(items.left, 'left')}\n                  <AppHeaderListItem ml=\"auto\">\n                    <IconButton\n                      aria-expanded={mobileMenuOpen}\n                      onClick={() => {\n                        setMobileMenuOpen(false);\n                      }}\n                      icon={MenuIcon}\n                      aria-label={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tip={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tipProps={{\n                        alignment: 'bottom-center',\n                        placement: 'floating',\n                      }}\n                      ref={closeButtonRef}\n                    />\n                  </AppHeaderListItem>\n                </StyledNavBar>\n              </StyledAppBar>\n              <Box background={theme.colors.beige} height=\"auto\">\n                <AppHeaderMainMenuMobile\n                  action={action}\n                  items={items.mainMenu}\n                  getItemType={onItemType}\n                  isAnon={isAnon}\n                />\n              </Box>\n            </HeaderHeightArea>\n          </Background>\n        </StyledOverlay>\n        {!isEnterprise && (\n          <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n            {searchPane}\n          </Box>\n        )}\n        <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n          {notificationsView}\n        </Box>\n      </SearchTrackingProvider>\n    </>\n  );\n};\n"]} */");
 const StyledNavBar = /*#__PURE__*/_styled("ul", {
   target: "e14c9jns0",
   label: "StyledNavBar"
@@ -47,7 +48,7 @@ const StyledNavBar = /*#__PURE__*/_styled("ul", {
       sm: 'flex-start'
     }
   }
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AppHeaderMobile/index.tsx"],"names":[],"mappings":"AA2DqB","file":"../../src/AppHeaderMobile/index.tsx","sourcesContent":["import {\n  Box,\n  ButtonBaseElements,\n  IconButton,\n  Overlay,\n} from '@codecademy/gamut';\nimport { MenuIcon } from '@codecademy/gamut-icons';\nimport { Background, css, states, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useRef, useState } from 'react';\nimport * as React from 'react';\n\nimport { AppHeaderSearch } from '..';\nimport { AppHeaderListItem } from '../AppHeader/AppHeaderElements/AppHeaderListItem';\nimport { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';\nimport {\n  AppHeaderAction,\n  AppHeaderItem,\n  appHeaderMobileBreakpoint,\n  FormattedMobileAppHeaderItems,\n  StyledAppBar,\n} from '../AppHeader/shared';\nimport { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';\nimport { AppHeaderMainMenuMobile } from '../AppHeaderMobile/AppHeaderMainMenuMobile';\nimport { NavigationMenuFormattedLabel } from '../GlobalHeader';\nimport { HeaderHeightArea } from '../HeaderHeightArea';\nimport { NotificationsContents } from '../Notifications/NotificationsContents';\nimport { AppHeaderNotificationSettings } from '../Notifications/types';\nimport { useHeaderNotifications } from '../Notifications/useHeaderNotifications';\n\nexport type AppHeaderMobileProps = AppHeaderAction & {\n  items: FormattedMobileAppHeaderItems;\n  notifications?: AppHeaderNotificationSettings;\n  redirectParam?: string;\n  search: AppHeaderSearch;\n  isAnon: boolean;\n  /**\n   * used to conditonally hide the default search icon and notification bell\n   */\n  isEnterprise?: boolean;\n  isSimple?: boolean;\n  hideRightMenuButton?: boolean;\n  navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;\n};\n\nconst StyledOverlay = styled(Overlay)(\n  css({\n    display: { _: `block`, [appHeaderMobileBreakpoint]: `none` },\n    width: `100vw`,\n    height: `100vh`,\n    opacity: 1,\n    bg: `beige`,\n    position: `fixed`,\n    left: 0,\n    top: 0,\n    overflowX: `hidden`,\n  })\n);\n\nconst StyledNavBar = styled.ul<{ center?: boolean }>(\n  css({\n    display: `flex`,\n    padding: 0,\n    listStyle: `none`,\n    margin: 0,\n    width: `100%`,\n    alignItems: 'center',\n  }),\n  states({\n    center: {\n      justifyContent: {\n        _: 'center',\n        sm: 'flex-start',\n      },\n    },\n  })\n);\n\nexport const AppHeaderMobile: React.FC<AppHeaderMobileProps> = ({\n  action,\n  items,\n  notifications,\n  search,\n  redirectParam,\n  isAnon,\n  isEnterprise,\n  isSimple,\n  hideRightMenuButton,\n  navigationMenuFormattedLabel,\n}) => {\n  const [mobileMenuOpen, setMobileMenuOpen] = useState<boolean | undefined>(\n    undefined\n  );\n  const [allowScroll, setAllowScroll] = useState<boolean>(false);\n  const openButtonRef = useRef<ButtonBaseElements>(null);\n  const closeButtonRef = useRef<ButtonBaseElements>(null);\n\n  const [notificationsBell, notificationsView] = useHeaderNotifications({\n    settings: notifications,\n    Renderer: NotificationsContents,\n  });\n\n  const [searchButton, searchPane] = useHeaderSearch({\n    ...search,\n  });\n\n  const openMobileMenu = () => {\n    setMobileMenuOpen(true);\n\n    if (closeButtonRef.current) {\n      closeButtonRef.current.focus();\n    }\n  };\n\n  useEffect(() => {\n    if (mobileMenuOpen === false && openButtonRef.current) {\n      setTimeout(() => {\n        if (openButtonRef.current) openButtonRef.current.focus();\n      }, 0);\n    }\n  }, [mobileMenuOpen]);\n\n  const mapItemsToElement = <T extends AppHeaderItem[]>(\n    items: T,\n    side: 'left' | 'right',\n    hideExtraItems?: boolean\n  ) => {\n    const shouldHideItems = hideExtraItems === true && items.length > 1;\n    return items.map((item, index) => {\n      const isLastItem = index + 1 === items.length;\n      const isHidable = !isLastItem && shouldHideItems;\n      return (\n        <AppHeaderListItem\n          key={item.id}\n          ml={side === 'right' && index === 0 ? 'auto' : 0}\n          display={{\n            _: isHidable ? 'none' : 'flex',\n            xs: 'flex',\n          }}\n        >\n          {mapAppHeaderItemToElement({\n            action,\n            isStandalone: undefined,\n            isTeams: undefined,\n            item,\n            mobile: true,\n            onKeyDown: undefined,\n            redirectParam,\n          })}\n        </AppHeaderListItem>\n      );\n    });\n  };\n\n  const right = [\n    ...(!isEnterprise ? [searchButton] : []),\n    ...(notificationsBell && !isEnterprise ? [notificationsBell] : []),\n    ...items.right,\n  ];\n\n  const onItemType = (type: string | undefined) => {\n    if (\n      type &&\n      (type === 'catalog-dropdown' || type === 'resources-dropdown')\n    ) {\n      setAllowScroll(true);\n    } else {\n      setAllowScroll(false);\n    }\n  };\n\n  return (\n    <>\n      {!mobileMenuOpen && ( // need this bc AppBar has a hardcoded z-Index of 15\n        <HeaderHeightArea\n          display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n        >\n          <StyledAppBar as=\"nav\" aria-label=\"Main\">\n            <StyledNavBar center={!!isSimple}>\n              {mapItemsToElement(items.left, 'left')}\n              {mapItemsToElement(right, 'right', true)}\n              {!hideRightMenuButton && (\n                <AppHeaderListItem ml={right.length === 0 ? 'auto' : 0}>\n                  <IconButton\n                    aria-expanded={mobileMenuOpen}\n                    aria-label={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tip={'Site\\nnavigation'}\n                    tipProps={{\n                      alignment: 'bottom-center',\n                      placement: 'floating',\n                    }}\n                    data-testid=\"header-mobile-menu\"\n                    onClick={() => {\n                      openMobileMenu();\n                    }}\n                    icon={MenuIcon}\n                    variant=\"interface\"\n                    ref={openButtonRef}\n                  />\n                </AppHeaderListItem>\n              )}\n            </StyledNavBar>\n          </StyledAppBar>\n        </HeaderHeightArea>\n      )}\n      <StyledOverlay\n        clickOutsideCloses\n        escapeCloses\n        isOpen={mobileMenuOpen}\n        onRequestClose={() => setMobileMenuOpen(false)}\n        allowScroll={allowScroll}\n      >\n        <Background bg=\"beige\">\n          <HeaderHeightArea\n            display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n            as=\"nav\"\n            ariaLabel=\"Main\"\n            data-testid=\"header-mobile-menu-dropdown\"\n          >\n            <StyledAppBar>\n              <StyledNavBar>\n                {mapItemsToElement(items.left, 'left')}\n                <AppHeaderListItem ml=\"auto\">\n                  <IconButton\n                    aria-expanded={mobileMenuOpen}\n                    onClick={() => {\n                      setMobileMenuOpen(false);\n                    }}\n                    icon={MenuIcon}\n                    aria-label={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tip={\n                      navigationMenuFormattedLabel?.siteNavigation ||\n                      'Site navigation'\n                    }\n                    tipProps={{\n                      alignment: 'bottom-center',\n                      placement: 'floating',\n                    }}\n                    ref={closeButtonRef}\n                  />\n                </AppHeaderListItem>\n              </StyledNavBar>\n            </StyledAppBar>\n            <Box background={theme.colors.beige} height=\"auto\">\n              <AppHeaderMainMenuMobile\n                action={action}\n                items={items.mainMenu}\n                getItemType={onItemType}\n                isAnon={isAnon}\n              />\n            </Box>\n          </HeaderHeightArea>\n        </Background>\n      </StyledOverlay>\n      {!isEnterprise && (\n        <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n          {searchPane}\n        </Box>\n      )}\n      <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n        {notificationsView}\n      </Box>\n    </>\n  );\n};\n"]} */");
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AppHeaderMobile/index.tsx"],"names":[],"mappings":"AA4DqB","file":"../../src/AppHeaderMobile/index.tsx","sourcesContent":["import {\n  Box,\n  ButtonBaseElements,\n  IconButton,\n  Overlay,\n} from '@codecademy/gamut';\nimport { MenuIcon } from '@codecademy/gamut-icons';\nimport { Background, css, states, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useRef, useState } from 'react';\nimport * as React from 'react';\n\nimport { AppHeaderSearch } from '..';\nimport { AppHeaderListItem } from '../AppHeader/AppHeaderElements/AppHeaderListItem';\nimport { SearchTrackingProvider } from '../AppHeader/Search/SearchTrackingProvider';\nimport { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';\nimport {\n  AppHeaderAction,\n  AppHeaderItem,\n  appHeaderMobileBreakpoint,\n  FormattedMobileAppHeaderItems,\n  StyledAppBar,\n} from '../AppHeader/shared';\nimport { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';\nimport { AppHeaderMainMenuMobile } from '../AppHeaderMobile/AppHeaderMainMenuMobile';\nimport { NavigationMenuFormattedLabel } from '../GlobalHeader';\nimport { HeaderHeightArea } from '../HeaderHeightArea';\nimport { NotificationsContents } from '../Notifications/NotificationsContents';\nimport { AppHeaderNotificationSettings } from '../Notifications/types';\nimport { useHeaderNotifications } from '../Notifications/useHeaderNotifications';\n\nexport type AppHeaderMobileProps = AppHeaderAction & {\n  items: FormattedMobileAppHeaderItems;\n  notifications?: AppHeaderNotificationSettings;\n  redirectParam?: string;\n  search: AppHeaderSearch;\n  isAnon: boolean;\n  /**\n   * used to conditonally hide the default search icon and notification bell\n   */\n  isEnterprise?: boolean;\n  isSimple?: boolean;\n  hideRightMenuButton?: boolean;\n  navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;\n};\n\nconst StyledOverlay = styled(Overlay)(\n  css({\n    display: { _: `block`, [appHeaderMobileBreakpoint]: `none` },\n    width: `100vw`,\n    height: `100vh`,\n    opacity: 1,\n    bg: `beige`,\n    position: `fixed`,\n    left: 0,\n    top: 0,\n    overflowX: `hidden`,\n  })\n);\n\nconst StyledNavBar = styled.ul<{ center?: boolean }>(\n  css({\n    display: `flex`,\n    padding: 0,\n    listStyle: `none`,\n    margin: 0,\n    width: `100%`,\n    alignItems: 'center',\n  }),\n  states({\n    center: {\n      justifyContent: {\n        _: 'center',\n        sm: 'flex-start',\n      },\n    },\n  })\n);\n\nexport const AppHeaderMobile: React.FC<AppHeaderMobileProps> = ({\n  action,\n  items,\n  notifications,\n  search,\n  redirectParam,\n  isAnon,\n  isEnterprise,\n  isSimple,\n  hideRightMenuButton,\n  navigationMenuFormattedLabel,\n}) => {\n  const [mobileMenuOpen, setMobileMenuOpen] = useState<boolean | undefined>(\n    undefined\n  );\n  const [allowScroll, setAllowScroll] = useState<boolean>(false);\n  const openButtonRef = useRef<ButtonBaseElements>(null);\n  const closeButtonRef = useRef<ButtonBaseElements>(null);\n\n  const [notificationsBell, notificationsView] = useHeaderNotifications({\n    settings: notifications,\n    Renderer: NotificationsContents,\n  });\n\n  const [searchButton, searchPane] = useHeaderSearch({\n    ...search,\n  });\n\n  const openMobileMenu = () => {\n    setMobileMenuOpen(true);\n\n    if (closeButtonRef.current) {\n      closeButtonRef.current.focus();\n    }\n  };\n\n  useEffect(() => {\n    if (mobileMenuOpen === false && openButtonRef.current) {\n      setTimeout(() => {\n        if (openButtonRef.current) openButtonRef.current.focus();\n      }, 0);\n    }\n  }, [mobileMenuOpen]);\n\n  const mapItemsToElement = <T extends AppHeaderItem[]>(\n    items: T,\n    side: 'left' | 'right',\n    hideExtraItems?: boolean\n  ) => {\n    const shouldHideItems = hideExtraItems === true && items.length > 1;\n    return items.map((item, index) => {\n      const isLastItem = index + 1 === items.length;\n      const isHidable = !isLastItem && shouldHideItems;\n      return (\n        <AppHeaderListItem\n          key={item.id}\n          ml={side === 'right' && index === 0 ? 'auto' : 0}\n          display={{\n            _: isHidable ? 'none' : 'flex',\n            xs: 'flex',\n          }}\n        >\n          {mapAppHeaderItemToElement({\n            action,\n            isStandalone: undefined,\n            isTeams: undefined,\n            item,\n            mobile: true,\n            onKeyDown: undefined,\n            redirectParam,\n          })}\n        </AppHeaderListItem>\n      );\n    });\n  };\n\n  const right = [\n    ...(!isEnterprise ? [searchButton] : []),\n    ...(notificationsBell && !isEnterprise ? [notificationsBell] : []),\n    ...items.right,\n  ];\n\n  const onItemType = (type: string | undefined) => {\n    if (\n      type &&\n      (type === 'catalog-dropdown' || type === 'resources-dropdown')\n    ) {\n      setAllowScroll(true);\n    } else {\n      setAllowScroll(false);\n    }\n  };\n\n  return (\n    <>\n      <SearchTrackingProvider>\n        {!mobileMenuOpen && ( // need this bc AppBar has a hardcoded z-Index of 15\n          <HeaderHeightArea\n            display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n          >\n            <StyledAppBar as=\"nav\" aria-label=\"Main\">\n              <StyledNavBar center={!!isSimple}>\n                {mapItemsToElement(items.left, 'left')}\n                {mapItemsToElement(right, 'right', true)}\n                {!hideRightMenuButton && (\n                  <AppHeaderListItem ml={right.length === 0 ? 'auto' : 0}>\n                    <IconButton\n                      aria-expanded={mobileMenuOpen}\n                      aria-label={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tip={'Site\\nnavigation'}\n                      tipProps={{\n                        alignment: 'bottom-center',\n                        placement: 'floating',\n                      }}\n                      data-testid=\"header-mobile-menu\"\n                      onClick={() => {\n                        openMobileMenu();\n                      }}\n                      icon={MenuIcon}\n                      variant=\"interface\"\n                      ref={openButtonRef}\n                    />\n                  </AppHeaderListItem>\n                )}\n              </StyledNavBar>\n            </StyledAppBar>\n          </HeaderHeightArea>\n        )}\n        <StyledOverlay\n          clickOutsideCloses\n          escapeCloses\n          isOpen={mobileMenuOpen}\n          onRequestClose={() => setMobileMenuOpen(false)}\n          allowScroll={allowScroll}\n        >\n          <Background bg=\"beige\">\n            <HeaderHeightArea\n              display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}\n              as=\"nav\"\n              ariaLabel=\"Main\"\n              data-testid=\"header-mobile-menu-dropdown\"\n            >\n              <StyledAppBar>\n                <StyledNavBar>\n                  {mapItemsToElement(items.left, 'left')}\n                  <AppHeaderListItem ml=\"auto\">\n                    <IconButton\n                      aria-expanded={mobileMenuOpen}\n                      onClick={() => {\n                        setMobileMenuOpen(false);\n                      }}\n                      icon={MenuIcon}\n                      aria-label={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tip={\n                        navigationMenuFormattedLabel?.siteNavigation ||\n                        'Site navigation'\n                      }\n                      tipProps={{\n                        alignment: 'bottom-center',\n                        placement: 'floating',\n                      }}\n                      ref={closeButtonRef}\n                    />\n                  </AppHeaderListItem>\n                </StyledNavBar>\n              </StyledAppBar>\n              <Box background={theme.colors.beige} height=\"auto\">\n                <AppHeaderMainMenuMobile\n                  action={action}\n                  items={items.mainMenu}\n                  getItemType={onItemType}\n                  isAnon={isAnon}\n                />\n              </Box>\n            </HeaderHeightArea>\n          </Background>\n        </StyledOverlay>\n        {!isEnterprise && (\n          <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n            {searchPane}\n          </Box>\n        )}\n        <Box display={{ _: `block`, [appHeaderMobileBreakpoint]: `none` }}>\n          {notificationsView}\n        </Box>\n      </SearchTrackingProvider>\n    </>\n  );\n};\n"]} */");
 export const AppHeaderMobile = ({
   action,
   items,
@@ -115,101 +116,103 @@ export const AppHeaderMobile = ({
       setAllowScroll(false);
     }
   };
-  return /*#__PURE__*/_jsxs(_Fragment, {
-    children: [!mobileMenuOpen &&
-    /*#__PURE__*/
-    // need this bc AppBar has a hardcoded z-Index of 15
-    _jsx(HeaderHeightArea, {
-      display: {
-        _: `block`,
-        [appHeaderMobileBreakpoint]: `none`
-      },
-      children: /*#__PURE__*/_jsx(StyledAppBar, {
-        as: "nav",
-        "aria-label": "Main",
-        children: /*#__PURE__*/_jsxs(StyledNavBar, {
-          center: !!isSimple,
-          children: [mapItemsToElement(items.left, 'left'), mapItemsToElement(right, 'right', true), !hideRightMenuButton && /*#__PURE__*/_jsx(AppHeaderListItem, {
-            ml: right.length === 0 ? 'auto' : 0,
-            children: /*#__PURE__*/_jsx(IconButton, {
-              "aria-expanded": mobileMenuOpen,
-              "aria-label": navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
-              tip: 'Site\nnavigation',
-              tipProps: {
-                alignment: 'bottom-center',
-                placement: 'floating'
-              },
-              "data-testid": "header-mobile-menu",
-              onClick: () => {
-                openMobileMenu();
-              },
-              icon: MenuIcon,
-              variant: "interface",
-              ref: openButtonRef
-            })
-          })]
-        })
-      })
-    }), /*#__PURE__*/_jsx(StyledOverlay, {
-      clickOutsideCloses: true,
-      escapeCloses: true,
-      isOpen: mobileMenuOpen,
-      onRequestClose: () => setMobileMenuOpen(false),
-      allowScroll: allowScroll,
-      children: /*#__PURE__*/_jsx(Background, {
-        bg: "beige",
-        children: /*#__PURE__*/_jsxs(HeaderHeightArea, {
-          display: {
-            _: `block`,
-            [appHeaderMobileBreakpoint]: `none`
-          },
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: /*#__PURE__*/_jsxs(SearchTrackingProvider, {
+      children: [!mobileMenuOpen &&
+      /*#__PURE__*/
+      // need this bc AppBar has a hardcoded z-Index of 15
+      _jsx(HeaderHeightArea, {
+        display: {
+          _: `block`,
+          [appHeaderMobileBreakpoint]: `none`
+        },
+        children: /*#__PURE__*/_jsx(StyledAppBar, {
           as: "nav",
-          ariaLabel: "Main",
-          "data-testid": "header-mobile-menu-dropdown",
-          children: [/*#__PURE__*/_jsx(StyledAppBar, {
-            children: /*#__PURE__*/_jsxs(StyledNavBar, {
-              children: [mapItemsToElement(items.left, 'left'), /*#__PURE__*/_jsx(AppHeaderListItem, {
-                ml: "auto",
-                children: /*#__PURE__*/_jsx(IconButton, {
-                  "aria-expanded": mobileMenuOpen,
-                  onClick: () => {
-                    setMobileMenuOpen(false);
-                  },
-                  icon: MenuIcon,
-                  "aria-label": navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
-                  tip: navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
-                  tipProps: {
-                    alignment: 'bottom-center',
-                    placement: 'floating'
-                  },
-                  ref: closeButtonRef
-                })
-              })]
-            })
-          }), /*#__PURE__*/_jsx(Box, {
-            background: theme.colors.beige,
-            height: "auto",
-            children: /*#__PURE__*/_jsx(AppHeaderMainMenuMobile, {
-              action: action,
-              items: items.mainMenu,
-              getItemType: onItemType,
-              isAnon: isAnon
-            })
-          })]
+          "aria-label": "Main",
+          children: /*#__PURE__*/_jsxs(StyledNavBar, {
+            center: !!isSimple,
+            children: [mapItemsToElement(items.left, 'left'), mapItemsToElement(right, 'right', true), !hideRightMenuButton && /*#__PURE__*/_jsx(AppHeaderListItem, {
+              ml: right.length === 0 ? 'auto' : 0,
+              children: /*#__PURE__*/_jsx(IconButton, {
+                "aria-expanded": mobileMenuOpen,
+                "aria-label": navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
+                tip: 'Site\nnavigation',
+                tipProps: {
+                  alignment: 'bottom-center',
+                  placement: 'floating'
+                },
+                "data-testid": "header-mobile-menu",
+                onClick: () => {
+                  openMobileMenu();
+                },
+                icon: MenuIcon,
+                variant: "interface",
+                ref: openButtonRef
+              })
+            })]
+          })
+        })
+      }), /*#__PURE__*/_jsx(StyledOverlay, {
+        clickOutsideCloses: true,
+        escapeCloses: true,
+        isOpen: mobileMenuOpen,
+        onRequestClose: () => setMobileMenuOpen(false),
+        allowScroll: allowScroll,
+        children: /*#__PURE__*/_jsx(Background, {
+          bg: "beige",
+          children: /*#__PURE__*/_jsxs(HeaderHeightArea, {
+            display: {
+              _: `block`,
+              [appHeaderMobileBreakpoint]: `none`
+            },
+            as: "nav",
+            ariaLabel: "Main",
+            "data-testid": "header-mobile-menu-dropdown",
+            children: [/*#__PURE__*/_jsx(StyledAppBar, {
+              children: /*#__PURE__*/_jsxs(StyledNavBar, {
+                children: [mapItemsToElement(items.left, 'left'), /*#__PURE__*/_jsx(AppHeaderListItem, {
+                  ml: "auto",
+                  children: /*#__PURE__*/_jsx(IconButton, {
+                    "aria-expanded": mobileMenuOpen,
+                    onClick: () => {
+                      setMobileMenuOpen(false);
+                    },
+                    icon: MenuIcon,
+                    "aria-label": navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
+                    tip: navigationMenuFormattedLabel?.siteNavigation || 'Site navigation',
+                    tipProps: {
+                      alignment: 'bottom-center',
+                      placement: 'floating'
+                    },
+                    ref: closeButtonRef
+                  })
+                })]
+              })
+            }), /*#__PURE__*/_jsx(Box, {
+              background: theme.colors.beige,
+              height: "auto",
+              children: /*#__PURE__*/_jsx(AppHeaderMainMenuMobile, {
+                action: action,
+                items: items.mainMenu,
+                getItemType: onItemType,
+                isAnon: isAnon
+              })
+            })]
+          })
         })
-      })
-    }), !isEnterprise && /*#__PURE__*/_jsx(Box, {
-      display: {
-        _: `block`,
-        [appHeaderMobileBreakpoint]: `none`
-      },
-      children: searchPane
-    }), /*#__PURE__*/_jsx(Box, {
-      display: {
-        _: `block`,
-        [appHeaderMobileBreakpoint]: `none`
-      },
-      children: notificationsView
-    })]
+      }), !isEnterprise && /*#__PURE__*/_jsx(Box, {
+        display: {
+          _: `block`,
+          [appHeaderMobileBreakpoint]: `none`
+        },
+        children: searchPane
+      }), /*#__PURE__*/_jsx(Box, {
+        display: {
+          _: `block`,
+          [appHeaderMobileBreakpoint]: `none`
+        },
+        children: notificationsView
+      })]
+    })
   });
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codecademy/brand",
   "description": "Brand component library for Codecademy",
-  "version": "3.25.0",
+  "version": "3.26.0-alpha.193077b42d.0",
   "author": "Codecademy Engineering <dev@codecademy.com>",
   "dependencies": {
     "@emotion/is-prop-valid": "^1.2.1",
@@ -27,12 +27,7 @@
   "main": "./dist/index.js",
   "peerDependencies": {
     "@codecademy/gamut": "*",
-    "@codecademy/gamut-icons": "*",
-    "@codecademy/gamut-illustrations": "*",
-    "@codecademy/gamut-patterns": "*",
-    "@codecademy/gamut-styles": "*",
     "@codecademy/tracking": "1.2.0",
-    "@codecademy/variance": "*",
     "@emotion/react": "^11.4.0",
     "@emotion/styled": "^11.3.0",
     "react": "^17.0.2 || ^18.2.0"