@primer/components 31.2.0-rc.fbb10090 → 31.2.0

package/lib/NewButton/button.jsx

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+const react_1 = __importStar(require("react"));
+const Box_1 = __importDefault(require("../Box"));
+const styled_components_1 = __importDefault(require("styled-components"));
+const sx_1 = __importStar(require("../sx"));
+const ThemeProvider_1 = require("../ThemeProvider");
+const getVariantStyles = (variant = 'default', theme) => {
+    const style = {
+        default: {
+            color: 'btn.text',
+            backgroundColor: 'btn.bg',
+            boxShadow: `${theme?.shadows.btn.shadow}, ${theme?.shadows.btn.insetShadow}`,
+            '&:hover:not([disabled])': {
+                backgroundColor: 'btn.hoverBg'
+            },
+            // focus must come before :active so that the active box shadow overrides
+            '&:focus:not([disabled])': {
+                boxShadow: `${theme?.shadows.btn.focusShadow}`
+            },
+            '&:active:not([disabled])': {
+                backgroundColor: 'btn.selectedBg',
+                boxShadow: `${theme?.shadows.btn.shadowActive}`
+            },
+            '&:disabled': {
+                color: 'primer.fg.disabled',
+                backgroundColor: 'btn.disabledBg'
+            }
+        },
+        primary: {
+            color: 'btn.primary.text',
+            backgroundColor: 'btn.primary.bg',
+            borderColor: 'border.subtle',
+            boxShadow: `${theme?.shadows.btn.primary.shadow}`,
+            '&:hover:not([disabled])': {
+                color: 'btn.primary.hoverText',
+                backgroundColor: 'btn.primary.hoverBg'
+            },
+            // focus must come before :active so that the active box shadow overrides
+            '&:focus:not([disabled])': {
+                boxShadow: `${theme?.shadows.btn.primary.focusShadow}`
+            },
+            '&:active:not([disabled])': {
+                backgroundColor: 'btn.primary.selectedBg',
+                boxShadow: `${theme?.shadows.btn.primary.selectedShadow}`
+            },
+            '&:disabled': {
+                color: 'btn.primary.disabledText',
+                backgroundColor: 'btn.primary.disabledBg'
+            },
+            '[data-component="ButtonCounter"]': {
+                backgroundColor: 'btn.primary.counterBg',
+                color: 'btn.primary.text'
+            }
+        },
+        danger: {
+            color: 'btn.danger.text',
+            backgroundColor: 'btn.bg',
+            boxShadow: `${theme?.shadows.btn.shadow}`,
+            '&:hover:not([disabled])': {
+                color: 'btn.danger.hoverText',
+                backgroundColor: 'btn.danger.hoverBg',
+                borderColor: 'btn.danger.hoverBorder',
+                boxShadow: `${theme?.shadows.btn.danger.hoverShadow}`,
+                '[data-component="ButtonCounter"]': {
+                    backgroundColor: 'btn.danger.hoverCounterBg',
+                    color: 'btn.danger.hoverText'
+                }
+            },
+            // focus must come before :active so that the active box shadow overrides
+            '&:focus:not([disabled])': {
+                borderColor: 'btn.danger.focusBorder',
+                boxShadow: `${theme?.shadows.btn.danger.focusShadow}`
+            },
+            '&:active:not([disabled])': {
+                color: 'btn.danger.selectedText',
+                backgroundColor: 'btn.danger.selectedBg',
+                boxShadow: `${theme?.shadows.btn.danger.selectedShadow}`,
+                borderColor: 'btn.danger.selectedBorder'
+            },
+            '&:disabled': {
+                color: 'btn.danger.disabledText',
+                backgroundColor: 'btn.danger.disabledBg',
+                borderColor: 'btn.danger.disabledBorder',
+                '[data-component="ButtonCounter"]': {
+                    backgroundColor: 'btn.danger.disabledCounterBg'
+                }
+            },
+            '[data-component="ButtonCounter"]': {
+                color: 'btn.danger.text',
+                backgroundColor: 'btn.danger.counterBg'
+            }
+        },
+        invisible: {
+            color: 'accent.fg',
+            backgroundColor: 'transparent',
+            border: '0',
+            boxShadow: 'none',
+            '&:hover:not([disabled])': {
+                backgroundColor: 'btn.hoverBg'
+            },
+            // focus must come before :active so that the active box shadow overrides
+            '&:focus:not([disabled])': {
+                boxShadow: `${theme?.shadows.btn.focusShadow}`
+            },
+            '&:active:not([disabled])': {
+                backgroundColor: 'btn.selectedBg'
+            },
+            '&:disabled': {
+                color: 'primer.fg.disabled'
+            }
+        },
+        outline: {
+            color: 'btn.outline.text',
+            boxShadow: `${theme?.shadows.btn.shadow}`,
+            '&:hover': {
+                color: 'btn.outline.hoverText',
+                backgroundColor: 'btn.outline.hoverBg',
+                borderColor: 'outline.hoverBorder',
+                boxShadow: `${theme?.shadows.btn.outline.hoverShadow}`,
+                '[data-component="ButtonCounter"]': {
+                    backgroundColor: 'btn.outline.hoverCounterBg',
+                    color: 'btn.outline.hoverText'
+                }
+            },
+            // focus must come before :active so that the active box shadow overrides
+            '&:focus': {
+                borderColor: 'btn.outline.focusBorder',
+                boxShadow: `${theme?.shadows.btn.outline.focusShadow}`
+            },
+            '&:active': {
+                color: 'btn.outline.selectedText',
+                backgroundColor: 'btn.outline.selectedBg',
+                boxShadow: `${theme?.shadows.btn.outline.selectedShadow}`,
+                borderColor: 'btn.outline.selectedBorder'
+            },
+            '&:disabled': {
+                color: 'btn.outline.disabledText',
+                backgroundColor: 'btn.outline.disabledBg',
+                borderColor: 'btn.border',
+                '[data-component="ButtonCounter"]': {
+                    backgroundColor: 'btn.outline.disabledCounterBg'
+                }
+            },
+            '[data-component="ButtonCounter"]': {
+                backgroundColor: 'btn.outline.counterBg',
+                color: 'btn.outline.text'
+            }
+        }
+    };
+    return style[variant];
+};
+const getSizeStyles = (size = 'medium', variant = 'default', iconOnly) => {
+    let paddingY, paddingX, fontSize;
+    switch (size) {
+        case 'small':
+            paddingY = 3;
+            paddingX = 12;
+            fontSize = 0;
+            break;
+        case 'large':
+            paddingY = 9;
+            paddingX = 20;
+            fontSize = 2;
+            break;
+        case 'medium':
+        default:
+            paddingY = 5;
+            paddingX = 16;
+            fontSize = 1;
+    }
+    if (iconOnly) {
+        paddingX = paddingY + 2;
+    }
+    if (variant === 'invisible') {
+        paddingY = paddingY + 1;
+    }
+    return {
+        paddingY: `${paddingY}px`,
+        paddingX: `${paddingX}px`,
+        fontSize,
+        '[data-component="ButtonCounter"]': {
+            fontSize
+        }
+    };
+};
+const ButtonBase = styled_components_1.default.button(sx_1.default);
+const Button = react_1.forwardRef(({ children, ...props }, forwardedRef) => {
+    const { icon: Icon, leadingIcon: LeadingIcon, trailingIcon: TrailingIcon, variant = 'default', size = 'medium', sx: sxProp = {} } = props;
+    const iconOnly = !!Icon;
+    const TEXT_ROW_HEIGHT = '20px'; // custom value off the scale
+    const { theme } = ThemeProvider_1.useTheme();
+    const styles = {
+        borderRadius: '2',
+        border: '1px solid',
+        borderColor: theme?.colors.btn.border,
+        display: 'grid',
+        gridTemplateAreas: '"leadingIcon text trailingIcon"',
+        fontWeight: 'bold',
+        lineHeight: TEXT_ROW_HEIGHT,
+        whiteSpace: 'nowrap',
+        verticalAlign: 'middle',
+        cursor: 'pointer',
+        appearance: 'none',
+        userSelect: 'none',
+        textDecoration: 'none',
+        textAlign: 'center',
+        '> :not(:last-child), :not(\'[data-component="icon-only"]\')': {
+            mr: '2'
+        },
+        '&:focus': {
+            outline: 'none'
+        },
+        '&:disabled': {
+            cursor: 'default'
+        },
+        '&:disabled svg': {
+            opacity: '0.6'
+        },
+        '[data-component="leadingIcon"]': {
+            gridArea: 'leadingIcon'
+        },
+        '[data-component="text"]': {
+            gridArea: 'text'
+        },
+        '[data-component="trailingIcon"]': {
+            gridArea: 'trailingIcon'
+        }
+    };
+    const variableStyles = { ...getSizeStyles(size, variant, iconOnly), ...getVariantStyles(variant, theme) };
+    const componentStyles = { ...styles, ...variableStyles };
+    const iconWrapStyles = {
+        display: 'inline-block'
+    };
+    return (
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Why wont it accept the sx prop?
+    <ButtonBase sx={sx_1.merge(componentStyles, sxProp)} ref={forwardedRef} {...props}>
+      {LeadingIcon && (<Box_1.default as="span" data-component="leadingIcon" sx={iconWrapStyles} aria-hidden={!iconOnly}>
+          <LeadingIcon />
+        </Box_1.default>)}
+      {Icon && (<Box_1.default data-component="icon-only" as="span" sx={{ display: 'inline-block' }} aria-hidden={!iconOnly}>
+          <Icon />
+        </Box_1.default>)}
+      <span data-component="text" hidden={Icon ? true : false}>
+        {children}
+      </span>
+      {TrailingIcon && (<Box_1.default as="span" data-component="trailingIcon" sx={{ ...iconWrapStyles, ml: 2 }} aria-hidden={!iconOnly}>
+          <TrailingIcon />
+        </Box_1.default>)}
+    </ButtonBase>);
+});
+exports.Button = Button;
+Button.displayName = 'Button';
+Object.assign(Button, {});

