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

package/dist/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/NavPanels.js

@@ -0,0 +1,340 @@
+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 { Anchor, Box, Card, FlexBox, GridBox, Text } from '@codecademy/gamut';
+import { LevelIcon } from '@codecademy/gamut-icons';
+import { useGlobalHeaderDynamicDataContext, useGlobalHeaderItemClick } from '../../../GlobalHeader/context';
+import { liveLearningNavPanelItems } from '../../../lib/catalogList';
+import { AppHeaderDietCard } from '../AppHeaderDietCard';
+import { useAppHeaderDropdownContext } from '../AppHeaderDropdownProvider';
+import { useAppHeaderSectionContext } from '../AppHeaderSection/AppHeaderSectionContext';
+import { PanelLayout } from '../AppHeaderSection/PanelLayout';
+import { SkillTile } from '../AppHeaderSkillTile';
+import { CERTIFICATION_PROVIDERS, popularLanguages, popularSubjects } from './consts';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+export const CourseTopicsPanel = () => {
+  const {
+    globalHeaderItemClick
+  } = useGlobalHeaderItemClick();
+  const {
+    tabIndex
+  } = useAppHeaderSectionContext();
+  const description = /*#__PURE__*/_jsxs(_Fragment, {
+    children: ["Explore free or paid courses in a wide variety of topics. With something for every skill level, it's easy to find a course that fits your goals. Not sure where to start? \xA0", /*#__PURE__*/_jsx(Anchor, {
+      tabIndex: tabIndex,
+      href: "/welcome/find-a-course",
+      onClick: event => globalHeaderItemClick(event, {
+        type: 'link',
+        href: '/welcome/find-a-course',
+        text: 'Take the quiz',
+        id: 'take-the-quiz'
+      }),
+      children: "Take the quiz"
+    })]
+  });
+  return /*#__PURE__*/_jsxs(PanelLayout, {
+    heading: "Course topics",
+    description: description,
+    linkItem: {
+      type: 'link',
+      href: '/catalog',
+      text: 'Explore the full catalog',
+      trackingTarget: 'topnav_catalog',
+      id: 'explore-all-courses'
+    },
+    children: [/*#__PURE__*/_jsx(Text, {
+      variant: "p-large",
+      fontWeight: 700,
+      as: "h3",
+      children: "Popular languages"
+    }), /*#__PURE__*/_jsx(GridBox, {
+      gridTemplateColumns: {
+        _: '1fr',
+        xs: '1fr 1fr',
+        md: '1fr 1fr 1fr'
+      },
+      gap: 8,
+      pl: 0,
+      as: "ul",
+      listStyle: "none",
+      mb: 24,
+      children: popularLanguages.map(item => /*#__PURE__*/_jsx("li", {
+        children: /*#__PURE__*/_jsx(SkillTile, {
+          item: item
+        })
+      }, item.id))
+    }), /*#__PURE__*/_jsx(Text, {
+      variant: "p-large",
+      fontWeight: 700,
+      as: "h3",
+      children: "Popular subjects"
+    }), /*#__PURE__*/_jsx(GridBox, {
+      gridTemplateColumns: {
+        _: '1fr',
+        xs: '1fr 1fr',
+        md: '1fr 1fr 1fr'
+      },
+      gap: 8,
+      pl: 0,
+      as: "ul",
+      listStyle: "none",
+      children: popularSubjects.map(item => /*#__PURE__*/_jsx("li", {
+        children: /*#__PURE__*/_jsx(SkillTile, {
+          item: item
+        })
+      }, item.id))
+    })]
+  });
+};
+export const DietCardGrid = ({
+  children
+}) => {
+  return /*#__PURE__*/_jsx(GridBox, {
+    as: "ul",
+    gridTemplateColumns: {
+      _: '1fr',
+      sm: 'repeat(2, minmax(0, 1fr))',
+      md: 'repeat(3, minmax(0, 1fr))'
+    },
+    gap: 16,
+    m: 0,
+    p: 0,
+    listStyleType: "none",
+    children: children
+  });
+};
+export const CareerPathsPanel = () => {
+  const {
+    globalHeaderDynamicData
+  } = useGlobalHeaderDynamicDataContext();
+  const totalCareerPathCount = globalHeaderDynamicData?.catalogDropdown.careerPaths.totalCareerPathCount;
+  const linkText = `Explore all${totalCareerPathCount ? ` ${totalCareerPathCount}` : ''} career paths`;
+  return /*#__PURE__*/_jsx(PanelLayout, {
+    heading: "Career paths",
+    description: "Choose your career and we'll teach you the skills to get job-ready. Each Career Path contains a curated list of lessons, quizzes, videos, and projects to help you learn and practice real-world skills.",
+    linkItem: {
+      type: 'link',
+      href: '/catalog?type=career-path',
+      text: linkText,
+      trackingTarget: 'topnav_catalog_header_explore_all_career_paths',
+      id: 'explore-all-career-paths'
+    },
+    children: /*#__PURE__*/_jsx(DietCardGrid, {
+      children: globalHeaderDynamicData?.catalogDropdown.careerPaths.promotedCareerPaths.map(path => {
+        return /*#__PURE__*/_jsx(AppHeaderDietCard, {
+          title: path.title,
+          hours: path.durationHours,
+          icon: /*#__PURE__*/_jsx(LevelIcon, {}),
+          difficulty: path.difficulty,
+          href: path.urlPath,
+          trackingTarget: `careerpath_${path.title}`
+        }, `${path.title}-card`);
+      })
+    })
+  });
+};
+export const SkillPathsPanel = () => {
+  const {
+    globalHeaderDynamicData
+  } = useGlobalHeaderDynamicDataContext();
+  const totalSkillPathCount = globalHeaderDynamicData?.catalogDropdown.skillPaths.totalSkillPathCount;
+  const linkText = `Explore all${totalSkillPathCount ? ` ${totalSkillPathCount}` : ''} skill paths`;
+  return /*#__PURE__*/_jsx(PanelLayout, {
+    heading: "Skill paths",
+    description: "Build in demand skills fast with a short, curated path. Each one includes interactive content to help you learn and apply your new skill in just a few months.",
+    linkItem: {
+      type: 'link',
+      href: '/catalog?type=skill-path',
+      text: linkText,
+      trackingTarget: 'topnav_catalog_header_explore_all_skill_paths',
+      id: 'explore-all-skill-paths'
+    },
+    children: /*#__PURE__*/_jsx(DietCardGrid, {
+      children: globalHeaderDynamicData?.catalogDropdown.skillPaths.promotedSkillPaths.map(path => {
+        return /*#__PURE__*/_jsx(AppHeaderDietCard, {
+          title: path.title,
+          hours: path.durationHours,
+          icon: /*#__PURE__*/_jsx(LevelIcon, {}),
+          difficulty: path.difficulty,
+          href: path.urlPath,
+          trackingTarget: `skill_${path.title}`
+        }, `${path.title}-card`);
+      })
+    })
+  });
+};
+const Image = Box.withComponent('img', {
+  target: "eqfnvo2",
+  label: "Image"
+});
+const GrayscaleToColorHoverLink = /*#__PURE__*/_styled(Anchor, {
+  target: "eqfnvo1",
+  label: "GrayscaleToColorHoverLink"
+})("border:1px solid ", ({
+  theme
+}) => theme.colors['border-tertiary'], ";border-radius:8px;filter:grayscale(1);transition:filter 0.2s ease-out;img{filter:", ({
+  overrideImgFilters
+}) => overrideImgFilters ? 'contrast(5)' : 'brightness(0.25)', ";transition:filter 0.2s ease-out;}&:hover,&:focus{filter:grayscale(0);border-color:", ({
+  theme
+}) => theme.colors.hyper, ";background-color:", ({
+  theme
+}) => theme.colors['navy-100'], ";img{filter:brightness(1);}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/NavPanels.tsx"],"names":[],"mappings":"AA0ME","file":"../../../../src/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/NavPanels.tsx","sourcesContent":["import { Anchor, Box, Card, FlexBox, GridBox, Text } from '@codecademy/gamut';\nimport { LevelIcon } from '@codecademy/gamut-icons';\nimport styled from '@emotion/styled';\n\nimport { CourseDifficulty } from '../../../ContentGroupBaseCard/types';\nimport {\n  useGlobalHeaderDynamicDataContext,\n  useGlobalHeaderItemClick,\n} from '../../../GlobalHeader/context';\nimport { liveLearningNavPanelItems } from '../../../lib/catalogList';\nimport { AppHeaderDietCard } from '../AppHeaderDietCard';\nimport { useAppHeaderDropdownContext } from '../AppHeaderDropdownProvider';\nimport { useAppHeaderSectionContext } from '../AppHeaderSection/AppHeaderSectionContext';\nimport { PanelLayout } from '../AppHeaderSection/PanelLayout';\nimport { SkillTile } from '../AppHeaderSkillTile';\nimport {\n  CERTIFICATION_PROVIDERS,\n  popularLanguages,\n  popularSubjects,\n} from './consts';\n\nexport const CourseTopicsPanel = () => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { tabIndex } = useAppHeaderSectionContext();\n\n  const description = (\n    <>\n      Explore free or paid courses in a wide variety of topics. With something\n      for every skill level, it&apos;s easy to find a course that fits your\n      goals. Not sure where to start? &nbsp;\n      <Anchor\n        tabIndex={tabIndex}\n        href=\"/welcome/find-a-course\"\n        onClick={(event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) =>\n          globalHeaderItemClick(event, {\n            type: 'link',\n            href: '/welcome/find-a-course',\n            text: 'Take the quiz',\n            id: 'take-the-quiz',\n          })\n        }\n      >\n        Take the quiz\n      </Anchor>\n    </>\n  );\n\n  return (\n    <PanelLayout\n      heading=\"Course topics\"\n      description={description}\n      linkItem={{\n        type: 'link',\n        href: '/catalog',\n        text: 'Explore the full catalog',\n        trackingTarget: 'topnav_catalog',\n        id: 'explore-all-courses',\n      }}\n    >\n      <Text variant=\"p-large\" fontWeight={700} as=\"h3\">\n        Popular languages\n      </Text>\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', xs: '1fr 1fr', md: '1fr 1fr 1fr' }}\n        gap={8}\n        pl={0}\n        as=\"ul\"\n        listStyle=\"none\"\n        mb={24}\n      >\n        {popularLanguages.map((item) => (\n          <li key={item.id}>\n            <SkillTile item={item} />\n          </li>\n        ))}\n      </GridBox>\n\n      <Text variant=\"p-large\" fontWeight={700} as=\"h3\">\n        Popular subjects\n      </Text>\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', xs: '1fr 1fr', md: '1fr 1fr 1fr' }}\n        gap={8}\n        pl={0}\n        as=\"ul\"\n        listStyle=\"none\"\n      >\n        {popularSubjects.map((item) => (\n          <li key={item.id}>\n            <SkillTile item={item} />\n          </li>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n\nexport const DietCardGrid = ({ children }: { children: React.ReactNode }) => {\n  return (\n    <GridBox\n      as=\"ul\"\n      gridTemplateColumns={{\n        _: '1fr',\n        sm: 'repeat(2, minmax(0, 1fr))',\n        md: 'repeat(3, minmax(0, 1fr))',\n      }}\n      gap={16}\n      m={0}\n      p={0}\n      listStyleType=\"none\"\n    >\n      {children}\n    </GridBox>\n  );\n};\n\nexport const CareerPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const totalCareerPathCount =\n    globalHeaderDynamicData?.catalogDropdown.careerPaths.totalCareerPathCount;\n  const linkText = `Explore all${\n    totalCareerPathCount ? ` ${totalCareerPathCount}` : ''\n  } career paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Career paths\"\n      description=\"Choose your career and we'll teach you the skills to get job-ready. Each Career Path contains a curated list of lessons, quizzes, videos, and projects to help you learn and practice real-world skills.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog?type=career-path',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_career_paths',\n        id: 'explore-all-career-paths',\n      }}\n    >\n      <DietCardGrid>\n        {globalHeaderDynamicData?.catalogDropdown.careerPaths.promotedCareerPaths.map(\n          (path) => {\n            return (\n              <AppHeaderDietCard\n                key={`${path.title}-card`}\n                title={path.title}\n                hours={path.durationHours}\n                icon={<LevelIcon />}\n                difficulty={path.difficulty as CourseDifficulty}\n                href={path.urlPath}\n                trackingTarget={`careerpath_${path.title}`}\n              />\n            );\n          }\n        )}\n      </DietCardGrid>\n    </PanelLayout>\n  );\n};\n\nexport const SkillPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const totalSkillPathCount =\n    globalHeaderDynamicData?.catalogDropdown.skillPaths.totalSkillPathCount;\n  const linkText = `Explore all${\n    totalSkillPathCount ? ` ${totalSkillPathCount}` : ''\n  } skill paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Skill paths\"\n      description=\"Build in demand skills fast with a short, curated path. Each one includes interactive content to help you learn and apply your new skill in just a few months.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog?type=skill-path',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_skill_paths',\n        id: 'explore-all-skill-paths',\n      }}\n    >\n      <DietCardGrid>\n        {globalHeaderDynamicData?.catalogDropdown.skillPaths.promotedSkillPaths.map(\n          (path) => {\n            return (\n              <AppHeaderDietCard\n                key={`${path.title}-card`}\n                title={path.title}\n                hours={path.durationHours}\n                icon={<LevelIcon />}\n                difficulty={path.difficulty as CourseDifficulty}\n                href={path.urlPath}\n                trackingTarget={`skill_${path.title}`}\n              />\n            );\n          }\n        )}\n      </DietCardGrid>\n    </PanelLayout>\n  );\n};\n\nconst Image = Box.withComponent('img');\n\nconst GrayscaleToColorHoverLink = styled(Anchor)<{\n  overrideImgFilters?: boolean;\n}>`\n  border: 1px solid ${({ theme }) => theme.colors['border-tertiary']};\n  border-radius: 8px;\n  filter: grayscale(1);\n  transition: filter 0.2s ease-out;\n  img {\n    filter: ${({ overrideImgFilters }) =>\n      overrideImgFilters ? 'contrast(5)' : 'brightness(0.25)'};\n    transition: filter 0.2s ease-out;\n  }\n  &:hover,\n  &:focus {\n    filter: grayscale(0);\n    img {\n      filter: brightness(1);\n    }\n    border-color: ${({ theme }) => theme.colors.hyper};\n    background-color: ${({ theme }) => theme.colors['navy-100']};\n  }\n`;\n\nconst ProviderTile = ({\n  name,\n  href,\n  imgSrc,\n  tabIndex,\n}: {\n  name: string;\n  href: string;\n  imgSrc: string;\n  tabIndex: number;\n}) => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { handleClose } = useAppHeaderDropdownContext();\n\n  const lowercasedProviderName = name.toLowerCase();\n\n  return (\n    <GrayscaleToColorHoverLink\n      href={href}\n      variant=\"interface\"\n      key={name}\n      tabIndex={tabIndex}\n      width=\"100%\"\n      height={48}\n      p={8}\n      display=\"block\"\n      onClick={(event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {\n        globalHeaderItemClick(event, {\n          type: 'link',\n          id: `topnav_catalog_cert_${lowercasedProviderName}`,\n          href,\n          text: name,\n          trackingTarget: `topnav_catalog_cert_${lowercasedProviderName}`,\n        });\n        handleClose();\n      }}\n      overrideImgFilters={name.toLowerCase() === 'kubernetes'}\n    >\n      <Image src={imgSrc} alt={name} display=\"block\" m=\"auto\" />\n    </GrayscaleToColorHoverLink>\n  );\n};\n\nexport const CertificationPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const { tabIndex } = useAppHeaderSectionContext();\n  const totalCertificationPathCount =\n    globalHeaderDynamicData?.catalogDropdown.certificationPaths\n      .totalCertificationPathCount;\n  const linkText = `Explore all${\n    totalCertificationPathCount ? ` ${totalCertificationPathCount}` : ''\n  } certification paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Certification paths\"\n      description=\"Prepare for top industry certifications with a guided path. Each one includes expert-reviewed lessons, hands-on projects, and practice tests to help you pass the exam.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog/certification-prep',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_certification_paths',\n        id: 'explore-all-certification-paths',\n      }}\n    >\n      <Text as=\"h3\" fontSize={18} fontWeight=\"bold\">\n        Providers\n      </Text>\n      <GridBox\n        gridTemplateColumns={{\n          _: '1fr',\n          xs: 'repeat(2, 1fr)',\n          sm: 'repeat(3, 1fr)',\n          md: 'repeat(4, 1fr)',\n        }}\n        gap={16}\n        width=\"100%\"\n        as=\"ul\"\n        listStyle=\"none\"\n        p={0}\n        m={0}\n      >\n        {CERTIFICATION_PROVIDERS.map(({ name, logoUrl, hubType }) => (\n          <Box as=\"li\" key={name} width=\"100%\">\n            <ProviderTile\n              name={name}\n              href={\n                hubType === 'subhub'\n                  ? `/search?query=${name} certifications`\n                  : `/catalog/certification-prep?provider=${name.toLowerCase()}`\n              }\n              imgSrc={logoUrl}\n              tabIndex={tabIndex}\n            />\n          </Box>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n\nconst LiveLearningImage = styled.img`\n  object-fit: cover;\n  width: 100%;\n`;\n\nconst getImageUrl = (id: string) =>\n  `https://static-assets.codecademy.com/assets/components/cards/global-header/live-learning/v1/${id}.webp`;\n\nexport const LiveLearningPanel = () => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { tabIndex } = useAppHeaderSectionContext();\n  const { handleClose } = useAppHeaderDropdownContext();\n\n  return (\n    <PanelLayout\n      heading=\"Live learning\"\n      description={liveLearningNavPanelItems.description}\n    >\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', md: 'repeat(2, 1fr)' }}\n        gap={16}\n      >\n        {liveLearningNavPanelItems.data.map((item) => (\n          <Anchor\n            href={item.href}\n            key={item.id}\n            variant=\"interface\"\n            onClick={(\n              event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n            ) => {\n              globalHeaderItemClick(event, item);\n              handleClose();\n            }}\n            tabIndex={tabIndex}\n          >\n            <Card\n              key={item.id}\n              overflow=\"hidden\"\n              border={1}\n              borderColor=\"border-tertiary\"\n              borderRadius=\"lg\"\n              isInteractive\n              p={0}\n            >\n              <LiveLearningImage\n                src={getImageUrl(item.id)}\n                alt=\"\"\n                loading=\"lazy\"\n              />\n              <FlexBox flexDirection=\"column\" gap={8} p={16}>\n                <Text variant=\"title-xs\">{item.text}</Text>\n                {'description' in item && <Text>{item.description}</Text>}\n              </FlexBox>\n            </Card>\n          </Anchor>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n"]} */"));
+const ProviderTile = ({
+  name,
+  href,
+  imgSrc,
+  tabIndex
+}) => {
+  const {
+    globalHeaderItemClick
+  } = useGlobalHeaderItemClick();
+  const {
+    handleClose
+  } = useAppHeaderDropdownContext();
+  const lowercasedProviderName = name.toLowerCase();
+  return /*#__PURE__*/_jsx(GrayscaleToColorHoverLink, {
+    href: href,
+    variant: "interface",
+    tabIndex: tabIndex,
+    width: "100%",
+    height: 48,
+    p: 8,
+    display: "block",
+    onClick: event => {
+      globalHeaderItemClick(event, {
+        type: 'link',
+        id: `topnav_catalog_cert_${lowercasedProviderName}`,
+        href,
+        text: name,
+        trackingTarget: `topnav_catalog_cert_${lowercasedProviderName}`
+      });
+      handleClose();
+    },
+    overrideImgFilters: name.toLowerCase() === 'kubernetes',
+    children: /*#__PURE__*/_jsx(Image, {
+      src: imgSrc,
+      alt: name,
+      display: "block",
+      m: "auto"
+    })
+  }, name);
+};
+export const CertificationPathsPanel = () => {
+  const {
+    globalHeaderDynamicData
+  } = useGlobalHeaderDynamicDataContext();
+  const {
+    tabIndex
+  } = useAppHeaderSectionContext();
+  const totalCertificationPathCount = globalHeaderDynamicData?.catalogDropdown.certificationPaths.totalCertificationPathCount;
+  const linkText = `Explore all${totalCertificationPathCount ? ` ${totalCertificationPathCount}` : ''} certification paths`;
+  return /*#__PURE__*/_jsxs(PanelLayout, {
+    heading: "Certification paths",
+    description: "Prepare for top industry certifications with a guided path. Each one includes expert-reviewed lessons, hands-on projects, and practice tests to help you pass the exam.",
+    linkItem: {
+      type: 'link',
+      href: '/catalog/certification-prep',
+      text: linkText,
+      trackingTarget: 'topnav_catalog_header_explore_all_certification_paths',
+      id: 'explore-all-certification-paths'
+    },
+    children: [/*#__PURE__*/_jsx(Text, {
+      as: "h3",
+      fontSize: 18,
+      fontWeight: "bold",
+      children: "Providers"
+    }), /*#__PURE__*/_jsx(GridBox, {
+      gridTemplateColumns: {
+        _: '1fr',
+        xs: 'repeat(2, 1fr)',
+        sm: 'repeat(3, 1fr)',
+        md: 'repeat(4, 1fr)'
+      },
+      gap: 16,
+      width: "100%",
+      as: "ul",
+      listStyle: "none",
+      p: 0,
+      m: 0,
+      children: CERTIFICATION_PROVIDERS.map(({
+        name,
+        logoUrl,
+        hubType
+      }) => /*#__PURE__*/_jsx(Box, {
+        as: "li",
+        width: "100%",
+        children: /*#__PURE__*/_jsx(ProviderTile, {
+          name: name,
+          href: hubType === 'subhub' ? `/search?query=${name} certifications` : `/catalog/certification-prep?provider=${name.toLowerCase()}`,
+          imgSrc: logoUrl,
+          tabIndex: tabIndex
+        })
+      }, name))
+    })]
+  });
+};
+const LiveLearningImage = /*#__PURE__*/_styled("img", {
+  target: "eqfnvo0",
+  label: "LiveLearningImage"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1okoyo9",
+  styles: "object-fit:cover;width:100%"
+} : {
+  name: "1okoyo9",
+  styles: "object-fit:cover;width:100%/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/NavPanels.tsx"],"names":[],"mappings":"AAoUoC","file":"../../../../src/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/NavPanels.tsx","sourcesContent":["import { Anchor, Box, Card, FlexBox, GridBox, Text } from '@codecademy/gamut';\nimport { LevelIcon } from '@codecademy/gamut-icons';\nimport styled from '@emotion/styled';\n\nimport { CourseDifficulty } from '../../../ContentGroupBaseCard/types';\nimport {\n  useGlobalHeaderDynamicDataContext,\n  useGlobalHeaderItemClick,\n} from '../../../GlobalHeader/context';\nimport { liveLearningNavPanelItems } from '../../../lib/catalogList';\nimport { AppHeaderDietCard } from '../AppHeaderDietCard';\nimport { useAppHeaderDropdownContext } from '../AppHeaderDropdownProvider';\nimport { useAppHeaderSectionContext } from '../AppHeaderSection/AppHeaderSectionContext';\nimport { PanelLayout } from '../AppHeaderSection/PanelLayout';\nimport { SkillTile } from '../AppHeaderSkillTile';\nimport {\n  CERTIFICATION_PROVIDERS,\n  popularLanguages,\n  popularSubjects,\n} from './consts';\n\nexport const CourseTopicsPanel = () => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { tabIndex } = useAppHeaderSectionContext();\n\n  const description = (\n    <>\n      Explore free or paid courses in a wide variety of topics. With something\n      for every skill level, it&apos;s easy to find a course that fits your\n      goals. Not sure where to start? &nbsp;\n      <Anchor\n        tabIndex={tabIndex}\n        href=\"/welcome/find-a-course\"\n        onClick={(event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) =>\n          globalHeaderItemClick(event, {\n            type: 'link',\n            href: '/welcome/find-a-course',\n            text: 'Take the quiz',\n            id: 'take-the-quiz',\n          })\n        }\n      >\n        Take the quiz\n      </Anchor>\n    </>\n  );\n\n  return (\n    <PanelLayout\n      heading=\"Course topics\"\n      description={description}\n      linkItem={{\n        type: 'link',\n        href: '/catalog',\n        text: 'Explore the full catalog',\n        trackingTarget: 'topnav_catalog',\n        id: 'explore-all-courses',\n      }}\n    >\n      <Text variant=\"p-large\" fontWeight={700} as=\"h3\">\n        Popular languages\n      </Text>\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', xs: '1fr 1fr', md: '1fr 1fr 1fr' }}\n        gap={8}\n        pl={0}\n        as=\"ul\"\n        listStyle=\"none\"\n        mb={24}\n      >\n        {popularLanguages.map((item) => (\n          <li key={item.id}>\n            <SkillTile item={item} />\n          </li>\n        ))}\n      </GridBox>\n\n      <Text variant=\"p-large\" fontWeight={700} as=\"h3\">\n        Popular subjects\n      </Text>\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', xs: '1fr 1fr', md: '1fr 1fr 1fr' }}\n        gap={8}\n        pl={0}\n        as=\"ul\"\n        listStyle=\"none\"\n      >\n        {popularSubjects.map((item) => (\n          <li key={item.id}>\n            <SkillTile item={item} />\n          </li>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n\nexport const DietCardGrid = ({ children }: { children: React.ReactNode }) => {\n  return (\n    <GridBox\n      as=\"ul\"\n      gridTemplateColumns={{\n        _: '1fr',\n        sm: 'repeat(2, minmax(0, 1fr))',\n        md: 'repeat(3, minmax(0, 1fr))',\n      }}\n      gap={16}\n      m={0}\n      p={0}\n      listStyleType=\"none\"\n    >\n      {children}\n    </GridBox>\n  );\n};\n\nexport const CareerPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const totalCareerPathCount =\n    globalHeaderDynamicData?.catalogDropdown.careerPaths.totalCareerPathCount;\n  const linkText = `Explore all${\n    totalCareerPathCount ? ` ${totalCareerPathCount}` : ''\n  } career paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Career paths\"\n      description=\"Choose your career and we'll teach you the skills to get job-ready. Each Career Path contains a curated list of lessons, quizzes, videos, and projects to help you learn and practice real-world skills.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog?type=career-path',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_career_paths',\n        id: 'explore-all-career-paths',\n      }}\n    >\n      <DietCardGrid>\n        {globalHeaderDynamicData?.catalogDropdown.careerPaths.promotedCareerPaths.map(\n          (path) => {\n            return (\n              <AppHeaderDietCard\n                key={`${path.title}-card`}\n                title={path.title}\n                hours={path.durationHours}\n                icon={<LevelIcon />}\n                difficulty={path.difficulty as CourseDifficulty}\n                href={path.urlPath}\n                trackingTarget={`careerpath_${path.title}`}\n              />\n            );\n          }\n        )}\n      </DietCardGrid>\n    </PanelLayout>\n  );\n};\n\nexport const SkillPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const totalSkillPathCount =\n    globalHeaderDynamicData?.catalogDropdown.skillPaths.totalSkillPathCount;\n  const linkText = `Explore all${\n    totalSkillPathCount ? ` ${totalSkillPathCount}` : ''\n  } skill paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Skill paths\"\n      description=\"Build in demand skills fast with a short, curated path. Each one includes interactive content to help you learn and apply your new skill in just a few months.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog?type=skill-path',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_skill_paths',\n        id: 'explore-all-skill-paths',\n      }}\n    >\n      <DietCardGrid>\n        {globalHeaderDynamicData?.catalogDropdown.skillPaths.promotedSkillPaths.map(\n          (path) => {\n            return (\n              <AppHeaderDietCard\n                key={`${path.title}-card`}\n                title={path.title}\n                hours={path.durationHours}\n                icon={<LevelIcon />}\n                difficulty={path.difficulty as CourseDifficulty}\n                href={path.urlPath}\n                trackingTarget={`skill_${path.title}`}\n              />\n            );\n          }\n        )}\n      </DietCardGrid>\n    </PanelLayout>\n  );\n};\n\nconst Image = Box.withComponent('img');\n\nconst GrayscaleToColorHoverLink = styled(Anchor)<{\n  overrideImgFilters?: boolean;\n}>`\n  border: 1px solid ${({ theme }) => theme.colors['border-tertiary']};\n  border-radius: 8px;\n  filter: grayscale(1);\n  transition: filter 0.2s ease-out;\n  img {\n    filter: ${({ overrideImgFilters }) =>\n      overrideImgFilters ? 'contrast(5)' : 'brightness(0.25)'};\n    transition: filter 0.2s ease-out;\n  }\n  &:hover,\n  &:focus {\n    filter: grayscale(0);\n    img {\n      filter: brightness(1);\n    }\n    border-color: ${({ theme }) => theme.colors.hyper};\n    background-color: ${({ theme }) => theme.colors['navy-100']};\n  }\n`;\n\nconst ProviderTile = ({\n  name,\n  href,\n  imgSrc,\n  tabIndex,\n}: {\n  name: string;\n  href: string;\n  imgSrc: string;\n  tabIndex: number;\n}) => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { handleClose } = useAppHeaderDropdownContext();\n\n  const lowercasedProviderName = name.toLowerCase();\n\n  return (\n    <GrayscaleToColorHoverLink\n      href={href}\n      variant=\"interface\"\n      key={name}\n      tabIndex={tabIndex}\n      width=\"100%\"\n      height={48}\n      p={8}\n      display=\"block\"\n      onClick={(event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {\n        globalHeaderItemClick(event, {\n          type: 'link',\n          id: `topnav_catalog_cert_${lowercasedProviderName}`,\n          href,\n          text: name,\n          trackingTarget: `topnav_catalog_cert_${lowercasedProviderName}`,\n        });\n        handleClose();\n      }}\n      overrideImgFilters={name.toLowerCase() === 'kubernetes'}\n    >\n      <Image src={imgSrc} alt={name} display=\"block\" m=\"auto\" />\n    </GrayscaleToColorHoverLink>\n  );\n};\n\nexport const CertificationPathsPanel = () => {\n  const { globalHeaderDynamicData } = useGlobalHeaderDynamicDataContext();\n  const { tabIndex } = useAppHeaderSectionContext();\n  const totalCertificationPathCount =\n    globalHeaderDynamicData?.catalogDropdown.certificationPaths\n      .totalCertificationPathCount;\n  const linkText = `Explore all${\n    totalCertificationPathCount ? ` ${totalCertificationPathCount}` : ''\n  } certification paths`;\n\n  return (\n    <PanelLayout\n      heading=\"Certification paths\"\n      description=\"Prepare for top industry certifications with a guided path. Each one includes expert-reviewed lessons, hands-on projects, and practice tests to help you pass the exam.\"\n      linkItem={{\n        type: 'link',\n        href: '/catalog/certification-prep',\n        text: linkText,\n        trackingTarget: 'topnav_catalog_header_explore_all_certification_paths',\n        id: 'explore-all-certification-paths',\n      }}\n    >\n      <Text as=\"h3\" fontSize={18} fontWeight=\"bold\">\n        Providers\n      </Text>\n      <GridBox\n        gridTemplateColumns={{\n          _: '1fr',\n          xs: 'repeat(2, 1fr)',\n          sm: 'repeat(3, 1fr)',\n          md: 'repeat(4, 1fr)',\n        }}\n        gap={16}\n        width=\"100%\"\n        as=\"ul\"\n        listStyle=\"none\"\n        p={0}\n        m={0}\n      >\n        {CERTIFICATION_PROVIDERS.map(({ name, logoUrl, hubType }) => (\n          <Box as=\"li\" key={name} width=\"100%\">\n            <ProviderTile\n              name={name}\n              href={\n                hubType === 'subhub'\n                  ? `/search?query=${name} certifications`\n                  : `/catalog/certification-prep?provider=${name.toLowerCase()}`\n              }\n              imgSrc={logoUrl}\n              tabIndex={tabIndex}\n            />\n          </Box>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n\nconst LiveLearningImage = styled.img`\n  object-fit: cover;\n  width: 100%;\n`;\n\nconst getImageUrl = (id: string) =>\n  `https://static-assets.codecademy.com/assets/components/cards/global-header/live-learning/v1/${id}.webp`;\n\nexport const LiveLearningPanel = () => {\n  const { globalHeaderItemClick } = useGlobalHeaderItemClick();\n  const { tabIndex } = useAppHeaderSectionContext();\n  const { handleClose } = useAppHeaderDropdownContext();\n\n  return (\n    <PanelLayout\n      heading=\"Live learning\"\n      description={liveLearningNavPanelItems.description}\n    >\n      <GridBox\n        gridTemplateColumns={{ _: '1fr', md: 'repeat(2, 1fr)' }}\n        gap={16}\n      >\n        {liveLearningNavPanelItems.data.map((item) => (\n          <Anchor\n            href={item.href}\n            key={item.id}\n            variant=\"interface\"\n            onClick={(\n              event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n            ) => {\n              globalHeaderItemClick(event, item);\n              handleClose();\n            }}\n            tabIndex={tabIndex}\n          >\n            <Card\n              key={item.id}\n              overflow=\"hidden\"\n              border={1}\n              borderColor=\"border-tertiary\"\n              borderRadius=\"lg\"\n              isInteractive\n              p={0}\n            >\n              <LiveLearningImage\n                src={getImageUrl(item.id)}\n                alt=\"\"\n                loading=\"lazy\"\n              />\n              <FlexBox flexDirection=\"column\" gap={8} p={16}>\n                <Text variant=\"title-xs\">{item.text}</Text>\n                {'description' in item && <Text>{item.description}</Text>}\n              </FlexBox>\n            </Card>\n          </Anchor>\n        ))}\n      </GridBox>\n    </PanelLayout>\n  );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const getImageUrl = id => `https://static-assets.codecademy.com/assets/components/cards/global-header/live-learning/v1/${id}.webp`;
+export const LiveLearningPanel = () => {
+  const {
+    globalHeaderItemClick
+  } = useGlobalHeaderItemClick();
+  const {
+    tabIndex
+  } = useAppHeaderSectionContext();
+  const {
+    handleClose
+  } = useAppHeaderDropdownContext();
+  return /*#__PURE__*/_jsx(PanelLayout, {
+    heading: "Live learning",
+    description: liveLearningNavPanelItems.description,
+    children: /*#__PURE__*/_jsx(GridBox, {
+      gridTemplateColumns: {
+        _: '1fr',
+        md: 'repeat(2, 1fr)'
+      },
+      gap: 16,
+      children: liveLearningNavPanelItems.data.map(item => /*#__PURE__*/_jsx(Anchor, {
+        href: item.href,
+        variant: "interface",
+        onClick: event => {
+          globalHeaderItemClick(event, item);
+          handleClose();
+        },
+        tabIndex: tabIndex,
+        children: /*#__PURE__*/_jsxs(Card, {
+          overflow: "hidden",
+          border: 1,
+          borderColor: "border-tertiary",
+          borderRadius: "lg",
+          isInteractive: true,
+          p: 0,
+          children: [/*#__PURE__*/_jsx(LiveLearningImage, {
+            src: getImageUrl(item.id),
+            alt: "",
+            loading: "lazy"
+          }), /*#__PURE__*/_jsxs(FlexBox, {
+            flexDirection: "column",
+            gap: 8,
+            p: 16,
+            children: [/*#__PURE__*/_jsx(Text, {
+              variant: "title-xs",
+              children: item.text
+            }), 'description' in item && /*#__PURE__*/_jsx(Text, {
+              children: item.description
+            })]
+          })]
+        }, item.id)
+      }, item.id))
+    })
+  });
+};

package/dist/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/consts.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { AppHeaderCatalogDropdownItem, AppHeaderLinkItem } from '../../shared';
+export type NavSectionConfig = {
+    item: AppHeaderCatalogDropdownItem;
+    panel: React.ComponentType<{
+        tabIndex?: number;
+    }>;
+};
+export declare const getCertificationProviderLogoUrl: (fileName: string) => string;
+export declare const CATALOG_NAV_SECTIONS: NavSectionConfig[];
+export declare const CERTIFICATION_PROVIDERS: {
+    name: string;
+    logoUrl: string;
+    hubType: string;
+}[];
+export declare const popularLanguages: AppHeaderLinkItem[];
+export declare const popularSubjects: AppHeaderLinkItem[];

package/dist/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/consts.js

@@ -0,0 +1,226 @@
+import { ArtificialIntelligenceIcon, BookLibraryIcon, BriefcaseIcon, CIcon, CloudComputingIcon, CPlusIcon, CSharpIcon, CybersecurityIcon, DataEngineeringIcon, DataScienceIcon, GrowthIcon, HtmlCssIcon, JavaIcon, JavascriptIcon, OnlineClassStudentIcon, PhpIcon, ProfessionalCertificateIcon, ProgrammingBrowserIcon, PythonIcon, SqlIcon, StudyBookIcon, WebDesignIcon, WebDevelopmentIcon } from '@codecademy/gamut-icons';
+import { CareerPathsPanel, CertificationPathsPanel, CourseTopicsPanel, LiveLearningPanel, SkillPathsPanel } from './NavPanels';
+export const getCertificationProviderLogoUrl = fileName => `https://static-assets.codecademy.com/assets/certification-provider-logos/catalog-dropdown/v2/${fileName}`;
+export const CATALOG_NAV_SECTIONS = [{
+  item: {
+    icon: StudyBookIcon,
+    text: 'Course topics',
+    id: 'course-topics',
+    type: 'catalog-dropdown',
+    trackingTarget: 'topnav_catalog_tab_course_topics'
+  },
+  panel: CourseTopicsPanel
+}, {
+  item: {
+    icon: OnlineClassStudentIcon,
+    text: 'Live learning',
+    id: 'live-learning',
+    type: 'catalog-dropdown',
+    trackingTarget: 'topnav_catalog_tab_live_learning'
+  },
+  panel: LiveLearningPanel
+}, {
+  item: {
+    icon: BookLibraryIcon,
+    text: 'Skill paths',
+    id: 'skill-paths',
+    type: 'catalog-dropdown',
+    trackingTarget: 'topnav_catalog_tab_skill_paths'
+  },
+  panel: SkillPathsPanel
+}, {
+  item: {
+    icon: BriefcaseIcon,
+    text: 'Career paths',
+    id: 'career-paths',
+    type: 'catalog-dropdown',
+    trackingTarget: 'topnav_catalog_tab_career_paths'
+  },
+  panel: CareerPathsPanel
+}, {
+  item: {
+    icon: ProfessionalCertificateIcon,
+    text: 'Certification paths',
+    id: 'certification-paths',
+    type: 'catalog-dropdown',
+    trackingTarget: 'topnav_catalog_tab_certification_paths'
+  },
+  panel: CertificationPathsPanel
+}];
+export const CERTIFICATION_PROVIDERS = [{
+  name: 'Microsoft',
+  logoUrl: getCertificationProviderLogoUrl('microsoft.svg'),
+  hubType: 'subhub'
+}, {
+  name: 'CompTIA',
+  logoUrl: getCertificationProviderLogoUrl('comptia.svg'),
+  hubType: 'subhub'
+}, {
+  name: 'ISC2',
+  logoUrl: getCertificationProviderLogoUrl('isc2.svg'),
+  hubType: 'subhub'
+}, {
+  name: 'AWS',
+  logoUrl: getCertificationProviderLogoUrl('aws.svg'),
+  hubType: 'subhub'
+}, {
+  name: 'Google',
+  logoUrl: getCertificationProviderLogoUrl('google.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'Cisco',
+  logoUrl: getCertificationProviderLogoUrl('cisco.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'IIBA',
+  logoUrl: getCertificationProviderLogoUrl('iiba.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'ISTQB',
+  logoUrl: getCertificationProviderLogoUrl('istqb.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'ISACA',
+  logoUrl: getCertificationProviderLogoUrl('isaca.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'Kubernetes',
+  logoUrl: getCertificationProviderLogoUrl('kubernetes.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'Oracle',
+  logoUrl: getCertificationProviderLogoUrl('oracle.svg'),
+  hubType: 'certification-prep'
+}, {
+  name: 'Project Management Institute',
+  logoUrl: getCertificationProviderLogoUrl('pmi.svg'),
+  hubType: 'certification-prep'
+}];
+export const popularLanguages = [{
+  id: 'python',
+  href: '/catalog/language/python',
+  trackingTarget: 'topnav_catalog_skill_python',
+  text: 'Python',
+  type: 'link',
+  icon: PythonIcon
+}, {
+  id: 'javascript',
+  href: '/catalog/language/javascript',
+  trackingTarget: 'topnav_catalog_skill_javascript',
+  text: 'JavaScript',
+  type: 'link',
+  icon: JavascriptIcon
+}, {
+  id: 'html-css',
+  href: '/catalog/language/html-css',
+  trackingTarget: 'topnav_catalog_skill_html-css',
+  text: 'HTML & CSS',
+  type: 'link',
+  icon: HtmlCssIcon
+}, {
+  id: 'c-sharp',
+  href: '/catalog/language/c-sharp',
+  trackingTarget: 'topnav_catalog_skill_c-sharp',
+  text: 'C#',
+  type: 'link',
+  icon: CSharpIcon
+}, {
+  id: 'c-plus-plus',
+  href: '/catalog/language/c-plus-plus',
+  trackingTarget: 'topnav_catalog_skill_c-plus-plus',
+  text: 'C++',
+  type: 'link',
+  icon: CPlusIcon
+}, {
+  id: 'c',
+  href: '/catalog/language/c',
+  trackingTarget: 'topnav_catalog_skill_c',
+  text: 'C',
+  type: 'link',
+  icon: CIcon
+}, {
+  id: 'php',
+  href: '/catalog/language/php',
+  trackingTarget: 'topnav_catalog_skill_php',
+  text: 'PHP',
+  type: 'link',
+  icon: PhpIcon
+}, {
+  id: 'java',
+  href: '/catalog/language/java',
+  trackingTarget: 'topnav_catalog_skill_java',
+  text: 'Java',
+  type: 'link',
+  icon: JavaIcon
+}, {
+  id: 'sql',
+  href: '/catalog/language/sql',
+  trackingTarget: 'topnav_catalog_skill_sql',
+  text: 'SQL',
+  type: 'link',
+  icon: SqlIcon
+}];
+export const popularSubjects = [{
+  id: 'artificial-intelligence',
+  href: '/catalog/subject/artificial-intelligence',
+  trackingTarget: 'topnav_catalog_skill_ai',
+  text: 'AI',
+  type: 'link',
+  icon: ArtificialIntelligenceIcon
+}, {
+  id: 'it',
+  href: '/catalog/subject/information-technology',
+  trackingTarget: 'topnav_catalog_skill_it',
+  text: 'IT',
+  type: 'link',
+  icon: DataEngineeringIcon
+}, {
+  id: 'cybersecurity',
+  href: '/catalog/subject/cybersecurity',
+  trackingTarget: 'topnav_catalog_skill_cybersecurity',
+  text: 'Cybersecurity',
+  type: 'link',
+  icon: CybersecurityIcon
+}, {
+  id: 'cloud-computing',
+  href: '/catalog/subject/cloud-computing',
+  trackingTarget: 'topnav_catalog_skill_cloud-computing',
+  text: 'Cloud computing',
+  type: 'link',
+  icon: CloudComputingIcon
+}, {
+  id: 'web-development',
+  href: '/catalog/subject/web-development',
+  trackingTarget: 'topnav_catalog_skill_web_development',
+  text: 'Web development',
+  type: 'link',
+  icon: WebDevelopmentIcon
+}, {
+  id: 'data-science',
+  href: '/catalog/subject/data-science',
+  trackingTarget: 'topnav_catalog_skill_data-science',
+  text: 'Data science',
+  type: 'link',
+  icon: DataScienceIcon
+}, {
+  id: 'web-design',
+  href: '/catalog/subject/web-design',
+  trackingTarget: 'topnav_catalog_skill_web-design',
+  text: 'Web design',
+  type: 'link',
+  icon: WebDesignIcon
+}, {
+  id: 'professional-skills',
+  href: '/catalog/subject/professional-skills',
+  trackingTarget: 'topnav_catalog_skill_professional-skills',
+  text: 'Professional skills',
+  type: 'link',
+  icon: GrowthIcon
+}, {
+  id: 'code-foundations',
+  href: '/catalog/subject/code-foundations',
+  trackingTarget: 'topnav_catalog_skill_code-foundations',
+  text: 'Code foundations',
+  type: 'link',
+  icon: ProgrammingBrowserIcon
+}];

package/dist/AppHeader/AppHeaderElements/AppHeaderCatalogDropdown/index.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { AppHeaderAction, AppHeaderCatalogDropdownItem } from '../../shared';
+export type AppHeaderCatalogDropdownProps = AppHeaderAction & {
+    item: AppHeaderCatalogDropdownItem;
+};
+export declare const AppHeaderCatalogDropdown: React.FC<AppHeaderCatalogDropdownProps>;