@auth0/quantum-product 1.5.1

package/menu/menu-item/menu-item-overrides.d.ts

@@ -0,0 +1,3 @@
+import type { MenuItemProps, MenuItemClassKey } from '@mui/material/MenuItem';
+import type { ComponentOverrideCreator } from '../../theme/create-component-overrides';
+export declare const createMuiMenuItemOverrides: ComponentOverrideCreator<MenuItemProps, MenuItemClassKey>;

package/menu/menu-item/menu-item-overrides.js

@@ -0,0 +1,25 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMuiMenuItemOverrides = void 0;
+var createMuiMenuItemOverrides = function (_a) {
+    var typography = _a.typography;
+    return {
+        styleOverrides: {
+            root: __assign(__assign({}, typography.body2), { height: 32, border: 'none', '&:last-child': {
+                    borderBottom: 'none',
+                } }),
+        },
+    };
+};
+exports.createMuiMenuItemOverrides = createMuiMenuItemOverrides;

package/menu/menu-list/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MenuList } from '@mui/material/MenuList';
+export type { MenuListProps as IMenuListProps } from '@mui/material/MenuList';

package/menu/menu-list/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuList = void 0;
+var MenuList_1 = require("@mui/material/MenuList");
+Object.defineProperty(exports, "MenuList", { enumerable: true, get: function () { return __importDefault(MenuList_1).default; } });

package/menu/menu-overrides.d.ts

@@ -0,0 +1,3 @@
+import type { MenuProps, MenuClassKey } from '@mui/material/Menu';
+import type { ComponentOverrideCreator } from '../theme/create-component-overrides';
+export declare const createMuiMenuOverrides: ComponentOverrideCreator<MenuProps, MenuClassKey>;

package/menu/menu-overrides.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMuiMenuOverrides = void 0;
+var createMuiMenuOverrides = function (_a) {
+    var tokens = _a.tokens;
+    return {
+        defaultProps: {
+            anchorOrigin: {
+                vertical: 'bottom',
+                horizontal: 'left',
+            },
+            transformOrigin: {
+                vertical: 'top',
+                horizontal: 'left',
+            },
+            // FIXME: No typing for this. Address during Component Migration
+            // getContentAnchorEl: null,
+        },
+        styleOverrides: {
+            paper: {
+                border: "1px solid ".concat(tokens.color_border_bold),
+                minWidth: 175,
+            },
+        },
+    };
+};
+exports.createMuiMenuOverrides = createMuiMenuOverrides;

package/menu/menu.d.ts

@@ -0,0 +1,2 @@
+export { default as Menu } from '@mui/material/Menu';
+export type { MenuProps as IMenuProps } from '@mui/material/Menu';

package/menu/menu.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Menu = void 0;
+var Menu_1 = require("@mui/material/Menu");
+Object.defineProperty(exports, "Menu", { enumerable: true, get: function () { return __importDefault(Menu_1).default; } });

package/mobile-stepper/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MobileStepper } from '@mui/material/MobileStepper';
+export type { MobileStepperProps as IMobileStepperProps } from '@mui/material/MobileStepper';

package/mobile-stepper/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileStepper = void 0;
+var MobileStepper_1 = require("@mui/material/MobileStepper");
+Object.defineProperty(exports, "MobileStepper", { enumerable: true, get: function () { return __importDefault(MobileStepper_1).default; } });

package/mobile-stepper/mobile-stepper-overrides.d.ts

@@ -0,0 +1,3 @@
+import type { MobileStepperProps, MobileStepperClassKey } from '@mui/material/MobileStepper';
+import type { ComponentOverrideCreator } from '../theme/create-component-overrides';
+export declare const createMuiMobileStepperOverrides: ComponentOverrideCreator<MobileStepperProps, MobileStepperClassKey>;

package/mobile-stepper/mobile-stepper-overrides.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMuiMobileStepperOverrides = void 0;
+var createMuiMobileStepperOverrides = function (_a) {
+    var spacing = _a.spacing;
+    return {
+        styleOverrides: {
+            dot: {
+                margin: spacing(0, 0.5),
+            },
+        },
+    };
+};
+exports.createMuiMobileStepperOverrides = createMuiMobileStepperOverrides;

package/mui-type-overrides.d.ts

