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

package/dist/PricingSection/PricingCard/index.js

@@ -0,0 +1,202 @@
+import _styled from "@emotion/styled/base";
+import { Badge, Box, Card, FlexBox, Text } from '@codecademy/gamut';
+import { CheckerDense } from '@codecademy/gamut-patterns';
+import { css, pxRem, theme, variant } from '@codecademy/gamut-styles';
+import { ConditionalColorMode } from '../ConditionalColorMode';
+import { getProductDescription } from '../config';
+import { ProductCTA } from '../ProductCTA';
+import { Product } from '../types';
+import { PricingAmount } from './PricingAmount';
+import { RecommendedBadge } from './RecommendedBadge';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const smSize = 728;
+const StyledCard = /*#__PURE__*/_styled(Card, {
+  target: "e3n4z5j3",
+  label: "StyledCard"
+})(css({
+  height: 1,
+  borderWidth: 0,
+  padding: 0,
+  width: '100%',
+  flexDirection: 'column'
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/PricingSection/PricingCard/index.tsx"],"names":[],"mappings":"AAemB","file":"../../../src/PricingSection/PricingCard/index.tsx","sourcesContent":["import { Badge, Box, Card, FlexBox, Text } from '@codecademy/gamut';\nimport { CheckerDense } from '@codecademy/gamut-patterns';\nimport { css, pxRem, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { ConditionalColorMode } from '../ConditionalColorMode';\nimport { getProductDescription, PlansByType } from '../config';\nimport { ProductCTA } from '../ProductCTA';\nimport { Product, ProductDetails, User } from '../types';\nimport { PricingAmount } from './PricingAmount';\nimport { RecommendedBadge } from './RecommendedBadge';\nimport { AllCurrency } from './types';\n\nexport const smSize = 728;\n\nconst StyledCard = styled(Card)(\n  css({\n    height: 1,\n    borderWidth: 0,\n    padding: 0,\n    width: '100%',\n    flexDirection: 'column',\n  })\n);\n\nconst Divider = styled(CheckerDense)(\n  css({\n    height: '0.1rem',\n  })\n);\n\ntype StyledListRowProps = {\n  showRecommendedBadge: boolean;\n};\n\nconst StyledListRow = styled('li')<StyledListRowProps>`\n  width: 100%;\n  max-width: ${pxRem(smSize)};\n  height: 100%;\n  display: grid;\n  ${theme.breakpoints.lg} {\n    min-width: 36rem;\n  }\n`;\n\nconst cardHeaderVariants = variant({\n  base: {\n    backgroundColor: 'transparent',\n  },\n  variants: {\n    [Product.Basic]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Enterprise]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Silver]: {\n      backgroundColor: theme.colors.paleYellow,\n    },\n    [Product.Gold]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Pro]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Teams]: {\n      backgroundColor: theme.colors.background,\n    },\n  },\n});\n\nconst CardHeader = styled(FlexBox)(cardHeaderVariants);\n\nconst getBadgeText = (product: Product): string | null => {\n  switch (product) {\n    case Product.Gold:\n      return 'Advance your career';\n    case Product.Silver:\n    case Product.Pro:\n      return 'Learn a skill';\n    case Product.Teams:\n      return 'Recommended for 2+';\n    case Product.Enterprise:\n      return 'Recommended for 25+';\n    default:\n      return null;\n  }\n};\n\nconst renderProductDescription = (product: Product) => {\n  const productFeatures = (\n    <Text maxWidth={{ md: '235px' }} textAlign=\"center\">\n      {getProductDescription(product)}\n    </Text>\n  );\n\n  return (\n    <FlexBox mt={8} alignItems=\"center\" flexDirection=\"column\">\n      {productFeatures}\n    </FlexBox>\n  );\n};\n\nexport const PricingCard = ({\n  product,\n  productDetails,\n  currency,\n  plansByType,\n  isUserInIndia,\n  user,\n  trackBusinessClick,\n}: {\n  product: Product;\n  productDetails: ProductDetails;\n  currency: AllCurrency;\n  plansByType: PlansByType;\n  isUserInIndia: boolean;\n  user: User;\n  trackBusinessClick?: ({\n    target,\n    context,\n  }: {\n    target: string;\n    context: string;\n  }) => void;\n}) => {\n  const isGoldProduct = product === Product.Gold;\n  const isTeamsProduct = product === Product.Teams;\n\n  return (\n    <StyledListRow showRecommendedBadge={product === Product.Gold}>\n      <StyledCard display=\"flex\" shadow=\"patternLeft\">\n        {isGoldProduct && <RecommendedBadge />}\n        <ConditionalColorMode condition={isTeamsProduct}>\n          <CardHeader\n            variant={product}\n            py={8}\n            px={24}\n            alignItems=\"center\"\n            justifyContent=\"space-between\"\n          >\n            <Text as=\"h2\" fontSize={{ _: 22, xl: 26 }}>\n              {plansByType[product].monthly?.displayName ||\n                plansByType[product].annual?.displayName}\n            </Text>\n            {isGoldProduct && <Text screenreader>Recommended</Text>}\n            {getBadgeText(product) && (\n              <Badge variant=\"tertiary\" ml={12}>\n                {getBadgeText(product)}\n              </Badge>\n            )}\n          </CardHeader>\n        </ConditionalColorMode>\n\n        <Box px={24} pt={24}>\n          <FlexBox center alignItems=\"flex-start\">\n            {product === Product.Enterprise ? (\n              <FlexBox\n                column\n                alignItems=\"center\"\n                justifyContent=\"center\"\n                minHeight={134}\n              >\n                <Text color=\"text-secondary\" mb={8} textAlign=\"center\">\n                  Looking to train a larger team?\n                </Text>\n                <Text variant=\"title-lg\" textAlign=\"center\">\n                  Contact us for a custom quote\n                </Text>\n              </FlexBox>\n            ) : (\n              <PricingAmount\n                monthlyPrice={plansByType[product].monthly?.price}\n                price={productDetails.price}\n                product={product}\n                currency={currency}\n                isUserInIndia={isUserInIndia}\n              />\n            )}\n          </FlexBox>\n\n          <FlexBox column alignItems=\"center\">\n            <Divider mt={16} />\n            <FlexBox\n              flexDirection=\"column\"\n              my={12}\n              /**\n               * Previously we were arbitrarily sizing cards to a width that was\n               * \"too small\" for the content they contained. The actual affect this was\n               * having was shrinking this section down to 256px, so rather than size\n               * the card, I'm opting to size this particular container w/i.\n               * This allows the cards themselves to be more flexible and simply styled\n               * while still maintaining the \"proper size\" on smaller screens.\n               */\n              width={{ _: 'unset', md: pxRem(256) }}\n            >\n              {renderProductDescription(product)}\n            </FlexBox>\n          </FlexBox>\n        </Box>\n        <FlexBox mb={24} mt=\"auto\" column>\n          <ProductCTA\n            user={user}\n            productDetails={productDetails}\n            product={product}\n            trackBusinessClick={trackBusinessClick}\n          />\n        </FlexBox>\n      </StyledCard>\n    </StyledListRow>\n  );\n};\n"]} */");
+const Divider = /*#__PURE__*/_styled(CheckerDense, {
+  target: "e3n4z5j2",
+  label: "Divider"
+})(css({
+  height: '0.1rem'
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/PricingSection/PricingCard/index.tsx"],"names":[],"mappings":"AAyBgB","file":"../../../src/PricingSection/PricingCard/index.tsx","sourcesContent":["import { Badge, Box, Card, FlexBox, Text } from '@codecademy/gamut';\nimport { CheckerDense } from '@codecademy/gamut-patterns';\nimport { css, pxRem, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { ConditionalColorMode } from '../ConditionalColorMode';\nimport { getProductDescription, PlansByType } from '../config';\nimport { ProductCTA } from '../ProductCTA';\nimport { Product, ProductDetails, User } from '../types';\nimport { PricingAmount } from './PricingAmount';\nimport { RecommendedBadge } from './RecommendedBadge';\nimport { AllCurrency } from './types';\n\nexport const smSize = 728;\n\nconst StyledCard = styled(Card)(\n  css({\n    height: 1,\n    borderWidth: 0,\n    padding: 0,\n    width: '100%',\n    flexDirection: 'column',\n  })\n);\n\nconst Divider = styled(CheckerDense)(\n  css({\n    height: '0.1rem',\n  })\n);\n\ntype StyledListRowProps = {\n  showRecommendedBadge: boolean;\n};\n\nconst StyledListRow = styled('li')<StyledListRowProps>`\n  width: 100%;\n  max-width: ${pxRem(smSize)};\n  height: 100%;\n  display: grid;\n  ${theme.breakpoints.lg} {\n    min-width: 36rem;\n  }\n`;\n\nconst cardHeaderVariants = variant({\n  base: {\n    backgroundColor: 'transparent',\n  },\n  variants: {\n    [Product.Basic]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Enterprise]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Silver]: {\n      backgroundColor: theme.colors.paleYellow,\n    },\n    [Product.Gold]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Pro]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Teams]: {\n      backgroundColor: theme.colors.background,\n    },\n  },\n});\n\nconst CardHeader = styled(FlexBox)(cardHeaderVariants);\n\nconst getBadgeText = (product: Product): string | null => {\n  switch (product) {\n    case Product.Gold:\n      return 'Advance your career';\n    case Product.Silver:\n    case Product.Pro:\n      return 'Learn a skill';\n    case Product.Teams:\n      return 'Recommended for 2+';\n    case Product.Enterprise:\n      return 'Recommended for 25+';\n    default:\n      return null;\n  }\n};\n\nconst renderProductDescription = (product: Product) => {\n  const productFeatures = (\n    <Text maxWidth={{ md: '235px' }} textAlign=\"center\">\n      {getProductDescription(product)}\n    </Text>\n  );\n\n  return (\n    <FlexBox mt={8} alignItems=\"center\" flexDirection=\"column\">\n      {productFeatures}\n    </FlexBox>\n  );\n};\n\nexport const PricingCard = ({\n  product,\n  productDetails,\n  currency,\n  plansByType,\n  isUserInIndia,\n  user,\n  trackBusinessClick,\n}: {\n  product: Product;\n  productDetails: ProductDetails;\n  currency: AllCurrency;\n  plansByType: PlansByType;\n  isUserInIndia: boolean;\n  user: User;\n  trackBusinessClick?: ({\n    target,\n    context,\n  }: {\n    target: string;\n    context: string;\n  }) => void;\n}) => {\n  const isGoldProduct = product === Product.Gold;\n  const isTeamsProduct = product === Product.Teams;\n\n  return (\n    <StyledListRow showRecommendedBadge={product === Product.Gold}>\n      <StyledCard display=\"flex\" shadow=\"patternLeft\">\n        {isGoldProduct && <RecommendedBadge />}\n        <ConditionalColorMode condition={isTeamsProduct}>\n          <CardHeader\n            variant={product}\n            py={8}\n            px={24}\n            alignItems=\"center\"\n            justifyContent=\"space-between\"\n          >\n            <Text as=\"h2\" fontSize={{ _: 22, xl: 26 }}>\n              {plansByType[product].monthly?.displayName ||\n                plansByType[product].annual?.displayName}\n            </Text>\n            {isGoldProduct && <Text screenreader>Recommended</Text>}\n            {getBadgeText(product) && (\n              <Badge variant=\"tertiary\" ml={12}>\n                {getBadgeText(product)}\n              </Badge>\n            )}\n          </CardHeader>\n        </ConditionalColorMode>\n\n        <Box px={24} pt={24}>\n          <FlexBox center alignItems=\"flex-start\">\n            {product === Product.Enterprise ? (\n              <FlexBox\n                column\n                alignItems=\"center\"\n                justifyContent=\"center\"\n                minHeight={134}\n              >\n                <Text color=\"text-secondary\" mb={8} textAlign=\"center\">\n                  Looking to train a larger team?\n                </Text>\n                <Text variant=\"title-lg\" textAlign=\"center\">\n                  Contact us for a custom quote\n                </Text>\n              </FlexBox>\n            ) : (\n              <PricingAmount\n                monthlyPrice={plansByType[product].monthly?.price}\n                price={productDetails.price}\n                product={product}\n                currency={currency}\n                isUserInIndia={isUserInIndia}\n              />\n            )}\n          </FlexBox>\n\n          <FlexBox column alignItems=\"center\">\n            <Divider mt={16} />\n            <FlexBox\n              flexDirection=\"column\"\n              my={12}\n              /**\n               * Previously we were arbitrarily sizing cards to a width that was\n               * \"too small\" for the content they contained. The actual affect this was\n               * having was shrinking this section down to 256px, so rather than size\n               * the card, I'm opting to size this particular container w/i.\n               * This allows the cards themselves to be more flexible and simply styled\n               * while still maintaining the \"proper size\" on smaller screens.\n               */\n              width={{ _: 'unset', md: pxRem(256) }}\n            >\n              {renderProductDescription(product)}\n            </FlexBox>\n          </FlexBox>\n        </Box>\n        <FlexBox mb={24} mt=\"auto\" column>\n          <ProductCTA\n            user={user}\n            productDetails={productDetails}\n            product={product}\n            trackBusinessClick={trackBusinessClick}\n          />\n        </FlexBox>\n      </StyledCard>\n    </StyledListRow>\n  );\n};\n"]} */");
+const StyledListRow = /*#__PURE__*/_styled('li', {
+  target: "e3n4z5j1",
+  label: "StyledListRow"
+})("width:100%;max-width:", pxRem(smSize), ";height:100%;display:grid;", theme.breakpoints.lg, "{min-width:36rem;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/PricingSection/PricingCard/index.tsx"],"names":[],"mappings":"AAmCsD","file":"../../../src/PricingSection/PricingCard/index.tsx","sourcesContent":["import { Badge, Box, Card, FlexBox, Text } from '@codecademy/gamut';\nimport { CheckerDense } from '@codecademy/gamut-patterns';\nimport { css, pxRem, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { ConditionalColorMode } from '../ConditionalColorMode';\nimport { getProductDescription, PlansByType } from '../config';\nimport { ProductCTA } from '../ProductCTA';\nimport { Product, ProductDetails, User } from '../types';\nimport { PricingAmount } from './PricingAmount';\nimport { RecommendedBadge } from './RecommendedBadge';\nimport { AllCurrency } from './types';\n\nexport const smSize = 728;\n\nconst StyledCard = styled(Card)(\n  css({\n    height: 1,\n    borderWidth: 0,\n    padding: 0,\n    width: '100%',\n    flexDirection: 'column',\n  })\n);\n\nconst Divider = styled(CheckerDense)(\n  css({\n    height: '0.1rem',\n  })\n);\n\ntype StyledListRowProps = {\n  showRecommendedBadge: boolean;\n};\n\nconst StyledListRow = styled('li')<StyledListRowProps>`\n  width: 100%;\n  max-width: ${pxRem(smSize)};\n  height: 100%;\n  display: grid;\n  ${theme.breakpoints.lg} {\n    min-width: 36rem;\n  }\n`;\n\nconst cardHeaderVariants = variant({\n  base: {\n    backgroundColor: 'transparent',\n  },\n  variants: {\n    [Product.Basic]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Enterprise]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Silver]: {\n      backgroundColor: theme.colors.paleYellow,\n    },\n    [Product.Gold]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Pro]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Teams]: {\n      backgroundColor: theme.colors.background,\n    },\n  },\n});\n\nconst CardHeader = styled(FlexBox)(cardHeaderVariants);\n\nconst getBadgeText = (product: Product): string | null => {\n  switch (product) {\n    case Product.Gold:\n      return 'Advance your career';\n    case Product.Silver:\n    case Product.Pro:\n      return 'Learn a skill';\n    case Product.Teams:\n      return 'Recommended for 2+';\n    case Product.Enterprise:\n      return 'Recommended for 25+';\n    default:\n      return null;\n  }\n};\n\nconst renderProductDescription = (product: Product) => {\n  const productFeatures = (\n    <Text maxWidth={{ md: '235px' }} textAlign=\"center\">\n      {getProductDescription(product)}\n    </Text>\n  );\n\n  return (\n    <FlexBox mt={8} alignItems=\"center\" flexDirection=\"column\">\n      {productFeatures}\n    </FlexBox>\n  );\n};\n\nexport const PricingCard = ({\n  product,\n  productDetails,\n  currency,\n  plansByType,\n  isUserInIndia,\n  user,\n  trackBusinessClick,\n}: {\n  product: Product;\n  productDetails: ProductDetails;\n  currency: AllCurrency;\n  plansByType: PlansByType;\n  isUserInIndia: boolean;\n  user: User;\n  trackBusinessClick?: ({\n    target,\n    context,\n  }: {\n    target: string;\n    context: string;\n  }) => void;\n}) => {\n  const isGoldProduct = product === Product.Gold;\n  const isTeamsProduct = product === Product.Teams;\n\n  return (\n    <StyledListRow showRecommendedBadge={product === Product.Gold}>\n      <StyledCard display=\"flex\" shadow=\"patternLeft\">\n        {isGoldProduct && <RecommendedBadge />}\n        <ConditionalColorMode condition={isTeamsProduct}>\n          <CardHeader\n            variant={product}\n            py={8}\n            px={24}\n            alignItems=\"center\"\n            justifyContent=\"space-between\"\n          >\n            <Text as=\"h2\" fontSize={{ _: 22, xl: 26 }}>\n              {plansByType[product].monthly?.displayName ||\n                plansByType[product].annual?.displayName}\n            </Text>\n            {isGoldProduct && <Text screenreader>Recommended</Text>}\n            {getBadgeText(product) && (\n              <Badge variant=\"tertiary\" ml={12}>\n                {getBadgeText(product)}\n              </Badge>\n            )}\n          </CardHeader>\n        </ConditionalColorMode>\n\n        <Box px={24} pt={24}>\n          <FlexBox center alignItems=\"flex-start\">\n            {product === Product.Enterprise ? (\n              <FlexBox\n                column\n                alignItems=\"center\"\n                justifyContent=\"center\"\n                minHeight={134}\n              >\n                <Text color=\"text-secondary\" mb={8} textAlign=\"center\">\n                  Looking to train a larger team?\n                </Text>\n                <Text variant=\"title-lg\" textAlign=\"center\">\n                  Contact us for a custom quote\n                </Text>\n              </FlexBox>\n            ) : (\n              <PricingAmount\n                monthlyPrice={plansByType[product].monthly?.price}\n                price={productDetails.price}\n                product={product}\n                currency={currency}\n                isUserInIndia={isUserInIndia}\n              />\n            )}\n          </FlexBox>\n\n          <FlexBox column alignItems=\"center\">\n            <Divider mt={16} />\n            <FlexBox\n              flexDirection=\"column\"\n              my={12}\n              /**\n               * Previously we were arbitrarily sizing cards to a width that was\n               * \"too small\" for the content they contained. The actual affect this was\n               * having was shrinking this section down to 256px, so rather than size\n               * the card, I'm opting to size this particular container w/i.\n               * This allows the cards themselves to be more flexible and simply styled\n               * while still maintaining the \"proper size\" on smaller screens.\n               */\n              width={{ _: 'unset', md: pxRem(256) }}\n            >\n              {renderProductDescription(product)}\n            </FlexBox>\n          </FlexBox>\n        </Box>\n        <FlexBox mb={24} mt=\"auto\" column>\n          <ProductCTA\n            user={user}\n            productDetails={productDetails}\n            product={product}\n            trackBusinessClick={trackBusinessClick}\n          />\n        </FlexBox>\n      </StyledCard>\n    </StyledListRow>\n  );\n};\n"]} */"));
+const cardHeaderVariants = variant({
+  base: {
+    backgroundColor: 'transparent'
+  },
+  variants: {
+    [Product.Basic]: {
+      borderBottomWidth: 1,
+      borderBottomStyle: 'solid',
+      borderBottomColor: theme.colors['navy-200'],
+      color: 'navy-500'
+    },
+    [Product.Enterprise]: {
+      borderBottomWidth: 1,
+      borderBottomStyle: 'solid',
+      borderBottomColor: theme.colors['navy-200'],
+      color: 'navy-500'
+    },
+    [Product.Silver]: {
+      backgroundColor: theme.colors.paleYellow
+    },
+    [Product.Gold]: {
+      backgroundColor: theme.colors.yellow
+    },
+    [Product.Pro]: {
+      backgroundColor: theme.colors.yellow
+    },
+    [Product.Teams]: {
+      backgroundColor: theme.colors.background
+    }
+  }
+});
+const CardHeader = /*#__PURE__*/_styled(FlexBox, {
+  target: "e3n4z5j0",
+  label: "CardHeader"
+})(cardHeaderVariants, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/PricingSection/PricingCard/index.tsx"],"names":[],"mappings":"AA6EmB","file":"../../../src/PricingSection/PricingCard/index.tsx","sourcesContent":["import { Badge, Box, Card, FlexBox, Text } from '@codecademy/gamut';\nimport { CheckerDense } from '@codecademy/gamut-patterns';\nimport { css, pxRem, theme, variant } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\n\nimport { ConditionalColorMode } from '../ConditionalColorMode';\nimport { getProductDescription, PlansByType } from '../config';\nimport { ProductCTA } from '../ProductCTA';\nimport { Product, ProductDetails, User } from '../types';\nimport { PricingAmount } from './PricingAmount';\nimport { RecommendedBadge } from './RecommendedBadge';\nimport { AllCurrency } from './types';\n\nexport const smSize = 728;\n\nconst StyledCard = styled(Card)(\n  css({\n    height: 1,\n    borderWidth: 0,\n    padding: 0,\n    width: '100%',\n    flexDirection: 'column',\n  })\n);\n\nconst Divider = styled(CheckerDense)(\n  css({\n    height: '0.1rem',\n  })\n);\n\ntype StyledListRowProps = {\n  showRecommendedBadge: boolean;\n};\n\nconst StyledListRow = styled('li')<StyledListRowProps>`\n  width: 100%;\n  max-width: ${pxRem(smSize)};\n  height: 100%;\n  display: grid;\n  ${theme.breakpoints.lg} {\n    min-width: 36rem;\n  }\n`;\n\nconst cardHeaderVariants = variant({\n  base: {\n    backgroundColor: 'transparent',\n  },\n  variants: {\n    [Product.Basic]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Enterprise]: {\n      borderBottomWidth: 1,\n      borderBottomStyle: 'solid',\n      borderBottomColor: theme.colors['navy-200'],\n      color: 'navy-500',\n    },\n    [Product.Silver]: {\n      backgroundColor: theme.colors.paleYellow,\n    },\n    [Product.Gold]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Pro]: {\n      backgroundColor: theme.colors.yellow,\n    },\n    [Product.Teams]: {\n      backgroundColor: theme.colors.background,\n    },\n  },\n});\n\nconst CardHeader = styled(FlexBox)(cardHeaderVariants);\n\nconst getBadgeText = (product: Product): string | null => {\n  switch (product) {\n    case Product.Gold:\n      return 'Advance your career';\n    case Product.Silver:\n    case Product.Pro:\n      return 'Learn a skill';\n    case Product.Teams:\n      return 'Recommended for 2+';\n    case Product.Enterprise:\n      return 'Recommended for 25+';\n    default:\n      return null;\n  }\n};\n\nconst renderProductDescription = (product: Product) => {\n  const productFeatures = (\n    <Text maxWidth={{ md: '235px' }} textAlign=\"center\">\n      {getProductDescription(product)}\n    </Text>\n  );\n\n  return (\n    <FlexBox mt={8} alignItems=\"center\" flexDirection=\"column\">\n      {productFeatures}\n    </FlexBox>\n  );\n};\n\nexport const PricingCard = ({\n  product,\n  productDetails,\n  currency,\n  plansByType,\n  isUserInIndia,\n  user,\n  trackBusinessClick,\n}: {\n  product: Product;\n  productDetails: ProductDetails;\n  currency: AllCurrency;\n  plansByType: PlansByType;\n  isUserInIndia: boolean;\n  user: User;\n  trackBusinessClick?: ({\n    target,\n    context,\n  }: {\n    target: string;\n    context: string;\n  }) => void;\n}) => {\n  const isGoldProduct = product === Product.Gold;\n  const isTeamsProduct = product === Product.Teams;\n\n  return (\n    <StyledListRow showRecommendedBadge={product === Product.Gold}>\n      <StyledCard display=\"flex\" shadow=\"patternLeft\">\n        {isGoldProduct && <RecommendedBadge />}\n        <ConditionalColorMode condition={isTeamsProduct}>\n          <CardHeader\n            variant={product}\n            py={8}\n            px={24}\n            alignItems=\"center\"\n            justifyContent=\"space-between\"\n          >\n            <Text as=\"h2\" fontSize={{ _: 22, xl: 26 }}>\n              {plansByType[product].monthly?.displayName ||\n                plansByType[product].annual?.displayName}\n            </Text>\n            {isGoldProduct && <Text screenreader>Recommended</Text>}\n            {getBadgeText(product) && (\n              <Badge variant=\"tertiary\" ml={12}>\n                {getBadgeText(product)}\n              </Badge>\n            )}\n          </CardHeader>\n        </ConditionalColorMode>\n\n        <Box px={24} pt={24}>\n          <FlexBox center alignItems=\"flex-start\">\n            {product === Product.Enterprise ? (\n              <FlexBox\n                column\n                alignItems=\"center\"\n                justifyContent=\"center\"\n                minHeight={134}\n              >\n                <Text color=\"text-secondary\" mb={8} textAlign=\"center\">\n                  Looking to train a larger team?\n                </Text>\n                <Text variant=\"title-lg\" textAlign=\"center\">\n                  Contact us for a custom quote\n                </Text>\n              </FlexBox>\n            ) : (\n              <PricingAmount\n                monthlyPrice={plansByType[product].monthly?.price}\n                price={productDetails.price}\n                product={product}\n                currency={currency}\n                isUserInIndia={isUserInIndia}\n              />\n            )}\n          </FlexBox>\n\n          <FlexBox column alignItems=\"center\">\n            <Divider mt={16} />\n            <FlexBox\n              flexDirection=\"column\"\n              my={12}\n              /**\n               * Previously we were arbitrarily sizing cards to a width that was\n               * \"too small\" for the content they contained. The actual affect this was\n               * having was shrinking this section down to 256px, so rather than size\n               * the card, I'm opting to size this particular container w/i.\n               * This allows the cards themselves to be more flexible and simply styled\n               * while still maintaining the \"proper size\" on smaller screens.\n               */\n              width={{ _: 'unset', md: pxRem(256) }}\n            >\n              {renderProductDescription(product)}\n            </FlexBox>\n          </FlexBox>\n        </Box>\n        <FlexBox mb={24} mt=\"auto\" column>\n          <ProductCTA\n            user={user}\n            productDetails={productDetails}\n            product={product}\n            trackBusinessClick={trackBusinessClick}\n          />\n        </FlexBox>\n      </StyledCard>\n    </StyledListRow>\n  );\n};\n"]} */");
+const getBadgeText = product => {
+  switch (product) {
+    case Product.Gold:
+      return 'Advance your career';
+    case Product.Silver:
+    case Product.Pro:
+      return 'Learn a skill';
+    case Product.Teams:
+      return 'Recommended for 2+';
+    case Product.Enterprise:
+      return 'Recommended for 25+';
+    default:
+      return null;
+  }
+};
+const renderProductDescription = product => {
+  const productFeatures = /*#__PURE__*/_jsx(Text, {
+    maxWidth: {
+      md: '235px'
+    },
+    textAlign: "center",
+    children: getProductDescription(product)
+  });
+  return /*#__PURE__*/_jsx(FlexBox, {
+    mt: 8,
+    alignItems: "center",
+    flexDirection: "column",
+    children: productFeatures
+  });
+};
+export const PricingCard = ({
+  product,
+  productDetails,
+  currency,
+  plansByType,
+  isUserInIndia,
+  user,
+  trackBusinessClick
+}) => {
+  const isGoldProduct = product === Product.Gold;
+  const isTeamsProduct = product === Product.Teams;
+  return /*#__PURE__*/_jsx(StyledListRow, {
+    showRecommendedBadge: product === Product.Gold,
+    children: /*#__PURE__*/_jsxs(StyledCard, {
+      display: "flex",
+      shadow: "patternLeft",
+      children: [isGoldProduct && /*#__PURE__*/_jsx(RecommendedBadge, {}), /*#__PURE__*/_jsx(ConditionalColorMode, {
+        condition: isTeamsProduct,
+        children: /*#__PURE__*/_jsxs(CardHeader, {
+          variant: product,
+          py: 8,
+          px: 24,
+          alignItems: "center",
+          justifyContent: "space-between",
+          children: [/*#__PURE__*/_jsx(Text, {
+            as: "h2",
+            fontSize: {
+              _: 22,
+              xl: 26
+            },
+            children: plansByType[product].monthly?.displayName || plansByType[product].annual?.displayName
+          }), isGoldProduct && /*#__PURE__*/_jsx(Text, {
+            screenreader: true,
+            children: "Recommended"
+          }), getBadgeText(product) && /*#__PURE__*/_jsx(Badge, {
+            variant: "tertiary",
+            ml: 12,
+            children: getBadgeText(product)
+          })]
+        })
+      }), /*#__PURE__*/_jsxs(Box, {
+        px: 24,
+        pt: 24,
+        children: [/*#__PURE__*/_jsx(FlexBox, {
+          center: true,
+          alignItems: "flex-start",
+          children: product === Product.Enterprise ? /*#__PURE__*/_jsxs(FlexBox, {
+            column: true,
+            alignItems: "center",
+            justifyContent: "center",
+            minHeight: 134,
+            children: [/*#__PURE__*/_jsx(Text, {
+              color: "text-secondary",
+              mb: 8,
+              textAlign: "center",
+              children: "Looking to train a larger team?"
+            }), /*#__PURE__*/_jsx(Text, {
+              variant: "title-lg",
+              textAlign: "center",
+              children: "Contact us for a custom quote"
+            })]
+          }) : /*#__PURE__*/_jsx(PricingAmount, {
+            monthlyPrice: plansByType[product].monthly?.price,
+            price: productDetails.price,
+            product: product,
+            currency: currency,
+            isUserInIndia: isUserInIndia
+          })
+        }), /*#__PURE__*/_jsxs(FlexBox, {
+          column: true,
+          alignItems: "center",
+          children: [/*#__PURE__*/_jsx(Divider, {
+            mt: 16
+          }), /*#__PURE__*/_jsx(FlexBox, {
+            flexDirection: "column",
+            my: 12
+            /**
+             * Previously we were arbitrarily sizing cards to a width that was
+             * "too small" for the content they contained. The actual affect this was
+             * having was shrinking this section down to 256px, so rather than size
+             * the card, I'm opting to size this particular container w/i.
+             * This allows the cards themselves to be more flexible and simply styled
+             * while still maintaining the "proper size" on smaller screens.
+             */,
+            width: {
+              _: 'unset',
+              md: pxRem(256)
+            },
+            children: renderProductDescription(product)
+          })]
+        })]
+      }), /*#__PURE__*/_jsx(FlexBox, {
+        mb: 24,
+        mt: "auto",
+        column: true,
+        children: /*#__PURE__*/_jsx(ProductCTA, {
+          user: user,
+          productDetails: productDetails,
+          product: product,
+          trackBusinessClick: trackBusinessClick
+        })
+      })]
+    })
+  });
+};

