@codecademy/brand 4.0.0-alpha.fb4adf2b4d.0 → 4.0.0

package/dist/AppHeaderMobile/AppHeaderSubMenuTarget/index.js

@@ -0,0 +1,60 @@
+import _styled from "@emotion/styled/base";
+import { Anchor, Text } from '@codecademy/gamut';
+import { ArrowChevronRightIcon } from '@codecademy/gamut-icons';
+import { css } from '@codecademy/gamut-styles';
+import * as React from 'react';
+import { Avatar } from '../../Avatar';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const StyledAnchor = /*#__PURE__*/_styled(Anchor, {
+  target: "etgovsy1",
+  label: "StyledAnchor"
+})(css({
+  alignItems: 'center',
+  display: 'flex',
+  justifyContent: 'space-between',
+  py: 16,
+  width: '100%'
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledText = /*#__PURE__*/_styled(Text, {
+  target: "etgovsy0",
+  label: "StyledText"
+})(css({
+  ml: 16,
+  maxWidth: `70vw`,
+  overflow: `hidden`,
+  textOverflow: `ellipsis`
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+export const AppHeaderSubMenuRow = ({
+  item,
+  openSubMenu
+}) => {
+  const getIcon = () => {
+    if (item.type !== 'profile-dropdown') {
+      const Icon = item.icon;
+      return Icon && /*#__PURE__*/_jsx(Icon, {
+        size: 24,
+        "aria-hidden": true
+      });
+    }
+    return /*#__PURE__*/_jsx(Avatar, {
+      src: item.avatar,
+      alt: "User profile avatar",
+      disableDropshadow: true,
+      size: 24
+    });
+  };
+  return /*#__PURE__*/_jsxs(StyledAnchor, {
+    "aria-label": `Open ${item.text} navigation`,
+    "data-testid": item.dataTestId,
+    onClick: event => openSubMenu(event, item),
+    variant: "interface",
+    children: [getIcon(), /*#__PURE__*/_jsx(StyledText, {
+      children: item.type === 'profile-dropdown' ? item.userDisplayName : item.text
+    }), /*#__PURE__*/_jsx(ArrowChevronRightIcon, {
+      ml: "auto",
+      my: "auto",
+      size: 12,
+      "aria-hidden": true
+    })]
+  });
+};

package/dist/AppHeaderMobile/index.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { AppHeaderSearch } from '..';
+import { AppHeaderAction, FormattedMobileAppHeaderItems } from '../AppHeader/shared';
+import { NavigationMenuFormattedLabel } from '../GlobalHeader';
+import { AppHeaderNotificationSettings } from '../Notifications/types';
+export type AppHeaderMobileProps = AppHeaderAction & {
+    items: FormattedMobileAppHeaderItems;
+    notifications?: AppHeaderNotificationSettings;
+    redirectParam?: string;
+    search: AppHeaderSearch;
+    isAnon: boolean;
+    /**
+     * used to conditonally hide the default search icon and notification bell
+     */
+    isEnterprise?: boolean;
+    isSimple?: boolean;
+    hideRightMenuButton?: boolean;
+    navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;
+};
+export declare const AppHeaderMobile: React.FC<AppHeaderMobileProps>;

package/dist/AppHeaderMobile/index.js

@@ -0,0 +1,214 @@
+import _styled from "@emotion/styled/base";
+import { Box, IconButton, Overlay } from '@codecademy/gamut';
+import { MenuIcon } from '@codecademy/gamut-icons';
+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 { useHeaderSearch } from '../AppHeader/Search/useHeaderSearch';
+import { appHeaderMobileBreakpoint, StyledAppBar } from '../AppHeader/shared';
+import { mapAppHeaderItemToElement } from '../AppHeader/shared/utils';
+import { AppHeaderMainMenuMobile } from '../AppHeaderMobile/AppHeaderMainMenuMobile';
+import { HeaderHeightArea } from '../HeaderHeightArea';
+import { NotificationsContents } from '../Notifications/NotificationsContents';
+import { useHeaderNotifications } from '../Notifications/useHeaderNotifications';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const StyledOverlay = /*#__PURE__*/_styled(Overlay, {
+  target: "e14c9jns1",
+  label: "StyledOverlay"
+})(css({
+  display: {
+    _: `block`,
+    [appHeaderMobileBreakpoint]: `none`
+  },
+  width: `100vw`,
+  height: `100vh`,
+  opacity: 1,
+  bg: `beige`,
+  position: `fixed`,
+  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            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"]} */");
+const StyledNavBar = /*#__PURE__*/_styled("ul", {
+  target: "e14c9jns0",
+  label: "StyledNavBar"
+})(css({
+  display: `flex`,
+  padding: 0,
+  listStyle: `none`,
+  margin: 0,
+  width: `100%`,
+  alignItems: 'center'
+}), states({
+  center: {
+    justifyContent: {
+      _: 'center',
+      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            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"]} */");
+export const AppHeaderMobile = ({
+  action,
+  items,
+  notifications,
+  search,
+  redirectParam,
+  isAnon,
+  isEnterprise,
+  isSimple,
+  hideRightMenuButton,
+  navigationMenuFormattedLabel
+}) => {
+  const [mobileMenuOpen, setMobileMenuOpen] = useState(undefined);
+  const [allowScroll, setAllowScroll] = useState(false);
+  const openButtonRef = useRef(null);
+  const closeButtonRef = useRef(null);
+  const [notificationsBell, notificationsView] = useHeaderNotifications({
+    settings: notifications,
+    Renderer: NotificationsContents
+  });
+  const [searchButton, searchPane] = useHeaderSearch({
+    ...search
+  });
+  const openMobileMenu = () => {
+    setMobileMenuOpen(true);
+    if (closeButtonRef.current) {
+      closeButtonRef.current.focus();
+    }
+  };
+  useEffect(() => {
+    if (mobileMenuOpen === false && openButtonRef.current) {
+      setTimeout(() => {
+        if (openButtonRef.current) openButtonRef.current.focus();
+      }, 0);
+    }
+  }, [mobileMenuOpen]);
+  const mapItemsToElement = (items, side, hideExtraItems) => {
+    const shouldHideItems = hideExtraItems === true && items.length > 1;
+    return items.map((item, index) => {
+      const isLastItem = index + 1 === items.length;
+      const isHidable = !isLastItem && shouldHideItems;
+      return /*#__PURE__*/_jsx(AppHeaderListItem, {
+        ml: side === 'right' && index === 0 ? 'auto' : 0,
+        display: {
+          _: isHidable ? 'none' : 'flex',
+          xs: 'flex'
+        },
+        children: mapAppHeaderItemToElement({
+          action,
+          isStandalone: undefined,
+          isTeams: undefined,
+          item,
+          mobile: true,
+          redirectParam
+        })
+      }, item.id);
+    });
+  };
+  const right = [...(!isEnterprise ? [searchButton] : []), ...(notificationsBell && !isEnterprise ? [notificationsBell] : []), ...items.right];
+  const onItemType = type => {
+    if (type && (type === 'catalog-dropdown' || type === 'resources-dropdown')) {
+      setAllowScroll(true);
+    } else {
+      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`
+          },
+          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
+    })]
+  });
+};

package/dist/Avatar/Avatar.stories.js

@@ -0,0 +1,15 @@
+import { Avatar } from '.';
+const meta = {
+  /* 👇 The title prop is optional.
+   * See https://storybook.js.org/docs/react/configure/overview#configure-story-loading
+   * to learn how to generate automatic titles
+   */
+  component: Avatar
+};
+export default meta;
+export const Primary = {
+  args: {
+    alt: 'The Codey character drinking Boba tea',
+    src: 'https://content.codecademy.com/courses/free/boba.svg'
+  }
+};

package/dist/Avatar/index.d.ts

@@ -0,0 +1,36 @@
+import { VisualTheme } from '@codecademy/gamut';
+import { ResponsiveProp } from '@codecademy/variance';
+import * as React from 'react';
+export type AvatarImageProps = {
+    alt: string;
+    'aria-labelledby'?: never;
+} | {
+    alt?: never;
+    'aria-labelledby': string;
+};
+export type AvatarBaseProps = {
+    /**
+     * path to image asset
+     */
+    src: string;
+    /**
+     * Disables the drop shadow entirely.
+     */
+    disableDropshadow?: boolean;
+    /**
+     * Size of the Avatar.
+     */
+    size?: ResponsiveProp<24 | 32 | 40 | 48 | 64 | 118> | '100%';
+    /**
+     * Overrides styles on the Avatar container.
+     */
+    className?: string;
+    /**
+     * @deprecated
+     * This will be determined automatically by the theme moving forward.
+     * Supplying it will determine the color of drop shadow.
+     */
+    mode?: VisualTheme;
+};
+export type AvatarProps = AvatarBaseProps & AvatarImageProps;
+export declare const Avatar: React.FC<AvatarProps>;

package/dist/Avatar/index.js

@@ -0,0 +1,45 @@
+import _styled from "@emotion/styled/base";
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+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)."; }
+import { styledOptions, system, theme } from '@codecademy/gamut-styles';
+import { css } from '@emotion/react';
+import * as React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+const Image = /*#__PURE__*/_styled('img', _extends({}, {
+  target: "e1u51ndw1",
+  label: "Image"
+}, styledOptions()))(system.layout, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "im73wu-AvatarContainer",
+  styles: "transform:scale(0.92);transform-origin:top left;label:AvatarContainer;"
+} : {
+  name: "im73wu-AvatarContainer",
+  styles: "transform:scale(0.92);transform-origin:top left;label:AvatarContainer;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const AvatarContainer = /*#__PURE__*/_styled("div", {
+  target: "e1u51ndw0",
+  label: "AvatarContainer"
+})("position:relative;display:table;", ({
+  disableDropshadow,
+  mode
+}) => !disableDropshadow && /*#__PURE__*/css("&::before{content:'';position:absolute;border-radius:50%;transform:scale(0.92);transform-origin:bottom right;height:100%;width:100%;background-color:", mode ? mode === 'light' ? theme.colors.lightGreen : theme.colors.green : theme.colors['feedback-success'], ";};label:AvatarContainer;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")), " ", Image, "{position:relative;border-radius:50%;object-fit:cover;", ({
+  disableDropshadow
+}) => !disableDropshadow && _ref, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+export const Avatar = ({
+  mode,
+  disableDropshadow,
+  // ENT-361 Fixed Firefox Issue, set default size to 24 from 118
+  size = 24,
+  className,
+  ...avatarImageProps
+}) => /*#__PURE__*/_jsx(AvatarContainer, {
+  className: className,
+  mode: mode,
+  disableDropshadow: disableDropshadow,
+  "data-testid": "avatar-container",
+  children: /*#__PURE__*/_jsx(Image, {
+    dimensions: size,
+    ...avatarImageProps
+  })
+});

package/dist/AvatarChooser/index.d.ts

@@ -0,0 +1,12 @@
+import { UseFormReturn, Validate } from '@codecademy/gamut';
+import * as React from 'react';
+type AvatarChooserProps = {
+    src: string;
+    name?: string;
+    register?: UseFormReturn['register'];
+    onImageChanged?: (imageFileList: FileList) => void;
+    validate?: Validate<FileList, [FileList]> | Record<string, Validate<FileList, [FileList]>>;
+    error?: string;
+};
+export declare const AvatarChooser: React.FC<AvatarChooserProps>;
+export {};

package/dist/AvatarChooser/index.js

@@ -0,0 +1,105 @@
+import _styled from "@emotion/styled/base";
+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)."; }
+import { FlexBox, FormError, Input, TextButton } from '@codecademy/gamut';
+import { pxRem, theme } from '@codecademy/gamut-styles';
+import { useCallback, useRef, useState } from 'react';
+import * as React from 'react';
+import { Avatar } from '../Avatar';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const baseSize = 75;
+const smBreakpointSize = 120;
+const StyledAvatar = /*#__PURE__*/_styled(Avatar, {
+  target: "e1ouehc42",
+  label: "StyledAvatar"
+})("img{width:", pxRem(baseSize), ";height:", pxRem(baseSize), ";}", theme.breakpoints.sm, "{img{width:", pxRem(smBreakpointSize), ";height:", pxRem(smBreakpointSize), ";}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const HiddenInput = /*#__PURE__*/_styled(Input, {
+  target: "e1ouehc41",
+  label: "HiddenInput"
+})(process.env.NODE_ENV === "production" ? {
+  name: "eivff4",
+  styles: "display:none"
+} : {
+  name: "eivff4",
+  styles: "display:none/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const StyledFormError = /*#__PURE__*/_styled(FormError, {
+  target: "e1ouehc40",
+  label: "StyledFormError"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1l8affw",
+  styles: "position:initial;text-align:center"
+} : {
+  name: "1l8affw",
+  styles: "position:initial;text-align:center/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export const AvatarChooser = ({
+  src: existingSrc,
+  onImageChanged,
+  error,
+  register,
+  validate = validatePhotoUpload,
+  name = 'Avatar Photo'
+}) => {
+  const [imageSrc, setImageSrc] = useState(existingSrc);
+  const choosePhotoLabelRef = useRef(null);
+  const onChange = useCallback(event => {
+    const target = event?.target;
+    const imageFilelist = target?.files;
+    const imageFile = imageFilelist?.[0];
+    if (imageFilelist) onImageChanged?.(imageFilelist);
+    if (imageFile) setImageSrc(URL.createObjectURL(imageFile));
+  }, [setImageSrc, onImageChanged]);
+  return /*#__PURE__*/_jsxs(FlexBox, {
+    alignItems: "center",
+    flexDirection: "column",
+    justifyContent: "center",
+    width: "fit-content",
+    maxWidth: pxRem(120),
+    "aria-live": "polite",
+    children: [/*#__PURE__*/_jsx(StyledAvatar, {
+      src: imageSrc,
+      disableDropshadow: true,
+      alt: "Avatar Photo"
+    }), /*#__PURE__*/_jsx(TextButton, {
+      mt: {
+        _: 4,
+        sm: 12
+      },
+      onClick: () => choosePhotoLabelRef.current?.click(),
+      children: /*#__PURE__*/_jsx("label", {
+        ref: choosePhotoLabelRef,
+        htmlFor: "avatar-chooser",
+        children: "Choose Photo"
+      })
+    }), /*#__PURE__*/_jsx(HiddenInput, {
+      type: "file",
+      id: "avatar-chooser",
+      "aria-invalid": Boolean(error),
+      name: name,
+      onChange: onChange,
+      ...register?.(name, {
+        onChange,
+        validate,
+        required: false
+      })
+    }), error && /*#__PURE__*/_jsx(StyledFormError, {
+      role: "alert",
+      children: error
+    })]
+  });
+};
+const validatePhotoUpload = files => {
+  const MAX_FILE_SIZE = 5242880;
+  const MAX_FILE_SIZE_IN_MB = 5;
+  const file = files?.item(0);
+  if (!file) return true;
+  const {
+    type,
+    size
+  } = file;
+  if (!['image/jpeg', 'image/png'].includes(type)) return 'Please upload a jpeg or png file.';
+  if (size > MAX_FILE_SIZE) return `Sorry, we cannot accept files larger than ${MAX_FILE_SIZE_IN_MB} MB.`;
+  return true;
+};

package/dist/BackToTopAnchor/index.d.ts

@@ -0,0 +1,13 @@
+type BackToTopAnchorProps = {
+    /** The id of the element to scroll to */
+    targetId: string;
+    /** Whether to show the arrow icon */
+    showIcon?: boolean;
+    /** The size of the anchor */
+    size?: 'small' | 'base';
+    /**  The onClick here usually contains tracking data */
+    onClick?: () => void;
+    variant?: false | 'inline' | 'standard' | 'interface';
+};
+export declare const BackToTopAnchor: React.FC<BackToTopAnchorProps>;
+export {};