@@ -0,0 +1,309 @@
+import * as MuiMaterialStyles from '@mui/material/styles';
+// tslint:disable: interface-name
+import * as MuiStyles from '@mui/styles';
+
+declare module '@mui/material' {
+  interface Color {
+    25: string;
+    1000: string;
+  }
+}
+
+declare module '@mui/material/styles' {
+  interface Theme {
+    layout: import('./theme/create-layout').ILayout;
+    /** Returns spacing as pc number value without the unit */
+    spacingPX(factor: number): number;
+    tokens: import('./theme/tokens').SemanticThemeTokens;
+  }
+
+  interface ThemeOptions {
+    layout?: Partial<import('./theme/create-layout').ILayout>;
+    /** Returns spacing as pc number value without the unit */
+    spacingPX?(factor: number): number;
+    tokens?: import('./theme/tokens').SemanticThemeTokens;
+  }
+
+  interface ComponentsPropsList {
+    QuantumAlert: import('./alert').IAlertProps;
+    QuantumAppBarActions: import('./app-bar').IAppBarActionsProps;
+    QuantumAppBarButton: import('./app-bar').IAppBarButtonProps;
+    QuantumAppBarContent: import('./app-bar').IAppBarContentProps;
+    QuantumAppBarDivider: import('./app-bar').IAppBarDividerProps;
+    QuantumAppBarIconButton: import('./app-bar').IAppBarIconButtonProps;
+    QuantumAvatar: import('./avatar').IAvatarProps;
+    QuantumDialogTitle: import('./dialog').IDialogTitleProps;
+    QuantumEmptyState: import('./empty-state').IEmptyStateProps;
+    QuantumLogo: import('./logo').ILogoProps;
+    QuantumSidebar: import('./sidebar').ISidebarProps;
+    QuantumSidebarBanner: import('./sidebar').ISidebarBannerProps;
+    QuantumSidebarItems: import('./sidebar').ISidebarItemsProps;
+    QuantumSidebarLink: import('./sidebar').ISidebarLinkProps;
+    QuantumSidebarMenu: import('./sidebar').ISidebarLinkProps;
+  }
+
+  interface ComponentNameToClassKey {
+    QuantumAlert: import('./alert/alert-classes').AlertClassKey;
+    QuantumAppBarActions: 'root';
+    QuantumAppBarButton: 'root';
+    QuantumAppBarContent: 'root';
+    QuantumAppBarDivider: 'root';
+    QuantumAppBarIconButton: 'root';
+    QuantumAvatar: import('./avatar/avatar-classes').AvatarClassKey;
+    QuantumDialogTitle: import('./dialog/dialog-title/dialog-title-classes').DialogTitleClassKey;
+    QuantumEmptyState: import('./empty-state/empty-state-classes').EmptyStateClassKey;
+    QuantumLogo: import('./logo/logo-classes').LogoClassKey;
+    QuantumSidebar: import('./sidebar/sidebar-classes').SidebarClassKey;
+    QuantumSidebarBanner: 'root';
+    QuantumSidebarItems: 'root';
+    QuantumSidebarLink: import('./sidebar/sidebar-link/sidebar-link-classes').SidebarLinkClassKey;
+    QuantumSidebarMenu: import('./sidebar/sidebar-menu').ISidebarMenuProps;
+  }
+
+  interface Components {
+    QuantumAppBarActions?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumAppBarActions'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumAppBarActions'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumAppBarActions'];
+    };
+    QuantumAppBarButton?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumAppBarButton'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumAppBarButton'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumAppBarButton'];
+    };
+    QuantumAppBarContent?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumAppBarContent'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumAppBarContent'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumAppBarContent'];
+    };
+    QuantumAppBarDivider?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumAppBarDivider'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumAppBarDivider'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumAppBarDivider'];
+    };
+    QuantumAppBarIconButton?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumAppBarIconButton'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumAppBarIconButton'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumAppBarIconButton'];
+    };
+    QuantumLogo?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumLogo'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumLogo'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumLogo'];
+    };
+    QuantumSidebar?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumSidebar'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumSidebar'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumSidebar'];
+    };
+    QuantumSidebarBanner?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumSidebarBanner'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumSidebarBanner'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumSidebarBanner'];
+    };
+    QuantumSidebarItems?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumSidebarItems'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumSidebarItems'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumSidebarItems'];
+    };
+    QuantumSidebarLink?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumSidebarLink'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumSidebarLink'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumSidebarLink'];
+    };
+    QuantumSidebarMenu?: {
+      defaultProps?: MuiMaterialStyles.ComponentsProps['QuantumSidebarMenu'];
+      styleOverrides?: MuiMaterialStyles.ComponentsOverrides<Theme>['QuantumSidebarMenu'];
+      variants?: MuiMaterialStyles.ComponentsVariants['QuantumSidebarMenu'];
+    };
+  }
+
+  interface PaletteColor {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+  }
+
+  interface Palette {
+    blue: import('./theme/colors').Color;
+    green: import('./theme/colors').Color;
+    magenta: import('./theme/colors').Color;
+    purple: import('./theme/colors').Color;
+    red: import('./theme/colors').Color;
+    yellow: import('./theme/colors').Color;
+    neutral: import('./theme/colors').Color;
+    border: {
+      light: string;
+      dark: string;
+      primary: string;
+      secondary: string;
+    };
+    background: {
+      surface: string;
+    };
+    default: MuiMaterialStyles.PaletteColor;
+    danger: MuiMaterialStyles.PaletteColor;
+    identicons: {
+      primary: {
+        light: string;
+        dark: string;
+        base: string;
+      };
+      default: {
+        light: string;
+        dark: string;
+        base: string;
+      };
+    };
+  }
+
+  interface TypeBackground {
+    surface: string;
+  }
+
+  interface TypeAction {
+    activeBackground: string;
+    hoverBackground: string;
+  }
+
+  interface PaletteOptions {
+    blue?: Partial<import('./theme/colors').Color>;
+    green?: Partial<import('./theme/colors').Color>;
+    magenta?: Partial<import('./theme/colors').Color>;
+    purple?: Partial<import('./theme/colors').Color>;
+    red?: Partial<import('./theme/colors').Color>;
+    yellow?: Partial<import('./theme/colors').Color>;
+    neutral?: Partial<import('./theme/colors').Color>;
+    border?: {
+      light?: string;
+      dark?: string;
+      primary?: string;
+      secondary?: string;
+    };
+    default?: Partial<MuiMaterialStyles.PaletteColor>;
+    danger?: Partial<MuiMaterialStyles.PaletteColor>;
+    identicons?: {
+      primary?: {
+        light: string;
+        dark: string;
+        base: string;
+      };
+      default?: {
+        light: string;
+        dark: string;
+        base: string;
+      };
+    };
+  }
+
+  interface TypographyVariants {
+    fontFamilyMonospace: string;
+    code1: MuiMaterialStyles.TypographyStyle;
+    code2: MuiMaterialStyles.TypographyStyle;
+    label: MuiMaterialStyles.TypographyStyle;
+    input: MuiMaterialStyles.TypographyStyle;
+    fontWeightSemibold: any;
+  }
+
+  interface TypographyVariantsOptions {
+    fontFamilyMonospace?: string;
+    code1?: MuiMaterialStyles.TypographyStyle;
+    code2?: MuiMaterialStyles.TypographyStyle;
+    label?: MuiMaterialStyles.TypographyStyle;
+    input?: MuiMaterialStyles.TypographyStyle;
+    fontWeightSemibold?: MuiMaterialStyles.TypographyStyle['fontWeight'];
+  }
+}
+
+declare module '@mui/material/styles/createMixins' {
+  interface Mixins {
+    focusRing(options?: { type?: 'default' | 'inset'; color?: string; opacity?: number }): MuiStyles.CSSProperties;
+    /** @deprecated  use tokens instead  */
+    shadeOfColor(color: import('./theme/colors').ColorName | 'grey', shade?: import('./theme/colors').Shade): string;
+    /** @deprecated use tokens instead */
+    textColorForShadeOfColor(
+      color: import('./theme/colors').ColorName | 'grey',
+      shade?: import('./theme/colors').Shade
+    ): string;
+    borderAsBoxShadow(color: string, width?: number): string;
+    appBarAction(): {
+      root: MuiStyles.CSSProperties;
+      hover: MuiStyles.CSSProperties;
+      focus: MuiStyles.CSSProperties;
+      active: MuiStyles.CSSProperties;
+    };
+    getColorModeValue<LightModeValue extends string = string, DarkModeValue extends string = string>(colorMap: {
+      light?: LightModeValue;
+      dark?: DarkModeValue;
+    }): LightModeValue | DarkModeValue;
+  }
+
+  interface MixinsOptions {
+    focusRing?(options?: { type?: 'default' | 'inset'; color?: string; opacity?: number }): MuiStyles.CSSProperties;
+    /** @deprecated  use tokens instead  */
+    shadeOfColor?(color: import('./theme/colors').ColorName | 'grey', shade?: import('./theme/colors').Shade): string;
+    /** @deprecated  use tokens instead  */
+    textColorForShadeOfColor?(
+      color: import('./theme/colors').ColorName | 'grey',
+      shade?: import('./theme/colors').Shade
+    ): string;
+    borderAsBoxShadow?(color: string, width?: number): string;
+    appBarAction?(): {
+      root: MuiStyles.CSSProperties;
+      hover: MuiStyles.CSSProperties;
+      focus: MuiStyles.CSSProperties;
+      active: MuiStyles.CSSProperties;
+    };
+    getColorModeValue?<LightModeValue extends string = string, DarkModeValue extends string = string>(colorMap: {
+      light?: LightModeValue;
+      dark?: DarkModeValue;
+    }): LightModeValue | DarkModeValue;
+  }
+}
+
+declare module '@mui/material/Button' {
+  interface ButtonPropsColorOverrides {
+    danger: true;
+    default: true;
+    error: false;
+    secondary: false;
+    success: false;
+    warning: false;
+  }
+
+  interface ButtonPropsVariantOverrides {
+    link: true;
+    text: false;
+  }
+}
+
+declare module '@mui/material/IconButton' {
+  interface IconButtonPropsColorOverrides {
+    danger: true;
+    error: false;
+    secondary: false;
+    success: false;
+    warning: false;
+  }
+}
+
+declare module '@mui/material/Badge' {
+  interface BadgePropsColorOverrides {
+    danger: true;
+    error: false;
+  }
+}
+
+declare module '@mui/material/Typography' {
+  interface TypographyPropsVariantOverrides {
+    code1: true;
+    code2: true;
+  }
+}