package/dist/PricingSection/PricingCard/types.d.ts

@@ -0,0 +1,40 @@
+export declare enum Currency {
+    Aud = "AUD",
+    Cad = "CAD",
+    Eur = "EUR",
+    Gbp = "GBP",
+    Inr = "INR",
+    Nok = "NOK",
+    Pln = "PLN",
+    Sek = "SEK",
+    Usd = "USD"
+}
+export declare enum CFBCurrency {
+    Dkk = "DKK",
+    Brl = "BRL",
+    Bgn = "BGN",
+    Chf = "CHF",
+    Czk = "CZK",
+    Hrk = "HRK",
+    Huf = "HUF",
+    Mxn = "MXN",
+    Ron = "RON"
+}
+export declare enum CurrencySymbol {
+    Dollar = "$",
+    Pound = "\u00A3",
+    Euro = "\u20AC",
+    Rupee = "\u20B9",
+    Krona = "kr",
+    Krone = "kr",
+    ZLOTY = "z\u0142",
+    Lev = "\u041B\u0432.",
+    Real = "R$",
+    Franc = "Fr.",
+    Koruna = "K\u010D",
+    Kuna = "kn",
+    Forint = "Ft",
+    Leu = "lei"
+}
+export type AllCurrency = Currency | CFBCurrency;
+export declare const getCurrencySymbol: (currency: AllCurrency) => CurrencySymbol;

