@codecademy/brand 3.0.0-alpha.220d4ef8ba.0 → 3.0.0-alpha.2ba7921cce.0

package/dist/LearningOutcomeCard/index.d.ts

@@ -1,27 +1,25 @@
 import { HeadingTags } from '@codecademy/gamut';
-declare enum LearningOutcomeLevels {
-    One = 1,
-    Two = 2,
-    Three = 3
-}
-export declare const levelTagText: {
-    1: string;
-    2: string;
-    3: string;
-};
+import { LearningOutcomeLevels } from '../LearningOutcomeBadges';
 interface LearningOutcomeSkill {
     title?: string | null | undefined;
 }
 interface LearningOutcomeCardProps {
     level: LearningOutcomeLevels | null | undefined;
     outcome: string;
+    as?: 'li';
     headingLevel?: HeadingTags;
-    emphasized?: boolean;
+    isInteractive?: boolean;
+    mode?: 'emphasized' | 'base';
     progress?: number;
     skills?: LearningOutcomeSkill[] | null;
+    /**
+     * Optional prop for progress updates, used to animate the radial progress from a previous value to the current value.
+     * Need to provide previousProgress and progressDuraion to animate the radial progress.
+     * If progress is 100, completionDelay needs to be provided instead of progressDuration to delay the display of the completion icon.
+     */
     progressUpdateData?: {
         previousProgress: number;
-        progressDuration: number;
+        progressDuration?: number;
         completionDelay?: number;
     };
 }

package/dist/LearningOutcomeCard/index.js

@@ -1,178 +1,203 @@
 import _styled from "@emotion/styled/base";
-import { Badge, Card, FlexBox, RadialProgress, Text } from '@codecademy/gamut';
-import { CheckFilledIcon } from '@codecademy/gamut-icons';
-import { css, theme } from '@codecademy/gamut-styles';
+import { Card, FlexBox, RadialProgress, Text } from '@codecademy/gamut';
+import { CheckIcon } from '@codecademy/gamut-icons';
+import { css, theme, variant } from '@codecademy/gamut-styles';
 import { useEffect, useMemo, useState } from 'react';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-var LearningOutcomeLevels = /*#__PURE__*/function (LearningOutcomeLevels) {
-  LearningOutcomeLevels[LearningOutcomeLevels["One"] = 1] = "One";
-  LearningOutcomeLevels[LearningOutcomeLevels["Two"] = 2] = "Two";
-  LearningOutcomeLevels[LearningOutcomeLevels["Three"] = 3] = "Three";
-  return LearningOutcomeLevels;
-}(LearningOutcomeLevels || {});
-export const levelTagText = {
-  [LearningOutcomeLevels.One]: 'Subskill',
-  [LearningOutcomeLevels.Two]: 'Skill',
-  [LearningOutcomeLevels.Three]: 'Skillset'
-};
+import { learningOutcomeLabels, LearningOutcomeLevelBadge, LearningOutcomeLevels } from '../LearningOutcomeBadges';
+import { progressState } from '../LearningOutcomeTile';
+import { Progress } from '../LearningOutcomeTile/types';
 
 // to match the type from gql schema