package/no-ssr/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NoSsr } from '@mui/material/NoSsr';
+export type { NoSsrProps as INoSsrProps } from '@mui/material/NoSsr';

package/no-ssr/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoSsr = void 0;
+var NoSsr_1 = require("@mui/material/NoSsr");
+Object.defineProperty(exports, "NoSsr", { enumerable: true, get: function () { return __importDefault(NoSsr_1).default; } });

package/overridable-component.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+/**
+ * A component whose root component can be controlled via a `component` prop.
+ *
+ * Adjusts valid props based on the type of `component`.
+ */
+export interface OverridableComponent<M extends OverridableTypeMap> {
+    <C extends React.ElementType>(props: {
+        /**
+         * The component used for the root node.
+         * Either a string to use a HTML element or a component.
+         */
+        component: C;
+    } & OverrideProps<M, C> & React.RefAttributes<unknown>): JSX.Element;
+    (props: DefaultComponentProps<M> & React.RefAttributes<unknown>): JSX.Element;
+}
+/**
+ * Props of the component if `component={Component}` is used.
+ */
+export declare type OverrideProps<M extends OverridableTypeMap, C extends React.ElementType> = M['props'] & Omit<React.ComponentProps<C>, keyof M['props'] | 'ref'>;
+/**
+ * Props if `component={Component}` is NOT used.
+ */
+export declare type DefaultComponentProps<M extends OverridableTypeMap> = M['props'] & Omit<React.ComponentProps<M['defaultComponent']>, keyof M['props'] | 'ref'>;
+export interface OverridableTypeMap {
+    props: {};
+    defaultComponent: React.ElementType;
+}

