@codecademy/brand 3.0.0-alpha.2ba7921cce.0 → 3.0.0-alpha.60d7fce419.0

package/dist/GlobalPage/index.d.ts

@@ -1,6 +1,6 @@
 import { ModalProps, WithChildrenProp } from '@codecademy/gamut';
 import * as React from 'react';
-import { BannerProps } from '../Banner';
+import { EnhancedBannerProps } from '../Banner/EnhancedBanner';
 import { GlobalFooterProps } from '../GlobalFooter';
 import { GlobalHeaderProps } from '../GlobalHeader';
 export type GlobalPageBackgroundColor = 'beige' | 'background' | 'background-contrast' | 'navy' | 'paleBlue' | 'paleGreen' | 'palePink' | 'paleYellow' | 'white';
@@ -9,7 +9,7 @@ export interface GlobalPageProps extends WithChildrenProp {
     /**
      * Props directly passed to the Banner.
      */
-    banner?: BannerProps;
+    banner?: EnhancedBannerProps;
     /**
      * Element type to render around the children.
      */

package/dist/GlobalPage/index.js

@@ -2,7 +2,7 @@ import { AppWrapper, Modal, SkipToContent, SkipToContentTarget } from '@codecade
 import { Background } from '@codecademy/gamut-styles';
 import { forwardRef } from 'react';
 import * as React from 'react';
-import { Banner } from '../Banner';
+import { EnhancedBanner } from '../Banner/EnhancedBanner';
 import { GlobalFooter } from '../GlobalFooter';
 import { GlobalHeader } from '../GlobalHeader';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
@@ -35,7 +35,7 @@ export const GlobalPage = ({
     minHeight: "100vh",
     children: [/*#__PURE__*/_jsx(SkipToContent, {
       contentId: skipToContentId || defaultSkipToContentId
-    }), banner && /*#__PURE__*/_jsx(Banner, {
+    }), banner && /*#__PURE__*/_jsx(EnhancedBanner, {
       ...banner
     }), !header.hideEnterpriseHeader && /*#__PURE__*/_jsx(GlobalHeader, {
       ...header

package/dist/LearningOutcomeFlyout/index.d.ts

@@ -14,7 +14,14 @@ export interface ParentLearningOutcome {
     outcome: string;
     level: number | null | undefined;
 }
-interface LearningOutcomeDetailsProps {
+interface ContentModuleLearningOutcomeDataFragment {
+    id: string;
+    title: string;
+    progressV2: {
+        percentComplete: number | undefined | null;
+    };
+}
+export interface LearningOutcomeDetailsProps {
     level: LearningOutcomeLevels;
     outcome: string;
     percentComplete: number | undefined | null;
@@ -24,6 +31,18 @@ interface LearningOutcomeDetailsProps {
     latestScoreAchievedAt: string | undefined | null;
     parentLOs?: ParentLearningOutcome[];
     skills?: LearningOutcomeSkill[] | null;
+    childLearningOutcomes?: {
+        id: string;
+        outcome: string;
+        percentComplete?: number | undefined | null;
+        contentModules: ContentModuleLearningOutcomeDataFragment[];
+        progress?: {
+            latestScore: number | undefined | null;
+            covered: boolean | undefined | null;
+            coveredAt: string | undefined | null;
+            highestScore: number | undefined | null;
+        };
+    }[];
 }
 interface LearningOutcomeFlyoutProps {
     expanded: boolean;
@@ -33,6 +52,7 @@ interface LearningOutcomeFlyoutProps {
     learningOutcomeOnClick?: () => void;
     skillTagOnClick?: (skillSlug: string) => void;
 }
+export declare function getAverageModulePercentComplete(contentModules: ContentModuleLearningOutcomeDataFragment[]): number;
 export declare const sortSkillsByClassification: (skills?: LearningOutcomeSkill[] | null) => LearningOutcomeSkill[];
 export declare const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps>;
 export {};

package/dist/LearningOutcomeFlyout/index.js

@@ -4,8 +4,24 @@ import { SmallCheckIcon } from '@codecademy/gamut-icons';
 import { css } from '@codecademy/gamut-styles';
 import { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';
 import { learningOutcomeLabels, LearningOutcomeLevelBadge, LearningOutcomeLevels, LearningOutcomeLowAssessmentBadge } from '../LearningOutcomeBadges';
+import { LearningOutcomeTile } from '../LearningOutcomeTile';
 import { LearningOutcomeCardList } from './LearningOutcomeCardList';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const ChildLearningOutcomeRow = /*#__PURE__*/_styled(FlexBox, {
+  target: "e1ylhic52",
+  label: "ChildLearningOutcomeRow"
+})(css({
+  '&:first-of-type': {
+    borderTopLeftRadius: '4px',
+    borderTopRightRadius: '4px',
+    borderTop: 1,
+    borderColor: 'border-tertiary'
+  },
+  '&:last-of-type': {
+    borderBottomLeftRadius: '4px',
+    borderBottomRightRadius: '4px'
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeFlyout/index.tsx"],"names":[],"mappings":"AAegC","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';\nimport { SmallCheckIcon } from '@codecademy/gamut-icons';\nimport { css } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n  LearningOutcomeLowAssessmentBadge,\n} from '../LearningOutcomeBadges';\nimport { LearningOutcomeTile } from '../LearningOutcomeTile';\nimport { LearningOutcomeCardList } from './LearningOutcomeCardList';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\n      borderTop: 1,\n      borderColor: 'border-tertiary',\n    },\n    '&:last-of-type': {\n      borderBottomLeftRadius: '4px',\n      borderBottomRightRadius: '4px',\n    },\n  })\n);\n\nconst StyledAnchor = styled(Anchor)(\n  css({\n    color: 'text',\n    fontSize: 26,\n    fontWeight: 700,\n    textDecoration: 'none',\n    '&:hover, &:focus': {\n      color: 'text',\n      textDecoration: 'underline',\n    },\n  })\n);\n\nconst SkillTag = styled(Anchor)(\n  css({\n    fontSize: 14,\n    borderRadius: 'md',\n    border: 1,\n    borderColor: 'border-primary',\n    '&:hover, &:focus': {\n      color: 'text',\n      bg: 'background-hover',\n    },\n  })\n);\n\nexport enum SkillClassification {\n  Language = 'language',\n  Subject = 'subject',\n}\n\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\n}\n\nexport interface ParentLearningOutcome {\n  id: string;\n  outcome: string;\n  level: number | null | undefined;\n}\n\ninterface ContentModuleLearningOutcomeDataFragment {\n  id: string;\n  title: string;\n  progressV2: {\n    percentComplete: number | undefined | null;\n  };\n}\n\nexport interface LearningOutcomeDetailsProps {\n  level: LearningOutcomeLevels;\n  outcome: string;\n  percentComplete: number | undefined | null;\n  highestScore: number | undefined | null;\n  highestScoreAchievedAt: string | undefined | null;\n  latestScore: number | undefined | null;\n  latestScoreAchievedAt: string | undefined | null;\n  parentLOs?: ParentLearningOutcome[];\n  skills?: LearningOutcomeSkill[] | null;\n  childLearningOutcomes?: {\n    id: string;\n    outcome: string;\n    percentComplete?: number | undefined | null; // not currently getting this from the API\n    contentModules: ContentModuleLearningOutcomeDataFragment[];\n    progress?: {\n      latestScore: number | undefined | null;\n      covered: boolean | undefined | null;\n      coveredAt: string | undefined | null;\n      highestScore: number | undefined | null;\n    };\n  }[];\n}\n\ninterface LearningOutcomeFlyoutProps {\n  expanded: boolean;\n  onClose: () => void;\n  learningOutcome: LearningOutcomeDetailsProps;\n  learningOutcomeHref: string;\n  learningOutcomeOnClick?: () => void;\n  skillTagOnClick?: (skillSlug: string) => void;\n}\n\nexport function getAverageModulePercentComplete(\n  contentModules: ContentModuleLearningOutcomeDataFragment[]\n): number {\n  if (!contentModules || contentModules.length === 0) return 0;\n\n  const total = contentModules.reduce((sum, module) => {\n    const { progressV2 } = module;\n    return sum + (progressV2?.percentComplete ?? 0);\n  }, 0);\n\n  return Math.floor(total / contentModules.length);\n}\n\nexport const sortSkillsByClassification = (\n  skills?: LearningOutcomeSkill[] | null\n) => {\n  if (!skills?.length) return [];\n  const skillsCopy = skills.slice();\n\n  const sortedSkills = skillsCopy?.sort((a, b) => {\n    if (a?.classification === 'language') {\n      return -1;\n    }\n    if (b?.classification === 'subject') {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nconst getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  learningOutcome: {\n    highestScore,\n    highestScoreAchievedAt,\n    latestScore,\n    latestScoreAchievedAt,\n    level,\n    outcome,\n    parentLOs,\n    percentComplete,\n    skills,\n    childLearningOutcomes,\n  },\n  skillTagOnClick,\n  onClose,\n}) => {\n  const percentCompletePercentage =\n    percentComplete != null ? percentComplete : 0;\n  const levelLabel = learningOutcomeLabels[level];\n\n  const hasLowLatestAssessment = Boolean(\n    latestScore != null && latestScore < 70\n  );\n\n  const showSkills = !!skills?.length;\n  const sortedSkills = sortSkillsByClassification(skills);\n\n  const isLevelTwoLearningOutcome = level === LearningOutcomeLevels.Two;\n  const showParentLOs =\n    level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;\n\n  const renderProgress = () => (\n    <FlexBox alignItems=\"center\">\n      {Boolean(percentCompletePercentage === 100) && (\n        <FlexBox\n          width={16}\n          height={16}\n          borderRadius=\"md\"\n          bg=\"primary\"\n          mr={8}\n          alignItems=\"center\"\n          justifyContent=\"center\"\n        >\n          <SmallCheckIcon size={11} color=\"white\" />\n        </FlexBox>\n      )}\n      <Text\n        color=\"text\"\n        variant=\"p-large\"\n      >{`${percentCompletePercentage}% progress`}</Text>\n    </FlexBox>\n  );\n\n  // Render subskills when the drawer is featuring a level 3 outcome\n\n  const renderSubskills = () => {\n    return (\n      <FlexBox as=\"ul\" flexDirection=\"column\" p={0}>\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, contentModules } = childLo;\n          const calculatedPercentComplete =\n            progress?.covered || progress?.coveredAt\n              ? 100\n              : getAverageModulePercentComplete(contentModules);\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          return (\n            <ChildLearningOutcomeRow\n              row\n              bg=\"white\"\n              borderColor=\"border-tertiary\"\n              borderLeft={1}\n              borderBottom={1}\n              borderRight={1}\n              px={16}\n              py={24}\n              alignItems=\"flex-start\"\n              as=\"li\"\n              key={id}\n              justifyContent=\"flex-start\"\n              gap={16}\n            >\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete: calculatedPercentComplete,\n                  }}\n                  size=\"small\"\n                  popover={false}\n                />\n              </FlexBox>\n              <FlexBox column gap={8}>\n                <Anchor\n                  variant=\"interface\"\n                  href={getLearningOutcomePath(id)}\n                  target=\"_blank\"\n                  whiteSpace=\"normal\"\n                  onClick={() => {\n                    // add tracking here\n                  }}\n                >\n                  {outcome}\n                </Anchor>\n                {showNeedsReviewIndicator && (\n                  <FlexBox>\n                    <LearningOutcomeLowAssessmentBadge />\n                  </FlexBox>\n                )}\n              </FlexBox>\n            </ChildLearningOutcomeRow>\n          );\n        })}\n      </FlexBox>\n    );\n  };\n\n  return (\n    <Flyout\n      aria-label={`${levelLabel} details`}\n      closeLabel={`Close ${levelLabel} details`}\n      expanded={expanded}\n      onClose={onClose}\n      openFrom=\"right\"\n      title={<Text variant=\"title-sm\">{`${levelLabel} details`}</Text>}\n    >\n      <FlexBox gap={32} mt={32} mx={24} column>\n        {/* Badges, Outcome, Topic tags, Progress */}\n        <FlexBox gap={24} column>\n          <FlexBox justifyContent=\"space-between\" alignItems=\"center\">\n            <LearningOutcomeLevelBadge level={level} size=\"base\" />\n            {hasLowLatestAssessment && <LearningOutcomeLowAssessmentBadge />}\n          </FlexBox>\n          <FlexBox gap={16} column>\n            <StyledAnchor\n              href={learningOutcomeHref}\n              onClick={() => learningOutcomeOnClick?.()}\n            >\n              {outcome}\n            </StyledAnchor>\n            {showSkills && (\n              <FlexBox alignItems=\"center\" gap={12} flexWrap=\"wrap\">\n                {sortedSkills.map((skill) => (\n                  <SkillTag\n                    key={skill.id}\n                    data-testid=\"skill-tag\"\n                    px={8}\n                    py={4}\n                    variant=\"interface\"\n                    href={getSkillsAreaPath(skill.slug)}\n                    onClick={() => skillTagOnClick?.(skill.slug)}\n                  >\n                    <FlexBox center>\n                      <Text>{skill.title}</Text>\n                    </FlexBox>\n                  </SkillTag>\n                ))}\n              </FlexBox>\n            )}\n          </FlexBox>\n          <FlexBox borderY={1} borderColor=\"background-hover\" py={16}>\n            {renderProgress()}\n          </FlexBox>\n        </FlexBox>\n\n        {/* Assessment scores */}\n        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\">Evaluation results</Text>\n          <LearningOutcomeAssessmentScores\n            highestScore={highestScore}\n            highestScoreAchievedAt={highestScoreAchievedAt}\n            latestScore={latestScore}\n            latestScoreAchievedAt={latestScoreAchievedAt}\n          />\n        </FlexBox>\n\n        {/* For level 2 and 3 LOs only: Children LOs goes below here */}\n        {isLevelTwoLearningOutcome && (\n          <FlexBox gap={16} column>\n            <Text variant=\"title-xs\">Subskills</Text>\n            {renderSubskills()}\n          </FlexBox>\n        )}\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\">Builds toward...</Text>\n            <LearningOutcomeCardList learningOutcomes={parentLOs} />\n          </FlexBox>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
 const StyledAnchor = /*#__PURE__*/_styled(Anchor, {
   target: "e1ylhic51",
   label: "StyledAnchor"
@@ -18,7 +34,7 @@ const StyledAnchor = /*#__PURE__*/_styled(Anchor, {
     color: 'text',
     textDecoration: 'underline'
   }
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeFlyout/index.tsx"],"names":[],"mappings":"AAcqB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';\nimport { SmallCheckIcon } from '@codecademy/gamut-icons';\nimport { css } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n  LearningOutcomeLowAssessmentBadge,\n} from '../LearningOutcomeBadges';\nimport { LearningOutcomeCardList } from './LearningOutcomeCardList';\n\nconst StyledAnchor = styled(Anchor)(\n  css({\n    color: 'text',\n    fontSize: 26,\n    fontWeight: 700,\n    textDecoration: 'none',\n    '&:hover, &:focus': {\n      color: 'text',\n      textDecoration: 'underline',\n    },\n  })\n);\n\nconst SkillTag = styled(Anchor)(\n  css({\n    fontSize: 14,\n    borderRadius: 'md',\n    border: 1,\n    borderColor: 'border-primary',\n    '&:hover, &:focus': {\n      color: 'text',\n      bg: 'background-hover',\n    },\n  })\n);\n\nexport enum SkillClassification {\n  Language = 'language',\n  Subject = 'subject',\n}\n\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\n}\n\nexport interface ParentLearningOutcome {\n  id: string;\n  outcome: string;\n  level: number | null | undefined;\n}\n\ninterface LearningOutcomeDetailsProps {\n  level: LearningOutcomeLevels;\n  outcome: string;\n  percentComplete: number | undefined | null;\n  highestScore: number | undefined | null;\n  highestScoreAchievedAt: string | undefined | null;\n  latestScore: number | undefined | null;\n  latestScoreAchievedAt: string | undefined | null;\n  parentLOs?: ParentLearningOutcome[];\n  skills?: LearningOutcomeSkill[] | null;\n}\n\ninterface LearningOutcomeFlyoutProps {\n  expanded: boolean;\n  onClose: () => void;\n  learningOutcome: LearningOutcomeDetailsProps;\n  learningOutcomeHref: string;\n  learningOutcomeOnClick?: () => void;\n  skillTagOnClick?: (skillSlug: string) => void;\n}\n\nexport const sortSkillsByClassification = (\n  skills?: LearningOutcomeSkill[] | null\n) => {\n  if (!skills?.length) return [];\n  const skillsCopy = skills.slice();\n\n  const sortedSkills = skillsCopy?.sort((a, b) => {\n    if (a?.classification === 'language') {\n      return -1;\n    }\n    if (b?.classification === 'subject') {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  learningOutcome: {\n    highestScore,\n    highestScoreAchievedAt,\n    latestScore,\n    latestScoreAchievedAt,\n    level,\n    outcome,\n    parentLOs,\n    percentComplete,\n    skills,\n  },\n  skillTagOnClick,\n  onClose,\n}) => {\n  const percentCompletePercentage =\n    percentComplete != null ? percentComplete : 0;\n  const levelLabel = learningOutcomeLabels[level];\n\n  const hasLowLatestAssessment = Boolean(\n    latestScore != null && latestScore < 70\n  );\n\n  const showSkills = !!skills?.length;\n  const sortedSkills = sortSkillsByClassification(skills);\n\n  const showParentLOs =\n    level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;\n\n  const renderProgress = () => (\n    <FlexBox alignItems=\"center\">\n      {Boolean(percentCompletePercentage === 100) && (\n        <FlexBox\n          width={16}\n          height={16}\n          borderRadius=\"md\"\n          bg=\"primary\"\n          mr={8}\n          alignItems=\"center\"\n          justifyContent=\"center\"\n        >\n          <SmallCheckIcon size={11} color=\"white\" />\n        </FlexBox>\n      )}\n      <Text\n        color=\"text\"\n        variant=\"p-large\"\n      >{`${percentCompletePercentage}% progress`}</Text>\n    </FlexBox>\n  );\n\n  return (\n    <Flyout\n      aria-label={`${levelLabel} details`}\n      closeLabel={`Close ${levelLabel} details`}\n      expanded={expanded}\n      onClose={onClose}\n      openFrom=\"right\"\n      title={<Text variant=\"title-sm\">{`${levelLabel} details`}</Text>}\n    >\n      <FlexBox gap={32} mt={32} mx={24} column>\n        {/* Badges, Outcome, Topic tags, Progress */}\n        <FlexBox gap={24} column>\n          <FlexBox justifyContent=\"space-between\" alignItems=\"center\">\n            <LearningOutcomeLevelBadge level={level} size=\"base\" />\n            {hasLowLatestAssessment && <LearningOutcomeLowAssessmentBadge />}\n          </FlexBox>\n          <FlexBox gap={16} column>\n            <StyledAnchor\n              href={learningOutcomeHref}\n              onClick={() => learningOutcomeOnClick?.()}\n            >\n              {outcome}\n            </StyledAnchor>\n            {showSkills && (\n              <FlexBox alignItems=\"center\" gap={12} flexWrap=\"wrap\">\n                {sortedSkills.map((skill) => (\n                  <SkillTag\n                    key={skill.id}\n                    data-testid=\"skill-tag\"\n                    px={8}\n                    py={4}\n                    variant=\"interface\"\n                    href={getSkillsAreaPath(skill.slug)}\n                    onClick={() => skillTagOnClick?.(skill.slug)}\n                  >\n                    <FlexBox center>\n                      <Text>{skill.title}</Text>\n                    </FlexBox>\n                  </SkillTag>\n                ))}\n              </FlexBox>\n            )}\n          </FlexBox>\n          <FlexBox borderY={1} borderColor=\"background-hover\" py={16}>\n            {renderProgress()}\n          </FlexBox>\n        </FlexBox>\n\n        {/* Assessment scores */}\n        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\">Evaluation results</Text>\n          <LearningOutcomeAssessmentScores\n            highestScore={highestScore}\n            highestScoreAchievedAt={highestScoreAchievedAt}\n            latestScore={latestScore}\n            latestScoreAchievedAt={latestScoreAchievedAt}\n          />\n        </FlexBox>\n\n        {/* For level 2 and 3 LOs only: Children LOs goes below here */}\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\">Builds toward...</Text>\n            <LearningOutcomeCardList learningOutcomes={parentLOs} />\n          </FlexBox>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeFlyout/index.tsx"],"names":[],"mappings":"AA8BqB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';\nimport { SmallCheckIcon } from '@codecademy/gamut-icons';\nimport { css } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n  LearningOutcomeLowAssessmentBadge,\n} from '../LearningOutcomeBadges';\nimport { LearningOutcomeTile } from '../LearningOutcomeTile';\nimport { LearningOutcomeCardList } from './LearningOutcomeCardList';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\n      borderTop: 1,\n      borderColor: 'border-tertiary',\n    },\n    '&:last-of-type': {\n      borderBottomLeftRadius: '4px',\n      borderBottomRightRadius: '4px',\n    },\n  })\n);\n\nconst StyledAnchor = styled(Anchor)(\n  css({\n    color: 'text',\n    fontSize: 26,\n    fontWeight: 700,\n    textDecoration: 'none',\n    '&:hover, &:focus': {\n      color: 'text',\n      textDecoration: 'underline',\n    },\n  })\n);\n\nconst SkillTag = styled(Anchor)(\n  css({\n    fontSize: 14,\n    borderRadius: 'md',\n    border: 1,\n    borderColor: 'border-primary',\n    '&:hover, &:focus': {\n      color: 'text',\n      bg: 'background-hover',\n    },\n  })\n);\n\nexport enum SkillClassification {\n  Language = 'language',\n  Subject = 'subject',\n}\n\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\n}\n\nexport interface ParentLearningOutcome {\n  id: string;\n  outcome: string;\n  level: number | null | undefined;\n}\n\ninterface ContentModuleLearningOutcomeDataFragment {\n  id: string;\n  title: string;\n  progressV2: {\n    percentComplete: number | undefined | null;\n  };\n}\n\nexport interface LearningOutcomeDetailsProps {\n  level: LearningOutcomeLevels;\n  outcome: string;\n  percentComplete: number | undefined | null;\n  highestScore: number | undefined | null;\n  highestScoreAchievedAt: string | undefined | null;\n  latestScore: number | undefined | null;\n  latestScoreAchievedAt: string | undefined | null;\n  parentLOs?: ParentLearningOutcome[];\n  skills?: LearningOutcomeSkill[] | null;\n  childLearningOutcomes?: {\n    id: string;\n    outcome: string;\n    percentComplete?: number | undefined | null; // not currently getting this from the API\n    contentModules: ContentModuleLearningOutcomeDataFragment[];\n    progress?: {\n      latestScore: number | undefined | null;\n      covered: boolean | undefined | null;\n      coveredAt: string | undefined | null;\n      highestScore: number | undefined | null;\n    };\n  }[];\n}\n\ninterface LearningOutcomeFlyoutProps {\n  expanded: boolean;\n  onClose: () => void;\n  learningOutcome: LearningOutcomeDetailsProps;\n  learningOutcomeHref: string;\n  learningOutcomeOnClick?: () => void;\n  skillTagOnClick?: (skillSlug: string) => void;\n}\n\nexport function getAverageModulePercentComplete(\n  contentModules: ContentModuleLearningOutcomeDataFragment[]\n): number {\n  if (!contentModules || contentModules.length === 0) return 0;\n\n  const total = contentModules.reduce((sum, module) => {\n    const { progressV2 } = module;\n    return sum + (progressV2?.percentComplete ?? 0);\n  }, 0);\n\n  return Math.floor(total / contentModules.length);\n}\n\nexport const sortSkillsByClassification = (\n  skills?: LearningOutcomeSkill[] | null\n) => {\n  if (!skills?.length) return [];\n  const skillsCopy = skills.slice();\n\n  const sortedSkills = skillsCopy?.sort((a, b) => {\n    if (a?.classification === 'language') {\n      return -1;\n    }\n    if (b?.classification === 'subject') {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nconst getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  learningOutcome: {\n    highestScore,\n    highestScoreAchievedAt,\n    latestScore,\n    latestScoreAchievedAt,\n    level,\n    outcome,\n    parentLOs,\n    percentComplete,\n    skills,\n    childLearningOutcomes,\n  },\n  skillTagOnClick,\n  onClose,\n}) => {\n  const percentCompletePercentage =\n    percentComplete != null ? percentComplete : 0;\n  const levelLabel = learningOutcomeLabels[level];\n\n  const hasLowLatestAssessment = Boolean(\n    latestScore != null && latestScore < 70\n  );\n\n  const showSkills = !!skills?.length;\n  const sortedSkills = sortSkillsByClassification(skills);\n\n  const isLevelTwoLearningOutcome = level === LearningOutcomeLevels.Two;\n  const showParentLOs =\n    level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;\n\n  const renderProgress = () => (\n    <FlexBox alignItems=\"center\">\n      {Boolean(percentCompletePercentage === 100) && (\n        <FlexBox\n          width={16}\n          height={16}\n          borderRadius=\"md\"\n          bg=\"primary\"\n          mr={8}\n          alignItems=\"center\"\n          justifyContent=\"center\"\n        >\n          <SmallCheckIcon size={11} color=\"white\" />\n        </FlexBox>\n      )}\n      <Text\n        color=\"text\"\n        variant=\"p-large\"\n      >{`${percentCompletePercentage}% progress`}</Text>\n    </FlexBox>\n  );\n\n  // Render subskills when the drawer is featuring a level 3 outcome\n\n  const renderSubskills = () => {\n    return (\n      <FlexBox as=\"ul\" flexDirection=\"column\" p={0}>\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, contentModules } = childLo;\n          const calculatedPercentComplete =\n            progress?.covered || progress?.coveredAt\n              ? 100\n              : getAverageModulePercentComplete(contentModules);\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          return (\n            <ChildLearningOutcomeRow\n              row\n              bg=\"white\"\n              borderColor=\"border-tertiary\"\n              borderLeft={1}\n              borderBottom={1}\n              borderRight={1}\n              px={16}\n              py={24}\n              alignItems=\"flex-start\"\n              as=\"li\"\n              key={id}\n              justifyContent=\"flex-start\"\n              gap={16}\n            >\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete: calculatedPercentComplete,\n                  }}\n                  size=\"small\"\n                  popover={false}\n                />\n              </FlexBox>\n              <FlexBox column gap={8}>\n                <Anchor\n                  variant=\"interface\"\n                  href={getLearningOutcomePath(id)}\n                  target=\"_blank\"\n                  whiteSpace=\"normal\"\n                  onClick={() => {\n                    // add tracking here\n                  }}\n                >\n                  {outcome}\n                </Anchor>\n                {showNeedsReviewIndicator && (\n                  <FlexBox>\n                    <LearningOutcomeLowAssessmentBadge />\n                  </FlexBox>\n                )}\n              </FlexBox>\n            </ChildLearningOutcomeRow>\n          );\n        })}\n      </FlexBox>\n    );\n  };\n\n  return (\n    <Flyout\n      aria-label={`${levelLabel} details`}\n      closeLabel={`Close ${levelLabel} details`}\n      expanded={expanded}\n      onClose={onClose}\n      openFrom=\"right\"\n      title={<Text variant=\"title-sm\">{`${levelLabel} details`}</Text>}\n    >\n      <FlexBox gap={32} mt={32} mx={24} column>\n        {/* Badges, Outcome, Topic tags, Progress */}\n        <FlexBox gap={24} column>\n          <FlexBox justifyContent=\"space-between\" alignItems=\"center\">\n            <LearningOutcomeLevelBadge level={level} size=\"base\" />\n            {hasLowLatestAssessment && <LearningOutcomeLowAssessmentBadge />}\n          </FlexBox>\n          <FlexBox gap={16} column>\n            <StyledAnchor\n              href={learningOutcomeHref}\n              onClick={() => learningOutcomeOnClick?.()}\n            >\n              {outcome}\n            </StyledAnchor>\n            {showSkills && (\n              <FlexBox alignItems=\"center\" gap={12} flexWrap=\"wrap\">\n                {sortedSkills.map((skill) => (\n                  <SkillTag\n                    key={skill.id}\n                    data-testid=\"skill-tag\"\n                    px={8}\n                    py={4}\n                    variant=\"interface\"\n                    href={getSkillsAreaPath(skill.slug)}\n                    onClick={() => skillTagOnClick?.(skill.slug)}\n                  >\n                    <FlexBox center>\n                      <Text>{skill.title}</Text>\n                    </FlexBox>\n                  </SkillTag>\n                ))}\n              </FlexBox>\n            )}\n          </FlexBox>\n          <FlexBox borderY={1} borderColor=\"background-hover\" py={16}>\n            {renderProgress()}\n          </FlexBox>\n        </FlexBox>\n\n        {/* Assessment scores */}\n        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\">Evaluation results</Text>\n          <LearningOutcomeAssessmentScores\n            highestScore={highestScore}\n            highestScoreAchievedAt={highestScoreAchievedAt}\n            latestScore={latestScore}\n            latestScoreAchievedAt={latestScoreAchievedAt}\n          />\n        </FlexBox>\n\n        {/* For level 2 and 3 LOs only: Children LOs goes below here */}\n        {isLevelTwoLearningOutcome && (\n          <FlexBox gap={16} column>\n            <Text variant=\"title-xs\">Subskills</Text>\n            {renderSubskills()}\n          </FlexBox>\n        )}\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\">Builds toward...</Text>\n            <LearningOutcomeCardList learningOutcomes={parentLOs} />\n          </FlexBox>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
 const SkillTag = /*#__PURE__*/_styled(Anchor, {
   target: "e1ylhic50",
   label: "SkillTag"
@@ -31,12 +47,22 @@ const SkillTag = /*#__PURE__*/_styled(Anchor, {
     color: 'text',
     bg: 'background-hover'
   }
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeFlyout/index.tsx"],"names":[],"mappings":"AA2BiB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';\nimport { SmallCheckIcon } from '@codecademy/gamut-icons';\nimport { css } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n  LearningOutcomeLowAssessmentBadge,\n} from '../LearningOutcomeBadges';\nimport { LearningOutcomeCardList } from './LearningOutcomeCardList';\n\nconst StyledAnchor = styled(Anchor)(\n  css({\n    color: 'text',\n    fontSize: 26,\n    fontWeight: 700,\n    textDecoration: 'none',\n    '&:hover, &:focus': {\n      color: 'text',\n      textDecoration: 'underline',\n    },\n  })\n);\n\nconst SkillTag = styled(Anchor)(\n  css({\n    fontSize: 14,\n    borderRadius: 'md',\n    border: 1,\n    borderColor: 'border-primary',\n    '&:hover, &:focus': {\n      color: 'text',\n      bg: 'background-hover',\n    },\n  })\n);\n\nexport enum SkillClassification {\n  Language = 'language',\n  Subject = 'subject',\n}\n\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\n}\n\nexport interface ParentLearningOutcome {\n  id: string;\n  outcome: string;\n  level: number | null | undefined;\n}\n\ninterface LearningOutcomeDetailsProps {\n  level: LearningOutcomeLevels;\n  outcome: string;\n  percentComplete: number | undefined | null;\n  highestScore: number | undefined | null;\n  highestScoreAchievedAt: string | undefined | null;\n  latestScore: number | undefined | null;\n  latestScoreAchievedAt: string | undefined | null;\n  parentLOs?: ParentLearningOutcome[];\n  skills?: LearningOutcomeSkill[] | null;\n}\n\ninterface LearningOutcomeFlyoutProps {\n  expanded: boolean;\n  onClose: () => void;\n  learningOutcome: LearningOutcomeDetailsProps;\n  learningOutcomeHref: string;\n  learningOutcomeOnClick?: () => void;\n  skillTagOnClick?: (skillSlug: string) => void;\n}\n\nexport const sortSkillsByClassification = (\n  skills?: LearningOutcomeSkill[] | null\n) => {\n  if (!skills?.length) return [];\n  const skillsCopy = skills.slice();\n\n  const sortedSkills = skillsCopy?.sort((a, b) => {\n    if (a?.classification === 'language') {\n      return -1;\n    }\n    if (b?.classification === 'subject') {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  learningOutcome: {\n    highestScore,\n    highestScoreAchievedAt,\n    latestScore,\n    latestScoreAchievedAt,\n    level,\n    outcome,\n    parentLOs,\n    percentComplete,\n    skills,\n  },\n  skillTagOnClick,\n  onClose,\n}) => {\n  const percentCompletePercentage =\n    percentComplete != null ? percentComplete : 0;\n  const levelLabel = learningOutcomeLabels[level];\n\n  const hasLowLatestAssessment = Boolean(\n    latestScore != null && latestScore < 70\n  );\n\n  const showSkills = !!skills?.length;\n  const sortedSkills = sortSkillsByClassification(skills);\n\n  const showParentLOs =\n    level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;\n\n  const renderProgress = () => (\n    <FlexBox alignItems=\"center\">\n      {Boolean(percentCompletePercentage === 100) && (\n        <FlexBox\n          width={16}\n          height={16}\n          borderRadius=\"md\"\n          bg=\"primary\"\n          mr={8}\n          alignItems=\"center\"\n          justifyContent=\"center\"\n        >\n          <SmallCheckIcon size={11} color=\"white\" />\n        </FlexBox>\n      )}\n      <Text\n        color=\"text\"\n        variant=\"p-large\"\n      >{`${percentCompletePercentage}% progress`}</Text>\n    </FlexBox>\n  );\n\n  return (\n    <Flyout\n      aria-label={`${levelLabel} details`}\n      closeLabel={`Close ${levelLabel} details`}\n      expanded={expanded}\n      onClose={onClose}\n      openFrom=\"right\"\n      title={<Text variant=\"title-sm\">{`${levelLabel} details`}</Text>}\n    >\n      <FlexBox gap={32} mt={32} mx={24} column>\n        {/* Badges, Outcome, Topic tags, Progress */}\n        <FlexBox gap={24} column>\n          <FlexBox justifyContent=\"space-between\" alignItems=\"center\">\n            <LearningOutcomeLevelBadge level={level} size=\"base\" />\n            {hasLowLatestAssessment && <LearningOutcomeLowAssessmentBadge />}\n          </FlexBox>\n          <FlexBox gap={16} column>\n            <StyledAnchor\n              href={learningOutcomeHref}\n              onClick={() => learningOutcomeOnClick?.()}\n            >\n              {outcome}\n            </StyledAnchor>\n            {showSkills && (\n              <FlexBox alignItems=\"center\" gap={12} flexWrap=\"wrap\">\n                {sortedSkills.map((skill) => (\n                  <SkillTag\n                    key={skill.id}\n                    data-testid=\"skill-tag\"\n                    px={8}\n                    py={4}\n                    variant=\"interface\"\n                    href={getSkillsAreaPath(skill.slug)}\n                    onClick={() => skillTagOnClick?.(skill.slug)}\n                  >\n                    <FlexBox center>\n                      <Text>{skill.title}</Text>\n                    </FlexBox>\n                  </SkillTag>\n                ))}\n              </FlexBox>\n            )}\n          </FlexBox>\n          <FlexBox borderY={1} borderColor=\"background-hover\" py={16}>\n            {renderProgress()}\n          </FlexBox>\n        </FlexBox>\n\n        {/* Assessment scores */}\n        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\">Evaluation results</Text>\n          <LearningOutcomeAssessmentScores\n            highestScore={highestScore}\n            highestScoreAchievedAt={highestScoreAchievedAt}\n            latestScore={latestScore}\n            latestScoreAchievedAt={latestScoreAchievedAt}\n          />\n        </FlexBox>\n\n        {/* For level 2 and 3 LOs only: Children LOs goes below here */}\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\">Builds toward...</Text>\n            <LearningOutcomeCardList learningOutcomes={parentLOs} />\n          </FlexBox>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeFlyout/index.tsx"],"names":[],"mappings":"AA2CiB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';\nimport { SmallCheckIcon } from '@codecademy/gamut-icons';\nimport { css } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n  LearningOutcomeLowAssessmentBadge,\n} from '../LearningOutcomeBadges';\nimport { LearningOutcomeTile } from '../LearningOutcomeTile';\nimport { LearningOutcomeCardList } from './LearningOutcomeCardList';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\n      borderTop: 1,\n      borderColor: 'border-tertiary',\n    },\n    '&:last-of-type': {\n      borderBottomLeftRadius: '4px',\n      borderBottomRightRadius: '4px',\n    },\n  })\n);\n\nconst StyledAnchor = styled(Anchor)(\n  css({\n    color: 'text',\n    fontSize: 26,\n    fontWeight: 700,\n    textDecoration: 'none',\n    '&:hover, &:focus': {\n      color: 'text',\n      textDecoration: 'underline',\n    },\n  })\n);\n\nconst SkillTag = styled(Anchor)(\n  css({\n    fontSize: 14,\n    borderRadius: 'md',\n    border: 1,\n    borderColor: 'border-primary',\n    '&:hover, &:focus': {\n      color: 'text',\n      bg: 'background-hover',\n    },\n  })\n);\n\nexport enum SkillClassification {\n  Language = 'language',\n  Subject = 'subject',\n}\n\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\n}\n\nexport interface ParentLearningOutcome {\n  id: string;\n  outcome: string;\n  level: number | null | undefined;\n}\n\ninterface ContentModuleLearningOutcomeDataFragment {\n  id: string;\n  title: string;\n  progressV2: {\n    percentComplete: number | undefined | null;\n  };\n}\n\nexport interface LearningOutcomeDetailsProps {\n  level: LearningOutcomeLevels;\n  outcome: string;\n  percentComplete: number | undefined | null;\n  highestScore: number | undefined | null;\n  highestScoreAchievedAt: string | undefined | null;\n  latestScore: number | undefined | null;\n  latestScoreAchievedAt: string | undefined | null;\n  parentLOs?: ParentLearningOutcome[];\n  skills?: LearningOutcomeSkill[] | null;\n  childLearningOutcomes?: {\n    id: string;\n    outcome: string;\n    percentComplete?: number | undefined | null; // not currently getting this from the API\n    contentModules: ContentModuleLearningOutcomeDataFragment[];\n    progress?: {\n      latestScore: number | undefined | null;\n      covered: boolean | undefined | null;\n      coveredAt: string | undefined | null;\n      highestScore: number | undefined | null;\n    };\n  }[];\n}\n\ninterface LearningOutcomeFlyoutProps {\n  expanded: boolean;\n  onClose: () => void;\n  learningOutcome: LearningOutcomeDetailsProps;\n  learningOutcomeHref: string;\n  learningOutcomeOnClick?: () => void;\n  skillTagOnClick?: (skillSlug: string) => void;\n}\n\nexport function getAverageModulePercentComplete(\n  contentModules: ContentModuleLearningOutcomeDataFragment[]\n): number {\n  if (!contentModules || contentModules.length === 0) return 0;\n\n  const total = contentModules.reduce((sum, module) => {\n    const { progressV2 } = module;\n    return sum + (progressV2?.percentComplete ?? 0);\n  }, 0);\n\n  return Math.floor(total / contentModules.length);\n}\n\nexport const sortSkillsByClassification = (\n  skills?: LearningOutcomeSkill[] | null\n) => {\n  if (!skills?.length) return [];\n  const skillsCopy = skills.slice();\n\n  const sortedSkills = skillsCopy?.sort((a, b) => {\n    if (a?.classification === 'language') {\n      return -1;\n    }\n    if (b?.classification === 'subject') {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nconst getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  learningOutcome: {\n    highestScore,\n    highestScoreAchievedAt,\n    latestScore,\n    latestScoreAchievedAt,\n    level,\n    outcome,\n    parentLOs,\n    percentComplete,\n    skills,\n    childLearningOutcomes,\n  },\n  skillTagOnClick,\n  onClose,\n}) => {\n  const percentCompletePercentage =\n    percentComplete != null ? percentComplete : 0;\n  const levelLabel = learningOutcomeLabels[level];\n\n  const hasLowLatestAssessment = Boolean(\n    latestScore != null && latestScore < 70\n  );\n\n  const showSkills = !!skills?.length;\n  const sortedSkills = sortSkillsByClassification(skills);\n\n  const isLevelTwoLearningOutcome = level === LearningOutcomeLevels.Two;\n  const showParentLOs =\n    level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;\n\n  const renderProgress = () => (\n    <FlexBox alignItems=\"center\">\n      {Boolean(percentCompletePercentage === 100) && (\n        <FlexBox\n          width={16}\n          height={16}\n          borderRadius=\"md\"\n          bg=\"primary\"\n          mr={8}\n          alignItems=\"center\"\n          justifyContent=\"center\"\n        >\n          <SmallCheckIcon size={11} color=\"white\" />\n        </FlexBox>\n      )}\n      <Text\n        color=\"text\"\n        variant=\"p-large\"\n      >{`${percentCompletePercentage}% progress`}</Text>\n    </FlexBox>\n  );\n\n  // Render subskills when the drawer is featuring a level 3 outcome\n\n  const renderSubskills = () => {\n    return (\n      <FlexBox as=\"ul\" flexDirection=\"column\" p={0}>\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, contentModules } = childLo;\n          const calculatedPercentComplete =\n            progress?.covered || progress?.coveredAt\n              ? 100\n              : getAverageModulePercentComplete(contentModules);\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          return (\n            <ChildLearningOutcomeRow\n              row\n              bg=\"white\"\n              borderColor=\"border-tertiary\"\n              borderLeft={1}\n              borderBottom={1}\n              borderRight={1}\n              px={16}\n              py={24}\n              alignItems=\"flex-start\"\n              as=\"li\"\n              key={id}\n              justifyContent=\"flex-start\"\n              gap={16}\n            >\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete: calculatedPercentComplete,\n                  }}\n                  size=\"small\"\n                  popover={false}\n                />\n              </FlexBox>\n              <FlexBox column gap={8}>\n                <Anchor\n                  variant=\"interface\"\n                  href={getLearningOutcomePath(id)}\n                  target=\"_blank\"\n                  whiteSpace=\"normal\"\n                  onClick={() => {\n                    // add tracking here\n                  }}\n                >\n                  {outcome}\n                </Anchor>\n                {showNeedsReviewIndicator && (\n                  <FlexBox>\n                    <LearningOutcomeLowAssessmentBadge />\n                  </FlexBox>\n                )}\n              </FlexBox>\n            </ChildLearningOutcomeRow>\n          );\n        })}\n      </FlexBox>\n    );\n  };\n\n  return (\n    <Flyout\n      aria-label={`${levelLabel} details`}\n      closeLabel={`Close ${levelLabel} details`}\n      expanded={expanded}\n      onClose={onClose}\n      openFrom=\"right\"\n      title={<Text variant=\"title-sm\">{`${levelLabel} details`}</Text>}\n    >\n      <FlexBox gap={32} mt={32} mx={24} column>\n        {/* Badges, Outcome, Topic tags, Progress */}\n        <FlexBox gap={24} column>\n          <FlexBox justifyContent=\"space-between\" alignItems=\"center\">\n            <LearningOutcomeLevelBadge level={level} size=\"base\" />\n            {hasLowLatestAssessment && <LearningOutcomeLowAssessmentBadge />}\n          </FlexBox>\n          <FlexBox gap={16} column>\n            <StyledAnchor\n              href={learningOutcomeHref}\n              onClick={() => learningOutcomeOnClick?.()}\n            >\n              {outcome}\n            </StyledAnchor>\n            {showSkills && (\n              <FlexBox alignItems=\"center\" gap={12} flexWrap=\"wrap\">\n                {sortedSkills.map((skill) => (\n                  <SkillTag\n                    key={skill.id}\n                    data-testid=\"skill-tag\"\n                    px={8}\n                    py={4}\n                    variant=\"interface\"\n                    href={getSkillsAreaPath(skill.slug)}\n                    onClick={() => skillTagOnClick?.(skill.slug)}\n                  >\n                    <FlexBox center>\n                      <Text>{skill.title}</Text>\n                    </FlexBox>\n                  </SkillTag>\n                ))}\n              </FlexBox>\n            )}\n          </FlexBox>\n          <FlexBox borderY={1} borderColor=\"background-hover\" py={16}>\n            {renderProgress()}\n          </FlexBox>\n        </FlexBox>\n\n        {/* Assessment scores */}\n        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\">Evaluation results</Text>\n          <LearningOutcomeAssessmentScores\n            highestScore={highestScore}\n            highestScoreAchievedAt={highestScoreAchievedAt}\n            latestScore={latestScore}\n            latestScoreAchievedAt={latestScoreAchievedAt}\n          />\n        </FlexBox>\n\n        {/* For level 2 and 3 LOs only: Children LOs goes below here */}\n        {isLevelTwoLearningOutcome && (\n          <FlexBox gap={16} column>\n            <Text variant=\"title-xs\">Subskills</Text>\n            {renderSubskills()}\n          </FlexBox>\n        )}\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\">Builds toward...</Text>\n            <LearningOutcomeCardList learningOutcomes={parentLOs} />\n          </FlexBox>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
 export let SkillClassification = /*#__PURE__*/function (SkillClassification) {
   SkillClassification["Language"] = "language";
   SkillClassification["Subject"] = "subject";
   return SkillClassification;
 }({});
+export function getAverageModulePercentComplete(contentModules) {
+  if (!contentModules || contentModules.length === 0) return 0;
+  const total = contentModules.reduce((sum, module) => {
+    const {
+      progressV2
+    } = module;
+    return sum + (progressV2?.percentComplete ?? 0);
+  }, 0);
+  return Math.floor(total / contentModules.length);
+}
 export const sortSkillsByClassification = skills => {
   if (!skills?.length) return [];
   const skillsCopy = skills.slice();
@@ -54,6 +80,9 @@ export const sortSkillsByClassification = skills => {
 const getSkillsAreaPath = skillSlug => {
   return skillSlug ? `/skill-areas/${skillSlug}` : '/';
 };
+const getLearningOutcomePath = id => {
+  return id ? `/learning-outcomes/${id}` : '/';
+};
 export const LearningOutcomeFlyout = ({
   expanded,
   learningOutcomeHref,
@@ -67,7 +96,8 @@ export const LearningOutcomeFlyout = ({
     outcome,
     parentLOs,
     percentComplete,
-    skills
+    skills,
+    childLearningOutcomes
   },
   skillTagOnClick,
   onClose
@@ -77,6 +107,7 @@ export const LearningOutcomeFlyout = ({
   const hasLowLatestAssessment = Boolean(latestScore != null && latestScore < 70);
   const showSkills = !!skills?.length;
   const sortedSkills = sortSkillsByClassification(skills);
+  const isLevelTwoLearningOutcome = level === LearningOutcomeLevels.Two;
   const showParentLOs = level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;
   const renderProgress = () => /*#__PURE__*/_jsxs(FlexBox, {
     alignItems: "center",
@@ -98,6 +129,70 @@ export const LearningOutcomeFlyout = ({
       children: `${percentCompletePercentage}% progress`
     })]
   });
+
+  // Render subskills when the drawer is featuring a level 3 outcome
+
+  const renderSubskills = () => {
+    return /*#__PURE__*/_jsx(FlexBox, {
+      as: "ul",
+      flexDirection: "column",
+      p: 0,
+      children: childLearningOutcomes?.map(childLo => {
+        const {
+          id,
+          outcome,
+          progress,
+          contentModules
+        } = childLo;
+        const calculatedPercentComplete = progress?.covered || progress?.coveredAt ? 100 : getAverageModulePercentComplete(contentModules);
+        const showNeedsReviewIndicator = progress?.latestScore !== null && progress?.latestScore !== undefined ? progress.latestScore < 70 : false;
+        return /*#__PURE__*/_jsxs(ChildLearningOutcomeRow, {
+          row: true,
+          bg: "white",
+          borderColor: "border-tertiary",
+          borderLeft: 1,
+          borderBottom: 1,
+          borderRight: 1,
+          px: 16,
+          py: 24,
+          alignItems: "flex-start",
+          as: "li",
+          justifyContent: "flex-start",
+          gap: 16,
+          children: [/*#__PURE__*/_jsx(FlexBox, {
+            minWidth: 32,
+            width: 32,
+            justifyContent: "center",
+            children: /*#__PURE__*/_jsx(LearningOutcomeTile, {
+              learningOutcomeDetails: {
+                id,
+                level: LearningOutcomeLevels.One,
+                outcome,
+                percentComplete: calculatedPercentComplete
+              },
+              size: "small",
+              popover: false
+            })
+          }), /*#__PURE__*/_jsxs(FlexBox, {
+            column: true,
+            gap: 8,
+            children: [/*#__PURE__*/_jsx(Anchor, {
+              variant: "interface",
+              href: getLearningOutcomePath(id),
+              target: "_blank",
+              whiteSpace: "normal",
+              onClick: () => {
+                // add tracking here
+              },
+              children: outcome
+            }), showNeedsReviewIndicator && /*#__PURE__*/_jsx(FlexBox, {
+              children: /*#__PURE__*/_jsx(LearningOutcomeLowAssessmentBadge, {})
+            })]
+          })]
+        }, id);
+      })
+    });
+  };
   return /*#__PURE__*/_jsx(Flyout, {
     "aria-label": `${levelLabel} details`,
     closeLabel: `Close ${levelLabel} details`,
@@ -167,6 +262,13 @@ export const LearningOutcomeFlyout = ({
           latestScore: latestScore,
           latestScoreAchievedAt: latestScoreAchievedAt
         })]
+      }), isLevelTwoLearningOutcome && /*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "title-xs",
+          children: "Subskills"
+        }), renderSubskills()]
       }), showParentLOs && /*#__PURE__*/_jsxs(FlexBox, {
         gap: 16,
         mb: 16,

package/dist/Recurly/context/NoProvider.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A symbol used as the default value for contexts that require a provider. When
+ * calling useContext, we can throw an error if we find this symbol rather than
+ * a provided value. This is useful in cases where we want to consider null or
+ * undefined as valid provided values.
+ */
+export declare const NO_PROVIDER: unique symbol;
+export type NoProvider = typeof NO_PROVIDER;

package/dist/Recurly/context/NoProvider.js

@@ -0,0 +1,7 @@
+/**
+ * A symbol used as the default value for contexts that require a provider. When
+ * calling useContext, we can throw an error if we find this symbol rather than
+ * a provided value. This is useful in cases where we want to consider null or
+ * undefined as valid provided values.
+ */
+export const NO_PROVIDER = Symbol('no provider');

package/dist/Recurly/context/elements/index.d.ts

@@ -0,0 +1,26 @@
+import type { ElementsInstance } from '@recurly/recurly-js';
+import { PropsWithChildren } from 'react';
+/**
+ * A provider that provides the Elements instance via context.
+ *
+ * If used outside of a RecurlyProvider, it will throw an error.
+ */
+export declare function Elements({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+/**
+ * A hook that returns the Elements instance from context.
+ *
+ * If used outside of an Elements provider, it will throw an error.
+ *
+ * Within an Elements provider:
+ * - If used on the server, it will return undefined.
+ * - If used on the client, it will initially return undefined and then return
+ *   the provided Elements instance once the Recurly library is loaded.
+ *
+ * @param options - An object to provide an alternate contextual error message
+ * to use if one tries to use this hook outside of an Elements provider.
+ *
+ * @returns The Elements instance.
+ */
+export declare function useElements(options?: {
+    noProviderError?: string;
+}): ElementsInstance | undefined;

package/dist/Recurly/context/elements/index.js

@@ -0,0 +1,46 @@
+import { createContext, useContext, useMemo } from 'react';
+import { NO_PROVIDER } from '../NoProvider';
+import { useRecurly } from '../recurly';
+import { jsx as _jsx } from "react/jsx-runtime";
+const ElementCtx = /*#__PURE__*/createContext(NO_PROVIDER);
+
+/**
+ * A provider that provides the Elements instance via context.
+ *
+ * If used outside of a RecurlyProvider, it will throw an error.
+ */
+export function Elements({
+  children
+}) {
+  const recurly = useRecurly({
+    noProviderError: 'Elements must be used within a RecurlyProvider.'
+  });
+  const elements = useMemo(() => recurly?.Elements(), [recurly]);
+  return /*#__PURE__*/_jsx(ElementCtx.Provider, {
+    value: elements,
+    children: children
+  });
+}
+
+/**
+ * A hook that returns the Elements instance from context.
+ *
+ * If used outside of an Elements provider, it will throw an error.
+ *
+ * Within an Elements provider:
+ * - If used on the server, it will return undefined.
+ * - If used on the client, it will initially return undefined and then return
+ *   the provided Elements instance once the Recurly library is loaded.
+ *
+ * @param options - An object to provide an alternate contextual error message
+ * to use if one tries to use this hook outside of an Elements provider.
+ *
+ * @returns The Elements instance.
+ */
+export function useElements(options) {
+  const elements = useContext(ElementCtx);
+  if (elements === NO_PROVIDER) {
+    throw new Error(options?.noProviderError ?? 'useElements must be used within a Elements provider.');
+  }
+  return elements;
+}

package/dist/Recurly/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './recurly';
+export * from './elements';

package/dist/Recurly/context/index.js

@@ -0,0 +1,2 @@
+export * from './recurly';
+export * from './elements';

package/dist/Recurly/context/recurly/index.d.ts

@@ -0,0 +1,30 @@
+import type { Recurly } from '@recurly/recurly-js';
+import { PropsWithChildren } from 'react';
+import { RecurlyConfig } from './loadRecurly';
+export type RecurlyProviderProps = PropsWithChildren<RecurlyConfig>;
+/**
+ * A provider that:
+ * - loads the Recurly library
+ * - ensures that only a single instance of the library is loaded
+ * - configures the library with the provided public key
+ * - provides the library instance via context
+ */
+export declare function RecurlyProvider({ children, ...config }: RecurlyProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * A hook that returns the Recurly instance from context.
+ *
+ * If used outside of a RecurlyProvider, it will throw an error.
+ *
+ * Within a RecurlyProvider:
+ * - If used on the server, it will return undefined.
+ * - If used on the client, it will initially return undefined and then return
+ *   the provided Recurly instance once it is loaded.
+ *
+ * @param options - An object to provide an alternate contextual error message
+ * to use if one tries to use this hook outside of a RecurlyProvider.
+ *
+ * @returns The Recurly instance.
+ */
+export declare function useRecurly(options?: {
+    noProviderError?: string;
+}): Recurly | undefined;

package/dist/Recurly/context/recurly/index.js

@@ -0,0 +1,50 @@
+import { createContext, useContext, useEffect, useState } from 'react';
+import { NO_PROVIDER } from '../NoProvider';
+import { loadRecurly } from './loadRecurly';
+import { jsx as _jsx } from "react/jsx-runtime";
+const RecurlyCtx = /*#__PURE__*/createContext(NO_PROVIDER);
+/**
+ * A provider that:
+ * - loads the Recurly library
+ * - ensures that only a single instance of the library is loaded
+ * - configures the library with the provided public key
+ * - provides the library instance via context
+ */
+export function RecurlyProvider({
+  children,
+  ...config
+}) {
+  const [recurly, setRecurly] = useState(undefined);
+  useEffect(() => {
+    loadRecurly(config)?.then(setRecurly);
+    // Exclude `config` dependency as it should be treated as static.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return /*#__PURE__*/_jsx(RecurlyCtx.Provider, {
+    value: recurly,
+    children: children
+  });
+}
+
+/**
+ * A hook that returns the Recurly instance from context.
+ *
+ * If used outside of a RecurlyProvider, it will throw an error.
+ *
+ * Within a RecurlyProvider:
+ * - If used on the server, it will return undefined.
+ * - If used on the client, it will initially return undefined and then return
+ *   the provided Recurly instance once it is loaded.
+ *
+ * @param options - An object to provide an alternate contextual error message
+ * to use if one tries to use this hook outside of a RecurlyProvider.
+ *
+ * @returns The Recurly instance.
+ */
+export function useRecurly(options) {
+  const recurly = useContext(RecurlyCtx);
+  if (recurly === NO_PROVIDER) {
+    throw new Error(options?.noProviderError ?? 'useRecurly must be used within a RecurlyProvider');
+  }
+  return recurly;
+}

package/dist/Recurly/context/recurly/loadRecurly.d.ts

@@ -0,0 +1,6 @@
+import type { Recurly } from '@recurly/recurly-js';
+export type RecurlyConfig = {
+    publicKey: string;
+    required: string[];
+};
+export declare function loadRecurly(config: RecurlyConfig): Promise<Recurly> | undefined;

package/dist/Recurly/context/recurly/loadRecurly.js

@@ -0,0 +1,22 @@
+import { w } from './w';
+export function loadRecurly(config) {
+  if (w && w._recurlyPromise) {
+    w._recurlyPromise = new Promise(resolve => {
+      const script = w.document.createElement('script');
+      script.src = 'https://js.recurly.com/v4/recurly.js';
+      script.async = true;
+      script.onload = () => {
+        const {
+          recurly
+        } = w;
+        if (!recurly) {
+          throw new Error('Recurly was not loaded by recurly.js');
+        }
+        recurly.configure(config);
+        resolve(recurly);
+      };
+      w.document.head.appendChild(script);
+    });
+  }
+  return w?._recurlyPromise;
+}

package/dist/Recurly/context/recurly/w.d.ts

@@ -0,0 +1,14 @@
+import type { Recurly } from '@recurly/recurly-js';
+type Doc = {
+    createElement: Document['createElement'];
+    head: {
+        appendChild: Document['head']['appendChild'];
+    };
+};
+export type W = {
+    recurly?: Recurly;
+    _recurlyPromise?: Promise<Recurly>;
+    document: Doc;
+};
+export declare const w: W | undefined;
+export {};

package/dist/Recurly/context/recurly/w.js

@@ -0,0 +1,4 @@
+// By importing/exporting w as a window object, we can easily mock it in tests.
+
+// Exported for easy mocking
+export const w = typeof window === 'undefined' ? undefined : window;

package/dist/Recurly/fields/RecurlyField.d.ts

@@ -0,0 +1,9 @@
+import { InputWrapperProps } from '@codecademy/gamut';
+export type RecurlyFieldProps = InputWrapperProps & {
+    label: string;
+};
+/**
+ * A wrapper around a Recurly element (or two elements in the case of MM/YY) to
+ * add Gamut border styling and a label.
+ */
+export declare function RecurlyField({ label, children, ...props }: RecurlyFieldProps): import("react/jsx-runtime").JSX.Element;