-
-const StyledBadge = /*#__PURE__*/_styled(Badge, {
-  target: "ev1pt783",
-  label: "StyledBadge"
-})(css({
-  border: 2,
-  borderColor: 'border-tertiary',
-  color: 'text'
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AA2CoB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Badge,\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckFilledIcon } from '@codecademy/gamut-icons';\nimport { css, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nenum LearningOutcomeLevels {\n  One = 1,\n  Two = 2,\n  Three = 3,\n}\n\nexport const levelTagText = {\n  [LearningOutcomeLevels.One]: 'Subskill',\n  [LearningOutcomeLevels.Two]: 'Skill',\n  [LearningOutcomeLevels.Three]: 'Skillset',\n};\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  headingLevel?: HeadingTags;\n  emphasized?: boolean;\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration: number;\n    completionDelay?: number;\n  };\n}\n\nconst StyledBadge = styled(Badge)(\n  css({\n    border: 2,\n    borderColor: 'border-tertiary',\n    color: 'text',\n  })\n);\n\nconst EmphasizedBadge = styled(StyledBadge)(\n  css({\n    bg: 'background-selected',\n  })\n);\n\nconst SimpleCard = styled(Card)(\n  css({\n    bg: 'background-primary',\n  })\n);\n// the 'navy' variant of Card applies a navy background to the card (navy-800) but the cards should have background navy-900\nconst EmphasizedCard = styled(Card)(\n  css({\n    bg: 'navy-900',\n  })\n);\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  emphasized = false,\n  headingLevel,\n  level,\n  outcome,\n  progress,\n  skills,\n  progressUpdateData,\n}) => {\n  const displayProgress = progress !== undefined && progress > 0;\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const renderedSortedSkills = useMemo(() => {\n    const sortedSkills = [...(skills ?? [])].sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n\n    if (sortedSkills && sortedSkills.length > 0) {\n      return sortedSkills.map((skill) => (\n        <FlexBox\n          as=\"li\"\n          px={8}\n          textColor=\"secondary\"\n          opacity=\"0.65\"\n          bg=\"background-selected\"\n          justifyContent=\"space-between\"\n          key={skill.title}\n        >\n          {skill.title}\n        </FlexBox>\n      ));\n    }\n    return null;\n  }, [skills]);\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n      } else if (progress === 100) {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  if (emphasized && skills) {\n    return (\n      <EmphasizedCard\n        py={32}\n        px={24}\n        flexDirection={displayProgress ? 'row' : 'column'}\n        isInteractive\n        gap={displayProgress ? 32 : 0}\n        border={2}\n        display=\"flex\"\n        borderColor={showCompletionIcon ? 'primary' : 'border-tertiary'}\n        borderRadius=\"lg\"\n        alignSelf=\"stretch\"\n        overflow=\"auto\"\n      >\n        <FlexBox flexDirection=\"column\" gap={24}>\n          {level && (\n            <EmphasizedBadge variant=\"tertiary\">\n              {levelTagText[level]}\n            </EmphasizedBadge>\n          )}\n          <Text variant=\"title-sm\" width=\"100%\" as={headingLevel}>\n            {outcome}\n          </Text>\n          <FlexBox wrap as=\"ul\" pl={0} alignItems=\"flex-start\" gap={8}>\n            {renderedSortedSkills}\n          </FlexBox>\n        </FlexBox>\n        {displayProgress && (\n          <FlexBox\n            flexDirection=\"column\"\n            flex=\"1 0 0\"\n            alignSelf=\"stretch\"\n            flexWrap=\"wrap\"\n            alignContent=\"end\"\n          >\n            {showCompletionIcon ? (\n              <CheckFilledIcon size={80} color=\"yellow-500\" />\n            ) : (\n              <RadialProgress\n                key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n                size={80}\n                strokeLinecap=\"round\"\n                strokeWidth={8}\n                value={radialValue ?? 0}\n                duration={progressDuration || undefined}\n                color={theme.colors['yellow-500']}\n              >\n                <Text as=\"span\" fontSize={22}>\n                  {displayValue}%\n                </Text>\n              </RadialProgress>\n            )}\n          </FlexBox>\n        )}\n      </EmphasizedCard>\n    );\n  }\n  return (\n    <SimpleCard\n      border={2}\n      display=\"flex\"\n      borderColor=\"border-tertiary\"\n      borderRadius=\"lg\"\n      gap={16}\n      py={24}\n      px={16}\n      alignSelf=\"stretch\"\n      flexDirection=\"column\"\n    >\n      {level && (\n        <StyledBadge size=\"sm\" variant=\"tertiary\">\n          {levelTagText[level]}\n        </StyledBadge>\n      )}\n      <Text variant=\"title-xs\" width=\"100%\" as={headingLevel}>\n        {outcome}\n      </Text>\n    </SimpleCard>\n  );\n};\n"]} */");
-const EmphasizedBadge = /*#__PURE__*/_styled(StyledBadge, {
-  target: "ev1pt782",
-  label: "EmphasizedBadge"
-})(css({
-  bg: 'background-selected'
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AAmDwB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Badge,\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckFilledIcon } from '@codecademy/gamut-icons';\nimport { css, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nenum LearningOutcomeLevels {\n  One = 1,\n  Two = 2,\n  Three = 3,\n}\n\nexport const levelTagText = {\n  [LearningOutcomeLevels.One]: 'Subskill',\n  [LearningOutcomeLevels.Two]: 'Skill',\n  [LearningOutcomeLevels.Three]: 'Skillset',\n};\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  headingLevel?: HeadingTags;\n  emphasized?: boolean;\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration: number;\n    completionDelay?: number;\n  };\n}\n\nconst StyledBadge = styled(Badge)(\n  css({\n    border: 2,\n    borderColor: 'border-tertiary',\n    color: 'text',\n  })\n);\n\nconst EmphasizedBadge = styled(StyledBadge)(\n  css({\n    bg: 'background-selected',\n  })\n);\n\nconst SimpleCard = styled(Card)(\n  css({\n    bg: 'background-primary',\n  })\n);\n// the 'navy' variant of Card applies a navy background to the card (navy-800) but the cards should have background navy-900\nconst EmphasizedCard = styled(Card)(\n  css({\n    bg: 'navy-900',\n  })\n);\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  emphasized = false,\n  headingLevel,\n  level,\n  outcome,\n  progress,\n  skills,\n  progressUpdateData,\n}) => {\n  const displayProgress = progress !== undefined && progress > 0;\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const renderedSortedSkills = useMemo(() => {\n    const sortedSkills = [...(skills ?? [])].sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n\n    if (sortedSkills && sortedSkills.length > 0) {\n      return sortedSkills.map((skill) => (\n        <FlexBox\n          as=\"li\"\n          px={8}\n          textColor=\"secondary\"\n          opacity=\"0.65\"\n          bg=\"background-selected\"\n          justifyContent=\"space-between\"\n          key={skill.title}\n        >\n          {skill.title}\n        </FlexBox>\n      ));\n    }\n    return null;\n  }, [skills]);\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n      } else if (progress === 100) {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  if (emphasized && skills) {\n    return (\n      <EmphasizedCard\n        py={32}\n        px={24}\n        flexDirection={displayProgress ? 'row' : 'column'}\n        isInteractive\n        gap={displayProgress ? 32 : 0}\n        border={2}\n        display=\"flex\"\n        borderColor={showCompletionIcon ? 'primary' : 'border-tertiary'}\n        borderRadius=\"lg\"\n        alignSelf=\"stretch\"\n        overflow=\"auto\"\n      >\n        <FlexBox flexDirection=\"column\" gap={24}>\n          {level && (\n            <EmphasizedBadge variant=\"tertiary\">\n              {levelTagText[level]}\n            </EmphasizedBadge>\n          )}\n          <Text variant=\"title-sm\" width=\"100%\" as={headingLevel}>\n            {outcome}\n          </Text>\n          <FlexBox wrap as=\"ul\" pl={0} alignItems=\"flex-start\" gap={8}>\n            {renderedSortedSkills}\n          </FlexBox>\n        </FlexBox>\n        {displayProgress && (\n          <FlexBox\n            flexDirection=\"column\"\n            flex=\"1 0 0\"\n            alignSelf=\"stretch\"\n            flexWrap=\"wrap\"\n            alignContent=\"end\"\n          >\n            {showCompletionIcon ? (\n              <CheckFilledIcon size={80} color=\"yellow-500\" />\n            ) : (\n              <RadialProgress\n                key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n                size={80}\n                strokeLinecap=\"round\"\n                strokeWidth={8}\n                value={radialValue ?? 0}\n                duration={progressDuration || undefined}\n                color={theme.colors['yellow-500']}\n              >\n                <Text as=\"span\" fontSize={22}>\n                  {displayValue}%\n                </Text>\n              </RadialProgress>\n            )}\n          </FlexBox>\n        )}\n      </EmphasizedCard>\n    );\n  }\n  return (\n    <SimpleCard\n      border={2}\n      display=\"flex\"\n      borderColor=\"border-tertiary\"\n      borderRadius=\"lg\"\n      gap={16}\n      py={24}\n      px={16}\n      alignSelf=\"stretch\"\n      flexDirection=\"column\"\n    >\n      {level && (\n        <StyledBadge size=\"sm\" variant=\"tertiary\">\n          {levelTagText[level]}\n        </StyledBadge>\n      )}\n      <Text variant=\"title-xs\" width=\"100%\" as={headingLevel}>\n        {outcome}\n      </Text>\n    </SimpleCard>\n  );\n};\n"]} */");
-const SimpleCard = /*#__PURE__*/_styled(Card, {
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const COMPLETED_COLOR = 'yellow-500';
+const SkillTag = /*#__PURE__*/_styled(FlexBox, {
   target: "ev1pt781",
-  label: "SimpleCard"
+  label: "SkillTag"
 })(css({
-  bg: 'background-primary'
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AAyDmB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Badge,\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckFilledIcon } from '@codecademy/gamut-icons';\nimport { css, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nenum LearningOutcomeLevels {\n  One = 1,\n  Two = 2,\n  Three = 3,\n}\n\nexport const levelTagText = {\n  [LearningOutcomeLevels.One]: 'Subskill',\n  [LearningOutcomeLevels.Two]: 'Skill',\n  [LearningOutcomeLevels.Three]: 'Skillset',\n};\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  headingLevel?: HeadingTags;\n  emphasized?: boolean;\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration: number;\n    completionDelay?: number;\n  };\n}\n\nconst StyledBadge = styled(Badge)(\n  css({\n    border: 2,\n    borderColor: 'border-tertiary',\n    color: 'text',\n  })\n);\n\nconst EmphasizedBadge = styled(StyledBadge)(\n  css({\n    bg: 'background-selected',\n  })\n);\n\nconst SimpleCard = styled(Card)(\n  css({\n    bg: 'background-primary',\n  })\n);\n// the 'navy' variant of Card applies a navy background to the card (navy-800) but the cards should have background navy-900\nconst EmphasizedCard = styled(Card)(\n  css({\n    bg: 'navy-900',\n  })\n);\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  emphasized = false,\n  headingLevel,\n  level,\n  outcome,\n  progress,\n  skills,\n  progressUpdateData,\n}) => {\n  const displayProgress = progress !== undefined && progress > 0;\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const renderedSortedSkills = useMemo(() => {\n    const sortedSkills = [...(skills ?? [])].sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n\n    if (sortedSkills && sortedSkills.length > 0) {\n      return sortedSkills.map((skill) => (\n        <FlexBox\n          as=\"li\"\n          px={8}\n          textColor=\"secondary\"\n          opacity=\"0.65\"\n          bg=\"background-selected\"\n          justifyContent=\"space-between\"\n          key={skill.title}\n        >\n          {skill.title}\n        </FlexBox>\n      ));\n    }\n    return null;\n  }, [skills]);\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n      } else if (progress === 100) {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  if (emphasized && skills) {\n    return (\n      <EmphasizedCard\n        py={32}\n        px={24}\n        flexDirection={displayProgress ? 'row' : 'column'}\n        isInteractive\n        gap={displayProgress ? 32 : 0}\n        border={2}\n        display=\"flex\"\n        borderColor={showCompletionIcon ? 'primary' : 'border-tertiary'}\n        borderRadius=\"lg\"\n        alignSelf=\"stretch\"\n        overflow=\"auto\"\n      >\n        <FlexBox flexDirection=\"column\" gap={24}>\n          {level && (\n            <EmphasizedBadge variant=\"tertiary\">\n              {levelTagText[level]}\n            </EmphasizedBadge>\n          )}\n          <Text variant=\"title-sm\" width=\"100%\" as={headingLevel}>\n            {outcome}\n          </Text>\n          <FlexBox wrap as=\"ul\" pl={0} alignItems=\"flex-start\" gap={8}>\n            {renderedSortedSkills}\n          </FlexBox>\n        </FlexBox>\n        {displayProgress && (\n          <FlexBox\n            flexDirection=\"column\"\n            flex=\"1 0 0\"\n            alignSelf=\"stretch\"\n            flexWrap=\"wrap\"\n            alignContent=\"end\"\n          >\n            {showCompletionIcon ? (\n              <CheckFilledIcon size={80} color=\"yellow-500\" />\n            ) : (\n              <RadialProgress\n                key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n                size={80}\n                strokeLinecap=\"round\"\n                strokeWidth={8}\n                value={radialValue ?? 0}\n                duration={progressDuration || undefined}\n                color={theme.colors['yellow-500']}\n              >\n                <Text as=\"span\" fontSize={22}>\n                  {displayValue}%\n                </Text>\n              </RadialProgress>\n            )}\n          </FlexBox>\n        )}\n      </EmphasizedCard>\n    );\n  }\n  return (\n    <SimpleCard\n      border={2}\n      display=\"flex\"\n      borderColor=\"border-tertiary\"\n      borderRadius=\"lg\"\n      gap={16}\n      py={24}\n      px={16}\n      alignSelf=\"stretch\"\n      flexDirection=\"column\"\n    >\n      {level && (\n        <StyledBadge size=\"sm\" variant=\"tertiary\">\n          {levelTagText[level]}\n        </StyledBadge>\n      )}\n      <Text variant=\"title-xs\" width=\"100%\" as={headingLevel}>\n        {outcome}\n      </Text>\n    </SimpleCard>\n  );\n};\n"]} */");
-// the 'navy' variant of Card applies a navy background to the card (navy-800) but the cards should have background navy-900
-const EmphasizedCard = /*#__PURE__*/_styled(Card, {
+  px: 8,
+  textColor: 'secondary',
+  opacity: '0.65',
+  bg: 'background-selected',
+  justifyContent: 'space-between'
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AAwDiB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckIcon } from '@codecademy/gamut-icons';\nimport { css, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n} from '../LearningOutcomeBadges';\nimport { progressState } from '../LearningOutcomeTile';\nimport { Progress } from '../LearningOutcomeTile/types';\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  as?: 'li';\n  headingLevel?: HeadingTags;\n  isInteractive?: boolean;\n  mode?: 'emphasized' | 'base';\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n\n  /**\n   * Optional prop for progress updates, used to animate the radial progress from a previous value to the current value.\n   * Need to provide previousProgress and progressDuraion to animate the radial progress.\n   * If progress is 100, completionDelay needs to be provided instead of progressDuration to delay the display of the completion icon.\n   */\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration?: number;\n    completionDelay?: number;\n  };\n}\n\ninterface ProgressProps {\n  displayValue: number;\n  progressDuration: number | undefined;\n  radialValue: number | number[];\n  startRadialAnimation: boolean;\n  showCompletionIcon: boolean;\n}\n\nconst COMPLETED_COLOR = 'yellow-500';\n\nconst SkillTag = styled(FlexBox)(\n  css({\n    px: 8,\n    textColor: 'secondary',\n    opacity: '0.65',\n    bg: 'background-selected',\n    justifyContent: 'space-between',\n  })\n);\n\nconst StyledCard = styled(Card)<{\n  progress: Progress;\n  mode?: 'emphasized' | 'base';\n}>((props) => ({\n  ...variant({\n    prop: 'mode',\n    defaultVariant: 'base',\n    base: {\n      border: 2,\n      borderRadius: 'lg',\n      borderColor:\n        props.progress === Progress.completed\n          ? COMPLETED_COLOR\n          : 'border-tertiary',\n      display: 'flex',\n      flexDirection: props.progress === Progress.notStarted ? 'column' : 'row',\n      alignSelf: 'stretch',\n      overflow: 'auto',\n      gap: props.progress === Progress.notStarted ? 0 : 32,\n    },\n    variants: {\n      emphasized: {\n        bg: 'background-primary',\n        borderRadius: 'xl',\n        py: 32,\n        px: 24,\n      },\n      base: {\n        bg: 'background-current',\n        py: 24,\n        px: 16,\n      },\n    },\n  })(props),\n}));\n\nconst renderProgress = ({\n  displayValue,\n  progressDuration,\n  radialValue,\n  startRadialAnimation,\n  showCompletionIcon,\n}: ProgressProps) => (\n  <FlexBox\n    flexDirection=\"column\"\n    flex=\"1 0 0\"\n    alignSelf=\"stretch\"\n    flexWrap=\"wrap\"\n    alignContent=\"end\"\n  >\n    {showCompletionIcon ? (\n      <FlexBox\n        bg={COMPLETED_COLOR}\n        width={80}\n        height={80}\n        center\n        borderRadius=\"full\"\n      >\n        <CheckIcon size={44} color=\"text\" />\n      </FlexBox>\n    ) : (\n      <RadialProgress\n        key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n        color={theme.colors[COMPLETED_COLOR]}\n        duration={progressDuration || undefined}\n        size={80}\n        strokeLinecap=\"round\"\n        strokeWidth={8}\n        value={radialValue ?? 0}\n      >\n        <Text as=\"span\" fontSize={22} fontWeight={700}>\n          {`${displayValue}%`}\n        </Text>\n      </RadialProgress>\n    )}\n  </FlexBox>\n);\n\nconst renderSkills = (skills: LearningOutcomeSkill[]) =>\n  skills.map((skill) => (\n    <SkillTag as=\"li\" key={skill.title}>\n      {skill.title}\n    </SkillTag>\n  ));\n\nconst fontVariant = (\n  isEmphasized: boolean,\n  level?: LearningOutcomeLevels | null\n) => {\n  if (isEmphasized) {\n    return 'title-sm';\n  }\n\n  switch (level) {\n    case LearningOutcomeLevels.One:\n      return 'p-base';\n    case LearningOutcomeLevels.Two:\n      return 'title-xs';\n    case LearningOutcomeLevels.Three:\n      return 'title-sm';\n    default:\n      return 'p-base';\n  }\n};\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  level,\n  outcome,\n  as,\n  headingLevel,\n  isInteractive = false,\n  mode = 'base',\n  progress = 0,\n  skills,\n  progressUpdateData,\n}) => {\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const progressStatus = progressState(progress);\n  const displayProgress = progressStatus !== Progress.notStarted;\n\n  // when previousProgress is provided, either start the progress animation or only display previous progress while we wait. If not provided then only display current progress\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  // when previousProgress is provided but we haven't started the animation yet then show previous progress, otherwise, if animation has started, then show current progress\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  const isEmphasized = mode === 'emphasized';\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n    }\n\n    if (progress === 100) {\n      // completionDelay is for animating the progress; the setTimeout will delay showing the checkmark icon so radial progress will appear first.\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n        // If completionDelay is not provided, the completion icon will show immediately and radial progress will not show.\n      } else {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const sortedSkills = useMemo(() => {\n    if (!skills || skills.length === 0) {\n      return undefined;\n    }\n\n    return skills.sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n  }, [skills]);\n\n  return (\n    <StyledCard\n      as={as}\n      aria-label={`${learningOutcomeLabels[level ?? 1]} - ${outcome}`}\n      isInteractive={isInteractive}\n      progress={progressStatus}\n      mode={mode}\n    >\n      <FlexBox flexDirection=\"column\" gap={24}>\n        {level && (\n          <LearningOutcomeLevelBadge\n            level={level}\n            size={isEmphasized ? 'base' : 'sm'}\n            textColor={\n              level !== LearningOutcomeLevels.One ? 'navy-800' : 'text'\n            }\n            removeBackground\n          />\n        )}\n        <Text\n          variant={fontVariant(isEmphasized, level)}\n          fontWeight={isEmphasized ? 700 : 400}\n          width=\"100%\"\n          as={headingLevel}\n        >\n          {outcome}\n        </Text>\n        {!!sortedSkills && (\n          <FlexBox as=\"ul\" pl={0} m={0} alignItems=\"flex-start\" gap={8} wrap>\n            {renderSkills(sortedSkills)}\n          </FlexBox>\n        )}\n      </FlexBox>\n\n      {displayProgress &&\n        renderProgress({\n          displayValue,\n          progressDuration,\n          radialValue,\n          startRadialAnimation,\n          showCompletionIcon,\n        })}\n    </StyledCard>\n  );\n};\n"]} */");
+const StyledCard = /*#__PURE__*/_styled(Card, {
   target: "ev1pt780",
-  label: "EmphasizedCard"
-})(css({
-  bg: 'navy-900'
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AA+DuB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Badge,\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckFilledIcon } from '@codecademy/gamut-icons';\nimport { css, theme } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nenum LearningOutcomeLevels {\n  One = 1,\n  Two = 2,\n  Three = 3,\n}\n\nexport const levelTagText = {\n  [LearningOutcomeLevels.One]: 'Subskill',\n  [LearningOutcomeLevels.Two]: 'Skill',\n  [LearningOutcomeLevels.Three]: 'Skillset',\n};\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  headingLevel?: HeadingTags;\n  emphasized?: boolean;\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration: number;\n    completionDelay?: number;\n  };\n}\n\nconst StyledBadge = styled(Badge)(\n  css({\n    border: 2,\n    borderColor: 'border-tertiary',\n    color: 'text',\n  })\n);\n\nconst EmphasizedBadge = styled(StyledBadge)(\n  css({\n    bg: 'background-selected',\n  })\n);\n\nconst SimpleCard = styled(Card)(\n  css({\n    bg: 'background-primary',\n  })\n);\n// the 'navy' variant of Card applies a navy background to the card (navy-800) but the cards should have background navy-900\nconst EmphasizedCard = styled(Card)(\n  css({\n    bg: 'navy-900',\n  })\n);\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  emphasized = false,\n  headingLevel,\n  level,\n  outcome,\n  progress,\n  skills,\n  progressUpdateData,\n}) => {\n  const displayProgress = progress !== undefined && progress > 0;\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const renderedSortedSkills = useMemo(() => {\n    const sortedSkills = [...(skills ?? [])].sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n\n    if (sortedSkills && sortedSkills.length > 0) {\n      return sortedSkills.map((skill) => (\n        <FlexBox\n          as=\"li\"\n          px={8}\n          textColor=\"secondary\"\n          opacity=\"0.65\"\n          bg=\"background-selected\"\n          justifyContent=\"space-between\"\n          key={skill.title}\n        >\n          {skill.title}\n        </FlexBox>\n      ));\n    }\n    return null;\n  }, [skills]);\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n      } else if (progress === 100) {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  if (emphasized && skills) {\n    return (\n      <EmphasizedCard\n        py={32}\n        px={24}\n        flexDirection={displayProgress ? 'row' : 'column'}\n        isInteractive\n        gap={displayProgress ? 32 : 0}\n        border={2}\n        display=\"flex\"\n        borderColor={showCompletionIcon ? 'primary' : 'border-tertiary'}\n        borderRadius=\"lg\"\n        alignSelf=\"stretch\"\n        overflow=\"auto\"\n      >\n        <FlexBox flexDirection=\"column\" gap={24}>\n          {level && (\n            <EmphasizedBadge variant=\"tertiary\">\n              {levelTagText[level]}\n            </EmphasizedBadge>\n          )}\n          <Text variant=\"title-sm\" width=\"100%\" as={headingLevel}>\n            {outcome}\n          </Text>\n          <FlexBox wrap as=\"ul\" pl={0} alignItems=\"flex-start\" gap={8}>\n            {renderedSortedSkills}\n          </FlexBox>\n        </FlexBox>\n        {displayProgress && (\n          <FlexBox\n            flexDirection=\"column\"\n            flex=\"1 0 0\"\n            alignSelf=\"stretch\"\n            flexWrap=\"wrap\"\n            alignContent=\"end\"\n          >\n            {showCompletionIcon ? (\n              <CheckFilledIcon size={80} color=\"yellow-500\" />\n            ) : (\n              <RadialProgress\n                key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n                size={80}\n                strokeLinecap=\"round\"\n                strokeWidth={8}\n                value={radialValue ?? 0}\n                duration={progressDuration || undefined}\n                color={theme.colors['yellow-500']}\n              >\n                <Text as=\"span\" fontSize={22}>\n                  {displayValue}%\n                </Text>\n              </RadialProgress>\n            )}\n          </FlexBox>\n        )}\n      </EmphasizedCard>\n    );\n  }\n  return (\n    <SimpleCard\n      border={2}\n      display=\"flex\"\n      borderColor=\"border-tertiary\"\n      borderRadius=\"lg\"\n      gap={16}\n      py={24}\n      px={16}\n      alignSelf=\"stretch\"\n      flexDirection=\"column\"\n    >\n      {level && (\n        <StyledBadge size=\"sm\" variant=\"tertiary\">\n          {levelTagText[level]}\n        </StyledBadge>\n      )}\n      <Text variant=\"title-xs\" width=\"100%\" as={headingLevel}>\n        {outcome}\n      </Text>\n    </SimpleCard>\n  );\n};\n"]} */");
+  label: "StyledCard"
+})(props => ({
+  ...variant({
+    prop: 'mode',
+    defaultVariant: 'base',
+    base: {
+      border: 2,
+      borderRadius: 'lg',
+      borderColor: props.progress === Progress.completed ? COMPLETED_COLOR : 'border-tertiary',
+      display: 'flex',
+      flexDirection: props.progress === Progress.notStarted ? 'column' : 'row',
+      alignSelf: 'stretch',
+      overflow: 'auto',
+      gap: props.progress === Progress.notStarted ? 0 : 32
+    },
+    variants: {
+      emphasized: {
+        bg: 'background-primary',
+        borderRadius: 'xl',
+        py: 32,
+        px: 24
+      },
+      base: {
+        bg: 'background-current',
+        py: 24,
+        px: 16
+      }
+    }
+  })(props)
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/LearningOutcomeCard/index.tsx"],"names":[],"mappings":"AAkEmB","file":"../../src/LearningOutcomeCard/index.tsx","sourcesContent":["import {\n  Card,\n  FlexBox,\n  HeadingTags,\n  RadialProgress,\n  Text,\n} from '@codecademy/gamut';\nimport { CheckIcon } from '@codecademy/gamut-icons';\nimport { css, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport { useEffect, useMemo, useState } from 'react';\n\nimport {\n  learningOutcomeLabels,\n  LearningOutcomeLevelBadge,\n  LearningOutcomeLevels,\n} from '../LearningOutcomeBadges';\nimport { progressState } from '../LearningOutcomeTile';\nimport { Progress } from '../LearningOutcomeTile/types';\n\n// to match the type from gql schema\ninterface LearningOutcomeSkill {\n  title?: string | null | undefined;\n}\ninterface LearningOutcomeCardProps {\n  level: LearningOutcomeLevels | null | undefined;\n  outcome: string;\n  as?: 'li';\n  headingLevel?: HeadingTags;\n  isInteractive?: boolean;\n  mode?: 'emphasized' | 'base';\n  progress?: number;\n  skills?: LearningOutcomeSkill[] | null;\n\n  /**\n   * Optional prop for progress updates, used to animate the radial progress from a previous value to the current value.\n   * Need to provide previousProgress and progressDuraion to animate the radial progress.\n   * If progress is 100, completionDelay needs to be provided instead of progressDuration to delay the display of the completion icon.\n   */\n  progressUpdateData?: {\n    previousProgress: number;\n    progressDuration?: number;\n    completionDelay?: number;\n  };\n}\n\ninterface ProgressProps {\n  displayValue: number;\n  progressDuration: number | undefined;\n  radialValue: number | number[];\n  startRadialAnimation: boolean;\n  showCompletionIcon: boolean;\n}\n\nconst COMPLETED_COLOR = 'yellow-500';\n\nconst SkillTag = styled(FlexBox)(\n  css({\n    px: 8,\n    textColor: 'secondary',\n    opacity: '0.65',\n    bg: 'background-selected',\n    justifyContent: 'space-between',\n  })\n);\n\nconst StyledCard = styled(Card)<{\n  progress: Progress;\n  mode?: 'emphasized' | 'base';\n}>((props) => ({\n  ...variant({\n    prop: 'mode',\n    defaultVariant: 'base',\n    base: {\n      border: 2,\n      borderRadius: 'lg',\n      borderColor:\n        props.progress === Progress.completed\n          ? COMPLETED_COLOR\n          : 'border-tertiary',\n      display: 'flex',\n      flexDirection: props.progress === Progress.notStarted ? 'column' : 'row',\n      alignSelf: 'stretch',\n      overflow: 'auto',\n      gap: props.progress === Progress.notStarted ? 0 : 32,\n    },\n    variants: {\n      emphasized: {\n        bg: 'background-primary',\n        borderRadius: 'xl',\n        py: 32,\n        px: 24,\n      },\n      base: {\n        bg: 'background-current',\n        py: 24,\n        px: 16,\n      },\n    },\n  })(props),\n}));\n\nconst renderProgress = ({\n  displayValue,\n  progressDuration,\n  radialValue,\n  startRadialAnimation,\n  showCompletionIcon,\n}: ProgressProps) => (\n  <FlexBox\n    flexDirection=\"column\"\n    flex=\"1 0 0\"\n    alignSelf=\"stretch\"\n    flexWrap=\"wrap\"\n    alignContent=\"end\"\n  >\n    {showCompletionIcon ? (\n      <FlexBox\n        bg={COMPLETED_COLOR}\n        width={80}\n        height={80}\n        center\n        borderRadius=\"full\"\n      >\n        <CheckIcon size={44} color=\"text\" />\n      </FlexBox>\n    ) : (\n      <RadialProgress\n        key={`radial-progress-${startRadialAnimation ? 1 : 0}`}\n        color={theme.colors[COMPLETED_COLOR]}\n        duration={progressDuration || undefined}\n        size={80}\n        strokeLinecap=\"round\"\n        strokeWidth={8}\n        value={radialValue ?? 0}\n      >\n        <Text as=\"span\" fontSize={22} fontWeight={700}>\n          {`${displayValue}%`}\n        </Text>\n      </RadialProgress>\n    )}\n  </FlexBox>\n);\n\nconst renderSkills = (skills: LearningOutcomeSkill[]) =>\n  skills.map((skill) => (\n    <SkillTag as=\"li\" key={skill.title}>\n      {skill.title}\n    </SkillTag>\n  ));\n\nconst fontVariant = (\n  isEmphasized: boolean,\n  level?: LearningOutcomeLevels | null\n) => {\n  if (isEmphasized) {\n    return 'title-sm';\n  }\n\n  switch (level) {\n    case LearningOutcomeLevels.One:\n      return 'p-base';\n    case LearningOutcomeLevels.Two:\n      return 'title-xs';\n    case LearningOutcomeLevels.Three:\n      return 'title-sm';\n    default:\n      return 'p-base';\n  }\n};\n\nexport const LearningOutcomeCard: React.FC<LearningOutcomeCardProps> = ({\n  level,\n  outcome,\n  as,\n  headingLevel,\n  isInteractive = false,\n  mode = 'base',\n  progress = 0,\n  skills,\n  progressUpdateData,\n}) => {\n  const [startRadialAnimation, setStartRadialAnimation] = useState(false);\n  const [showCompletionIcon, setShowCompletionIcon] = useState(false);\n\n  const { previousProgress, progressDuration, completionDelay } =\n    progressUpdateData || {};\n  const progressStatus = progressState(progress);\n  const displayProgress = progressStatus !== Progress.notStarted;\n\n  // when previousProgress is provided, either start the progress animation or only display previous progress while we wait. If not provided then only display current progress\n  const radialValue =\n    previousProgress !== undefined && progress !== undefined\n      ? startRadialAnimation\n        ? [previousProgress, progress]\n        : previousProgress\n      : progress;\n\n  // when previousProgress is provided but we haven't started the animation yet then show previous progress, otherwise, if animation has started, then show current progress\n  const displayValue =\n    previousProgress !== undefined && !startRadialAnimation\n      ? previousProgress\n      : progress;\n\n  const isEmphasized = mode === 'emphasized';\n\n  useEffect(() => {\n    if (progress && progressDuration) {\n      setTimeout(() => {\n        setStartRadialAnimation(true);\n      }, progressDuration);\n    }\n\n    if (progress === 100) {\n      // completionDelay is for animating the progress; the setTimeout will delay showing the checkmark icon so radial progress will appear first.\n      if (completionDelay) {\n        setTimeout(() => {\n          setShowCompletionIcon(true);\n        }, completionDelay);\n        // If completionDelay is not provided, the completion icon will show immediately and radial progress will not show.\n      } else {\n        setShowCompletionIcon(true);\n      }\n    }\n  }, [progressDuration, progress, completionDelay]);\n\n  const sortedSkills = useMemo(() => {\n    if (!skills || skills.length === 0) {\n      return undefined;\n    }\n\n    return skills.sort((a, b) => {\n      const titleA = a.title ?? '';\n      const titleB = b.title ?? '';\n\n      return titleA.localeCompare(titleB);\n    });\n  }, [skills]);\n\n  return (\n    <StyledCard\n      as={as}\n      aria-label={`${learningOutcomeLabels[level ?? 1]} - ${outcome}`}\n      isInteractive={isInteractive}\n      progress={progressStatus}\n      mode={mode}\n    >\n      <FlexBox flexDirection=\"column\" gap={24}>\n        {level && (\n          <LearningOutcomeLevelBadge\n            level={level}\n            size={isEmphasized ? 'base' : 'sm'}\n            textColor={\n              level !== LearningOutcomeLevels.One ? 'navy-800' : 'text'\n            }\n            removeBackground\n          />\n        )}\n        <Text\n          variant={fontVariant(isEmphasized, level)}\n          fontWeight={isEmphasized ? 700 : 400}\n          width=\"100%\"\n          as={headingLevel}\n        >\n          {outcome}\n        </Text>\n        {!!sortedSkills && (\n          <FlexBox as=\"ul\" pl={0} m={0} alignItems=\"flex-start\" gap={8} wrap>\n            {renderSkills(sortedSkills)}\n          </FlexBox>\n        )}\n      </FlexBox>\n\n      {displayProgress &&\n        renderProgress({\n          displayValue,\n          progressDuration,\n          radialValue,\n          startRadialAnimation,\n          showCompletionIcon,\n        })}\n    </StyledCard>\n  );\n};\n"]} */");
+const renderProgress = ({
+  displayValue,
+  progressDuration,
+  radialValue,
+  startRadialAnimation,
+  showCompletionIcon
+}) => /*#__PURE__*/_jsx(FlexBox, {
+  flexDirection: "column",
+  flex: "1 0 0",
+  alignSelf: "stretch",
+  flexWrap: "wrap",
+  alignContent: "end",
+  children: showCompletionIcon ? /*#__PURE__*/_jsx(FlexBox, {
+    bg: COMPLETED_COLOR,
+    width: 80,
+    height: 80,
+    center: true,
+    borderRadius: "full",
+    children: /*#__PURE__*/_jsx(CheckIcon, {
+      size: 44,
+      color: "text"
+    })
+  }) : /*#__PURE__*/_jsx(RadialProgress, {
+    color: theme.colors[COMPLETED_COLOR],
+    duration: progressDuration || undefined,
+    size: 80,
+    strokeLinecap: "round",
+    strokeWidth: 8,
+    value: radialValue ?? 0,
+    children: /*#__PURE__*/_jsx(Text, {
+      as: "span",
+      fontSize: 22,
+      fontWeight: 700,
+      children: `${displayValue}%`
+    })
+  }, `radial-progress-${startRadialAnimation ? 1 : 0}`)
+});
+const renderSkills = skills => skills.map(skill => /*#__PURE__*/_jsx(SkillTag, {
+  as: "li",
+  children: skill.title
+}, skill.title));
+const fontVariant = (isEmphasized, level) => {
+  if (isEmphasized) {
+    return 'title-sm';
+  }
+  switch (level) {
+    case LearningOutcomeLevels.One:
+      return 'p-base';
+    case LearningOutcomeLevels.Two:
+      return 'title-xs';
+    case LearningOutcomeLevels.Three:
+      return 'title-sm';
+    default:
+      return 'p-base';
+  }
+};
 export const LearningOutcomeCard = ({
-  emphasized = false,
-  headingLevel,
   level,
   outcome,
-  progress,
+  as,
+  headingLevel,
+  isInteractive = false,
+  mode = 'base',
+  progress = 0,
   skills,
   progressUpdateData
 }) => {
-  const displayProgress = progress !== undefined && progress > 0;
+  const [startRadialAnimation, setStartRadialAnimation] = useState(false);
+  const [showCompletionIcon, setShowCompletionIcon] = useState(false);
   const {
     previousProgress,
     progressDuration,
     completionDelay
   } = progressUpdateData || {};
-  const [startRadialAnimation, setStartRadialAnimation] = useState(false);
-  const [showCompletionIcon, setShowCompletionIcon] = useState(false);
-  const renderedSortedSkills = useMemo(() => {
-    const sortedSkills = [...(skills ?? [])].sort((a, b) => {
-      const titleA = a.title ?? '';
-      const titleB = b.title ?? '';
-      return titleA.localeCompare(titleB);
-    });
-    if (sortedSkills && sortedSkills.length > 0) {
-      return sortedSkills.map(skill => /*#__PURE__*/_jsx(FlexBox, {
-        as: "li",
-        px: 8,
-        textColor: "secondary",
-        opacity: "0.65",
-        bg: "background-selected",
-        justifyContent: "space-between",
-        children: skill.title
-      }, skill.title));
-    }
-    return null;
-  }, [skills]);
+  const progressStatus = progressState(progress);
+  const displayProgress = progressStatus !== Progress.notStarted;
+
+  // when previousProgress is provided, either start the progress animation or only display previous progress while we wait. If not provided then only display current progress
+  const radialValue = previousProgress !== undefined && progress !== undefined ? startRadialAnimation ? [previousProgress, progress] : previousProgress : progress;
+
+  // when previousProgress is provided but we haven't started the animation yet then show previous progress, otherwise, if animation has started, then show current progress
+  const displayValue = previousProgress !== undefined && !startRadialAnimation ? previousProgress : progress;
+  const isEmphasized = mode === 'emphasized';
   useEffect(() => {
     if (progress && progressDuration) {
       setTimeout(() => {
         setStartRadialAnimation(true);
       }, progressDuration);
+    }
+    if (progress === 100) {
+      // completionDelay is for animating the progress; the setTimeout will delay showing the checkmark icon so radial progress will appear first.
       if (completionDelay) {
         setTimeout(() => {
           setShowCompletionIcon(true);
         }, completionDelay);
-      } else if (progress === 100) {
+        // If completionDelay is not provided, the completion icon will show immediately and radial progress will not show.
+      } else {
         setShowCompletionIcon(true);
       }
     }
   }, [progressDuration, progress, completionDelay]);
-  const radialValue = previousProgress !== undefined && progress !== undefined ? startRadialAnimation ? [previousProgress, progress] : previousProgress : progress;
-  const displayValue = previousProgress !== undefined && !startRadialAnimation ? previousProgress : progress;
-  if (emphasized && skills) {
-    return /*#__PURE__*/_jsxs(EmphasizedCard, {
-      py: 32,
-      px: 24,
-      flexDirection: displayProgress ? 'row' : 'column',
-      isInteractive: true,
-      gap: displayProgress ? 32 : 0,
-      border: 2,
-      display: "flex",
-      borderColor: showCompletionIcon ? 'primary' : 'border-tertiary',
-      borderRadius: "lg",
-      alignSelf: "stretch",
-      overflow: "auto",
-      children: [/*#__PURE__*/_jsxs(FlexBox, {
-        flexDirection: "column",
-        gap: 24,
-        children: [level && /*#__PURE__*/_jsx(EmphasizedBadge, {
-          variant: "tertiary",
-          children: levelTagText[level]
-        }), /*#__PURE__*/_jsx(Text, {
-          variant: "title-sm",
-          width: "100%",
-          as: headingLevel,
-          children: outcome
-        }), /*#__PURE__*/_jsx(FlexBox, {
-          wrap: true,
-          as: "ul",
-          pl: 0,
-          alignItems: "flex-start",
-          gap: 8,
-          children: renderedSortedSkills
-        })]
-      }), displayProgress && /*#__PURE__*/_jsx(FlexBox, {
-        flexDirection: "column",
-        flex: "1 0 0",
-        alignSelf: "stretch",
-        flexWrap: "wrap",
-        alignContent: "end",
-        children: showCompletionIcon ? /*#__PURE__*/_jsx(CheckFilledIcon, {
-          size: 80,
-          color: "yellow-500"
-        }) : /*#__PURE__*/_jsx(RadialProgress, {
-          size: 80,
-          strokeLinecap: "round",
-          strokeWidth: 8,
-          value: radialValue ?? 0,
-          duration: progressDuration || undefined,
-          color: theme.colors['yellow-500'],
-          children: /*#__PURE__*/_jsxs(Text, {
-            as: "span",
-            fontSize: 22,
-            children: [displayValue, "%"]
-          })
-        }, `radial-progress-${startRadialAnimation ? 1 : 0}`)
-      })]
+  const sortedSkills = useMemo(() => {
+    if (!skills || skills.length === 0) {
+      return undefined;
+    }
+    return skills.sort((a, b) => {
+      const titleA = a.title ?? '';
+      const titleB = b.title ?? '';
+      return titleA.localeCompare(titleB);
     });
-  }
-  return /*#__PURE__*/_jsxs(SimpleCard, {
-    border: 2,
-    display: "flex",
-    borderColor: "border-tertiary",
-    borderRadius: "lg",
-    gap: 16,
-    py: 24,
-    px: 16,
-    alignSelf: "stretch",
-    flexDirection: "column",
-    children: [level && /*#__PURE__*/_jsx(StyledBadge, {
-      size: "sm",
-      variant: "tertiary",
-      children: levelTagText[level]
-    }), /*#__PURE__*/_jsx(Text, {
-      variant: "title-xs",
-      width: "100%",
-      as: headingLevel,
-      children: outcome
+  }, [skills]);
+  return /*#__PURE__*/_jsxs(StyledCard, {
+    as: as,
+    "aria-label": `${learningOutcomeLabels[level ?? 1]} - ${outcome}`,
+    isInteractive: isInteractive,
+    progress: progressStatus,
+    mode: mode,
+    children: [/*#__PURE__*/_jsxs(FlexBox, {
+      flexDirection: "column",
+      gap: 24,
+      children: [level && /*#__PURE__*/_jsx(LearningOutcomeLevelBadge, {
+        level: level,
+        size: isEmphasized ? 'base' : 'sm',
+        textColor: level !== LearningOutcomeLevels.One ? 'navy-800' : 'text',
+        removeBackground: true
+      }), /*#__PURE__*/_jsx(Text, {
+        variant: fontVariant(isEmphasized, level),
+        fontWeight: isEmphasized ? 700 : 400,
+        width: "100%",
+        as: headingLevel,
+        children: outcome
+      }), !!sortedSkills && /*#__PURE__*/_jsx(FlexBox, {
+        as: "ul",
+        pl: 0,
+        m: 0,
+        alignItems: "flex-start",
+        gap: 8,
+        wrap: true,
+        children: renderSkills(sortedSkills)
+      })]
+    }), displayProgress && renderProgress({
+      displayValue,
+      progressDuration,
+      radialValue,
+      startRadialAnimation,
+      showCompletionIcon
     })]
   });
 };

package/dist/LearningOutcomeFlyout/LearningOutcomeCardList.d.ts

@@ -0,0 +1,6 @@
+import { ParentLearningOutcome } from '../LearningOutcomeFlyout';
+interface LearningOutcomeCardListProps {
+    learningOutcomes: ParentLearningOutcome[];
+}
+export declare const LearningOutcomeCardList: React.FC<LearningOutcomeCardListProps>;
+export {};

package/dist/LearningOutcomeFlyout/LearningOutcomeCardList.js

@@ -0,0 +1,23 @@
+import { FlexBox } from '@codecademy/gamut';
+import { LearningOutcomeCard } from '../LearningOutcomeCard';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const LearningOutcomeCardList = ({
+  learningOutcomes
+}) => {
+  return /*#__PURE__*/_jsx(FlexBox, {
+    as: "ul",
+    m: 0,
+    p: 0,
+    gap: 12,
+    column: true,
+    children: learningOutcomes.map(({
+      id,
+      level,
+      outcome
+    }) => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      as: "li",
+      level: level,
+      outcome: outcome
+    }, id))
+  });
+};

package/dist/LearningOutcomeFlyout/index.d.ts

@@ -9,6 +9,11 @@ interface LearningOutcomeSkill {
     title?: string | null;
     classification?: SkillClassification | null;
 }
+export interface ParentLearningOutcome {
+    id: string;
+    outcome: string;
+    level: number | null | undefined;
+}
 interface LearningOutcomeDetailsProps {
     level: LearningOutcomeLevels;
     outcome: string;
@@ -17,6 +22,7 @@ interface LearningOutcomeDetailsProps {
     highestScoreAchievedAt: string | undefined | null;
     latestScore: number | undefined | null;
     latestScoreAchievedAt: string | undefined | null;
+    parentLOs?: ParentLearningOutcome[];
     skills?: LearningOutcomeSkill[] | null;
 }
 interface LearningOutcomeFlyoutProps {

package/dist/LearningOutcomeFlyout/index.js

@@ -3,7 +3,8 @@ import { Anchor, FlexBox, Flyout, Text } from '@codecademy/gamut';
 import { SmallCheckIcon } from '@codecademy/gamut-icons';
 import { css } from '@codecademy/gamut-styles';
 import { LearningOutcomeAssessmentScores } from '../LearningOutcomeAssessmentScores';
-import { learningOutcomeLabels, LearningOutcomeLevelBadge, LearningOutcomeLowAssessmentBadge } from '../LearningOutcomeBadges';
+import { learningOutcomeLabels, LearningOutcomeLevelBadge, LearningOutcomeLevels, LearningOutcomeLowAssessmentBadge } from '../LearningOutcomeBadges';
+import { LearningOutcomeCardList } from './LearningOutcomeCardList';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const StyledAnchor = /*#__PURE__*/_styled(Anchor, {
   target: "e1ylhic51",
@@ -17,7 +18,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":"AAaqB","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';\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}\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\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  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    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 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: Parent LOs goes below here */}\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":"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"]} */");
 const SkillTag = /*#__PURE__*/_styled(Anchor, {
   target: "e1ylhic50",
   label: "SkillTag"
@@ -30,7 +31,7 @@ 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":"AA0BiB","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';\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}\ninterface LearningOutcomeSkill {\n  id: string;\n  slug: string;\n  title?: string | null;\n  classification?: SkillClassification | null;\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  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    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 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: Parent LOs goes below here */}\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":"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"]} */");
 export let SkillClassification = /*#__PURE__*/function (SkillClassification) {
   SkillClassification["Language"] = "language";
   SkillClassification["Subject"] = "subject";
@@ -64,6 +65,7 @@ export const LearningOutcomeFlyout = ({
     latestScoreAchievedAt,
     level,
     outcome,
+    parentLOs,
     percentComplete,
     skills
   },
@@ -75,6 +77,7 @@ export const LearningOutcomeFlyout = ({
   const hasLowLatestAssessment = Boolean(latestScore != null && latestScore < 70);
   const showSkills = !!skills?.length;
   const sortedSkills = sortSkillsByClassification(skills);
+  const showParentLOs = level === LearningOutcomeLevels.Two && !!parentLOs && parentLOs.length > 0;
   const renderProgress = () => /*#__PURE__*/_jsxs(FlexBox, {
     alignItems: "center",
     children: [Boolean(percentCompletePercentage === 100) && /*#__PURE__*/_jsx(FlexBox, {
@@ -164,6 +167,16 @@ export const LearningOutcomeFlyout = ({
           latestScore: latestScore,
           latestScoreAchievedAt: latestScoreAchievedAt
         })]
+      }), showParentLOs && /*#__PURE__*/_jsxs(FlexBox, {
+        gap: 16,
+        mb: 16,
+        column: true,
+        children: [/*#__PURE__*/_jsx(Text, {
+          variant: "title-xs",
+          children: "Builds toward..."
+        }), /*#__PURE__*/_jsx(LearningOutcomeCardList, {
+          learningOutcomes: parentLOs
+        })]
       })]
     })
   });

package/dist/LearningOutcomeTile/index.d.ts

@@ -1,2 +1,3 @@
-import { LearningOutcomeTileProps } from './types';
+import { LearningOutcomeTileProps, Progress } from './types';
+export declare const progressState: (percentComplete: number) => Progress;
 export declare const LearningOutcomeTile: React.FC<LearningOutcomeTileProps>;

package/dist/LearningOutcomeTile/index.js

@@ -29,8 +29,8 @@ const ProgressText = /*#__PURE__*/_styled(Text, {
       [Progress.completed]: {}
     }
   })(props)
-}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
-const progressState = percentComplete => {
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+export const progressState = percentComplete => {
   if (percentComplete === 0) {
     return Progress.notStarted;
   }

package/dist/stories/Molecules/LearningOutcomeCard.stories.d.ts

@@ -3,8 +3,13 @@ import { LearningOutcomeCard } from '../../LearningOutcomeCard';
 declare const meta: Meta<typeof LearningOutcomeCard>;
 export default meta;
 type Story = StoryObj<typeof LearningOutcomeCard>;
-export declare const Default: Story;
+export declare const Base: Story;
+export declare const BaseCardWithHover: Story;
+export declare const BaseCardWithTopics: Story;
 export declare const EmphasizedCard: Story;
+export declare const EmphasizedCardWithHover: Story;
+export declare const EmphasizedCardWithTopics: Story;
 export declare const EmphasizedCardWithProgress: Story;
 export declare const EmphasizedCardWithProgress100: Story;
-export declare const EmphasizedCardWithAnimation: Story;
+export declare const EmphasizedCardWithProgressAnimation: Story;
+export declare const EmphasizedCardWithProgress100Animation: Story;

package/dist/stories/Molecules/LearningOutcomeCard.stories.js

@@ -1,75 +1,189 @@
-import { Background } from '@codecademy/gamut-styles';
+import { FlexBox } from '@codecademy/gamut';
 import { LearningOutcomeCard } from '../../LearningOutcomeCard';
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const meta = {
   component: LearningOutcomeCard,
   args: {
+    outcome: 'Implement sorting algorithms in Java.'
+  }
+};
+export default meta;
+export const Base = {
+  render: args => /*#__PURE__*/_jsxs(FlexBox, {
+    gap: 16,
+    children: [/*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 1
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 2
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 3
+    })]
+  }),
+  name: 'Base card'
+};
+export const BaseCardWithHover = {
+  render: args => /*#__PURE__*/_jsxs(FlexBox, {
+    gap: 16,
+    children: [/*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 1,
+      isInteractive: true
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 2,
+      isInteractive: true
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 3,
+      isInteractive: true
+    })]
+  }),
+  name: 'Base card with hover'
+};
+export const BaseCardWithTopics = {
+  render: args => /*#__PURE__*/_jsxs(FlexBox, {
+    gap: 16,
+    children: [/*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 1,
+      skills: [{
+        title: 'java'
+      }, {
+        title: 'skill'
+      }, {
+        title: 'computer science'
+      }]
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 2,
+      skills: [{
+        title: 'java'
+      }, {
+        title: 'skill'
+      }, {
+        title: 'computer science'
+      }]
+    }), /*#__PURE__*/_jsx(LearningOutcomeCard, {
+      ...args,
+      level: 3,
+      skills: [{
+        title: 'java'
+      }, {
+        title: 'skill'
+      }, {
+        title: 'computer science'
+      }]
+    })]
+  }),
+  name: 'Base card with topics'
+};
+export const EmphasizedCard = {
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
     level: 1,
-    outcome: 'Implement sorting algorithms in Java.',
+    mode: "emphasized"
+  }),
+  name: 'Emphasized card'
+};
+export const EmphasizedCardWithHover = {
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 2,
+    mode: "emphasized",
+    isInteractive: true
+  }),
+  name: 'Emphasized card with hover'
+};
+export const EmphasizedCardWithTopics = {
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 3,
     skills: [{
       title: 'java'
     }, {
       title: 'skill'
     }, {
       title: 'computer science'
-    }]
-  }
-};
-export default meta;
-export const Default = {
-  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
-    ...args
+    }],
+    mode: "emphasized",
+    isInteractive: true
   }),
-  name: 'Learning Outcome Simple Card'
-};
-export const EmphasizedCard = {
-  render: args => /*#__PURE__*/_jsx(Background, {
-    bg: "navy",
-    p: 24,
-    children: /*#__PURE__*/_jsx(LearningOutcomeCard, {
-      emphasized: true,
-      ...args
-    })
-  }),
-  name: 'Emphasized Card'
+  name: 'Emphasized card with topics'
 };
 export const EmphasizedCardWithProgress = {
-  render: args => /*#__PURE__*/_jsx(Background, {
-    bg: "navy",
-    p: 24,
-    children: /*#__PURE__*/_jsx(LearningOutcomeCard, {
-      emphasized: true,
-      progress: 60,
-      ...args
-    })
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 2,
+    progress: 60,
+    skills: [{
+      title: 'java'
+    }, {
+      title: 'skill'
+    }, {
+      title: 'computer science'
+    }],
+    mode: "emphasized",
+    isInteractive: true
   }),
-  name: 'Emphasized card displaying progress, for use in the Learning Environment'
+  name: 'Emphasized card with progress'
 };
 export const EmphasizedCardWithProgress100 = {
-  render: args => /*#__PURE__*/_jsx(Background, {
-    bg: "navy",
-    p: 24,
-    children: /*#__PURE__*/_jsx(LearningOutcomeCard, {
-      emphasized: true,
-      progress: 100,
-      ...args
-    })
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 3,
+    progress: 100,
+    skills: [{
+      title: 'java'
+    }, {
+      title: 'skill'
+    }, {
+      title: 'computer science'
+    }],
+    mode: "emphasized",
+    isInteractive: true
   }),
-  name: 'Emphasized card displaying 100% progress, for use in the Learning Environment'
+  name: 'Emphasized card with 100% progress'
 };
-export const EmphasizedCardWithAnimation = {
-  render: args => /*#__PURE__*/_jsx(Background, {
-    bg: "navy",
-    p: 24,
-    children: /*#__PURE__*/_jsx(LearningOutcomeCard, {
-      emphasized: true,
-      progress: 80,
-      progressUpdateData: {
-        previousProgress: 50,
-        progressDuration: 500
-      },
-      ...args
-    })
+export const EmphasizedCardWithProgressAnimation = {
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 2,
+    progress: 80,
+    progressUpdateData: {
+      previousProgress: 50,
+      progressDuration: 500
+    },
+    skills: [{
+      title: 'java'
+    }, {
+      title: 'skill'
+    }, {
+      title: 'computer science'
+    }],
+    mode: "emphasized"
+  }),
+  name: 'Emphasized card with progress with animation'
+};
+export const EmphasizedCardWithProgress100Animation = {
+  render: args => /*#__PURE__*/_jsx(LearningOutcomeCard, {
+    ...args,
+    level: 2,
+    progress: 100,
+    progressUpdateData: {
+      previousProgress: 50,
+      completionDelay: 500
+    },
+    skills: [{
+      title: 'java'
+    }, {
+      title: 'skill'
+    }, {
+      title: 'computer science'
+    }],
+    mode: "emphasized"
   }),
-  name: 'Emphasized card first displays 50% progress then animates until showing 80%, for use in the Learning Environment'
+  name: 'Emphasized card with 100% progress with animation'
 };

package/dist/stories/Molecules/LearningOutcomeFlyout.stories.js

@@ -25,7 +25,16 @@ export const Example = () => {
           latestScoreAchievedAt: '10/01',
           level: 2,
           outcome: 'Understand the basics of React',
-          percentComplete: 75
+          percentComplete: 75,
+          parentLOs: [{
+            id: '1',
+            outcome: 'Build a React component',
+            level: 3
+          }, {
+            id: '2',
+            outcome: 'Manage state in React',
+            level: 3
+          }]
         },
         learningOutcomeHref: "/learning-outcomes/123",
         onClose: () => setIsExpanded(false)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codecademy/brand",
   "description": "Brand component library for Codecademy",
-  "version": "3.0.0-alpha.220d4ef8ba.0",
+  "version": "3.0.0-alpha.2ba7921cce.0",
   "author": "Codecademy Engineering <dev@codecademy.com>",
   "dependencies": {
     "@emotion/is-prop-valid": "^1.2.1",