package/dist/PricingSection/PricingCard/types.js

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
+export let Currency = /*#__PURE__*/function (Currency) {
+  Currency["Aud"] = "AUD";
+  Currency["Cad"] = "CAD";
+  Currency["Eur"] = "EUR";
+  Currency["Gbp"] = "GBP";
+  Currency["Inr"] = "INR";
+  Currency["Nok"] = "NOK";
+  Currency["Pln"] = "PLN";
+  Currency["Sek"] = "SEK";
+  Currency["Usd"] = "USD";
+  return Currency;
+}({});
+export let CFBCurrency = /*#__PURE__*/function (CFBCurrency) {
+  CFBCurrency["Dkk"] = "DKK";
+  CFBCurrency["Brl"] = "BRL";
+  CFBCurrency["Bgn"] = "BGN";
+  CFBCurrency["Chf"] = "CHF";
+  CFBCurrency["Czk"] = "CZK";
+  CFBCurrency["Hrk"] = "HRK";
+  CFBCurrency["Huf"] = "HUF";
+  CFBCurrency["Mxn"] = "MXN";
+  CFBCurrency["Ron"] = "RON";
+  return CFBCurrency;
+}({});
+export let CurrencySymbol = /*#__PURE__*/function (CurrencySymbol) {
+  CurrencySymbol["Dollar"] = "$";
+  CurrencySymbol["Pound"] = "\xA3";
+  CurrencySymbol["Euro"] = "\u20AC";
+  CurrencySymbol["Rupee"] = "\u20B9";
+  CurrencySymbol["Krona"] = "kr";
+  CurrencySymbol["Krone"] = "kr";
+  CurrencySymbol["ZLOTY"] = "z\u0142";
+  CurrencySymbol["Lev"] = "\u041B\u0432.";
+  CurrencySymbol["Real"] = "R$";
+  CurrencySymbol["Franc"] = "Fr.";
+  CurrencySymbol["Koruna"] = "K\u010D";
+  CurrencySymbol["Kuna"] = "kn";
+  CurrencySymbol["Forint"] = "Ft";
+  CurrencySymbol["Leu"] = "lei";
+  return CurrencySymbol;
+}({});
+const currencySymbols = {
+  [Currency.Usd]: CurrencySymbol.Dollar,
+  [Currency.Cad]: CurrencySymbol.Dollar,
+  [Currency.Aud]: CurrencySymbol.Dollar,
+  [Currency.Eur]: CurrencySymbol.Euro,
+  [Currency.Gbp]: CurrencySymbol.Pound,
+  [Currency.Inr]: CurrencySymbol.Rupee,
+  [Currency.Sek]: CurrencySymbol.Krona,
+  [Currency.Nok]: CurrencySymbol.Krone,
+  [Currency.Pln]: CurrencySymbol.ZLOTY,
+  [CFBCurrency.Bgn]: CurrencySymbol.Lev,
+  [CFBCurrency.Brl]: CurrencySymbol.Real,
+  [CFBCurrency.Chf]: CurrencySymbol.Franc,
+  [CFBCurrency.Czk]: CurrencySymbol.Koruna,
+  [CFBCurrency.Dkk]: CurrencySymbol.Krone,
+  [CFBCurrency.Hrk]: CurrencySymbol.Kuna,
+  [CFBCurrency.Huf]: CurrencySymbol.Forint,
+  [CFBCurrency.Mxn]: CurrencySymbol.Dollar,
+  [CFBCurrency.Ron]: CurrencySymbol.Leu
+};
+export const getCurrencySymbol = currency => currencySymbols[currency];

