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

package/dist/GlobalHeader/types.d.ts

@@ -0,0 +1,120 @@
+import { WithChildrenProp } from '@codecademy/gamut';
+import { ReactNode } from 'react';
+import { AppHeaderAction, AppHeaderClickHandler, AppHeaderItemWithHref, AppHeaderSearch } from '..';
+import { CourseDifficulty } from '../ContentGroupBaseCard/types';
+import { AppHeaderNotificationSettings } from '../Notifications/types';
+type RenderProfile = {
+    desktop: () => ReactNode;
+    mobile: () => ReactNode;
+};
+export type NavigationMenuFormattedLabel = Record<'openMenuTip' | 'closeMenuTip' | 'siteNavigation', string>;
+export type ResourceDropdownFormattedLabel = {
+    title?: string;
+    workspaces?: string;
+    docs?: string;
+    articles?: string;
+};
+type localizedLabels = {
+    enterpriseFormattedHomeLabel?: string;
+    resourcesDropdown?: ResourceDropdownFormattedLabel;
+    navigationMenuFormattedLabel?: NavigationMenuFormattedLabel;
+};
+interface BaseHeader extends WithChildrenProp, AppHeaderAction {
+    /** A method to be called on click/activating a header item */
+    action: AppHeaderClickHandler;
+    /** A method to be called only on click/activating a *link* header item */
+    onLinkAction?: AppHeaderClickHandler<AppHeaderItemWithHref>;
+    className?: string;
+    hidePricing?: boolean;
+    hideHeaderLinksInChromeless?: boolean;
+    hideHeaderResourcesDropdown?: boolean;
+    hideEnterpriseHeader?: boolean;
+    localizedLabels?: localizedLabels;
+    search: AppHeaderSearch;
+    isInRevampedBlpExperimentVariant?: boolean;
+    dynamicData?: GlobalHeaderDynamicData | null;
+    dynamicDataLoading?: boolean;
+}
+export type User = {
+    avatar: string;
+    displayName: string;
+    enterpriseUrl?: string;
+    isAdmin?: boolean;
+    isBusinessAdmin?: boolean;
+    isBusinessSsoUser?: boolean;
+    isCoach?: boolean;
+    isCustomerSupport?: boolean;
+    isAccountManager?: boolean;
+    isPaused?: boolean;
+    isPlusUser?: boolean;
+    isBusinessUser?: boolean;
+    inBusinessTrial?: boolean;
+    isSkillsoftUser?: boolean;
+    hasBusinessSubscription?: boolean;
+    hasCoachingSubscription?: boolean;
+    proCheckoutUrl?: string;
+    showProUpgrade?: boolean;
+    hideCareerPaths?: boolean;
+    enrolledInTwoOrMoreContainers?: boolean;
+};
+type LoggedInHeader = BaseHeader & {
+    notifications: AppHeaderNotificationSettings;
+    renderProfile?: RenderProfile;
+    user: User;
+};
+export type AnonHeaderVariant = 'landing' | 'login' | 'signup';
+export type AnonHeader = BaseHeader & {
+    redirectParam?: string;
+    type: 'anon';
+    variant?: AnonHeaderVariant;
+    user?: User;
+};
+export type FreeHeader = LoggedInHeader & {
+    type: 'free';
+};
+export type ProHeader = LoggedInHeader & {
+    type: 'pro';
+};
+export type TeamsHeader = LoggedInHeader & {
+    type: 'teams';
+};
+export type EnterpriseHeader = BaseHeader & {
+    type: 'enterprise';
+    user: User;
+};
+export type LoadingHeader = BaseHeader & {
+    type: 'loading';
+};
+export type SimpleHeader = BaseHeader & {
+    type: 'simple';
+};
+export type SimpleBootcampHeader = BaseHeader & {
+    type: 'bootcamp';
+    bootcampSlug: string;
+};
+export type PromotedPath = {
+    title: string;
+    urlPath: string;
+    difficulty: CourseDifficulty | null;
+    durationHours: number | null;
+};
+export type GlobalHeaderDynamicData = {
+    catalogDropdown: {
+        banner: {
+            text: string;
+            href: string;
+        };
+        skillPaths: {
+            totalSkillPathCount: number;
+            promotedSkillPaths: PromotedPath[];
+        };
+        careerPaths: {
+            totalCareerPathCount: number;
+            promotedCareerPaths: PromotedPath[];
+        };
+        certificationPaths: {
+            totalCertificationPathCount: number;
+        };
+    };
+};
+export {};

package/dist/GlobalHeader/types.js

@@ -0,0 +1 @@
+export {};

package/dist/GlobalHeader/urlHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const formatUrlWithRedirect: (url: string, redirectUrl?: string) => string;
+export declare const formatEnterpriseUrl: (url?: string) => string | undefined;

package/dist/GlobalHeader/urlHelpers.js

@@ -0,0 +1,21 @@
+export const formatUrlWithRedirect = (url, redirectUrl) => {
+  if (!redirectUrl) {
+    return url;
+  }
+  const base = window.location.origin;
+  const uri = new URL(url, base);
+  const redirectUri = new URL(redirectUrl);
+  const redirectParam = redirectUri.searchParams.get('redirect');
+  if (redirectParam) {
+    uri.searchParams.append('redirect', redirectParam);
+  } else {
+    uri.searchParams.append('redirect', redirectUri.toString());
+  }
+  return uri.toString();
+};
+export const formatEnterpriseUrl = url => {
+  if (!url) return undefined;
+  const protocol = 'https://';
+  if (url.includes(protocol)) return url;
+  return new URL(protocol + url).toString();
+};

package/dist/GlobalPage/index.d.ts

@@ -0,0 +1,48 @@
+import { ModalProps, WithChildrenProp } from '@codecademy/gamut';
+import * as React from 'react';
+import { EnhancedBannerProps } from '../Banner/EnhancedBanner';
+import { GlobalFooterProps } from '../GlobalFooter';
+import { GlobalHeaderProps } from '../GlobalHeader';
+type ErrorContext = {
+    message?: string;
+    [k: string]: any;
+};
+type LogErrorContextType = {
+    logError?: (error: unknown, context?: ErrorContext | string) => void;
+};
+export declare const LogErrorContext: React.Context<LogErrorContextType>;
+export type GlobalPageBackgroundColor = 'beige' | 'background' | 'background-contrast' | 'navy' | 'paleBlue' | 'paleGreen' | 'palePink' | 'paleYellow' | 'white';
+export interface GlobalPageProps extends WithChildrenProp {
+    backgroundColor?: GlobalPageBackgroundColor;
+    /**
+     * Props directly passed to the Banner.
+     */
+    banner?: EnhancedBannerProps;
+    /**
+     * Element type to render around the children.
+     */
+    contentAs?: 'div' | 'main';
+    /**
+     * Props directly passed to the GlobalFooter.
+     */
+    footer?: GlobalFooterProps;
+    /**
+     * Props directly passed to the GlobalHeader.
+     */
+    header: GlobalHeaderProps;
+    /**
+     * Props directly passed to the Modal.
+     */
+    modal?: ModalProps;
+    /**
+     * Custom element ID to link to by the SkipToContent control, if not a default one at the beginning of the page.
+     */
+    skipToContentId?: string;
+    /**
+     * Temporary function called with error and context when an error occurs to
+     * help with debugging.
+     */
+    onError?: (error: unknown, context?: ErrorContext | string) => void;
+}
+export declare const GlobalPage: React.FC<GlobalPageProps>;
+export {};

