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

package/dist/LearningOutcomeFlyout/index.js

@@ -0,0 +1,354 @@
+import _styled from "@emotion/styled/base";
+import { Alert, Anchor, FillButton, FlexBox, Flyout, Shimmer, StrokeButton, Text, ToolTip } from '@codecademy/gamut';
+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 { SkillClassification } from './types';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const ChildLearningOutcomeRow = /*#__PURE__*/_styled(FlexBox, {
+  target: "e1ylhic52",
+  label: "ChildLearningOutcomeRow"
+})(css({
+  background: 'white',
+  borderColor: 'border-tertiary',
+  borderTopWidth: 0,
+  borderLeftWidth: 1,
+  borderRightWidth: 1,
+  borderBottomWidth: 1,
+  borderStyle: 'solid',
+  padding: '24px 16px',
+  alignItems: 'flex-start',
+  justifyContent: 'flex-start',
+  gap: 16,
+  '&:first-of-type': {
+    borderTopLeftRadius: '4px',
+    borderTopRightRadius: '4px'
+  },
+  '&: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":"AA8BgC","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import {\n  Alert,\n  Anchor,\n  FillButton,\n  FlexBox,\n  Flyout,\n  Shimmer,\n  StrokeButton,\n  Text,\n  ToolTip,\n} 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';\nimport {\n  LearningOutcomeFlyoutProps,\n  LearningOutcomeSkill,\n  SkillClassification,\n} from './types';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    background: 'white',\n    borderColor: 'border-tertiary',\n    borderTopWidth: 0,\n    borderLeftWidth: 1,\n    borderRightWidth: 1,\n    borderBottomWidth: 1,\n    borderStyle: 'solid',\n    padding: '24px 16px',\n    alignItems: 'flex-start',\n    justifyContent: 'flex-start',\n    gap: 16,\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\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    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 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 === SkillClassification.Language) {\n      return -1;\n    }\n    if (b?.classification === SkillClassification.Subject) {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nexport const getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nexport const miscTrackingData = (\n  level?: LearningOutcomeLevels | null,\n  id?: string,\n  latestScore?: number | null,\n  outcome?: string\n) => {\n  return {\n    misc: JSON.stringify({\n      last_assessed_score: latestScore,\n      LO_level: level,\n      title: outcome,\n      unique_id: id,\n    }),\n  };\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  childLearningOutcomeOnClick,\n  parentLearningOutcomeOnClick,\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  assessmentHref,\n  assessmentEligible,\n  bestMatchResponse,\n  bestMatchOnClick,\n  showBestMatchCTA,\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 {\n    data: bestMatchData,\n    loading: bestMatchLoading,\n    error: bestMatchError,\n  } = bestMatchResponse;\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 bestMatchCTA = bestMatchLoading ? (\n    <Shimmer width=\"50%\" data-testid=\"best-match-shimmer\" />\n  ) : (\n    <FillButton\n      href={bestMatchData?.urlPath ?? ''}\n      disabled={!bestMatchData?.urlPath || bestMatchError}\n      data-testid=\"best-match-button\"\n      width=\"50%\"\n      onClick={() => bestMatchOnClick?.()}\n    >\n      Learn\n    </FillButton>\n  );\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 skills when the drawer is featuring a level 3 outcome\n  const renderSkills = () => {\n    return <FlexBox as=\"ul\">Skills go here</FlexBox>;\n  };\n\n  // Render subskills when the drawer is featuring a level 2 outcome\n  const renderSubskills = () => {\n    return (\n      <FlexBox\n        as=\"ul\"\n        flexDirection=\"column\"\n        p={0}\n        borderTop={1}\n        borderColor=\"border-tertiary\"\n        borderRadius=\"md\"\n      >\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, percentComplete } = childLo;\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          const trackingData = miscTrackingData(\n            LearningOutcomeLevels.One,\n            id,\n            progress?.latestScore,\n            outcome\n          );\n\n          return (\n            <ChildLearningOutcomeRow row as=\"li\" key={id}>\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete,\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={() => childLearningOutcomeOnClick?.(trackingData)}\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          {showBestMatchCTA && (!bestMatchData?.urlPath || bestMatchError) && (\n            <Alert\n              placement=\"inline\"\n              type=\"subtle\"\n              data-testid=\"best-match-alert\"\n            >\n              {`We were unable to load the associated ${levelLabel.toLocaleLowerCase()}. Please refresh the\n            page and try again.`}\n            </Alert>\n          )}\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              <Text as=\"h2\" variant=\"title-md\">\n                {outcome}\n              </Text>\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\" as=\"h3\">\n            Evaluation results\n          </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        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\" as=\"h3\">\n            {isLevelTwoLearningOutcome ? `Subskills` : `Skills`}\n          </Text>\n          {isLevelTwoLearningOutcome ? renderSubskills() : renderSkills()}\n        </FlexBox>\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\" as=\"h3\">\n              Builds toward...\n            </Text>\n            <LearningOutcomeCardList\n              learningOutcomes={parentLOs}\n              onClick={parentLearningOutcomeOnClick}\n            />\n          </FlexBox>\n        )}\n      </FlexBox>\n      <FlexBox\n        borderTop={1}\n        bg=\"white\"\n        bottom=\"-3px\"\n        boxShadow=\"0px -4px 16px 0px #00000014\"\n        borderColor=\"border-tertiary\"\n        py={12}\n        px={16}\n        position=\"sticky\"\n        justifyContent=\"center\"\n        gap={12}\n      >\n        {showBestMatchCTA ? bestMatchCTA : null}\n        {assessmentEligible ? (\n          <StrokeButton\n            href={assessmentHref}\n            width={showBestMatchCTA ? { _: 209, xs: '50%' } : '100%'}\n          >\n            Evaluate\n          </StrokeButton>\n        ) : (\n          <ToolTip\n            id=\"disabled-evaluate\"\n            data-testid=\"disabled-evaluate\"\n            info={`Not available for this ${levelLabel.toLowerCase()}`}\n            placement=\"inline\"\n            inheritDims\n          >\n            <StrokeButton\n              aria-describedby=\"disabled-evaluate\"\n              aria-disabled\n              width={showBestMatchCTA ? 209 : '100%'}\n            >\n              Evaluate\n            </StrokeButton>\n          </ToolTip>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
+const StyledAnchor = /*#__PURE__*/_styled(Anchor, {
+  target: "e1ylhic51",
+  label: "StyledAnchor"
+})(css({
+  color: 'text',
+  textDecoration: 'none',
+  '&:hover, &:focus': {
+    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":"AAsDqB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import {\n  Alert,\n  Anchor,\n  FillButton,\n  FlexBox,\n  Flyout,\n  Shimmer,\n  StrokeButton,\n  Text,\n  ToolTip,\n} 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';\nimport {\n  LearningOutcomeFlyoutProps,\n  LearningOutcomeSkill,\n  SkillClassification,\n} from './types';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    background: 'white',\n    borderColor: 'border-tertiary',\n    borderTopWidth: 0,\n    borderLeftWidth: 1,\n    borderRightWidth: 1,\n    borderBottomWidth: 1,\n    borderStyle: 'solid',\n    padding: '24px 16px',\n    alignItems: 'flex-start',\n    justifyContent: 'flex-start',\n    gap: 16,\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\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    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 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 === SkillClassification.Language) {\n      return -1;\n    }\n    if (b?.classification === SkillClassification.Subject) {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nexport const getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nexport const miscTrackingData = (\n  level?: LearningOutcomeLevels | null,\n  id?: string,\n  latestScore?: number | null,\n  outcome?: string\n) => {\n  return {\n    misc: JSON.stringify({\n      last_assessed_score: latestScore,\n      LO_level: level,\n      title: outcome,\n      unique_id: id,\n    }),\n  };\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  childLearningOutcomeOnClick,\n  parentLearningOutcomeOnClick,\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  assessmentHref,\n  assessmentEligible,\n  bestMatchResponse,\n  bestMatchOnClick,\n  showBestMatchCTA,\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 {\n    data: bestMatchData,\n    loading: bestMatchLoading,\n    error: bestMatchError,\n  } = bestMatchResponse;\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 bestMatchCTA = bestMatchLoading ? (\n    <Shimmer width=\"50%\" data-testid=\"best-match-shimmer\" />\n  ) : (\n    <FillButton\n      href={bestMatchData?.urlPath ?? ''}\n      disabled={!bestMatchData?.urlPath || bestMatchError}\n      data-testid=\"best-match-button\"\n      width=\"50%\"\n      onClick={() => bestMatchOnClick?.()}\n    >\n      Learn\n    </FillButton>\n  );\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 skills when the drawer is featuring a level 3 outcome\n  const renderSkills = () => {\n    return <FlexBox as=\"ul\">Skills go here</FlexBox>;\n  };\n\n  // Render subskills when the drawer is featuring a level 2 outcome\n  const renderSubskills = () => {\n    return (\n      <FlexBox\n        as=\"ul\"\n        flexDirection=\"column\"\n        p={0}\n        borderTop={1}\n        borderColor=\"border-tertiary\"\n        borderRadius=\"md\"\n      >\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, percentComplete } = childLo;\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          const trackingData = miscTrackingData(\n            LearningOutcomeLevels.One,\n            id,\n            progress?.latestScore,\n            outcome\n          );\n\n          return (\n            <ChildLearningOutcomeRow row as=\"li\" key={id}>\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete,\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={() => childLearningOutcomeOnClick?.(trackingData)}\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          {showBestMatchCTA && (!bestMatchData?.urlPath || bestMatchError) && (\n            <Alert\n              placement=\"inline\"\n              type=\"subtle\"\n              data-testid=\"best-match-alert\"\n            >\n              {`We were unable to load the associated ${levelLabel.toLocaleLowerCase()}. Please refresh the\n            page and try again.`}\n            </Alert>\n          )}\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              <Text as=\"h2\" variant=\"title-md\">\n                {outcome}\n              </Text>\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\" as=\"h3\">\n            Evaluation results\n          </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        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\" as=\"h3\">\n            {isLevelTwoLearningOutcome ? `Subskills` : `Skills`}\n          </Text>\n          {isLevelTwoLearningOutcome ? renderSubskills() : renderSkills()}\n        </FlexBox>\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\" as=\"h3\">\n              Builds toward...\n            </Text>\n            <LearningOutcomeCardList\n              learningOutcomes={parentLOs}\n              onClick={parentLearningOutcomeOnClick}\n            />\n          </FlexBox>\n        )}\n      </FlexBox>\n      <FlexBox\n        borderTop={1}\n        bg=\"white\"\n        bottom=\"-3px\"\n        boxShadow=\"0px -4px 16px 0px #00000014\"\n        borderColor=\"border-tertiary\"\n        py={12}\n        px={16}\n        position=\"sticky\"\n        justifyContent=\"center\"\n        gap={12}\n      >\n        {showBestMatchCTA ? bestMatchCTA : null}\n        {assessmentEligible ? (\n          <StrokeButton\n            href={assessmentHref}\n            width={showBestMatchCTA ? { _: 209, xs: '50%' } : '100%'}\n          >\n            Evaluate\n          </StrokeButton>\n        ) : (\n          <ToolTip\n            id=\"disabled-evaluate\"\n            data-testid=\"disabled-evaluate\"\n            info={`Not available for this ${levelLabel.toLowerCase()}`}\n            placement=\"inline\"\n            inheritDims\n          >\n            <StrokeButton\n              aria-describedby=\"disabled-evaluate\"\n              aria-disabled\n              width={showBestMatchCTA ? 209 : '100%'}\n            >\n              Evaluate\n            </StrokeButton>\n          </ToolTip>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
+const SkillTag = /*#__PURE__*/_styled(Anchor, {
+  target: "e1ylhic50",
+  label: "SkillTag"
+})(css({
+  fontSize: 14,
+  borderRadius: 'md',
+  border: 1,
+  borderColor: 'border-primary',
+  '&:hover, &:focus': {
+    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":"AAiEiB","file":"../../src/LearningOutcomeFlyout/index.tsx","sourcesContent":["import {\n  Alert,\n  Anchor,\n  FillButton,\n  FlexBox,\n  Flyout,\n  Shimmer,\n  StrokeButton,\n  Text,\n  ToolTip,\n} 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';\nimport {\n  LearningOutcomeFlyoutProps,\n  LearningOutcomeSkill,\n  SkillClassification,\n} from './types';\n\nconst ChildLearningOutcomeRow = styled(FlexBox)(\n  css({\n    background: 'white',\n    borderColor: 'border-tertiary',\n    borderTopWidth: 0,\n    borderLeftWidth: 1,\n    borderRightWidth: 1,\n    borderBottomWidth: 1,\n    borderStyle: 'solid',\n    padding: '24px 16px',\n    alignItems: 'flex-start',\n    justifyContent: 'flex-start',\n    gap: 16,\n    '&:first-of-type': {\n      borderTopLeftRadius: '4px',\n      borderTopRightRadius: '4px',\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    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 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 === SkillClassification.Language) {\n      return -1;\n    }\n    if (b?.classification === SkillClassification.Subject) {\n      return 1;\n    }\n    return 0;\n  });\n\n  return sortedSkills;\n};\n\nexport const getLearningOutcomePath = (id?: string) => {\n  return id ? `/learning-outcomes/${id}` : '/';\n};\n\nconst getSkillsAreaPath = (skillSlug?: string) => {\n  return skillSlug ? `/skill-areas/${skillSlug}` : '/';\n};\n\nexport const miscTrackingData = (\n  level?: LearningOutcomeLevels | null,\n  id?: string,\n  latestScore?: number | null,\n  outcome?: string\n) => {\n  return {\n    misc: JSON.stringify({\n      last_assessed_score: latestScore,\n      LO_level: level,\n      title: outcome,\n      unique_id: id,\n    }),\n  };\n};\n\nexport const LearningOutcomeFlyout: React.FC<LearningOutcomeFlyoutProps> = ({\n  expanded,\n  learningOutcomeHref,\n  learningOutcomeOnClick,\n  childLearningOutcomeOnClick,\n  parentLearningOutcomeOnClick,\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  assessmentHref,\n  assessmentEligible,\n  bestMatchResponse,\n  bestMatchOnClick,\n  showBestMatchCTA,\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 {\n    data: bestMatchData,\n    loading: bestMatchLoading,\n    error: bestMatchError,\n  } = bestMatchResponse;\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 bestMatchCTA = bestMatchLoading ? (\n    <Shimmer width=\"50%\" data-testid=\"best-match-shimmer\" />\n  ) : (\n    <FillButton\n      href={bestMatchData?.urlPath ?? ''}\n      disabled={!bestMatchData?.urlPath || bestMatchError}\n      data-testid=\"best-match-button\"\n      width=\"50%\"\n      onClick={() => bestMatchOnClick?.()}\n    >\n      Learn\n    </FillButton>\n  );\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 skills when the drawer is featuring a level 3 outcome\n  const renderSkills = () => {\n    return <FlexBox as=\"ul\">Skills go here</FlexBox>;\n  };\n\n  // Render subskills when the drawer is featuring a level 2 outcome\n  const renderSubskills = () => {\n    return (\n      <FlexBox\n        as=\"ul\"\n        flexDirection=\"column\"\n        p={0}\n        borderTop={1}\n        borderColor=\"border-tertiary\"\n        borderRadius=\"md\"\n      >\n        {childLearningOutcomes?.map((childLo) => {\n          const { id, outcome, progress, percentComplete } = childLo;\n          const showNeedsReviewIndicator =\n            progress?.latestScore !== null &&\n            progress?.latestScore !== undefined\n              ? progress.latestScore < 70\n              : false;\n\n          const trackingData = miscTrackingData(\n            LearningOutcomeLevels.One,\n            id,\n            progress?.latestScore,\n            outcome\n          );\n\n          return (\n            <ChildLearningOutcomeRow row as=\"li\" key={id}>\n              <FlexBox minWidth={32} width={32} justifyContent=\"center\">\n                <LearningOutcomeTile\n                  learningOutcomeDetails={{\n                    id,\n                    level: LearningOutcomeLevels.One,\n                    outcome,\n                    percentComplete,\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={() => childLearningOutcomeOnClick?.(trackingData)}\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          {showBestMatchCTA && (!bestMatchData?.urlPath || bestMatchError) && (\n            <Alert\n              placement=\"inline\"\n              type=\"subtle\"\n              data-testid=\"best-match-alert\"\n            >\n              {`We were unable to load the associated ${levelLabel.toLocaleLowerCase()}. Please refresh the\n            page and try again.`}\n            </Alert>\n          )}\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              <Text as=\"h2\" variant=\"title-md\">\n                {outcome}\n              </Text>\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\" as=\"h3\">\n            Evaluation results\n          </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        <FlexBox gap={16} column>\n          <Text variant=\"title-xs\" as=\"h3\">\n            {isLevelTwoLearningOutcome ? `Subskills` : `Skills`}\n          </Text>\n          {isLevelTwoLearningOutcome ? renderSubskills() : renderSkills()}\n        </FlexBox>\n\n        {/* For level 2 LOs only: show Parent LOs */}\n        {showParentLOs && (\n          <FlexBox gap={16} mb={16} column>\n            <Text variant=\"title-xs\" as=\"h3\">\n              Builds toward...\n            </Text>\n            <LearningOutcomeCardList\n              learningOutcomes={parentLOs}\n              onClick={parentLearningOutcomeOnClick}\n            />\n          </FlexBox>\n        )}\n      </FlexBox>\n      <FlexBox\n        borderTop={1}\n        bg=\"white\"\n        bottom=\"-3px\"\n        boxShadow=\"0px -4px 16px 0px #00000014\"\n        borderColor=\"border-tertiary\"\n        py={12}\n        px={16}\n        position=\"sticky\"\n        justifyContent=\"center\"\n        gap={12}\n      >\n        {showBestMatchCTA ? bestMatchCTA : null}\n        {assessmentEligible ? (\n          <StrokeButton\n            href={assessmentHref}\n            width={showBestMatchCTA ? { _: 209, xs: '50%' } : '100%'}\n          >\n            Evaluate\n          </StrokeButton>\n        ) : (\n          <ToolTip\n            id=\"disabled-evaluate\"\n            data-testid=\"disabled-evaluate\"\n            info={`Not available for this ${levelLabel.toLowerCase()}`}\n            placement=\"inline\"\n            inheritDims\n          >\n            <StrokeButton\n              aria-describedby=\"disabled-evaluate\"\n              aria-disabled\n              width={showBestMatchCTA ? 209 : '100%'}\n            >\n              Evaluate\n            </StrokeButton>\n          </ToolTip>\n        )}\n      </FlexBox>\n    </Flyout>\n  );\n};\n"]} */");
+export const sortSkillsByClassification = skills => {
+  if (!skills?.length) return [];
+  const skillsCopy = skills.slice();
+  const sortedSkills = skillsCopy?.sort((a, b) => {
+    if (a?.classification === SkillClassification.Language) {
+      return -1;
+    }
+    if (b?.classification === SkillClassification.Subject) {
+      return 1;
+    }
+    return 0;
+  });
+  return sortedSkills;
+};
+export const getLearningOutcomePath = id => {
+  return id ? `/learning-outcomes/${id}` : '/';
+};
+const getSkillsAreaPath = skillSlug => {
+  return skillSlug ? `/skill-areas/${skillSlug}` : '/';
+};
+export const miscTrackingData = (level, id, latestScore, outcome) => {
+  return {
+    misc: JSON.stringify({
+      last_assessed_score: latestScore,
+      LO_level: level,
+      title: outcome,
+      unique_id: id
+    })
+  };
+};
+export const LearningOutcomeFlyout = ({
+  expanded,
+  learningOutcomeHref,
+  learningOutcomeOnClick,
+  childLearningOutcomeOnClick,
+  parentLearningOutcomeOnClick,
+  learningOutcome: {
+    highestScore,
+    highestScoreAchievedAt,
+    latestScore,
+    latestScoreAchievedAt,
+    level,
+    outcome,
+    parentLOs,
+    percentComplete,
+    skills,
+    childLearningOutcomes
+  },
+  skillTagOnClick,
+  onClose,
+  assessmentHref,
+  assessmentEligible,
+  bestMatchResponse,
+  bestMatchOnClick,
+  showBestMatchCTA
+}) => {
+  const percentCompletePercentage = percentComplete != null ? percentComplete : 0;
+  const levelLabel = learningOutcomeLabels[level];
+  const hasLowLatestAssessment = Boolean(latestScore != null && latestScore < 70);
+  const {
+    data: bestMatchData,
+    loading: bestMatchLoading,
+    error: bestMatchError
+  } = bestMatchResponse;
+  const showSkills = !!skills?.length;
+  const sortedSkills = sortSkillsByClassification(skills);
+  const isLevelTwoLearningOutcome = level === LearningOutcomeLevels.Two;
+  const showParentLOs = level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;
+  const bestMatchCTA = bestMatchLoading ? /*#__PURE__*/_jsx(Shimmer, {
+    width: "50%",
+    "data-testid": "best-match-shimmer"
+  }) : /*#__PURE__*/_jsx(FillButton, {
+    href: bestMatchData?.urlPath ?? '',
+    disabled: !bestMatchData?.urlPath || bestMatchError,
+    "data-testid": "best-match-button",
+    width: "50%",
+    onClick: () => bestMatchOnClick?.(),
+    children: "Learn"
+  });
+  const renderProgress = () => /*#__PURE__*/_jsxs(FlexBox, {
+    alignItems: "center",
+    children: [Boolean(percentCompletePercentage === 100) && /*#__PURE__*/_jsx(FlexBox, {
+      width: 16,
+      height: 16,
+      borderRadius: "md",
+      bg: "primary",
+      mr: 8,
+      alignItems: "center",
+      justifyContent: "center",
+      children: /*#__PURE__*/_jsx(SmallCheckIcon, {
+        size: 11,
+        color: "white"
+      })
+    }), /*#__PURE__*/_jsx(Text, {
+      color: "text",
+      variant: "p-large",
+      children: `${percentCompletePercentage}% progress`
+    })]
+  });
+
+  // Render skills when the drawer is featuring a level 3 outcome
+  const renderSkills = () => {
+    return /*#__PURE__*/_jsx(FlexBox, {
+      as: "ul",
+      children: "Skills go here"
+    });
+  };
+
+  // Render subskills when the drawer is featuring a level 2 outcome
+  const renderSubskills = () => {
+    return /*#__PURE__*/_jsx(FlexBox, {
+      as: "ul",
+      flexDirection: "column",
+      p: 0,
+      borderTop: 1,
+      borderColor: "border-tertiary",
+      borderRadius: "md",
+      children: childLearningOutcomes?.map(childLo => {
+        const {
+          id,
+          outcome,
+          progress,
+          percentComplete
+        } = childLo;
+        const showNeedsReviewIndicator = progress?.latestScore !== null && progress?.latestScore !== undefined ? progress.latestScore < 70 : false;
+        const trackingData = miscTrackingData(LearningOutcomeLevels.One, id, progress?.latestScore, outcome);
+        return /*#__PURE__*/_jsxs(ChildLearningOutcomeRow, {
+          row: true,
+          as: "li",
+          children: [/*#__PURE__*/_jsx(FlexBox, {
+            minWidth: 32,
+            width: 32,
+            justifyContent: "center",
+            children: /*#__PURE__*/_jsx(LearningOutcomeTile, {
+              learningOutcomeDetails: {
+                id,
+                level: LearningOutcomeLevels.One,
+                outcome,
+                percentComplete
+              },
+              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: () => childLearningOutcomeOnClick?.(trackingData),
+              children: outcome
+            }), showNeedsReviewIndicator && /*#__PURE__*/_jsx(FlexBox, {
+              children: /*#__PURE__*/_jsx(LearningOutcomeLowAssessmentBadge, {})
+            })]
+          })]
+        }, id);
+      })
+    });
+  };
+  return /*#__PURE__*/_jsxs(Flyout, {
+    "aria-label": `${levelLabel} details`,
+    closeLabel: `Close ${levelLabel} details`,
+    expanded: expanded,
+    onClose: onClose,
+    openFrom: "right",
+    title: /*#__PURE__*/_jsx(Text, {
+      variant: "title-sm",
+      children: `${levelLabel} details`
+    }),
+    children: [/*#__PURE__*/_jsxs(FlexBox, {
+      gap: 32,
+      mt: 32,
+      mx: 24,
+      column: true,
+      children: [/*#__PURE__*/_jsxs(FlexBox, {
+        gap: 24,
+        column: true,
+        children: [showBestMatchCTA && (!bestMatchData?.urlPath || bestMatchError) && /*#__PURE__*/_jsx(Alert, {
+          placement: "inline",
+          type: "subtle",
+          "data-testid": "best-match-alert",
+          children: `We were unable to load the associated ${levelLabel.toLocaleLowerCase()}. Please refresh the
+            page and try again.`
+        }), /*#__PURE__*/_jsxs(FlexBox, {
+          justifyContent: "space-between",
+          alignItems: "center",
+          children: [/*#__PURE__*/_jsx(LearningOutcomeLevelBadge, {
+            level: level,
+            size: "base"
+          }), hasLowLatestAssessment && /*#__PURE__*/_jsx(LearningOutcomeLowAssessmentBadge, {})]
+        }), /*#__PURE__*/_jsxs(FlexBox, {
+          gap: 16,
+          column: true,
+          children: [/*#__PURE__*/_jsx(StyledAnchor, {
+            href: learningOutcomeHref,
+            onClick: () => learningOutcomeOnClick?.(),
+            children: /*#__PURE__*/_jsx(Text, {
+              as: "h2",
+              variant: "title-md",
+              children: outcome
+            })
+          }), showSkills && /*#__PURE__*/_jsx(FlexBox, {
+            alignItems: "center",
+            gap: 12,
+            flexWrap: "wrap",
+            children: sortedSkills.map(skill => /*#__PURE__*/_jsx(SkillTag, {
+              "data-testid": "skill-tag",
+              px: 8,
+              py: 4,
+              variant: "interface",
+              href: getSkillsAreaPath(skill.slug),
+              onClick: () => skillTagOnClick?.(skill.slug),
+              children: /*#__PURE__*/_jsx(FlexBox, {
+                center: true,
+                children: /*#__PURE__*/_jsx(Text, {
+                  children: skill.title
+                })
+              })
+            }, skill.id))
+          })]
+        }), /*#__PURE__*/_jsx(FlexBox, {
+          borderY: 1,
+          borderColor: "background-hover",
+          py: 16,
+          children: renderProgress()
+        })]
+      }), /*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "title-xs",
+          as: "h3",
+          children: "Evaluation results"
+        }), /*#__PURE__*/_jsx(LearningOutcomeAssessmentScores, {
+          highestScore: highestScore,
+          highestScoreAchievedAt: highestScoreAchievedAt,
+          latestScore: latestScore,
+          latestScoreAchievedAt: latestScoreAchievedAt
+        })]
+      }), /*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "title-xs",
+          as: "h3",
+          children: isLevelTwoLearningOutcome ? `Subskills` : `Skills`
+        }), isLevelTwoLearningOutcome ? renderSubskills() : renderSkills()]
+      }), showParentLOs && /*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        mb: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "title-xs",
+          as: "h3",
+          children: "Builds toward..."
+        }), /*#__PURE__*/_jsx(LearningOutcomeCardList, {
+          learningOutcomes: parentLOs,
+          onClick: parentLearningOutcomeOnClick
+        })]
+      })]
+    }), /*#__PURE__*/_jsxs(FlexBox, {
+      borderTop: 1,
+      bg: "white",
+      bottom: "-3px",
+      boxShadow: "0px -4px 16px 0px #00000014",
+      borderColor: "border-tertiary",
+      py: 12,
+      px: 16,
+      position: "sticky",
+      justifyContent: "center",
+      gap: 12,
+      children: [showBestMatchCTA ? bestMatchCTA : null, assessmentEligible ? /*#__PURE__*/_jsx(StrokeButton, {
+        href: assessmentHref,
+        width: showBestMatchCTA ? {
+          _: 209,
+          xs: '50%'
+        } : '100%',
+        children: "Evaluate"
+      }) : /*#__PURE__*/_jsx(ToolTip, {
+        id: "disabled-evaluate",
+        "data-testid": "disabled-evaluate",
+        info: `Not available for this ${levelLabel.toLowerCase()}`,
+        placement: "inline",
+        inheritDims: true,
+        children: /*#__PURE__*/_jsx(StrokeButton, {
+          "aria-describedby": "disabled-evaluate",
+          "aria-disabled": true,
+          width: showBestMatchCTA ? 209 : '100%',
+          children: "Evaluate"
+        })
+      })]
+    })]
+  });
+};

package/dist/LearningOutcomeFlyout/types.d.ts

@@ -0,0 +1,63 @@
+import { LearningOutcomeLevels } from '../LearningOutcomeBadges';
+export declare enum SkillClassification {
+    Language = "language",
+    Subject = "subject"
+}
+export interface LearningOutcomeSkill {
+    id: string;
+    slug: string;
+    title?: string | null;
+    classification?: SkillClassification | null;
+}
+export interface ParentLearningOutcome {
+    id: string;
+    outcome: string;
+    level: number | null | undefined;
+}
+export type BestMatchContainerType = {
+    urlPath: string | null;
+    title?: string | null;
+};
+export interface BestMatchContainerResponseType {
+    data: BestMatchContainerType | null;
+    loading: boolean;
+    error: boolean;
+}
+interface LearningOutcomeDetailsProps {
+    level: LearningOutcomeLevels;
+    outcome: string;
+    percentComplete: number | undefined | null;
+    highestScore: number | undefined | null;
+    highestScoreAchievedAt: string | undefined | null;
+    latestScore: number | undefined | null;
+    latestScoreAchievedAt: string | undefined | null;
+    parentLOs?: ParentLearningOutcome[];
+    skills?: LearningOutcomeSkill[] | null;
+    childLearningOutcomes?: {
+        id: string;
+        outcome: string;
+        percentComplete?: number | undefined | null;
+        progress?: {
+            latestScore?: number | null;
+            covered: boolean | undefined | null;
+            coveredAt?: string | null;
+            highestScore?: number | null;
+        };
+    }[];
+}
+export interface LearningOutcomeFlyoutProps {
+    expanded: boolean;
+    onClose: () => void;
+    learningOutcome: LearningOutcomeDetailsProps;
+    learningOutcomeHref: string;
+    learningOutcomeOnClick?: () => void;
+    skillTagOnClick?: (skillSlug: string) => void;
+    childLearningOutcomeOnClick?: (misc: Record<string, string>) => void;
+    parentLearningOutcomeOnClick?: (misc: Record<string, string>) => void;
+    assessmentHref?: string;
+    assessmentEligible?: boolean;
+    bestMatchResponse: BestMatchContainerResponseType;
+    bestMatchOnClick?: () => void;
+    showBestMatchCTA?: boolean;
+}
+export {};

package/dist/LearningOutcomeFlyout/types.js

@@ -0,0 +1,5 @@
+export let SkillClassification = /*#__PURE__*/function (SkillClassification) {
+  SkillClassification["Language"] = "language";
+  SkillClassification["Subject"] = "subject";
+  return SkillClassification;
+}({});

package/dist/LearningOutcomePopover/index.d.ts

@@ -0,0 +1,10 @@
+import { LearningOutcomePopoverDetailsProps } from '../LearningOutcomeTile/types';
+interface LearningOutcomePopoverProps {
+    activeElRef: React.RefObject<HTMLDivElement> | React.RefObject<HTMLAnchorElement>;
+    id: string;
+    isOpen: boolean;
+    learningOutcomeDetails: LearningOutcomePopoverDetailsProps;
+    horizontalOffset?: number;
+}
+export declare const LearningOutcomePopover: React.FC<LearningOutcomePopoverProps>;
+export {};

package/dist/LearningOutcomePopover/index.js

@@ -0,0 +1,125 @@
+import { FlexBox, Popover, Text } from '@codecademy/gamut';
+import { SmallCheckIcon } from '@codecademy/gamut-icons';
+import { LearningOutcomeLevelBadge, LearningOutcomeLowAssessmentBadge } from '../LearningOutcomeBadges';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const POPOVER_WIDTH = 332;
+const POPOVER_HORIZONTAL_PADDING = 16;
+const ASSESSMENT_WIDTH = (POPOVER_WIDTH - POPOVER_HORIZONTAL_PADDING * 2) / 2;
+const Assessment = ({
+  score,
+  type,
+  noBorderLeft
+}) => /*#__PURE__*/_jsxs(FlexBox, {
+  borderTop: 1,
+  borderBottom: 1,
+  borderRight: 1,
+  borderLeft: !noBorderLeft ? 1 : undefined,
+  borderColor: "background-hover",
+  p: 8,
+  gap: 4,
+  width: ASSESSMENT_WIDTH,
+  children: [/*#__PURE__*/_jsx(Text, {
+    variant: "p-small",
+    color: "text-secondary",
+    children: type === 'highest' ? 'Highest score:' : 'Most recent:'
+  }), score != null ? /*#__PURE__*/_jsx(Text, {
+    variant: "p-small",
+    color: score && score >= 70 ? 'green-700' : 'text',
+    fontWeight: 700,
+    children: `${score}%`
+  }) : /*#__PURE__*/_jsx(Text, {
+    variant: "p-small",
+    color: "text-disabled",
+    children: "-"
+  })]
+});
+export const LearningOutcomePopover = ({
+  activeElRef,
+  isOpen,
+  learningOutcomeDetails,
+  ...rest
+}) => {
+  const {
+    level,
+    outcome,
+    latestScore,
+    highestScore,
+    percentComplete = 0
+  } = learningOutcomeDetails || {};
+  const lowLatestAssessment = Boolean(latestScore != null && latestScore < 70);
+  const renderProgress = () => /*#__PURE__*/_jsxs(FlexBox, {
+    alignItems: "center",
+    children: [Boolean(percentComplete === 100) && /*#__PURE__*/_jsx(FlexBox, {
+      width: 16,
+      height: 16,
+      borderRadius: "md",
+      bg: "primary",
+      mr: 8,
+      alignItems: "center",
+      justifyContent: "center",
+      children: /*#__PURE__*/_jsx(SmallCheckIcon, {
+        size: 11,
+        color: "white"
+      })
+    }), /*#__PURE__*/_jsx(Text, {
+      color: "text",
+      variant: "p-small",
+      children: `${percentComplete}% progress`
+    })]
+  });
+  return /*#__PURE__*/_jsx(Popover, {
+    ...rest,
+    isOpen: isOpen,
+    targetRef: activeElRef,
+    position: "above",
+    beak: "center",
+    outline: true,
+    skipFocusTrap: true,
+    children: /*#__PURE__*/_jsxs(FlexBox, {
+      width: POPOVER_WIDTH,
+      pt: 24,
+      pb: 4,
+      px: POPOVER_HORIZONTAL_PADDING,
+      gap: 24,
+      column: true,
+      children: [/*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsxs(FlexBox, {
+          justifyContent: "space-between",
+          children: [!!level && /*#__PURE__*/_jsx(LearningOutcomeLevelBadge, {
+            level: level
+          }), lowLatestAssessment && /*#__PURE__*/_jsx(LearningOutcomeLowAssessmentBadge, {})]
+        }), /*#__PURE__*/_jsx(Text, {
+          color: "text",
+          textAlign: "left",
+          variant: "title-xs",
+          whiteSpace: "break-spaces",
+          children: outcome
+        }), renderProgress()]
+      }), /*#__PURE__*/_jsxs(FlexBox, {
+        alignItems: "flex-start",
+        gap: 4,
+        pt: 16,
+        pb: 12,
+        borderTop: 1,
+        borderColor: "background-hover",
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "p-small",
+          fontWeight: 700,
+          children: "Evaluation results"
+        }), /*#__PURE__*/_jsxs(FlexBox, {
+          children: [/*#__PURE__*/_jsx(Assessment, {
+            score: highestScore,
+            type: "highest"
+          }), /*#__PURE__*/_jsx(Assessment, {
+            score: latestScore,
+            type: "latest",
+            noBorderLeft: true
+          })]
+        })]
+      })]
+    })
+  });
+};