package/overridable-component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@auth0/quantum-product",
+  "version": "1.5.1",
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/auth0/quantum-product.git",
+    "directory": "packages/quantum-product"
+  },
+  "author": "Okta, Inc.",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "@auth0/quantum-tokens": "^1.1.1",
+    "@mui/material": "5.8.7",
+    "@mui/styles": "5.8.7",
+    "@mui/system": "5.8.7",
+    "@mui/utils": "5.8.6",
+    "clsx": "^1.2.1",
+    "md5": "^2.3.0",
+    "react-feather": "^2.0.10"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-dom": "*"
+  },
+  "scripts": {
+    "artifactory": "cd ./build && npm publish",
+    "build-storybook": "build-storybook",
+    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn copy:files",
+    "build:cjs": "tsc --project ./tsconfig.publish.json",
+    "build:esm": "tsc --project ./tsconfig.publish.esm.json",
+    "identicons": "rm -rf src/identicons/icons && yarn svgr --config-file .svgr.identicon.js -d src/identicons/icons src/identicons/svg",
+    "illustrations": "rm -rf src/illustrations/components && yarn svgr --config-file .svgr.illustration.js -d src/illustrations/components src/illustrations/svg",
+    "clean": "rm -rf ./build",
+    "copy:files": "node scripts/copy-files.js",
+    "storybook": "start-storybook -p 6006",
+    "verify": "yarn tsc --noEmit",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@a0/quantum-fonts": "^1.0.0",
+    "@babel/core": "^7.14.6",
+    "@faker-js/faker": "^7.4.0",
+    "@storybook/addon-a11y": "6.5.10",
+    "@storybook/addon-actions": "6.5.10",
+    "@storybook/addon-essentials": "6.5.10",
+    "@storybook/addon-links": "6.5.10",
+    "@storybook/react": "6.5.10",
+    "@storybook/theming": "6.5.10",
+    "@svgr/babel-plugin-replace-jsx-attribute-value": "^5.0.1",
+    "@svgr/cli": "^5.5.0",
+    "@testing-library/react": "v12.1.5",
+    "@types/md5": "^2.3.2",
+    "@types/node": "12.12.47",
+    "babel-loader": "^8.2.2",
+    "chromatic": "^6.5.4",
+    "figma-js": "^1.15.0",
+    "storybook-addon-designs": "^6.3.1",
+    "storybook-addon-themes": "^6.1.0",
+    "styled-components": "^5.3.3"
+  },
+  "module": "./esm/index.js"
+}

