@primer/components 0.0.0-2021103231920 → 0.0.0-20211040245

package/lib/AnchoredOverlay/AnchoredOverlay.d.ts

@@ -26,6 +26,8 @@ interface AnchoredOverlayPropsWithoutAnchor {
      */
     anchorRef: React.RefObject<HTMLElement>;
 }
+export declare type OverlayOpenGesture = 'anchor-click' | 'anchor-key-press';
+export declare type OverlayCloseGesture = 'anchor-click' | 'click-outside' | 'escape';
 export declare type AnchoredOverlayWrapperAnchorProps = Partial<AnchoredOverlayPropsWithAnchor> | AnchoredOverlayPropsWithoutAnchor;
 interface AnchoredOverlayBaseProps extends Pick<OverlayProps, 'height' | 'width'> {
     /**
@@ -35,11 +37,11 @@ interface AnchoredOverlayBaseProps extends Pick<OverlayProps, 'height' | 'width'
     /**
      * A callback which is called whenever the overlay is currently closed and an "open gesture" is detected.
      */
-    onOpen?: (gesture: 'anchor-click' | 'anchor-key-press') => unknown;
+    onOpen?: (gesture: OverlayOpenGesture) => unknown;
     /**
      * A callback which is called whenever the overlay is currently open and a "close gesture" is detected.
      */
-    onClose?: (gesture: 'anchor-click' | 'click-outside' | 'escape') => unknown;
+    onClose?: (gesture: OverlayCloseGesture) => unknown;
     /**
      * Props to be spread on the internal `Overlay` component.
      */

package/lib/Autocomplete/Autocomplete.d.ts

@@ -12,12 +12,14 @@ export type { AutocompleteOverlayProps } from './AutocompleteOverlay';
 declare const _default: React.FC<{
     id?: string | undefined;
 }> & {
-    Input: import("@radix-ui/react-polymorphic").ForwardRefComponent<React.ForwardRefExoticComponent<Pick<Omit<Pick<{
+    Input: import("@radix-ui/react-polymorphic").ForwardRefComponent<React.ForwardRefExoticComponent<Pick<Omit<Pick<({
         [x: string]: any;
         [x: number]: any;
     } & {
         theme?: any;
-    } & {
+    } & ({} | {
+        children?: React.ReactNode;
+    })) & {
         as?: string | React.ComponentType<any> | undefined;
         forwardedAs?: string | React.ComponentType<any> | undefined;
     }, string | number | symbol>, "maxWidth" | "minWidth" | "width" | "theme" | "className" | "block" | "icon" | "sx" | "disabled" | "variant" | "contrast"> & {

package/lib/Autocomplete/AutocompleteInput.d.ts

@@ -4,12 +4,14 @@ import { ComponentProps } from '../utils/types';
 declare type InternalAutocompleteInputProps = {
     as?: React.ComponentType<any>;
 };
-declare const AutocompleteInput: PolymorphicForwardRefComponent<React.ForwardRefExoticComponent<Pick<Omit<Pick<{
+declare const AutocompleteInput: PolymorphicForwardRefComponent<React.ForwardRefExoticComponent<Pick<Omit<Pick<({
     [x: string]: any;
     [x: number]: any;
 } & {
     theme?: any;
-} & {
+} & ({} | {
+    children?: React.ReactNode;
+})) & {
     as?: string | React.ComponentType<any> | undefined;
     forwardedAs?: string | React.ComponentType<any> | undefined;
 }, string | number | symbol>, "maxWidth" | "minWidth" | "width" | "theme" | "className" | "block" | "icon" | "sx" | "disabled" | "variant" | "contrast"> & {

package/lib/DatePicker/DatePicker.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { OverlayProps } from '../Overlay';
+import { FocusTrapHookSettings } from '../hooks/useFocusTrap';
+import { FocusZoneHookSettings } from '../hooks/useFocusZone';
+import { DatePickerConfiguration, Selection } from './useDatePicker';
+declare type OpenGesture = 'anchor-click' | 'anchor-key-press';
+declare type CloseGesture = 'anchor-click' | 'click-outside' | 'escape';
+export interface DatePickerProps extends DatePickerConfiguration {
+    /**
+     * An override to the internal ref that will be spread on to the renderAnchor
+     */
+    anchorRef?: React.RefObject<HTMLElement>;
+    /**
+     * Settings to apply to the Focus Zone on the internal `Overlay` component.
+     */
+    focusTrapSettings?: Partial<FocusTrapHookSettings>;
+    /**
+     * Settings to apply to the Focus Zone on the internal `Overlay` component.
+     */
+    focusZoneSettings?: Partial<FocusZoneHookSettings>;
+    initialValue?: 'today' | Date | string | null;
+    iconOnly?: boolean;
+    placeholder?: string;
+    /**
+     * Determines whether the overlay portion of the component should be shown or not
+     */
+    open?: boolean;
+    /**
+     * A callback which is called whenever the overlay is currently closed and an "open gesture" is detected.
+     */
+    onOpen?: (gesture: OpenGesture) => unknown;
+    /**
+     * A callback which is called whenever the overlay is currently open and a "close gesture" is detected.
+     */
+    onClose?: (gesture: CloseGesture) => unknown;
+    /**
+     * Props to be spread on the internal `Overlay` component.
+     */
+    overlayProps?: Partial<OverlayProps>;
+    /**
+     * A custom function component used to render the anchor element.
+     * Will receive the selected text as `children` prop when an item is activated.
+     */
+    renderAnchor?: <T extends React.HTMLAttributes<HTMLElement>>(props: T) => JSX.Element;
+    value?: Selection;
+    /**
+     * Minimum date to select
+     */
+    minDate?: Date | null;
+}
+export declare const DatePicker: React.FC<DatePickerProps>;
+export {};

package/lib/DatePicker/DatePicker.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatePicker = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _DatePickerAnchor = require("./DatePickerAnchor");
+
+var _useDatePicker = require("./useDatePicker");
+
+var _DatePickerOverlay = require("./DatePickerOverlay");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const DatePicker = ({
+  anchorVariant,
+  anchorRef: externalAnchorRef,
+  confirmation,
+  confirmUnsavedClose,
+  compressedHeader,
+  dateFormat,
+  disableWeekends,
+  focusTrapSettings,
+  focusZoneSettings,
+  iconPlacement,
+  maxDate,
+  maxRangeSize,
+  maxSelections,
+  minDate,
+  onOpen: onOpenExternal,
+  onClose: onCloseExternal,
+  open,
+  overlayProps,
+  placeholder,
+  renderAnchor = null,
+  showInputPrompt,
+  value,
+  variant,
+  view,
+  weekStartsOn
+}) => {
+  const anchorRef = (0, _react.useRef)(null);
+  const [isOpen, setIsOpen] = (0, _react.useState)(false);
+  const datePickerConfiguration = {
+    anchorVariant,
+    confirmation,
+    confirmUnsavedClose,
+    compressedHeader,
+    dateFormat,
+    disableWeekends,
+    iconPlacement,
+    maxDate: maxDate ? new Date(new Date(maxDate).toDateString()) : maxDate,
+    maxRangeSize,
+    maxSelections,
+    minDate: minDate ? new Date(new Date(minDate).toDateString()) : minDate,
+    placeholder,
+    showInputPrompt,
+    variant,
+    view,
+    weekStartsOn
+  };
+
+  const onOpen = gesture => {
+    setIsOpen(true);
+    onOpenExternal === null || onOpenExternal === void 0 ? void 0 : onOpenExternal(gesture);
+  };
+
+  const onClose = gesture => {
+    setIsOpen(false);
+    onCloseExternal === null || onCloseExternal === void 0 ? void 0 : onCloseExternal(gesture);
+  };
+
+  const toggleIsOpen = () => {
+    if (isOpen) {
+      setIsOpen(false);
+      onCloseExternal === null || onCloseExternal === void 0 ? void 0 : onCloseExternal('anchor-click');
+    } else {
+      setIsOpen(true);
+      onCloseExternal === null || onCloseExternal === void 0 ? void 0 : onCloseExternal('anchor-click');
+    }
+  };
+
+  return /*#__PURE__*/_react.default.createElement(_useDatePicker.DatePickerProvider, {
+    configuration: datePickerConfiguration,
+    isOpen: isOpen,
+    value: value,
+    closePicker: () => setIsOpen(false)
+  }, /*#__PURE__*/_react.default.createElement(_DatePickerAnchor.DatePickerAnchor, {
+    ref: anchorRef,
+    onAction: toggleIsOpen
+  }), /*#__PURE__*/_react.default.createElement(_DatePickerOverlay.DatePickerOverlay, {
+    anchorRef: externalAnchorRef !== null && externalAnchorRef !== void 0 ? externalAnchorRef : anchorRef,
+    renderAnchor: renderAnchor,
+    open: open !== null && open !== void 0 ? open : isOpen,
+    onOpen: onOpen,
+    onClose: onClose,
+    overlayProps: overlayProps,
+    focusTrapSettings: focusTrapSettings,
+    focusZoneSettings: focusZoneSettings
+  }));
+};
+
+exports.DatePicker = DatePicker;
+DatePicker.displayName = "DatePicker";

package/lib/DatePicker/DatePickerAnchor.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface DatePickerAnchorProps {
+    onAction?: (event?: React.MouseEvent<HTMLDivElement> | React.KeyboardEvent<HTMLDivElement>) => void;
+}
+export declare const DatePickerAnchor: React.ForwardRefExoticComponent<DatePickerAnchorProps & React.RefAttributes<HTMLDivElement>>;

package/lib/DatePicker/DatePickerAnchor.js

@@ -0,0 +1,202 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatePickerAnchor = void 0;
+
+var _octiconsReact = require("@primer/octicons-react");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _Button = _interopRequireWildcard(require("../Button"));
+
+var _Text = _interopRequireDefault(require("../Text"));
+
+var _constants = require("../constants");
+
+var _StyledOcticon = _interopRequireDefault(require("../StyledOcticon"));
+
+var _useDatePicker = _interopRequireDefault(require("./useDatePicker"));
+
+var _TextInput = _interopRequireDefault(require("../TextInput"));
+
+var _Box = _interopRequireDefault(require("../Box"));
+
+var _dateParser = require("./dateParser");
+
+var _ = require("..");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DatePickerAnchorButton = (0, _styledComponents.default)(_Button.default).withConfig({
+  displayName: "DatePickerAnchor__DatePickerAnchorButton",
+  componentId: "sc-8gpb9d-0"
+})(["align-items:center;display:flex;flex-direction:row;justify-content:space-between;max-width:350px;overflow:hidden;& ", " ~ svg{margin-left:", ";}& svg ~ ", "{margin-left:", ";}"], _Text.default, (0, _constants.get)('space.2'), _Text.default, (0, _constants.get)('space.2'));
+
+const DatePickerAnchor = /*#__PURE__*/_react.default.forwardRef(({
+  onAction
+}, ref) => {
+  const {
+    configuration: {
+      anchorVariant,
+      iconPlacement,
+      placeholder,
+      variant
+    },
+    disabled,
+    formattedDate,
+    inputDate,
+    onDateInput
+  } = (0, _useDatePicker.default)();
+  const [inputValue, setInputValue] = (0, _react.useState)(formattedDate);
+  const inputRef = (0, _react.useRef)(null);
+  const [inputValid, setInputValid] = (0, _react.useState)(true);
+  const [inputFocused, setInputFocused] = (0, _react.useState)(false);
+  const keyPressHandler = (0, _react.useCallback)(event => {
+    if (disabled) {
+      return;
+    }
+
+    if ([' ', 'Enter'].includes(event.key)) {
+      onAction === null || onAction === void 0 ? void 0 : onAction(event);
+    }
+  }, [disabled, onAction]);
+  const clickHandler = (0, _react.useCallback)(event => {
+    if (disabled) {
+      return;
+    }
+
+    onAction === null || onAction === void 0 ? void 0 : onAction(event);
+  }, [disabled, onAction]);
+  (0, _react.useEffect)(() => {
+    if (document.activeElement !== inputRef.current) {
+      setInputValue(formattedDate);
+    }
+  }, [formattedDate]);
+  const onInputChangeHandler = (0, _react.useCallback)(e => {
+    const value = e.currentTarget.value;
+    setInputValue(value);
+
+    if (!value) {
+      return;
+    }
+
+    const parsedDate = (0, _dateParser.parseDate)(value, variant);
+    setInputValid(!!parsedDate);
+
+    if (parsedDate) {
+      onDateInput(parsedDate);
+    }
+  }, [onDateInput, variant]);
+
+  const onFocusHandler = () => {
+    setInputValue(inputDate);
+    setInputFocused(true);
+  };
+
+  const onBlurHandler = () => {
+    setInputValue(formattedDate);
+    setInputValid(true);
+    setInputFocused(false);
+  };
+
+  const inputSx = (0, _react.useMemo)(() => {
+    let sxObject = {};
+
+    if (iconPlacement === 'start') {
+      sxObject = { ...sxObject,
+        pl: 5,
+        pr: 2
+      };
+    } else if (iconPlacement === 'end') {
+      sxObject = { ...sxObject,
+        pl: 2,
+        pr: 5
+      };
+    }
+
+    return sxObject;
+  }, [iconPlacement]);
+
+  if (anchorVariant === 'input') {
+    const calendarButton = side => /*#__PURE__*/_react.default.createElement(_Button.ButtonInvisible, {
+      onClick: clickHandler,
+      sx: {
+        width: '32px',
+        px: '6px',
+        position: 'absolute',
+        [side]: '1px',
+        top: '1px',
+        bottom: '1px'
+      }
+    }, /*#__PURE__*/_react.default.createElement(_StyledOcticon.default, {
+      icon: _octiconsReact.CalendarIcon
+    }));
+
+    const iconSx = () => ({
+      position: 'absolute',
+      top: 0,
+      bottom: 0,
+      right: iconPlacement === 'end' ? '36px' : '10px',
+      display: 'flex',
+      alignItems: 'center'
+    });
+
+    return /*#__PURE__*/_react.default.createElement(_Box.default, {
+      ref: ref,
+      sx: {
+        position: 'relative',
+        display: 'flex'
+      }
+    }, iconPlacement === 'start' && calendarButton('left'), /*#__PURE__*/_react.default.createElement(_TextInput.default, {
+      ref: inputRef,
+      placeholder: placeholder,
+      value: inputValue,
+      onChange: onInputChangeHandler,
+      sx: inputSx,
+      onBlur: onBlurHandler,
+      onFocus: onFocusHandler
+    }), /*#__PURE__*/_react.default.createElement(_Box.default, {
+      sx: iconSx()
+    }, inputValid && inputFocused && /*#__PURE__*/_react.default.createElement(_StyledOcticon.default, {
+      icon: _octiconsReact.CheckIcon,
+      color: "success.emphasis"
+    }), !inputValid && /*#__PURE__*/_react.default.createElement(_.Tooltip, {
+      direction: "s",
+      text: "Invalid entry. Please make sure you use the 'MM/DD/YYYY' format."
+    }, /*#__PURE__*/_react.default.createElement(_StyledOcticon.default, {
+      icon: _octiconsReact.AlertIcon,
+      color: "attention.emphasis"
+    }))), iconPlacement === 'end' && calendarButton('right'));
+  }
+
+  const calendarIcon = () => /*#__PURE__*/_react.default.createElement(_StyledOcticon.default, {
+    icon: _octiconsReact.CalendarIcon,
+    color: "fg.muted",
+    sx: {
+      my: '2px'
+    }
+  });
+
+  return /*#__PURE__*/_react.default.createElement(_Box.default, {
+    ref: ref
+  }, /*#__PURE__*/_react.default.createElement(DatePickerAnchorButton, {
+    onClick: clickHandler,
+    onKeyPress: keyPressHandler,
+    "aria-label": formattedDate
+  }, iconPlacement === 'start' && calendarIcon(), anchorVariant !== 'icon-only' && /*#__PURE__*/_react.default.createElement(_Text.default, {
+    sx: {
+      overflow: 'hidden',
+      textOverflow: 'ellipsis'
+    }
+  }, formattedDate), iconPlacement === 'end' && calendarIcon()));
+});
+
+exports.DatePickerAnchor = DatePickerAnchor;

package/lib/DatePicker/DatePickerOverlay.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { AnchoredOverlayProps } from '../AnchoredOverlay';
+export declare const DatePickerOverlay: React.FC<AnchoredOverlayProps>;

package/lib/DatePicker/DatePickerOverlay.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatePickerOverlay = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _useDatePicker = _interopRequireDefault(require("./useDatePicker"));
+
+var _AnchoredOverlay = require("../AnchoredOverlay");
+
+var _DatePickerPanel = require("./DatePickerPanel");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+const DatePickerOverlay = ({
+  onClose,
+  ...rest
+}) => {
+  const {
+    dialogOpen,
+    onClose: onDatePickerClose,
+    setDialogOpen,
+    currentViewingDate
+  } = (0, _useDatePicker.default)();
+
+  const onOverlayClose = async gesture => {
+    if (!dialogOpen) {
+      setDialogOpen(true);
+      await onDatePickerClose();
+      setDialogOpen(false);
+      onClose === null || onClose === void 0 ? void 0 : onClose(gesture);
+    }
+  };
+
+  return /*#__PURE__*/_react.default.createElement(_AnchoredOverlay.AnchoredOverlay, _extends({}, rest, {
+    onClose: onOverlayClose,
+    focusTrapSettings: {
+      restoreFocusOnCleanUp: true
+    },
+    focusZoneSettings: {
+      disabled: true
+    },
+    "aria-modal": "true",
+    "aria-labelledby": `${currentViewingDate.getMonth()} ${currentViewingDate.getFullYear()}`,
+    "aria-live": "polite"
+  }), /*#__PURE__*/_react.default.createElement(_DatePickerPanel.DatePickerPanel, null));
+};
+
+exports.DatePickerOverlay = DatePickerOverlay;
+DatePickerOverlay.displayName = "DatePickerOverlay";

package/lib/DatePicker/DatePickerPanel.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const DatePickerPanel: () => JSX.Element;