package/lib/NewButton/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { ButtonProps } from './types';
+export type { ButtonProps as NewButtonProps };
+export declare const NewButton: import("react").ForwardRefExoticComponent<{
+    variant?: import("./types").VariantType | undefined;
+    size?: import("./types").Size | undefined;
+    icon?: import("react").FunctionComponent<import("@primer/octicons-react/dist/icons").IconProps> | undefined;
+    leadingIcon?: import("react").FunctionComponent<import("@primer/octicons-react/dist/icons").IconProps> | undefined;
+    trailingIcon?: import("react").FunctionComponent<import("@primer/octicons-react/dist/icons").IconProps> | undefined;
+    disabled?: boolean | undefined;
+    children: import("react").ReactNode;
+} & import("../sx").SxProp & import("react").HTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>> & {
+    Counter: ({ children, sx: sxProp, ...props }: import("./button-counter").CounterProps) => JSX.Element;
+};

package/lib/NewButton/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewButton = void 0;
+const button_1 = require("./button");
+const button_counter_1 = require("./button-counter");
+exports.NewButton = Object.assign(button_1.Button, {
+    Counter: button_counter_1.Counter
+});

package/lib/NewButton/types.d.ts

@@ -0,0 +1,32 @@
+import React, { HTMLAttributes } from 'react';
+import { IconProps } from '@primer/octicons-react';
+import { SxProp } from '../sx';
+export declare type VariantType = 'default' | 'primary' | 'invisible' | 'danger' | 'outline';
+export declare type Size = 'small' | 'medium' | 'large';
+export declare type ButtonProps = {
+    /**
+     * Determine's the styles on a button one of 'default' | 'primary' | 'invisible' | 'danger'
+     */
+    variant?: VariantType;
+    /**
+     * Size of button and fontSize of text in button
+     */
+    size?: Size;
+    /**
+     * This is to be used if it is an icon-only button. Will make text visually hidden
+     */
+    icon?: React.FunctionComponent<IconProps>;
+    /**
+     * The leading icon comes before button content
+     */
+    leadingIcon?: React.FunctionComponent<IconProps>;
+    /**
+     * The trailing icon comes after button content
+     */
+    trailingIcon?: React.FunctionComponent<IconProps>;
+    /**
+     * Items that are disabled can not be clicked, selected, or navigated through.
+     */
+    disabled?: boolean;
+    children: React.ReactNode;
+} & SxProp & HTMLAttributes<HTMLButtonElement>;