package/dist/PricingSection/ProductCTA.d.ts

@@ -0,0 +1,12 @@
+import { Product, ProductDetails, User } from './types';
+export declare const getCTATitle: (product: Product, isTrialPlan: boolean, isPlusUser?: boolean) => "" | "Request a demo" | "Try Teams for free" | "Purchase now" | "Sign up" | "Try Pro for free" | "Upgrade to Pro" | "Upgrade now" | "Try Plus for free" | "Your current plan";
+export declare const ProductCTA: ({ product, productDetails, user, simple, trackBusinessClick, }: {
+    product: Product;
+    productDetails: ProductDetails;
+    user: User;
+    simple?: boolean;
+    trackBusinessClick?: ({ target, context, }: {
+        target: string;
+        context: string;
+    }) => void;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/PricingSection/ProductCTA.js

@@ -0,0 +1,135 @@
+import { Box, FillButton, FlexBox, StrokeButton, Text } from '@codecademy/gamut';
+import { Product } from './types';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+export const getCTATitle = (product, isTrialPlan, isPlusUser) => {
+  switch (product) {
+    case Product.Teams:
+      if (isTrialPlan) {
+        return 'Try Teams for free';
+      }
+      return 'Purchase now';
+    case Product.Enterprise:
+      return 'Request a demo';
+    case Product.Basic:
+      return 'Sign up';
+    case Product.Pro:
+    case Product.Gold:
+      if (isTrialPlan) {
+        return 'Try Pro for free';
+      }
+      if (isPlusUser) return 'Upgrade to Pro';
+      return 'Upgrade now';
+    case Product.Silver:
+      if (isTrialPlan) {
+        return 'Try Plus for free';
+      }
+      if (isPlusUser) return 'Your current plan';
+      return 'Upgrade now';
+    default:
+      return '';
+  }
+};
+const getCTAUrl = ({
+  product,
+  productDetails,
+  userHasSilver
+}) => {
+  const planId = productDetails?.planId;
+  switch (product) {
+    case Product.Basic:
+      return '/register';
+    case Product.Pro:
+    case Product.Silver:
+    case Product.Gold:
+      if (userHasSilver) {
+        return '/account/billing?changePlan=true';
+      }
+      return `/checkout?plan_id=${planId || undefined}`;
+    case Product.Teams:
+      return '/business/checkout?plan_type=trial';
+    case Product.Enterprise:
+      return '/business/teams-quote';
+    default:
+      return '';
+  }
+};
+export const ProductCTA = ({
+  product,
+  productDetails,
+  user,
+  simple,
+  trackBusinessClick
+}) => {
+  const userHasBasic = !user.anonymous && (!user.proSilver || !user.proGold);
+  const userHasSilver = user.proSilver;
+  const isTeams = product === Product.Teams;
+  const isEnterprise = product === Product.Enterprise;
+  const shouldHideCTA = () => {
+    if (isTeams) return false;
+    if ((userHasBasic || userHasSilver) && product === Product.Basic) {
+      return true;
+    }
+    if (userHasSilver) return false;
+    if (user.proGold) return true;
+    return false;
+  };
+  const hideCTAButton = shouldHideCTA();
+  const ButtonComponent = product === Product.Gold || product === Product.Pro || product === Product.Teams ? FillButton : StrokeButton;
+  return hideCTAButton ? null : /*#__PURE__*/_jsxs(Box, {
+    pt: 0,
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center",
+    flexDirection: isTeams && !simple ? 'row' : 'column',
+    gap: 8,
+    children: [/*#__PURE__*/_jsx(ButtonComponent, {
+      mt: 8,
+      disabled: product === Product.Silver && userHasSilver,
+      href: getCTAUrl({
+        productDetails,
+        product,
+        userHasSilver
+      }),
+      onClick: () => {
+        if (trackBusinessClick) {
+          if (isTeams) {
+            trackBusinessClick({
+              target: 'business_trial',
+              context: 'top_card'
+            });
+          }
+          if (isEnterprise) {
+            trackBusinessClick({
+              target: 'business_enterprise',
+              context: 'top_card'
+            });
+          }
+        }
+      },
+      children: /*#__PURE__*/_jsx(Text, {
+        as: "span",
+        children: getCTATitle(product, !!productDetails?.isTrialPlan, userHasSilver)
+      })
+    }), isTeams ? /*#__PURE__*/_jsxs(_Fragment, {
+      children: [simple ? null : /*#__PURE__*/_jsx(Text, {
+        as: "span",
+        mt: 8,
+        children: ` or `
+      }), /*#__PURE__*/_jsx(FlexBox, {
+        mt: 8,
+        children: /*#__PURE__*/_jsx(StrokeButton, {
+          href: "/business/checkout?plan_type=directpurchase",
+          onClick: () => {
+            if (trackBusinessClick) {
+              trackBusinessClick({
+                target: 'business_purchase',
+                context: 'top_card'
+              });
+            }
+          },
+          children: "Purchase now"
+        })
+      })]
+    }) : null]
+  });
+};

package/dist/PricingSection/Products.d.ts

@@ -0,0 +1,15 @@
+import { PlansByType } from './config';
+import { AllCurrency } from './PricingCard/types';
+import { User } from './types';
+interface ProductsProps {
+    plansByType: PlansByType;
+    user: User;
+    isUserInIndia: boolean;
+    currency: AllCurrency;
+    trackBusinessClick: ({ target, context, }: {
+        target: string;
+        context: string;
+    }) => void;
+}
+export declare const Products: React.FC<ProductsProps>;
+export {};

package/dist/PricingSection/Products.js

@@ -0,0 +1,92 @@
+import { GridBox } from '@codecademy/gamut';
+import { getProductDetails } from './config';
+import { PricingCard } from './PricingCard';
+import { Product } from './types';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const Products = ({
+  plansByType,
+  user,
+  isUserInIndia,
+  currency,
+  trackBusinessClick
+}) => {
+  const productsLength = Object.keys(plansByType).length;
+  const renderCard = product => {
+    switch (product) {
+      case Product.Basic:
+        return /*#__PURE__*/_jsx(PricingCard, {
+          product: Product.Basic,
+          productDetails: getProductDetails(plansByType, product),
+          plansByType: plansByType,
+          isUserInIndia: isUserInIndia,
+          currency: currency,
+          user: user
+        }, product);
+      case Product.Silver:
+        return /*#__PURE__*/_jsx(PricingCard, {
+          product: Product.Silver,
+          productDetails: getProductDetails(plansByType, product),
+          plansByType: plansByType,
+          isUserInIndia: isUserInIndia,
+          currency: currency,
+          user: user
+        }, product);
+      case Product.Gold:
+        return /*#__PURE__*/_jsx(PricingCard, {
+          product: Product.Gold,
+          productDetails: getProductDetails(plansByType, product),
+          plansByType: plansByType,
+          isUserInIndia: isUserInIndia,
+          currency: currency,
+          user: user
+        }, product);
+      case Product.Teams:
+        return /*#__PURE__*/_jsx(PricingCard, {
+          product: Product.Teams,
+          productDetails: getProductDetails(plansByType, product),
+          plansByType: plansByType,
+          isUserInIndia: isUserInIndia,
+          currency: currency,
+          user: user,
+          trackBusinessClick: trackBusinessClick
+        }, product);
+      case Product.Enterprise:
+        return /*#__PURE__*/_jsx(PricingCard, {
+          product: Product.Enterprise,
+          productDetails: getProductDetails(plansByType, product),
+          plansByType: plansByType,
+          isUserInIndia: isUserInIndia,
+          currency: currency,
+          user: user,
+          trackBusinessClick: trackBusinessClick
+        }, product);
+      default:
+        return null;
+    }
+  };
+  return /*#__PURE__*/_jsx(GridBox, {
+    as: "ul",
+    pt: 16,
+    pb: 24,
+    px: 0,
+    mb: 0,
+    center: true,
+    fit: true,
+    gridAutoFlow: {
+      _: 'row',
+      md: 'column'
+    },
+    columnGap: 24,
+    rowGap: 24,
+    alignItems: {
+      _: 'unset',
+      md: 'stretch'
+    },
+    justifyItems: "center",
+    gridTemplateColumns: {
+      _: '1fr',
+      md: `repeat(${productsLength}, ${productsLength <= 2 ? 'max-content' : '1fr'})`
+    },
+    children: Object.keys(plansByType).map(renderCard)
+  });
+};

package/dist/PricingSection/config.d.ts

@@ -0,0 +1,8 @@
+import { Product, ProductDetails } from './types';
+type Period = 'annual' | 'monthly';
+type PlansByPeriod = Record<Period, ProductDetails>;
+export type PlansByType = Record<Product, PlansByPeriod>;
+export declare const getProductDescription: (product: Product) => "Start learning something new with basic access" | "Train your team with in-demand skills and flexible admin tools" | "Customizable training for your organization" | "Build in-demand technical skills for work or a personal project" | "Develop the skills and experience to land a job in tech";
+export declare const getProductDetails: (products: PlansByType, product: Product) => ProductDetails;
+export declare const groupPlansByType: (products: ProductDetails[]) => PlansByType;
+export {};