package/page/index.d.ts

@@ -0,0 +1,3 @@
+export { Page } from './page';
+export type { IPageProps } from './page';
+export * from './page-header';

package/page/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+var page_1 = require("./page");
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return page_1.Page; } });
+__exportStar(require("./page-header"), exports);

package/page/page-context.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface IPageContextValue {
+    fullWidth: boolean;
+    compact: boolean;
+}
+export declare const defaultPageSize = false;
+export declare const defaultCompactSize = false;
+export declare const PageContext: React.Context<IPageContextValue>;
+export declare const usePageContext: () => IPageContextValue;

package/page/page-context.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePageContext = exports.PageContext = exports.defaultCompactSize = exports.defaultPageSize = void 0;
+var React = __importStar(require("react"));
+exports.defaultPageSize = false;
+exports.defaultCompactSize = false;
+exports.PageContext = React.createContext({
+    fullWidth: exports.defaultPageSize,
+    compact: exports.defaultCompactSize,
+});
+var usePageContext = function () { return React.useContext(exports.PageContext); };
+exports.usePageContext = usePageContext;

package/page/page-header/index.d.ts

@@ -0,0 +1,3 @@
+export { PageHeader } from './page-header';
+export type { IPageHeaderProps } from './page-header';
+export { pageHeaderClasses } from './page-header-classes';

package/page/page-header/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageHeaderClasses = exports.PageHeader = void 0;
+var page_header_1 = require("./page-header");
+Object.defineProperty(exports, "PageHeader", { enumerable: true, get: function () { return page_header_1.PageHeader; } });
+var page_header_classes_1 = require("./page-header-classes");
+Object.defineProperty(exports, "pageHeaderClasses", { enumerable: true, get: function () { return page_header_classes_1.pageHeaderClasses; } });

package/page/page-header/page-header-classes.d.ts

@@ -0,0 +1,5 @@
+export declare const pageHeaderComponentName: "QuantumPageHeader";
+export declare function getPageHeaderUtilityClass(slot: string): string;
+export declare const pageHeaderClasses: Record<"title" | "metadata" | "content" | "root" | "avatar" | "actions" | "description" | "avatarBlock", string>;
+export declare type PageHeaderClasses = typeof pageHeaderClasses;
+export declare type PageHeaderClassKey = keyof PageHeaderClasses;