package/dist/GlobalPage/index.js

@@ -0,0 +1,60 @@
+import { AppWrapper, Modal, SkipToContent, SkipToContentTarget } from '@codecademy/gamut';
+import { Background } from '@codecademy/gamut-styles';
+import { forwardRef } from 'react';
+import * as React from 'react';
+import { EnhancedBanner } from '../Banner/EnhancedBanner';
+import { GlobalFooter } from '../GlobalFooter';
+import { GlobalHeader } from '../GlobalHeader';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const LogErrorContext = /*#__PURE__*/React.createContext({});
+const defaultSkipToContentId = 'page-skip-to-content-target';
+const RestrictedBackground = /*#__PURE__*/forwardRef(({
+  children,
+  ...rest
+}, ref) => /*#__PURE__*/_jsx(Background, {
+  "data-testid": "global-page-wrapper",
+  ...rest,
+  ref: ref,
+  children: children
+}));
+const GlobalPageWrapper = AppWrapper.withComponent(RestrictedBackground, {
+  target: "e8ekv6f0",
+  label: "GlobalPageWrapper"
+});
+export const GlobalPage = ({
+  backgroundColor = 'background',
+  banner,
+  children,
+  contentAs = 'div',
+  footer,
+  header,
+  modal,
+  skipToContentId,
+  onError
+}) => {
+  return /*#__PURE__*/_jsxs(GlobalPageWrapper, {
+    bg: backgroundColor,
+    minHeight: "100vh",
+    children: [/*#__PURE__*/_jsx(SkipToContent, {
+      contentId: skipToContentId || defaultSkipToContentId
+    }), banner && /*#__PURE__*/_jsx(EnhancedBanner, {
+      ...banner
+    }), /*#__PURE__*/_jsx(LogErrorContext.Provider, {
+      value: {
+        logError: onError
+      },
+      children: !header.hideEnterpriseHeader && /*#__PURE__*/_jsx(GlobalHeader, {
+        ...header
+      })
+    }), !skipToContentId && /*#__PURE__*/_jsx(SkipToContentTarget, {
+      id: defaultSkipToContentId
+    }), /*#__PURE__*/_jsx(AppWrapper, {
+      as: contentAs,
+      children: children
+    }), footer && /*#__PURE__*/_jsx(GlobalFooter, {
+      ...footer
+    }), modal && /*#__PURE__*/_jsx(Modal, {
+      ...modal
+    })]
+  });
+};

package/dist/Grid/GridCollapse.d.ts

@@ -0,0 +1,41 @@
+import { Box, GridBox } from '@codecademy/gamut';
+import { MediaQueryMap } from '@codecademy/variance';
+import React, { ComponentProps } from 'react';
+import { ColumnCount } from './getCSSFromColumnCount';
+export declare const getMediaQuery: ({ css, start, end, }: {
+    css: string;
+    start: string;
+    end?: string;
+}) => string;
+export type GridCollapseProps = ComponentProps<typeof GridBox> & {
+    /**
+     * the number of columns per row in the grid
+     */
+    columnCount: ColumnCount;
+    /**
+     * the number of items to display when collapsed
+     */
+    initialMaxShown: MediaQueryMap<number>;
+    /**
+     * the number of new items to display on each "expand" click; if not provided, a binary toggle is used
+     * note: must include exactly the same keys as initialMaxShown
+     */
+    pageSize?: MediaQueryMap<number>;
+    /**
+     * text to display when "show more" is available
+     */
+    expandLabel?: string;
+    /**
+     * text to display when "show fewer" is available
+     */
+    collapseLabel?: string;
+    /**
+     * called when clicking the show more/see less toggle; accepts the current expanded state as an arg
+     */
+    onExpandClick?: (expanded?: boolean) => void;
+    /**
+     * props to pass to the expand/collapse container (useful for changing the margin between the grid and controls)
+     */
+    expandCollapseProps?: ComponentProps<typeof Box>;
+};
+export declare const GridCollapse: React.FC<GridCollapseProps>;

package/dist/Grid/GridCollapse.js