package/lib/NewButton/types.js

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

package/lib/Overlay.js

@@ -11,6 +11,8 @@ var _react = _interopRequireWildcard(require("react"));
 
 var _constants = require("./constants");
 
+var _useIsomorphicLayoutEffect = _interopRequireDefault(require("./utils/useIsomorphicLayoutEffect"));
+
 var _hooks = require("./hooks");
 
 var _Portal = _interopRequireDefault(require("./Portal"));
@@ -139,7 +141,7 @@ const Overlay = /*#__PURE__*/_react.default.forwardRef(({
       combinedRef.current.style.height = `${combinedRef.current.clientHeight}px`;
     }
   }, [height, combinedRef]);
-  (0, _react.useLayoutEffect)(() => {
+  (0, _useIsomorphicLayoutEffect.default)(() => {
     var _overlayRef$current;
 
     const {

package/lib/Overlay.jsx

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const styled_components_1 = __importDefault(require("styled-components"));
+const react_1 = __importStar(require("react"));
+const constants_1 = require("./constants");
+const useIsomorphicLayoutEffect_1 = __importDefault(require("./utils/useIsomorphicLayoutEffect"));
+const hooks_1 = require("./hooks");
+const Portal_1 = __importDefault(require("./Portal"));
+const sx_1 = __importDefault(require("./sx"));
+const useCombinedRefs_1 = require("./hooks/useCombinedRefs");
+const ThemeProvider_1 = require("./ThemeProvider");
+const heightMap = {
+    xsmall: '192px',
+    small: '256px',
+    medium: '320px',
+    large: '432px',
+    xlarge: '600px',
+    auto: 'auto',
+    initial: 'auto' // Passing 'initial' initially applies 'auto'
+};
+const widthMap = {
+    small: '256px',
+    medium: '320px',
+    large: '480px',
+    xlarge: '640px',
+    xxlarge: '960px',
+    auto: 'auto'
+};
+const animationDuration = 200;
+function getSlideAnimationStartingVector(anchorSide) {
+    if (anchorSide?.endsWith('bottom')) {
+        return { x: 0, y: -1 };
+    }
+    else if (anchorSide?.endsWith('top')) {
+        return { x: 0, y: 1 };
+    }
+    else if (anchorSide?.endsWith('right')) {
+        return { x: -1, y: 0 };
+    }
+    else if (anchorSide?.endsWith('left')) {
+        return { x: 1, y: 0 };
+    }
+    return { x: 0, y: 0 };
+}
+const StyledOverlay = styled_components_1.default.div `
+  background-color: ${constants_1.get('colors.canvas.overlay')};
+  box-shadow: ${constants_1.get('shadows.overlay.shadow')};
+  position: absolute;
+  min-width: 192px;
+  max-width: 640px;
+  height: ${props => heightMap[props.height || 'auto']};
+  max-height: ${props => props.maxHeight && heightMap[props.maxHeight]};
+  width: ${props => widthMap[props.width || 'auto']};
+  border-radius: 12px;
+  overflow: hidden;
+  animation: overlay-appear ${animationDuration}ms ${constants_1.get('animation.easeOutCubic')};
+
+  @keyframes overlay-appear {
+    0% {
+      opacity: 0;
+    }
+    100% {
+      opacity: 1;
+    }
+  }
+  visibility: var(--styled-overlay-visibility);
+  :focus {
+    outline: none;
+  }
+  ${constants_1.COMMON};
+  ${sx_1.default};
+`;
+/**
+ * An `Overlay` is a flexible floating surface, used to display transient content such as menus,
+ * selection options, dialogs, and more. Overlays use shadows to express elevation. The `Overlay`
+ * component handles all behaviors needed by overlay UIs as well as the common styles that all overlays * should have.
+ * @param ignoreClickRefs Optional. An array of ref objects to ignore clicks on in the `onOutsideClick` behavior. This is often used to ignore clicking on the element that toggles the open/closed state for the `Overlay` to prevent the `Overlay` from being toggled twice.
+ * @param initialFocusRef Optional. Ref for the element to focus when the `Overlay` is opened. If nothing is provided, the first focusable element in the `Overlay` body is focused.
+ * @param returnFocusRef Required. Ref for the element to focus when the `Overlay` is closed.
+ * @param onClickOutside  Required. Function to call when clicking outside of the `Overlay`. Typically this function removes the Overlay.
+ * @param onEscape Required. Function to call when user presses `Escape`. Typically this function removes the Overlay.
+ * @param width Sets the width of the `Overlay`, pick from our set list of widths, or pass `auto` to automatically set the width based on the content of the `Overlay`. `small` corresponds to `256px`, `medium` corresponds to `320px`, `large` corresponds to `480px`, `xlarge` corresponds to `640px`, `xxlarge` corresponds to `960px`.
+ * @param height Sets the height of the `Overlay`, pick from our set list of heights, or pass `auto` to automatically set the height based on the content of the `Overlay`, or pass `initial` to set the height based on the initial content of the `Overlay` (i.e. ignoring content changes). `xsmall` corresponds to `192px`, `small` corresponds to `256px`, `medium` corresponds to `320px`, `large` corresponds to `432px`, `xlarge` corresponds to `600px`.
+ * @param maxHeight Sets the maximum height of the `Overlay`, pick from our set list of heights. `xsmall` corresponds to `192px`, `small` corresponds to `256px`, `medium` corresponds to `320px`, `large` corresponds to `432px`, `xlarge` corresponds to `600px`.
+ * @param anchorSide If provided, the Overlay will slide into position from the side of the anchor with a brief animation
+ * @param top Optional. Vertical position of the overlay, relative to its closest positioned ancestor (often its `Portal`).
+ * @param left Optional. Horizontal position of the overlay, relative to its closest positioned ancestor (often its `Portal`).
+ * @param portalContainerName Optional. The name of the portal container to render the Overlay into.
+ */
+const Overlay = react_1.default.forwardRef(({ onClickOutside, role = 'none', initialFocusRef, returnFocusRef, ignoreClickRefs, onEscape, visibility = 'visible', height, top, left, anchorSide, portalContainerName, preventFocusOnOpen, ...rest }, forwardedRef) => {
+    const overlayRef = react_1.useRef(null);
+    const combinedRef = useCombinedRefs_1.useCombinedRefs(overlayRef, forwardedRef);
+    const { theme } = ThemeProvider_1.useTheme();
+    const slideAnimationDistance = parseInt(constants_1.get('space.2')(theme).replace('px', ''));
+    const slideAnimationEasing = constants_1.get('animation.easeOutCubic')(theme);
+    hooks_1.useOverlay({
+        overlayRef,
+        returnFocusRef,
+        onEscape,
+        ignoreClickRefs,
+        onClickOutside,
+        initialFocusRef,
+        preventFocusOnOpen
+    });
+    react_1.useEffect(() => {
+        if (height === 'initial' && combinedRef.current?.clientHeight) {
+            combinedRef.current.style.height = `${combinedRef.current.clientHeight}px`;
+        }
+    }, [height, combinedRef]);
+    useIsomorphicLayoutEffect_1.default(() => {
+        const { x, y } = getSlideAnimationStartingVector(anchorSide);
+        if ((!x && !y) || !overlayRef.current?.animate || visibility === 'hidden') {
+            return;
+        }
+        // JS animation is required because Safari does not allow css animations to start paused and then run
+        overlayRef.current.animate({ transform: [`translate(${slideAnimationDistance * x}px, ${slideAnimationDistance * y}px)`, `translate(0, 0)`] }, {
+            duration: animationDuration,
+            easing: slideAnimationEasing
+        });
+    }, [anchorSide, slideAnimationDistance, slideAnimationEasing, visibility]);
+    return (<Portal_1.default containerName={portalContainerName}>
+        <StyledOverlay height={height} role={role} {...rest} ref={combinedRef} style={{
+            top: `${top || 0}px`,
+            left: `${left || 0}px`,
+            ...rest.style,
+            '--styled-overlay-visibility': visibility
+        }}/>
+      </Portal_1.default>);
+});
+Overlay.defaultProps = {
+    height: 'auto',
+    width: 'auto'
+};
+exports.default = Overlay;

package/lib/Pagehead.jsx

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const styled_components_1 = __importDefault(require("styled-components"));
+const constants_1 = require("./constants");
+const sx_1 = __importDefault(require("./sx"));
+const Pagehead = styled_components_1.default.div `
+  position: relative;
+  padding-top: ${constants_1.get('space.4')};
+  padding-bottom: ${constants_1.get('space.4')};
+  margin-bottom: ${constants_1.get('space.4')};
+  border-bottom: 1px solid ${constants_1.get('colors.border.default')};
+  ${constants_1.COMMON};
+  ${sx_1.default};
+`;
+exports.default = Pagehead;