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

package/dist/DropdownButton/index.js

@@ -0,0 +1,169 @@
+import _styled from "@emotion/styled/base";
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import { FillButton, IconButton, Popover, StrokeButton, TextButton } from '@codecademy/gamut';
+import { ArrowChevronDownFilledIcon, MiniKebabMenuIcon } from '@codecademy/gamut-icons';
+import { css, pxRem, styledOptions } from '@codecademy/gamut-styles';
+import { forwardRef, useId, useImperativeHandle, useRef, useState } from 'react';
+import * as React from 'react';
+import { DropdownList } from './DropdownList';
+import { useDynamicPopoverPosition } from './useDynamicPopoverPosition';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const DownArrow = /*#__PURE__*/_styled(ArrowChevronDownFilledIcon, _extends({}, {
+  target: "e1mfstzo1",
+  label: "DownArrow"
+}, styledOptions))("margin-left:", pxRem(8), ";transition:transform 0.35s ease-out;", ({
+  isOpen
+}) => isOpen && 'transform: rotate(-180deg)', ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/DropdownButton/index.tsx"],"names":[],"mappings":"AA+BE","file":"../../src/DropdownButton/index.tsx","sourcesContent":["import {\n  ButtonProps,\n  FillButton,\n  IconButton,\n  Popover,\n  PopoverProps,\n  PopoverYPositionType,\n  StrokeButton,\n  TextButton,\n} from '@codecademy/gamut';\nimport {\n  ArrowChevronDownFilledIcon,\n  MiniKebabMenuIcon,\n} from '@codecademy/gamut-icons';\nimport { css, pxRem, styledOptions } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport {\n  forwardRef,\n  PropsWithChildren,\n  useId,\n  useImperativeHandle,\n  useRef,\n  useState,\n} from 'react';\nimport * as React from 'react';\n\nimport { DropdownList, DropdownListProps } from './DropdownList';\nimport { useDynamicPopoverPosition } from './useDynamicPopoverPosition';\n\nconst DownArrow = styled(ArrowChevronDownFilledIcon, styledOptions)<{\n  isOpen?: boolean;\n}>`\n  margin-left: ${pxRem(8)};\n  transition: transform 0.35s ease-out;\n  ${({ isOpen }) => isOpen && 'transform: rotate(-180deg)'};\n`;\n\nconst HorizontalKebabIcon = styled(MiniKebabMenuIcon)(\n  css({\n    transform: 'rotate(90deg)',\n  })\n);\n\nexport type DropdownButtonRefType = {\n  focus: HTMLButtonElement['focus'];\n};\n\nexport type DropdownButtonProps = PropsWithChildren<\n  {\n    align?: PopoverProps['align'];\n    buttonType?: 'fill' | 'stroke' | 'text' | 'kebab' | 'horizontalKebab';\n    defaultPosition?: PopoverYPositionType['position'];\n    dropdownItems: DropdownListProps['dropdownItems'];\n    horizontalOffset?: number;\n    /**\n     * Sets the size of the down arrow icon in the buttons that have text or the kebab and horizontal kebab icons.\n     */\n    iconSize?: number;\n    /**\n     * If the dropdown should semantically be a menu\n     */\n    isMenu?: boolean;\n    onClick?: (event: React.MouseEvent) => void;\n    tipProps?: React.ComponentProps<typeof IconButton>['tipProps'];\n    verticalOffset?: number;\n  } & ButtonProps\n>;\n\nexport const DropdownButton = forwardRef<\n  DropdownButtonRefType,\n  DropdownButtonProps\n>(\n  (\n    {\n      align = 'left',\n      buttonType = 'fill',\n      children,\n      defaultPosition = 'below',\n      dropdownItems,\n      horizontalOffset,\n      iconSize,\n      isMenu,\n      onClick,\n      tipProps,\n      verticalOffset = 0,\n      size,\n      variant = 'primary',\n      ...buttonStyleProps\n    },\n    ref\n  ) => {\n    const buttonId = useId();\n    const targetRef = useRef<HTMLAnchorElement | HTMLButtonElement>(null);\n    const { position, popoverContainerRefCallback } = useDynamicPopoverPosition(\n      {\n        targetRef,\n        verticalOffset,\n        defaultPosition,\n      }\n    );\n\n    const [isOpen, setIsOpen] = useState(false);\n\n    useImperativeHandle(ref, () => ({\n      focus: () => targetRef.current?.focus(),\n    }));\n\n    const handleClick = (event: React.MouseEvent) => {\n      if (!isOpen) {\n        onClick?.(event);\n      }\n      setIsOpen(!isOpen);\n    };\n    const handleRequestClosed = () => {\n      setIsOpen(false);\n    };\n\n    const textButtonDefaultSize = 'normal';\n    const iconButtonDefaultSize = 'small';\n\n    let clickTarget: React.ReactNode;\n    switch (buttonType) {\n      case 'fill':\n        clickTarget = (\n          <FillButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-fill-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={iconSize || 12} />\n          </FillButton>\n        );\n        break;\n      case 'stroke':\n        clickTarget = (\n          <StrokeButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-stroke-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={iconSize || 12} />\n          </StrokeButton>\n        );\n        break;\n      case 'text':\n        clickTarget = (\n          <TextButton\n            ref={targetRef}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-stroke-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={12} />\n          </TextButton>\n        );\n        break;\n      case 'kebab':\n        clickTarget = (\n          <IconButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            aria-haspopup=\"menu\"\n            id={buttonId}\n            icon={() => <MiniKebabMenuIcon size={iconSize} />}\n            size={size || iconButtonDefaultSize}\n            variant=\"secondary\"\n            onClick={handleClick}\n            data-testid=\"dropdown-kebab-button\"\n            tip=\"Show options\"\n            tipProps={tipProps}\n            {...(buttonStyleProps ?? {})}\n          />\n        );\n        break;\n      case 'horizontalKebab':\n        clickTarget = (\n          <IconButton\n            aria-label=\"Options\"\n            ref={targetRef}\n            aria-expanded={isOpen}\n            aria-haspopup=\"menu\"\n            id={buttonId}\n            icon={() => <HorizontalKebabIcon size={iconSize} />}\n            size={size || iconButtonDefaultSize}\n            variant=\"secondary\"\n            onClick={handleClick}\n            data-testid=\"dropdown-horizontal-kebab-button\"\n            tipProps={tipProps}\n            tip=\"Show more options\"\n            {...(buttonStyleProps ?? {})}\n          />\n        );\n    }\n\n    return (\n      <>\n        {clickTarget}\n        {dropdownItems.length !== 0 && (\n          <Popover\n            popoverContainerRef={popoverContainerRefCallback}\n            targetRef={targetRef}\n            isOpen={isOpen}\n            onRequestClose={handleRequestClosed}\n            align={align}\n            verticalOffset={verticalOffset}\n            horizontalOffset={horizontalOffset}\n            position={position}\n            outline\n          >\n            <DropdownList\n              dropdownItems={dropdownItems}\n              isMenu={isMenu}\n              menuButtonId={buttonId}\n              onClose={handleRequestClosed}\n            />\n          </Popover>\n        )}\n      </>\n    );\n  }\n);\n"]} */"));
+const HorizontalKebabIcon = /*#__PURE__*/_styled(MiniKebabMenuIcon, {
+  target: "e1mfstzo0",
+  label: "HorizontalKebabIcon"
+})(css({
+  transform: 'rotate(90deg)'
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/DropdownButton/index.tsx"],"names":[],"mappings":"AAqC4B","file":"../../src/DropdownButton/index.tsx","sourcesContent":["import {\n  ButtonProps,\n  FillButton,\n  IconButton,\n  Popover,\n  PopoverProps,\n  PopoverYPositionType,\n  StrokeButton,\n  TextButton,\n} from '@codecademy/gamut';\nimport {\n  ArrowChevronDownFilledIcon,\n  MiniKebabMenuIcon,\n} from '@codecademy/gamut-icons';\nimport { css, pxRem, styledOptions } from '@codecademy/gamut-styles';\nimport styled from '@emotion/styled';\nimport {\n  forwardRef,\n  PropsWithChildren,\n  useId,\n  useImperativeHandle,\n  useRef,\n  useState,\n} from 'react';\nimport * as React from 'react';\n\nimport { DropdownList, DropdownListProps } from './DropdownList';\nimport { useDynamicPopoverPosition } from './useDynamicPopoverPosition';\n\nconst DownArrow = styled(ArrowChevronDownFilledIcon, styledOptions)<{\n  isOpen?: boolean;\n}>`\n  margin-left: ${pxRem(8)};\n  transition: transform 0.35s ease-out;\n  ${({ isOpen }) => isOpen && 'transform: rotate(-180deg)'};\n`;\n\nconst HorizontalKebabIcon = styled(MiniKebabMenuIcon)(\n  css({\n    transform: 'rotate(90deg)',\n  })\n);\n\nexport type DropdownButtonRefType = {\n  focus: HTMLButtonElement['focus'];\n};\n\nexport type DropdownButtonProps = PropsWithChildren<\n  {\n    align?: PopoverProps['align'];\n    buttonType?: 'fill' | 'stroke' | 'text' | 'kebab' | 'horizontalKebab';\n    defaultPosition?: PopoverYPositionType['position'];\n    dropdownItems: DropdownListProps['dropdownItems'];\n    horizontalOffset?: number;\n    /**\n     * Sets the size of the down arrow icon in the buttons that have text or the kebab and horizontal kebab icons.\n     */\n    iconSize?: number;\n    /**\n     * If the dropdown should semantically be a menu\n     */\n    isMenu?: boolean;\n    onClick?: (event: React.MouseEvent) => void;\n    tipProps?: React.ComponentProps<typeof IconButton>['tipProps'];\n    verticalOffset?: number;\n  } & ButtonProps\n>;\n\nexport const DropdownButton = forwardRef<\n  DropdownButtonRefType,\n  DropdownButtonProps\n>(\n  (\n    {\n      align = 'left',\n      buttonType = 'fill',\n      children,\n      defaultPosition = 'below',\n      dropdownItems,\n      horizontalOffset,\n      iconSize,\n      isMenu,\n      onClick,\n      tipProps,\n      verticalOffset = 0,\n      size,\n      variant = 'primary',\n      ...buttonStyleProps\n    },\n    ref\n  ) => {\n    const buttonId = useId();\n    const targetRef = useRef<HTMLAnchorElement | HTMLButtonElement>(null);\n    const { position, popoverContainerRefCallback } = useDynamicPopoverPosition(\n      {\n        targetRef,\n        verticalOffset,\n        defaultPosition,\n      }\n    );\n\n    const [isOpen, setIsOpen] = useState(false);\n\n    useImperativeHandle(ref, () => ({\n      focus: () => targetRef.current?.focus(),\n    }));\n\n    const handleClick = (event: React.MouseEvent) => {\n      if (!isOpen) {\n        onClick?.(event);\n      }\n      setIsOpen(!isOpen);\n    };\n    const handleRequestClosed = () => {\n      setIsOpen(false);\n    };\n\n    const textButtonDefaultSize = 'normal';\n    const iconButtonDefaultSize = 'small';\n\n    let clickTarget: React.ReactNode;\n    switch (buttonType) {\n      case 'fill':\n        clickTarget = (\n          <FillButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-fill-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={iconSize || 12} />\n          </FillButton>\n        );\n        break;\n      case 'stroke':\n        clickTarget = (\n          <StrokeButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-stroke-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={iconSize || 12} />\n          </StrokeButton>\n        );\n        break;\n      case 'text':\n        clickTarget = (\n          <TextButton\n            ref={targetRef}\n            id={buttonId}\n            onClick={handleClick}\n            data-testid=\"dropdown-stroke-button\"\n            size={size || textButtonDefaultSize}\n            variant={variant}\n            {...(buttonStyleProps ?? {})}\n          >\n            {children}\n            <DownArrow isOpen={isOpen} size={12} />\n          </TextButton>\n        );\n        break;\n      case 'kebab':\n        clickTarget = (\n          <IconButton\n            ref={targetRef}\n            aria-expanded={isOpen}\n            aria-haspopup=\"menu\"\n            id={buttonId}\n            icon={() => <MiniKebabMenuIcon size={iconSize} />}\n            size={size || iconButtonDefaultSize}\n            variant=\"secondary\"\n            onClick={handleClick}\n            data-testid=\"dropdown-kebab-button\"\n            tip=\"Show options\"\n            tipProps={tipProps}\n            {...(buttonStyleProps ?? {})}\n          />\n        );\n        break;\n      case 'horizontalKebab':\n        clickTarget = (\n          <IconButton\n            aria-label=\"Options\"\n            ref={targetRef}\n            aria-expanded={isOpen}\n            aria-haspopup=\"menu\"\n            id={buttonId}\n            icon={() => <HorizontalKebabIcon size={iconSize} />}\n            size={size || iconButtonDefaultSize}\n            variant=\"secondary\"\n            onClick={handleClick}\n            data-testid=\"dropdown-horizontal-kebab-button\"\n            tipProps={tipProps}\n            tip=\"Show more options\"\n            {...(buttonStyleProps ?? {})}\n          />\n        );\n    }\n\n    return (\n      <>\n        {clickTarget}\n        {dropdownItems.length !== 0 && (\n          <Popover\n            popoverContainerRef={popoverContainerRefCallback}\n            targetRef={targetRef}\n            isOpen={isOpen}\n            onRequestClose={handleRequestClosed}\n            align={align}\n            verticalOffset={verticalOffset}\n            horizontalOffset={horizontalOffset}\n            position={position}\n            outline\n          >\n            <DropdownList\n              dropdownItems={dropdownItems}\n              isMenu={isMenu}\n              menuButtonId={buttonId}\n              onClose={handleRequestClosed}\n            />\n          </Popover>\n        )}\n      </>\n    );\n  }\n);\n"]} */");
+export const DropdownButton = /*#__PURE__*/forwardRef(({
+  align = 'left',
+  buttonType = 'fill',
+  children,
+  defaultPosition = 'below',
+  dropdownItems,
+  horizontalOffset,
+  iconSize,
+  isMenu,
+  onClick,
+  tipProps,
+  verticalOffset = 0,
+  size,
+  variant = 'primary',
+  ...buttonStyleProps
+}, ref) => {
+  const buttonId = useId();
+  const targetRef = useRef(null);
+  const {
+    position,
+    popoverContainerRefCallback
+  } = useDynamicPopoverPosition({
+    targetRef,
+    verticalOffset,
+    defaultPosition
+  });
+  const [isOpen, setIsOpen] = useState(false);
+  useImperativeHandle(ref, () => ({
+    focus: () => targetRef.current?.focus()
+  }));
+  const handleClick = event => {
+    if (!isOpen) {
+      onClick?.(event);
+    }
+    setIsOpen(!isOpen);
+  };
+  const handleRequestClosed = () => {
+    setIsOpen(false);
+  };
+  const textButtonDefaultSize = 'normal';
+  const iconButtonDefaultSize = 'small';
+  let clickTarget;
+  switch (buttonType) {
+    case 'fill':
+      clickTarget = /*#__PURE__*/_jsxs(FillButton, {
+        ref: targetRef,
+        "aria-expanded": isOpen,
+        id: buttonId,
+        onClick: handleClick,
+        "data-testid": "dropdown-fill-button",
+        size: size || textButtonDefaultSize,
+        variant: variant,
+        ...(buttonStyleProps ?? {}),
+        children: [children, /*#__PURE__*/_jsx(DownArrow, {
+          isOpen: isOpen,
+          size: iconSize || 12
+        })]
+      });
+      break;
+    case 'stroke':
+      clickTarget = /*#__PURE__*/_jsxs(StrokeButton, {
+        ref: targetRef,
+        "aria-expanded": isOpen,
+        id: buttonId,
+        onClick: handleClick,
+        "data-testid": "dropdown-stroke-button",
+        size: size || textButtonDefaultSize,
+        variant: variant,
+        ...(buttonStyleProps ?? {}),
+        children: [children, /*#__PURE__*/_jsx(DownArrow, {
+          isOpen: isOpen,
+          size: iconSize || 12
+        })]
+      });
+      break;
+    case 'text':
+      clickTarget = /*#__PURE__*/_jsxs(TextButton, {
+        ref: targetRef,
+        id: buttonId,
+        onClick: handleClick,
+        "data-testid": "dropdown-stroke-button",
+        size: size || textButtonDefaultSize,
+        variant: variant,
+        ...(buttonStyleProps ?? {}),
+        children: [children, /*#__PURE__*/_jsx(DownArrow, {
+          isOpen: isOpen,
+          size: 12
+        })]
+      });
+      break;
+    case 'kebab':
+      clickTarget = /*#__PURE__*/_jsx(IconButton, {
+        ref: targetRef,
+        "aria-expanded": isOpen,
+        "aria-haspopup": "menu",
+        id: buttonId,
+        icon: () => /*#__PURE__*/_jsx(MiniKebabMenuIcon, {
+          size: iconSize
+        }),
+        size: size || iconButtonDefaultSize,
+        variant: "secondary",
+        onClick: handleClick,
+        "data-testid": "dropdown-kebab-button",
+        tip: "Show options",
+        tipProps: tipProps,
+        ...(buttonStyleProps ?? {})
+      });
+      break;
+    case 'horizontalKebab':
+      clickTarget = /*#__PURE__*/_jsx(IconButton, {
+        "aria-label": "Options",
+        ref: targetRef,
+        "aria-expanded": isOpen,
+        "aria-haspopup": "menu",
+        id: buttonId,
+        icon: () => /*#__PURE__*/_jsx(HorizontalKebabIcon, {
+          size: iconSize
+        }),
+        size: size || iconButtonDefaultSize,
+        variant: "secondary",
+        onClick: handleClick,
+        "data-testid": "dropdown-horizontal-kebab-button",
+        tipProps: tipProps,
+        tip: "Show more options",
+        ...(buttonStyleProps ?? {})
+      });
+  }
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [clickTarget, dropdownItems.length !== 0 && /*#__PURE__*/_jsx(Popover, {
+      popoverContainerRef: popoverContainerRefCallback,
+      targetRef: targetRef,
+      isOpen: isOpen,
+      onRequestClose: handleRequestClosed,
+      align: align,
+      verticalOffset: verticalOffset,
+      horizontalOffset: horizontalOffset,
+      position: position,
+      outline: true,
+      children: /*#__PURE__*/_jsx(DropdownList, {
+        dropdownItems: dropdownItems,
+        isMenu: isMenu,
+        menuButtonId: buttonId,
+        onClose: handleRequestClosed
+      })
+    })]
+  });
+});

package/dist/DropdownButton/useDynamicPopoverPosition.d.ts

@@ -0,0 +1,14 @@
+import { PopoverYPositionType } from '@codecademy/gamut';
+import { RefCallback, RefObject } from 'react';
+type Position = Required<PopoverYPositionType>['position'];
+export type UseDynamicPopoverPositionProps = {
+    targetRef: RefObject<HTMLElement>;
+    verticalOffset: number;
+    defaultPosition: Position;
+};
+export type UseDynamicPopoverPositionReturn = {
+    position: Position;
+    popoverContainerRefCallback: RefCallback<HTMLElement | null>;
+};
+export declare const useDynamicPopoverPosition: ({ targetRef, verticalOffset, defaultPosition, }: UseDynamicPopoverPositionProps) => UseDynamicPopoverPositionReturn;
+export {};

package/dist/DropdownButton/useDynamicPopoverPosition.js

@@ -0,0 +1,55 @@
+import { useCallback, useState } from 'react';
+import { useWindowScroll, useWindowSize } from 'react-use';
+
+// space between target and edge of window
+
+const getClearance = (targetEl, winHeight) => {
+  const {
+    top,
+    bottom
+  } = targetEl.getBoundingClientRect();
+  return {
+    above: top,
+    below: winHeight - bottom
+  };
+};
+const getClearanceNeeded = (popoverContainerEl, verticalOffset) => {
+  const {
+    height
+  } = popoverContainerEl.getBoundingClientRect();
+  return verticalOffset + height;
+};
+export const useDynamicPopoverPosition = ({
+  targetRef,
+  verticalOffset,
+  defaultPosition
+}) => {
+  const [popoverContainerEl, setPopoverContainerEl] = useState(null);
+
+  // called when the popover container is renderd or removed
+  const popoverContainerRefCallback = useCallback(instance => {
+    setPopoverContainerEl(instance);
+  }, []);
+  const {
+    height: winHeight
+  } = useWindowSize(); // re-calc on window resize
+  useWindowScroll(); // re-calc on scroll
+
+  if (targetRef?.current && popoverContainerEl) {
+    const clearance = getClearance(targetRef.current, winHeight);
+    const clearanceNeeded = getClearanceNeeded(popoverContainerEl, verticalOffset);
+    const clearedAbove = clearance.above >= clearanceNeeded;
+    const clearedBelow = clearance.below >= clearanceNeeded;
+    const verticallyCentered = clearance.above === clearance.below;
+    if (!verticallyCentered && (!clearedAbove || !clearedBelow)) {
+      return {
+        position: clearance.above > clearance.below ? 'above' : 'below',
+        popoverContainerRefCallback
+      };
+    }
+  }
+  return {
+    position: defaultPosition,
+    popoverContainerRefCallback
+  };
+};

package/dist/DropdownButton/useDynamicPopoverPosition.test.js

@@ -0,0 +1,85 @@
+import { act, renderHook } from '@testing-library/react';
+import { useDynamicPopoverPosition } from './useDynamicPopoverPosition';
+const WINDOW_HEIGHT = 1000;
+jest.mock('react-use', () => ({
+  useWindowSize: () => ({
+    height: WINDOW_HEIGHT
+  }),
+  useWindowScroll: () => ({
+    y: 0
+  })
+}));
+const testCases = [{
+  scenario: {
+    defaultPosition: 'below',
+    targetBox: {
+      top: 550,
+      bottom: 600,
+      height: 50
+    },
+    popoverContainerHeight: 200
+  },
+  expectation: {
+    position: 'below',
+    because: 'there is plenty of room for the popover beneath the target'
+  }
+}, {
+  scenario: {
+    defaultPosition: 'below',
+    targetBox: {
+      top: 850,
+      bottom: 900,
+      height: 50
+    },
+    popoverContainerHeight: 200
+  },
+  expectation: {
+    position: 'above',
+    because: 'the target is near the bottom of the window'
+  }
+}, {
+  scenario: {
+    defaultPosition: 'below',
+    targetBox: {
+      top: 550,
+      bottom: 600,
+      height: 50
+    },
+    popoverContainerHeight: 500
+  },
+  expectation: {
+    position: 'above',
+    because: 'the popover is too tall to fit beneath the target'
+  }
+}];
+describe('useDynamicPopoverPosition', () => {
+  test.each(testCases)(`for default position: $scenario.defaultPosition, with target: $scenario.targetBox, popover container height: $scenario.popoverContainerHeight, and window height: ${WINDOW_HEIGHT},
+    position should be: "$expectation.position" because $expectation.because`, async ({
+    scenario,
+    expectation
+  }) => {
+    const {
+      defaultPosition,
+      targetBox,
+      popoverContainerHeight
+    } = scenario;
+    const targetRef = {
+      current: {
+        getBoundingClientRect: () => targetBox
+      }
+    };
+    const {
+      result
+    } = renderHook(() => useDynamicPopoverPosition({
+      targetRef,
+      verticalOffset: 0,
+      defaultPosition
+    }));
+    await act(() => result.current.popoverContainerRefCallback({
+      getBoundingClientRect: () => ({
+        height: popoverContainerHeight
+      })
+    }));
+    expect(result.current.position).toEqual(expectation.position);
+  });
+});

package/dist/EmptySection/index.d.ts

@@ -0,0 +1,28 @@
+import { ButtonProps } from '@codecademy/gamut';
+import { IllustrationProps } from '@codecademy/gamut-illustrations';
+import * as React from 'react';
+import { DropdownButtonProps } from '..';
+export type EmptySectionProps = {
+    /**
+     * Paragraph text that displays beneath the heading text
+     */
+    bodyText?: string;
+    /**
+     * Button or dropdown button with an action for the user to take
+     */
+    children?: React.ReactElement<ButtonProps | DropdownButtonProps>;
+    /**
+     * The larger heading text that appears over the body text
+     */
+    headingText: string;
+    illustration: React.ComponentType<IllustrationProps>;
+    /**
+     * Whether the illustration appears to the left or right of the rest of the section's content
+     */
+    illustrationPosition?: 'left' | 'right';
+    /**
+     * Whether the pattern background stretches to the end of the left or right of the viewport
+     */
+    stretchDirection: 'left' | 'right' | 'none';
+};
+export declare const EmptySection: React.FC<EmptySectionProps>;

package/dist/EmptySection/index.js

@@ -0,0 +1,183 @@
+import _styled from "@emotion/styled/base";
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import { FlexBox, Text } from '@codecademy/gamut';
+import { DotLoose } from '@codecademy/gamut-patterns';
+import { pxRem, styledOptions, variant } from '@codecademy/gamut-styles';
+import * as React from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const EmptyContainer = /*#__PURE__*/_styled(FlexBox, {
+  target: "eysqnl62",
+  label: "EmptyContainer"
+})(variant({
+  prop: 'stretchDirection',
+  defaultVariant: 'left',
+  base: {
+    justifySelf: 'center',
+    position: 'relative',
+    px: 32,
+    py: {
+      _: 64,
+      lg: 96
+    },
+    width: 1
+  },
+  variants: {
+    left: {
+      pl: {
+        sm: 0
+      },
+      pr: {
+        sm: 64,
+        lg: 96
+      }
+    },
+    right: {
+      pr: {
+        sm: 0
+      },
+      pl: {
+        sm: 64,
+        lg: 96
+      }
+    },
+    none: {}
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const Dots = /*#__PURE__*/_styled(DotLoose, {
+  target: "eysqnl61",
+  label: "Dots"
+})(variant({
+  prop: 'stretchDirection',
+  defaultVariant: 'left',
+  base: {
+    position: 'absolute',
+    top: 0,
+    bottom: 0,
+    left: -16
+  },
+  variants: {
+    left: {
+      left: {
+        xs: -32,
+        sm: -64,
+        lg: -96,
+        xl: 'calc((1248px - 100vw) / 2)'
+      },
+      width: {
+        _: '100vw',
+        xs: 'calc(100vw - 32px)',
+        sm: 'calc(100vw - 64px)',
+        lg: 'calc(100vw - 96px)',
+        xl: 'calc(1248px + ((100vw - 1248px) / 2))'
+      }
+    },
+    right: {
+      left: {
+        xs: 0
+      },
+      width: {
+        _: '100vw',
+        xs: 'calc(100vw - 32px)',
+        sm: 'calc(100vw - 64px)',
+        lg: 'calc(100vw - 96px)',
+        xl: 'calc(1248px + ((100vw - 1248px) / 2))'
+      }
+    },
+    none: {
+      left: 0,
+      width: '100%'
+    }
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const illustrationPositionVariants = variant({
+  prop: 'illustrationPosition',
+  defaultVariant: 'right',
+  base: {
+    mx: {
+      _: 'auto',
+      sm: 0
+    },
+    mb: {
+      _: 32,
+      sm: 0
+    }
+  },
+  variants: {
+    left: {
+      mr: {
+        sm: 48
+      }
+    },
+    right: {
+      ml: {
+        sm: 48
+      }
+    }
+  }
+});
+const IllustrationContainer = /*#__PURE__*/_styled('div', _extends({}, {
+  target: "eysqnl60",
+  label: "IllustrationContainer"
+}, styledOptions))(illustrationPositionVariants, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+export const EmptySection = ({
+  bodyText,
+  children,
+  headingText,
+  illustration: Illustration,
+  stretchDirection,
+  illustrationPosition = stretchDirection === 'right' ? 'left' : 'right'
+}) => {
+  const flexDirection = illustrationPosition === 'right' ? 'row-reverse' : 'row';
+  return /*#__PURE__*/_jsxs(EmptyContainer, {
+    stretchDirection: stretchDirection,
+    children: [/*#__PURE__*/_jsx(Dots, {
+      stretchDirection: stretchDirection
+    }), /*#__PURE__*/_jsxs(FlexBox, {
+      maxWidth: "822px",
+      flexBasis: "100%",
+      position: "relative",
+      bg: "background-current",
+      py: 48,
+      px: {
+        _: 16,
+        sm: 48,
+        md: 64
+      },
+      zIndex: 1,
+      flexDirection: {
+        _: 'column',
+        sm: flexDirection
+      },
+      justifyContent: {
+        _: 'space-around',
+        md: 'space-between'
+      },
+      alignItems: "center",
+      textAlign: {
+        _: 'center',
+        sm: 'start'
+      },
+      children: [/*#__PURE__*/_jsx(IllustrationContainer, {
+        illustrationPosition: illustrationPosition,
+        children: /*#__PURE__*/_jsx(Illustration, {
+          width: pxRem(100)
+        })
+      }), /*#__PURE__*/_jsxs(FlexBox, {
+        flexDirection: "column",
+        alignItems: {
+          _: 'center',
+          sm: 'start'
+        },
+        children: [/*#__PURE__*/_jsx(Text, {
+          as: "h2",
+          fontSize: 22,
+          mb: 8,
+          children: headingText
+        }), bodyText && /*#__PURE__*/_jsx(Text, {
+          mb: 32,
+          children: bodyText
+        }), children]
+      })]
+    })]
+  });
+};

package/dist/ErrorContents/index.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type ErrorContentsProps = {
+    /**
+     * Any debug info to display, such as ["User ID", <user-id>].
+     */
+    supportInformation?: [string, string][];
+};
+export declare const ErrorContents: React.FC<ErrorContentsProps>;

package/dist/ErrorContents/index.js

@@ -0,0 +1,48 @@
+import { Anchor, Box, Text } from '@codecademy/gamut';
+import * as React from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const ErrorContents = ({
+  supportInformation
+}) => /*#__PURE__*/_jsxs(Box, {
+  maxWidth: "40rem",
+  my: 96,
+  mx: "auto",
+  as: "main",
+  children: [/*#__PURE__*/_jsx(Text, {
+    as: "h1",
+    fontSize: 44,
+    children: "Something has gone wrong"
+  }), /*#__PURE__*/_jsx(Text, {
+    as: "p",
+    my: 16,
+    children: "We're sorry, and our best are working to fix this. In the meantime, have you tried the following?"
+  }), /*#__PURE__*/_jsxs(Box, {
+    as: "ul",
+    children: [/*#__PURE__*/_jsx("li", {
+      children: "Refreshing this page."
+    }), /*#__PURE__*/_jsx("li", {
+      children: "Clearing your browser cache."
+    })]
+  }), /*#__PURE__*/_jsxs(Text, {
+    as: "p",
+    children: ["If that doesn't help, please let us know on our", ' ', /*#__PURE__*/_jsx(Anchor, {
+      href: "https://help.codecademy.com/hc/en-us",
+      children: "Help Center"
+    }), "!"]
+  }), supportInformation && /*#__PURE__*/_jsxs(Box, {
+    as: "details",
+    fontSize: 16,
+    textColor: "gray-900",
+    children: [/*#__PURE__*/_jsx(Box, {
+      as: "summary",
+      mt: 48,
+      mb: 8,
+      children: "Support information"
+    }), supportInformation.map(([key, value]) => /*#__PURE__*/_jsxs(Text, {
+      as: "code",
+      display: "block",
+      fontSize: "small",
+      children: [key, ": ", value]
+    }, key))]
+  })]
+});