@@ -0,0 +1,199 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Anchor, Box, FlexBox, GridBox } from '@codecademy/gamut';
+import { ArrowChevronDownIcon, ArrowChevronUpIcon } from '@codecademy/gamut-icons';
+import { breakpoints } from '@codecademy/gamut-styles';
+import React, { useState } from 'react';
+import { getCSSFromColumnCount } from './getCSSFromColumnCount';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+function ExpandCollapseDefaults({
+  variant = 'standard',
+  ...props
+}) {
+  return /*#__PURE__*/_jsx(Anchor, {
+    variant: variant,
+    ...props
+  });
+}
+const DownChevron = /*#__PURE__*/_styled(ArrowChevronDownIcon, {
+  target: "en0qdm3",
+  label: "DownChevron"
+})(process.env.NODE_ENV === "production" ? {
+  name: "vrwdxf",
+  styles: "path{stroke-width:3;}"
+} : {
+  name: "vrwdxf",
+  styles: "path{stroke-width:3;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Grid/GridCollapse.tsx"],"names":[],"mappings":"AAoBgD","file":"../../src/Grid/GridCollapse.tsx","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Anchor, Box, FlexBox, GridBox } from '@codecademy/gamut';\nimport {\n  ArrowChevronDownIcon,\n  ArrowChevronUpIcon,\n} from '@codecademy/gamut-icons';\nimport { breakpoints } from '@codecademy/gamut-styles';\nimport { MediaQueryMap } from '@codecademy/variance';\nimport styled from '@emotion/styled';\nimport React, { ComponentProps, useState } from 'react';\n\nimport { ColumnCount, getCSSFromColumnCount } from './getCSSFromColumnCount';\n\nfunction ExpandCollapseDefaults({\n  variant = 'standard',\n  ...props\n}: React.ComponentProps<typeof Anchor>) {\n  return <Anchor variant={variant} {...props} />;\n}\n\nconst DownChevron = styled(ArrowChevronDownIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst UpChevron = styled(ArrowChevronUpIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst breakpointsWithBase = {\n  _: '0px',\n  ...breakpoints,\n} as const;\n\nexport const getMediaQuery = ({\n  css,\n  start,\n  end,\n}: {\n  css: string;\n  start: string;\n  end?: string;\n}) =>\n  end\n    ? `@media only screen and (min-width: ${start}) and (max-width: calc(${end} - 1px)) { ${css} }`\n    : `@media only screen and (min-width: ${start}) { ${css} }`;\n\ntype GridItemProps = {\n  itemsShown: MediaQueryMap<number>;\n};\n\nconst GridItem = styled(Box)<GridItemProps>`\n  ${({ itemsShown }) =>\n    (Object.keys(itemsShown) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = itemsShown[breakpointKey];\n        if (max === undefined) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        // hide all grid items after the max\n        const css = `&:nth-of-type(n + ${max + 1}) { display: none; }`;\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css, start })\n          : getMediaQuery({ css, start, end });\n      })\n      .join('\\n')}\n`;\n\ntype ExpandCollapseProps = {\n  hideWhenTotalIsLessThan: MediaQueryMap<number>;\n  totalCount: number;\n};\n\nconst ExpandCollapse = styled(ExpandCollapseDefaults)`\n  display: none;\n  white-space: pre-wrap;\n\n  &:not(:first-of-type) {\n    margin-left: 2.5rem;\n  }\n\n  ${({ hideWhenTotalIsLessThan, totalCount }: ExpandCollapseProps) =>\n    (Object.keys(hideWhenTotalIsLessThan) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = hideWhenTotalIsLessThan[breakpointKey];\n        if (max === undefined || totalCount <= max) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css: 'display: block;', start })\n          : getMediaQuery({ css: 'display: block;', start, end });\n      })\n      .join('\\n')}\n`;\n\nexport type GridCollapseProps = ComponentProps<typeof GridBox> & {\n  /**\n   * the number of columns per row in the grid\n   */\n  columnCount: ColumnCount;\n  /**\n   * the number of items to display when collapsed\n   */\n  initialMaxShown: MediaQueryMap<number>;\n  /**\n   * the number of new items to display on each \"expand\" click; if not provided, a binary toggle is used\n   * note: must include exactly the same keys as initialMaxShown\n   */\n  pageSize?: MediaQueryMap<number>;\n  /**\n   * text to display when \"show more\" is available\n   */\n  expandLabel?: string;\n  /**\n   * text to display when \"show fewer\" is available\n   */\n  collapseLabel?: string;\n  /**\n   * called when clicking the show more/see less toggle; accepts the current expanded state as an arg\n   */\n  onExpandClick?: (expanded?: boolean) => void;\n  /**\n   * props to pass to the expand/collapse container (useful for changing the margin between the grid and controls)\n   */\n  expandCollapseProps?: ComponentProps<typeof Box>;\n};\n\nexport const GridCollapse: React.FC<GridCollapseProps> = ({\n  columnCount,\n  initialMaxShown,\n  pageSize,\n  expandLabel = 'Show all',\n  collapseLabel = 'Show fewer',\n  onExpandClick,\n  expandCollapseProps,\n  children,\n  ...gridBoxProps\n}) => {\n  const [page, setPage] = useState(0);\n\n  const expanded = page > 0;\n\n  // calculate the number of items to show based on page, pageSize, and initialMaxShown\n  const itemsShown = (\n    Object.keys(initialMaxShown) as (keyof MediaQueryMap<number>)[]\n  ).reduce((acc: MediaQueryMap<number>, breakpointKey) => {\n    if (pageSize) {\n      // if pageSize is defined, itemsShown = initialMaxShown + (page * pageSize)\n      acc[breakpointKey] =\n        (initialMaxShown[breakpointKey] ?? 0) +\n        page * (pageSize?.[breakpointKey] ?? 0);\n    } else {\n      // if pageSize is not defined, itemsShown is either initialMaxShown or all children\n      acc[breakpointKey] =\n        page > 0\n          ? React.Children.count(children)\n          : initialMaxShown[breakpointKey];\n    }\n    return acc;\n  }, {});\n\n  return (\n    <>\n      <GridBox\n        as=\"ul\"\n        listStyleType=\"none\"\n        p={0}\n        m={0}\n        {...gridBoxProps}\n        gridTemplateColumns={getCSSFromColumnCount(\n          columnCount,\n          (value) => `repeat(${value}, minmax(0, 1fr))` // this minmax prevents cells from resizing based on content\n        )}\n        aria-live=\"polite\"\n        aria-expanded={expanded}\n      >\n        {/*\n         * note that GridCollapse maps each of its direct children into a GridItem - this means that\n         * if you pass in a single component that aggregates children on its own, that component (and\n         * all of its children) will be considered a single grid item. Consider extracting the contents\n         * of that component into a function instead, turning this example:\n         *\n         * const AggregateComponent: React.FC = (items) => (\n         *   <>\n         *     {items.map((item) => <div>{item}</div>)}\n         *   </>\n         * );\n         *\n         * <GridCollapse><AggregateComponent items={[...]}/></GridCollapse>\n         *\n         * into:\n         *\n         * const getAggregateChildren = (items) => items.map((item) => <div>{item}</div>)\n         *\n         * <GridCollapse>{getAggregateChildren([...])}</GridCollapse>\n         */}\n        {React.Children.map(children, (child) => (\n          <GridItem as=\"li\" itemsShown={itemsShown}>\n            {child}\n          </GridItem>\n        ))}\n      </GridBox>\n      {pageSize ? (\n        <Box\n          {...expandCollapseProps}\n          mt={page > 0 ? 16 : expandCollapseProps?.mt}\n        >\n          <ExpandCollapse\n            fontWeight=\"title\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={itemsShown}\n            onClick={() => {\n              onExpandClick?.(false);\n              setPage((currentPage) => currentPage + 1);\n            }}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expandLabel} <DownChevron size={12} />\n            </FlexBox>\n          </ExpandCollapse>\n          {page > 0 && (\n            <ExpandCollapse\n              variant=\"interface\"\n              fontWeight=\"title\"\n              totalCount={React.Children.count(children)}\n              hideWhenTotalIsLessThan={initialMaxShown}\n              onClick={() => {\n                onExpandClick?.(true);\n                setPage(0);\n              }}\n            >\n              <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n                {collapseLabel} <UpChevron size={12} />\n              </FlexBox>\n            </ExpandCollapse>\n          )}\n        </Box>\n      ) : (\n        <Box {...expandCollapseProps}>\n          <ExpandCollapse\n            variant={expanded ? 'interface' : undefined}\n            fontWeight=\"bold\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={initialMaxShown}\n            onClick={() => {\n              onExpandClick?.(expanded);\n              setPage((currentPage) => (currentPage > 0 ? 0 : 1));\n            }}\n            aria-expanded={expanded}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expanded ? (\n                <>\n                  {collapseLabel}\n                  <UpChevron size={12} />\n                </>\n              ) : (\n                <>\n                  {expandLabel}\n                  <DownChevron size={12} />\n                </>\n              )}\n            </FlexBox>\n          </ExpandCollapse>\n        </Box>\n      )}\n    </>\n  );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const UpChevron = /*#__PURE__*/_styled(ArrowChevronUpIcon, {
+  target: "en0qdm2",
+  label: "UpChevron"
+})(process.env.NODE_ENV === "production" ? {
+  name: "vrwdxf",
+  styles: "path{stroke-width:3;}"
+} : {
+  name: "vrwdxf",
+  styles: "path{stroke-width:3;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Grid/GridCollapse.tsx"],"names":[],"mappings":"AA0B4C","file":"../../src/Grid/GridCollapse.tsx","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Anchor, Box, FlexBox, GridBox } from '@codecademy/gamut';\nimport {\n  ArrowChevronDownIcon,\n  ArrowChevronUpIcon,\n} from '@codecademy/gamut-icons';\nimport { breakpoints } from '@codecademy/gamut-styles';\nimport { MediaQueryMap } from '@codecademy/variance';\nimport styled from '@emotion/styled';\nimport React, { ComponentProps, useState } from 'react';\n\nimport { ColumnCount, getCSSFromColumnCount } from './getCSSFromColumnCount';\n\nfunction ExpandCollapseDefaults({\n  variant = 'standard',\n  ...props\n}: React.ComponentProps<typeof Anchor>) {\n  return <Anchor variant={variant} {...props} />;\n}\n\nconst DownChevron = styled(ArrowChevronDownIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst UpChevron = styled(ArrowChevronUpIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst breakpointsWithBase = {\n  _: '0px',\n  ...breakpoints,\n} as const;\n\nexport const getMediaQuery = ({\n  css,\n  start,\n  end,\n}: {\n  css: string;\n  start: string;\n  end?: string;\n}) =>\n  end\n    ? `@media only screen and (min-width: ${start}) and (max-width: calc(${end} - 1px)) { ${css} }`\n    : `@media only screen and (min-width: ${start}) { ${css} }`;\n\ntype GridItemProps = {\n  itemsShown: MediaQueryMap<number>;\n};\n\nconst GridItem = styled(Box)<GridItemProps>`\n  ${({ itemsShown }) =>\n    (Object.keys(itemsShown) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = itemsShown[breakpointKey];\n        if (max === undefined) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        // hide all grid items after the max\n        const css = `&:nth-of-type(n + ${max + 1}) { display: none; }`;\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css, start })\n          : getMediaQuery({ css, start, end });\n      })\n      .join('\\n')}\n`;\n\ntype ExpandCollapseProps = {\n  hideWhenTotalIsLessThan: MediaQueryMap<number>;\n  totalCount: number;\n};\n\nconst ExpandCollapse = styled(ExpandCollapseDefaults)`\n  display: none;\n  white-space: pre-wrap;\n\n  &:not(:first-of-type) {\n    margin-left: 2.5rem;\n  }\n\n  ${({ hideWhenTotalIsLessThan, totalCount }: ExpandCollapseProps) =>\n    (Object.keys(hideWhenTotalIsLessThan) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = hideWhenTotalIsLessThan[breakpointKey];\n        if (max === undefined || totalCount <= max) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css: 'display: block;', start })\n          : getMediaQuery({ css: 'display: block;', start, end });\n      })\n      .join('\\n')}\n`;\n\nexport type GridCollapseProps = ComponentProps<typeof GridBox> & {\n  /**\n   * the number of columns per row in the grid\n   */\n  columnCount: ColumnCount;\n  /**\n   * the number of items to display when collapsed\n   */\n  initialMaxShown: MediaQueryMap<number>;\n  /**\n   * the number of new items to display on each \"expand\" click; if not provided, a binary toggle is used\n   * note: must include exactly the same keys as initialMaxShown\n   */\n  pageSize?: MediaQueryMap<number>;\n  /**\n   * text to display when \"show more\" is available\n   */\n  expandLabel?: string;\n  /**\n   * text to display when \"show fewer\" is available\n   */\n  collapseLabel?: string;\n  /**\n   * called when clicking the show more/see less toggle; accepts the current expanded state as an arg\n   */\n  onExpandClick?: (expanded?: boolean) => void;\n  /**\n   * props to pass to the expand/collapse container (useful for changing the margin between the grid and controls)\n   */\n  expandCollapseProps?: ComponentProps<typeof Box>;\n};\n\nexport const GridCollapse: React.FC<GridCollapseProps> = ({\n  columnCount,\n  initialMaxShown,\n  pageSize,\n  expandLabel = 'Show all',\n  collapseLabel = 'Show fewer',\n  onExpandClick,\n  expandCollapseProps,\n  children,\n  ...gridBoxProps\n}) => {\n  const [page, setPage] = useState(0);\n\n  const expanded = page > 0;\n\n  // calculate the number of items to show based on page, pageSize, and initialMaxShown\n  const itemsShown = (\n    Object.keys(initialMaxShown) as (keyof MediaQueryMap<number>)[]\n  ).reduce((acc: MediaQueryMap<number>, breakpointKey) => {\n    if (pageSize) {\n      // if pageSize is defined, itemsShown = initialMaxShown + (page * pageSize)\n      acc[breakpointKey] =\n        (initialMaxShown[breakpointKey] ?? 0) +\n        page * (pageSize?.[breakpointKey] ?? 0);\n    } else {\n      // if pageSize is not defined, itemsShown is either initialMaxShown or all children\n      acc[breakpointKey] =\n        page > 0\n          ? React.Children.count(children)\n          : initialMaxShown[breakpointKey];\n    }\n    return acc;\n  }, {});\n\n  return (\n    <>\n      <GridBox\n        as=\"ul\"\n        listStyleType=\"none\"\n        p={0}\n        m={0}\n        {...gridBoxProps}\n        gridTemplateColumns={getCSSFromColumnCount(\n          columnCount,\n          (value) => `repeat(${value}, minmax(0, 1fr))` // this minmax prevents cells from resizing based on content\n        )}\n        aria-live=\"polite\"\n        aria-expanded={expanded}\n      >\n        {/*\n         * note that GridCollapse maps each of its direct children into a GridItem - this means that\n         * if you pass in a single component that aggregates children on its own, that component (and\n         * all of its children) will be considered a single grid item. Consider extracting the contents\n         * of that component into a function instead, turning this example:\n         *\n         * const AggregateComponent: React.FC = (items) => (\n         *   <>\n         *     {items.map((item) => <div>{item}</div>)}\n         *   </>\n         * );\n         *\n         * <GridCollapse><AggregateComponent items={[...]}/></GridCollapse>\n         *\n         * into:\n         *\n         * const getAggregateChildren = (items) => items.map((item) => <div>{item}</div>)\n         *\n         * <GridCollapse>{getAggregateChildren([...])}</GridCollapse>\n         */}\n        {React.Children.map(children, (child) => (\n          <GridItem as=\"li\" itemsShown={itemsShown}>\n            {child}\n          </GridItem>\n        ))}\n      </GridBox>\n      {pageSize ? (\n        <Box\n          {...expandCollapseProps}\n          mt={page > 0 ? 16 : expandCollapseProps?.mt}\n        >\n          <ExpandCollapse\n            fontWeight=\"title\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={itemsShown}\n            onClick={() => {\n              onExpandClick?.(false);\n              setPage((currentPage) => currentPage + 1);\n            }}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expandLabel} <DownChevron size={12} />\n            </FlexBox>\n          </ExpandCollapse>\n          {page > 0 && (\n            <ExpandCollapse\n              variant=\"interface\"\n              fontWeight=\"title\"\n              totalCount={React.Children.count(children)}\n              hideWhenTotalIsLessThan={initialMaxShown}\n              onClick={() => {\n                onExpandClick?.(true);\n                setPage(0);\n              }}\n            >\n              <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n                {collapseLabel} <UpChevron size={12} />\n              </FlexBox>\n            </ExpandCollapse>\n          )}\n        </Box>\n      ) : (\n        <Box {...expandCollapseProps}>\n          <ExpandCollapse\n            variant={expanded ? 'interface' : undefined}\n            fontWeight=\"bold\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={initialMaxShown}\n            onClick={() => {\n              onExpandClick?.(expanded);\n              setPage((currentPage) => (currentPage > 0 ? 0 : 1));\n            }}\n            aria-expanded={expanded}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expanded ? (\n                <>\n                  {collapseLabel}\n                  <UpChevron size={12} />\n                </>\n              ) : (\n                <>\n                  {expandLabel}\n                  <DownChevron size={12} />\n                </>\n              )}\n            </FlexBox>\n          </ExpandCollapse>\n        </Box>\n      )}\n    </>\n  );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const breakpointsWithBase = {
+  _: '0px',
+  ...breakpoints
+};
+export const getMediaQuery = ({
+  css,
+  start,
+  end
+}) => end ? `@media only screen and (min-width: ${start}) and (max-width: calc(${end} - 1px)) { ${css} }` : `@media only screen and (min-width: ${start}) { ${css} }`;
+const GridItem = /*#__PURE__*/_styled(Box, {
+  target: "en0qdm1",
+  label: "GridItem"
+})(({
+  itemsShown
+}) => Object.keys(itemsShown).map((breakpointKey, i, breakpointKeys) => {
+  const max = itemsShown[breakpointKey];
+  if (max === undefined) return;
+  const start = breakpointsWithBase[breakpointKey];
+  const end = breakpointsWithBase[breakpointKeys[i + 1]];
+
+  // hide all grid items after the max
+  const css = `&:nth-of-type(n + ${max + 1}) { display: none; }`;
+  return i === breakpointKeys.length - 1 ? getMediaQuery({
+    css,
+    start
+  }) : getMediaQuery({
+    css,
+    start,
+    end
+  });
+}).join('\n'), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Grid/GridCollapse.tsx"],"names":[],"mappings":"AAsD2C","file":"../../src/Grid/GridCollapse.tsx","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Anchor, Box, FlexBox, GridBox } from '@codecademy/gamut';\nimport {\n  ArrowChevronDownIcon,\n  ArrowChevronUpIcon,\n} from '@codecademy/gamut-icons';\nimport { breakpoints } from '@codecademy/gamut-styles';\nimport { MediaQueryMap } from '@codecademy/variance';\nimport styled from '@emotion/styled';\nimport React, { ComponentProps, useState } from 'react';\n\nimport { ColumnCount, getCSSFromColumnCount } from './getCSSFromColumnCount';\n\nfunction ExpandCollapseDefaults({\n  variant = 'standard',\n  ...props\n}: React.ComponentProps<typeof Anchor>) {\n  return <Anchor variant={variant} {...props} />;\n}\n\nconst DownChevron = styled(ArrowChevronDownIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst UpChevron = styled(ArrowChevronUpIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst breakpointsWithBase = {\n  _: '0px',\n  ...breakpoints,\n} as const;\n\nexport const getMediaQuery = ({\n  css,\n  start,\n  end,\n}: {\n  css: string;\n  start: string;\n  end?: string;\n}) =>\n  end\n    ? `@media only screen and (min-width: ${start}) and (max-width: calc(${end} - 1px)) { ${css} }`\n    : `@media only screen and (min-width: ${start}) { ${css} }`;\n\ntype GridItemProps = {\n  itemsShown: MediaQueryMap<number>;\n};\n\nconst GridItem = styled(Box)<GridItemProps>`\n  ${({ itemsShown }) =>\n    (Object.keys(itemsShown) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = itemsShown[breakpointKey];\n        if (max === undefined) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        // hide all grid items after the max\n        const css = `&:nth-of-type(n + ${max + 1}) { display: none; }`;\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css, start })\n          : getMediaQuery({ css, start, end });\n      })\n      .join('\\n')}\n`;\n\ntype ExpandCollapseProps = {\n  hideWhenTotalIsLessThan: MediaQueryMap<number>;\n  totalCount: number;\n};\n\nconst ExpandCollapse = styled(ExpandCollapseDefaults)`\n  display: none;\n  white-space: pre-wrap;\n\n  &:not(:first-of-type) {\n    margin-left: 2.5rem;\n  }\n\n  ${({ hideWhenTotalIsLessThan, totalCount }: ExpandCollapseProps) =>\n    (Object.keys(hideWhenTotalIsLessThan) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = hideWhenTotalIsLessThan[breakpointKey];\n        if (max === undefined || totalCount <= max) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css: 'display: block;', start })\n          : getMediaQuery({ css: 'display: block;', start, end });\n      })\n      .join('\\n')}\n`;\n\nexport type GridCollapseProps = ComponentProps<typeof GridBox> & {\n  /**\n   * the number of columns per row in the grid\n   */\n  columnCount: ColumnCount;\n  /**\n   * the number of items to display when collapsed\n   */\n  initialMaxShown: MediaQueryMap<number>;\n  /**\n   * the number of new items to display on each \"expand\" click; if not provided, a binary toggle is used\n   * note: must include exactly the same keys as initialMaxShown\n   */\n  pageSize?: MediaQueryMap<number>;\n  /**\n   * text to display when \"show more\" is available\n   */\n  expandLabel?: string;\n  /**\n   * text to display when \"show fewer\" is available\n   */\n  collapseLabel?: string;\n  /**\n   * called when clicking the show more/see less toggle; accepts the current expanded state as an arg\n   */\n  onExpandClick?: (expanded?: boolean) => void;\n  /**\n   * props to pass to the expand/collapse container (useful for changing the margin between the grid and controls)\n   */\n  expandCollapseProps?: ComponentProps<typeof Box>;\n};\n\nexport const GridCollapse: React.FC<GridCollapseProps> = ({\n  columnCount,\n  initialMaxShown,\n  pageSize,\n  expandLabel = 'Show all',\n  collapseLabel = 'Show fewer',\n  onExpandClick,\n  expandCollapseProps,\n  children,\n  ...gridBoxProps\n}) => {\n  const [page, setPage] = useState(0);\n\n  const expanded = page > 0;\n\n  // calculate the number of items to show based on page, pageSize, and initialMaxShown\n  const itemsShown = (\n    Object.keys(initialMaxShown) as (keyof MediaQueryMap<number>)[]\n  ).reduce((acc: MediaQueryMap<number>, breakpointKey) => {\n    if (pageSize) {\n      // if pageSize is defined, itemsShown = initialMaxShown + (page * pageSize)\n      acc[breakpointKey] =\n        (initialMaxShown[breakpointKey] ?? 0) +\n        page * (pageSize?.[breakpointKey] ?? 0);\n    } else {\n      // if pageSize is not defined, itemsShown is either initialMaxShown or all children\n      acc[breakpointKey] =\n        page > 0\n          ? React.Children.count(children)\n          : initialMaxShown[breakpointKey];\n    }\n    return acc;\n  }, {});\n\n  return (\n    <>\n      <GridBox\n        as=\"ul\"\n        listStyleType=\"none\"\n        p={0}\n        m={0}\n        {...gridBoxProps}\n        gridTemplateColumns={getCSSFromColumnCount(\n          columnCount,\n          (value) => `repeat(${value}, minmax(0, 1fr))` // this minmax prevents cells from resizing based on content\n        )}\n        aria-live=\"polite\"\n        aria-expanded={expanded}\n      >\n        {/*\n         * note that GridCollapse maps each of its direct children into a GridItem - this means that\n         * if you pass in a single component that aggregates children on its own, that component (and\n         * all of its children) will be considered a single grid item. Consider extracting the contents\n         * of that component into a function instead, turning this example:\n         *\n         * const AggregateComponent: React.FC = (items) => (\n         *   <>\n         *     {items.map((item) => <div>{item}</div>)}\n         *   </>\n         * );\n         *\n         * <GridCollapse><AggregateComponent items={[...]}/></GridCollapse>\n         *\n         * into:\n         *\n         * const getAggregateChildren = (items) => items.map((item) => <div>{item}</div>)\n         *\n         * <GridCollapse>{getAggregateChildren([...])}</GridCollapse>\n         */}\n        {React.Children.map(children, (child) => (\n          <GridItem as=\"li\" itemsShown={itemsShown}>\n            {child}\n          </GridItem>\n        ))}\n      </GridBox>\n      {pageSize ? (\n        <Box\n          {...expandCollapseProps}\n          mt={page > 0 ? 16 : expandCollapseProps?.mt}\n        >\n          <ExpandCollapse\n            fontWeight=\"title\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={itemsShown}\n            onClick={() => {\n              onExpandClick?.(false);\n              setPage((currentPage) => currentPage + 1);\n            }}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expandLabel} <DownChevron size={12} />\n            </FlexBox>\n          </ExpandCollapse>\n          {page > 0 && (\n            <ExpandCollapse\n              variant=\"interface\"\n              fontWeight=\"title\"\n              totalCount={React.Children.count(children)}\n              hideWhenTotalIsLessThan={initialMaxShown}\n              onClick={() => {\n                onExpandClick?.(true);\n                setPage(0);\n              }}\n            >\n              <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n                {collapseLabel} <UpChevron size={12} />\n              </FlexBox>\n            </ExpandCollapse>\n          )}\n        </Box>\n      ) : (\n        <Box {...expandCollapseProps}>\n          <ExpandCollapse\n            variant={expanded ? 'interface' : undefined}\n            fontWeight=\"bold\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={initialMaxShown}\n            onClick={() => {\n              onExpandClick?.(expanded);\n              setPage((currentPage) => (currentPage > 0 ? 0 : 1));\n            }}\n            aria-expanded={expanded}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expanded ? (\n                <>\n                  {collapseLabel}\n                  <UpChevron size={12} />\n                </>\n              ) : (\n                <>\n                  {expandLabel}\n                  <DownChevron size={12} />\n                </>\n              )}\n            </FlexBox>\n          </ExpandCollapse>\n        </Box>\n      )}\n    </>\n  );\n};\n"]} */"));
+const ExpandCollapse = /*#__PURE__*/_styled(ExpandCollapseDefaults, {
+  target: "en0qdm0",
+  label: "ExpandCollapse"
+})("display:none;white-space:pre-wrap;&:not(:first-of-type){margin-left:2.5rem;}", ({
+  hideWhenTotalIsLessThan,
+  totalCount
+}) => Object.keys(hideWhenTotalIsLessThan).map((breakpointKey, i, breakpointKeys) => {
+  const max = hideWhenTotalIsLessThan[breakpointKey];
+  if (max === undefined || totalCount <= max) return;
+  const start = breakpointsWithBase[breakpointKey];
+  const end = breakpointsWithBase[breakpointKeys[i + 1]];
+  return i === breakpointKeys.length - 1 ? getMediaQuery({
+    css: 'display: block;',
+    start
+  }) : getMediaQuery({
+    css: 'display: block;',
+    start,
+    end
+  });
+}).join('\n'), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/Grid/GridCollapse.tsx"],"names":[],"mappings":"AA+EqD","file":"../../src/Grid/GridCollapse.tsx","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Anchor, Box, FlexBox, GridBox } from '@codecademy/gamut';\nimport {\n  ArrowChevronDownIcon,\n  ArrowChevronUpIcon,\n} from '@codecademy/gamut-icons';\nimport { breakpoints } from '@codecademy/gamut-styles';\nimport { MediaQueryMap } from '@codecademy/variance';\nimport styled from '@emotion/styled';\nimport React, { ComponentProps, useState } from 'react';\n\nimport { ColumnCount, getCSSFromColumnCount } from './getCSSFromColumnCount';\n\nfunction ExpandCollapseDefaults({\n  variant = 'standard',\n  ...props\n}: React.ComponentProps<typeof Anchor>) {\n  return <Anchor variant={variant} {...props} />;\n}\n\nconst DownChevron = styled(ArrowChevronDownIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst UpChevron = styled(ArrowChevronUpIcon)`\n  path {\n    stroke-width: 3;\n  }\n`;\n\nconst breakpointsWithBase = {\n  _: '0px',\n  ...breakpoints,\n} as const;\n\nexport const getMediaQuery = ({\n  css,\n  start,\n  end,\n}: {\n  css: string;\n  start: string;\n  end?: string;\n}) =>\n  end\n    ? `@media only screen and (min-width: ${start}) and (max-width: calc(${end} - 1px)) { ${css} }`\n    : `@media only screen and (min-width: ${start}) { ${css} }`;\n\ntype GridItemProps = {\n  itemsShown: MediaQueryMap<number>;\n};\n\nconst GridItem = styled(Box)<GridItemProps>`\n  ${({ itemsShown }) =>\n    (Object.keys(itemsShown) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = itemsShown[breakpointKey];\n        if (max === undefined) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        // hide all grid items after the max\n        const css = `&:nth-of-type(n + ${max + 1}) { display: none; }`;\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css, start })\n          : getMediaQuery({ css, start, end });\n      })\n      .join('\\n')}\n`;\n\ntype ExpandCollapseProps = {\n  hideWhenTotalIsLessThan: MediaQueryMap<number>;\n  totalCount: number;\n};\n\nconst ExpandCollapse = styled(ExpandCollapseDefaults)`\n  display: none;\n  white-space: pre-wrap;\n\n  &:not(:first-of-type) {\n    margin-left: 2.5rem;\n  }\n\n  ${({ hideWhenTotalIsLessThan, totalCount }: ExpandCollapseProps) =>\n    (Object.keys(hideWhenTotalIsLessThan) as (keyof MediaQueryMap<number>)[])\n      .map((breakpointKey, i, breakpointKeys) => {\n        const max = hideWhenTotalIsLessThan[breakpointKey];\n        if (max === undefined || totalCount <= max) return;\n\n        const start = breakpointsWithBase[breakpointKey];\n        const end = breakpointsWithBase[breakpointKeys[i + 1]];\n\n        return i === breakpointKeys.length - 1\n          ? getMediaQuery({ css: 'display: block;', start })\n          : getMediaQuery({ css: 'display: block;', start, end });\n      })\n      .join('\\n')}\n`;\n\nexport type GridCollapseProps = ComponentProps<typeof GridBox> & {\n  /**\n   * the number of columns per row in the grid\n   */\n  columnCount: ColumnCount;\n  /**\n   * the number of items to display when collapsed\n   */\n  initialMaxShown: MediaQueryMap<number>;\n  /**\n   * the number of new items to display on each \"expand\" click; if not provided, a binary toggle is used\n   * note: must include exactly the same keys as initialMaxShown\n   */\n  pageSize?: MediaQueryMap<number>;\n  /**\n   * text to display when \"show more\" is available\n   */\n  expandLabel?: string;\n  /**\n   * text to display when \"show fewer\" is available\n   */\n  collapseLabel?: string;\n  /**\n   * called when clicking the show more/see less toggle; accepts the current expanded state as an arg\n   */\n  onExpandClick?: (expanded?: boolean) => void;\n  /**\n   * props to pass to the expand/collapse container (useful for changing the margin between the grid and controls)\n   */\n  expandCollapseProps?: ComponentProps<typeof Box>;\n};\n\nexport const GridCollapse: React.FC<GridCollapseProps> = ({\n  columnCount,\n  initialMaxShown,\n  pageSize,\n  expandLabel = 'Show all',\n  collapseLabel = 'Show fewer',\n  onExpandClick,\n  expandCollapseProps,\n  children,\n  ...gridBoxProps\n}) => {\n  const [page, setPage] = useState(0);\n\n  const expanded = page > 0;\n\n  // calculate the number of items to show based on page, pageSize, and initialMaxShown\n  const itemsShown = (\n    Object.keys(initialMaxShown) as (keyof MediaQueryMap<number>)[]\n  ).reduce((acc: MediaQueryMap<number>, breakpointKey) => {\n    if (pageSize) {\n      // if pageSize is defined, itemsShown = initialMaxShown + (page * pageSize)\n      acc[breakpointKey] =\n        (initialMaxShown[breakpointKey] ?? 0) +\n        page * (pageSize?.[breakpointKey] ?? 0);\n    } else {\n      // if pageSize is not defined, itemsShown is either initialMaxShown or all children\n      acc[breakpointKey] =\n        page > 0\n          ? React.Children.count(children)\n          : initialMaxShown[breakpointKey];\n    }\n    return acc;\n  }, {});\n\n  return (\n    <>\n      <GridBox\n        as=\"ul\"\n        listStyleType=\"none\"\n        p={0}\n        m={0}\n        {...gridBoxProps}\n        gridTemplateColumns={getCSSFromColumnCount(\n          columnCount,\n          (value) => `repeat(${value}, minmax(0, 1fr))` // this minmax prevents cells from resizing based on content\n        )}\n        aria-live=\"polite\"\n        aria-expanded={expanded}\n      >\n        {/*\n         * note that GridCollapse maps each of its direct children into a GridItem - this means that\n         * if you pass in a single component that aggregates children on its own, that component (and\n         * all of its children) will be considered a single grid item. Consider extracting the contents\n         * of that component into a function instead, turning this example:\n         *\n         * const AggregateComponent: React.FC = (items) => (\n         *   <>\n         *     {items.map((item) => <div>{item}</div>)}\n         *   </>\n         * );\n         *\n         * <GridCollapse><AggregateComponent items={[...]}/></GridCollapse>\n         *\n         * into:\n         *\n         * const getAggregateChildren = (items) => items.map((item) => <div>{item}</div>)\n         *\n         * <GridCollapse>{getAggregateChildren([...])}</GridCollapse>\n         */}\n        {React.Children.map(children, (child) => (\n          <GridItem as=\"li\" itemsShown={itemsShown}>\n            {child}\n          </GridItem>\n        ))}\n      </GridBox>\n      {pageSize ? (\n        <Box\n          {...expandCollapseProps}\n          mt={page > 0 ? 16 : expandCollapseProps?.mt}\n        >\n          <ExpandCollapse\n            fontWeight=\"title\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={itemsShown}\n            onClick={() => {\n              onExpandClick?.(false);\n              setPage((currentPage) => currentPage + 1);\n            }}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expandLabel} <DownChevron size={12} />\n            </FlexBox>\n          </ExpandCollapse>\n          {page > 0 && (\n            <ExpandCollapse\n              variant=\"interface\"\n              fontWeight=\"title\"\n              totalCount={React.Children.count(children)}\n              hideWhenTotalIsLessThan={initialMaxShown}\n              onClick={() => {\n                onExpandClick?.(true);\n                setPage(0);\n              }}\n            >\n              <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n                {collapseLabel} <UpChevron size={12} />\n              </FlexBox>\n            </ExpandCollapse>\n          )}\n        </Box>\n      ) : (\n        <Box {...expandCollapseProps}>\n          <ExpandCollapse\n            variant={expanded ? 'interface' : undefined}\n            fontWeight=\"bold\"\n            totalCount={React.Children.count(children)}\n            hideWhenTotalIsLessThan={initialMaxShown}\n            onClick={() => {\n              onExpandClick?.(expanded);\n              setPage((currentPage) => (currentPage > 0 ? 0 : 1));\n            }}\n            aria-expanded={expanded}\n          >\n            <FlexBox alignItems=\"center\" gap={10 as any} my={8}>\n              {expanded ? (\n                <>\n                  {collapseLabel}\n                  <UpChevron size={12} />\n                </>\n              ) : (\n                <>\n                  {expandLabel}\n                  <DownChevron size={12} />\n                </>\n              )}\n            </FlexBox>\n          </ExpandCollapse>\n        </Box>\n      )}\n    </>\n  );\n};\n"]} */"));
+export const GridCollapse = ({
+  columnCount,
+  initialMaxShown,
+  pageSize,
+  expandLabel = 'Show all',
+  collapseLabel = 'Show fewer',
+  onExpandClick,
+  expandCollapseProps,
+  children,
+  ...gridBoxProps
+}) => {
+  const [page, setPage] = useState(0);
+  const expanded = page > 0;
+
+  // calculate the number of items to show based on page, pageSize, and initialMaxShown
+  const itemsShown = Object.keys(initialMaxShown).reduce((acc, breakpointKey) => {
+    if (pageSize) {
+      // if pageSize is defined, itemsShown = initialMaxShown + (page * pageSize)
+      acc[breakpointKey] = (initialMaxShown[breakpointKey] ?? 0) + page * (pageSize?.[breakpointKey] ?? 0);
+    } else {
+      // if pageSize is not defined, itemsShown is either initialMaxShown or all children
+      acc[breakpointKey] = page > 0 ? React.Children.count(children) : initialMaxShown[breakpointKey];
+    }
+    return acc;
+  }, {});
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(GridBox, {
+      as: "ul",
+      listStyleType: "none",
+      p: 0,
+      m: 0,
+      ...gridBoxProps,
+      gridTemplateColumns: getCSSFromColumnCount(columnCount, value => `repeat(${value}, minmax(0, 1fr))` // this minmax prevents cells from resizing based on content
+      ),
+      "aria-live": "polite",
+      "aria-expanded": expanded,
+      children: React.Children.map(children, child => /*#__PURE__*/_jsx(GridItem, {
+        as: "li",
+        itemsShown: itemsShown,
+        children: child
+      }))
+    }), pageSize ? /*#__PURE__*/_jsxs(Box, {
+      ...expandCollapseProps,
+      mt: page > 0 ? 16 : expandCollapseProps?.mt,
+      children: [/*#__PURE__*/_jsx(ExpandCollapse, {
+        fontWeight: "title",
+        totalCount: React.Children.count(children),
+        hideWhenTotalIsLessThan: itemsShown,
+        onClick: () => {
+          onExpandClick?.(false);
+          setPage(currentPage => currentPage + 1);
+        },
+        children: /*#__PURE__*/_jsxs(FlexBox, {
+          alignItems: "center",
+          gap: 10,
+          my: 8,
+          children: [expandLabel, " ", /*#__PURE__*/_jsx(DownChevron, {
+            size: 12
+          })]
+        })
+      }), page > 0 && /*#__PURE__*/_jsx(ExpandCollapse, {
+        variant: "interface",
+        fontWeight: "title",
+        totalCount: React.Children.count(children),
+        hideWhenTotalIsLessThan: initialMaxShown,
+        onClick: () => {
+          onExpandClick?.(true);
+          setPage(0);
+        },
+        children: /*#__PURE__*/_jsxs(FlexBox, {
+          alignItems: "center",
+          gap: 10,
+          my: 8,
+          children: [collapseLabel, " ", /*#__PURE__*/_jsx(UpChevron, {
+            size: 12
+          })]
+        })
+      })]
+    }) : /*#__PURE__*/_jsx(Box, {
+      ...expandCollapseProps,
+      children: /*#__PURE__*/_jsx(ExpandCollapse, {
+        variant: expanded ? 'interface' : undefined,
+        fontWeight: "bold",
+        totalCount: React.Children.count(children),
+        hideWhenTotalIsLessThan: initialMaxShown,
+        onClick: () => {
+          onExpandClick?.(expanded);
+          setPage(currentPage => currentPage > 0 ? 0 : 1);
+        },
+        "aria-expanded": expanded,
+        children: /*#__PURE__*/_jsx(FlexBox, {
+          alignItems: "center",
+          gap: 10,
+          my: 8,
+          children: expanded ? /*#__PURE__*/_jsxs(_Fragment, {
+            children: [collapseLabel, /*#__PURE__*/_jsx(UpChevron, {
+              size: 12
+            })]
+          }) : /*#__PURE__*/_jsxs(_Fragment, {
+            children: [expandLabel, /*#__PURE__*/_jsx(DownChevron, {
+              size: 12
+            })]
+          })
+        })
+      })
+    })]
+  });
+};