@primer/components 0.0.0-2021111171525 → 0.0.0-20211111716

package/lib/TextInputWithTokens.js

@@ -0,0 +1,318 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _props = require("@styled-system/props");
+
+var _focusZone = require("./behaviors/focusZone");
+
+var _useCombinedRefs = require("./hooks/useCombinedRefs");
+
+var _useFocusZone = require("./hooks/useFocusZone");
+
+var _Token = _interopRequireDefault(require("./Token/Token"));
+
+var _hooks = require("./hooks");
+
+var _UnstyledTextInput = _interopRequireDefault(require("./_UnstyledTextInput"));
+
+var _TextInputWrapper = _interopRequireDefault(require("./_TextInputWrapper"));
+
+var _Box = _interopRequireDefault(require("./Box"));
+
+var _Text = _interopRequireDefault(require("./Text"));
+
+var _iterateFocusableElements = require("./utils/iterateFocusableElements");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 _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 overflowCountFontSizeMap = {
+  small: 0,
+  medium: 1,
+  large: 1,
+  extralarge: 2
+}; // using forwardRef is important so that other components (ex. Autocomplete) can use the ref
+
+function TextInputWithTokensInnerComponent({
+  icon: IconComponent,
+  contrast,
+  className,
+  block,
+  disabled,
+  theme,
+  sx: sxProp,
+  tokens,
+  onTokenRemove,
+  tokenComponent: TokenComponent,
+  preventTokenWrapping,
+  size,
+  hideTokenRemoveButtons,
+  maxHeight,
+  width: widthProp,
+  minWidth: minWidthProp,
+  maxWidth: maxWidthProp,
+  variant: variantProp,
+  visibleTokenCount,
+  ...rest
+}, externalRef) {
+  const {
+    onBlur,
+    onFocus,
+    onKeyDown,
+    ...inputPropsRest
+  } = (0, _props.omit)(rest);
+  const ref = (0, _hooks.useProvidedRefOrCreate)(externalRef);
+  const localInputRef = (0, _react.useRef)(null);
+  const combinedInputRef = (0, _useCombinedRefs.useCombinedRefs)(localInputRef, ref);
+  const [selectedTokenIndex, setSelectedTokenIndex] = (0, _react.useState)();
+  const [tokensAreTruncated, setTokensAreTruncated] = (0, _react.useState)(Boolean(visibleTokenCount));
+  const {
+    containerRef
+  } = (0, _useFocusZone.useFocusZone)({
+    focusOutBehavior: 'wrap',
+    bindKeys: _focusZone.FocusKeys.ArrowHorizontal | _focusZone.FocusKeys.HomeAndEnd,
+    focusableElementFilter: element => {
+      return !element.getAttributeNames().includes('aria-hidden');
+    },
+    getNextFocusable: direction => {
+      var _containerRef$current;
+
+      if (!selectedTokenIndex && selectedTokenIndex !== 0) {
+        return undefined;
+      }
+
+      let nextIndex = selectedTokenIndex + 1; // "+ 1" accounts for the first element: the text input
+
+      if (direction === 'next') {
+        nextIndex += 1;
+      }
+
+      if (direction === 'previous') {
+        nextIndex -= 1;
+      }
+
+      if (nextIndex > tokens.length || nextIndex < 1) {
+        return combinedInputRef.current || undefined;
+      }
+
+      return (_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.children[nextIndex];
+    }
+  }, [selectedTokenIndex]);
+
+  const handleTokenRemove = tokenId => {
+    onTokenRemove(tokenId); // HACK: wait a tick for the the token node to be removed from the DOM
+
+    setTimeout(() => {
+      var _containerRef$current2, _containerRef$current3;
+
+      const nextElementToFocus = (_containerRef$current2 = containerRef.current) === null || _containerRef$current2 === void 0 ? void 0 : _containerRef$current2.children[selectedTokenIndex || 0]; // when removing the first token by keying "Backspace" or "Delete",
+      // `nextFocusableElement` is the div that wraps the input
+
+      const firstFocusable = nextElementToFocus && (0, _iterateFocusableElements.isFocusable)(nextElementToFocus) ? nextElementToFocus : Array.from(((_containerRef$current3 = containerRef.current) === null || _containerRef$current3 === void 0 ? void 0 : _containerRef$current3.children) || []).find(el => (0, _iterateFocusableElements.isFocusable)(el));
+
+      if (firstFocusable) {
+        firstFocusable.focus();
+      } else {
+        var _ref$current;
+
+        // if there are no tokens left, focus the input
+        (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
+      }
+    }, 0);
+  };
+
+  const handleTokenFocus = tokenIndex => () => {
+    setSelectedTokenIndex(tokenIndex);
+  };
+
+  const handleTokenBlur = () => {
+    setSelectedTokenIndex(undefined); // HACK: wait a tick and check the focused element before hiding truncated tokens
+    // this prevents the tokens from hiding when the user is moving focus between tokens,
+    // but still hides the tokens when the user blurs the token by tabbing out or clicking somewhere else on the page
+
+    setTimeout(() => {
+      var _containerRef$current4;
+
+      if (!((_containerRef$current4 = containerRef.current) !== null && _containerRef$current4 !== void 0 && _containerRef$current4.contains(document.activeElement)) && visibleTokenCount) {
+        setTokensAreTruncated(true);
+      }
+    }, 0);
+  };
+
+  const handleTokenKeyUp = event => {
+    if (event.key === 'Escape') {
+      var _ref$current2;
+
+      (_ref$current2 = ref.current) === null || _ref$current2 === void 0 ? void 0 : _ref$current2.focus();
+    }
+  };
+
+  const handleInputFocus = event => {
+    onFocus && onFocus(event);
+    setSelectedTokenIndex(undefined);
+    visibleTokenCount && setTokensAreTruncated(false);
+  };
+
+  const handleInputBlur = event => {
+    onBlur && onBlur(event); // HACK: wait a tick and check the focused element before hiding truncated tokens
+    // this prevents the tokens from hiding when the user is moving focus from the input to a token,
+    // but still hides the tokens when the user blurs the input by tabbing out or clicking somewhere else on the page
+
+    setTimeout(() => {
+      var _containerRef$current5;
+
+      if (!((_containerRef$current5 = containerRef.current) !== null && _containerRef$current5 !== void 0 && _containerRef$current5.contains(document.activeElement)) && visibleTokenCount) {
+        setTokensAreTruncated(true);
+      }
+    }, 0);
+  };
+
+  const handleInputKeyDown = e => {
+    var _ref$current3;
+
+    if (onKeyDown) {
+      onKeyDown(e);
+    }
+
+    if ((_ref$current3 = ref.current) !== null && _ref$current3 !== void 0 && _ref$current3.value) {
+      return;
+    }
+
+    const lastToken = tokens[tokens.length - 1];
+
+    if (e.key === 'Backspace' && lastToken) {
+      handleTokenRemove(lastToken.id);
+
+      if (ref.current) {
+        // TODO: eliminate the first hack by making changes to the Autocomplete component
+        //
+        // HACKS:
+        // 1. Directly setting `ref.current.value` instead of updating state because the autocomplete
+        //    highlight behavior doesn't work correctly if we update the value with a setState action in onChange
+        // 2. Adding an extra space so that when I backspace, it doesn't delete the last letter
+        ref.current.value = `${lastToken.text} `;
+      } // HACK: for some reason we need to wait a tick for `.select()` to work
+
+
+      setTimeout(() => {
+        var _ref$current4;
+
+        (_ref$current4 = ref.current) === null || _ref$current4 === void 0 ? void 0 : _ref$current4.select();
+      }, 0);
+    }
+  };
+
+  const focusInput = () => {
+    var _combinedInputRef$cur;
+
+    (_combinedInputRef$cur = combinedInputRef.current) === null || _combinedInputRef$cur === void 0 ? void 0 : _combinedInputRef$cur.focus();
+  };
+
+  const preventTokenClickPropagation = event => {
+    event.stopPropagation();
+  };
+
+  const visibleTokens = tokensAreTruncated ? tokens.slice(0, visibleTokenCount) : tokens;
+  return /*#__PURE__*/_react.default.createElement(_TextInputWrapper.default, {
+    block: block,
+    className: className,
+    contrast: contrast,
+    disabled: disabled,
+    hasIcon: !!IconComponent,
+    theme: theme,
+    width: widthProp,
+    minWidth: minWidthProp,
+    maxWidth: maxWidthProp,
+    variant: variantProp,
+    onClick: focusInput,
+    sx: { ...(block ? {
+        display: 'flex',
+        width: '100%'
+      } : {}),
+      ...(maxHeight ? {
+        maxHeight,
+        overflow: 'auto'
+      } : {}),
+      ...(preventTokenWrapping ? {
+        overflow: 'auto'
+      } : {}),
+      ...sxProp
+    }
+  }, /*#__PURE__*/_react.default.createElement(_Box.default, {
+    ref: containerRef,
+    display: "flex",
+    sx: {
+      alignItems: 'center',
+      flexWrap: preventTokenWrapping ? 'nowrap' : 'wrap',
+      marginLeft: '-0.25rem',
+      marginBottom: '-0.25rem',
+      flexGrow: 1,
+      '> *': {
+        flexShrink: 0,
+        marginLeft: '0.25rem',
+        marginBottom: '0.25rem'
+      }
+    }
+  }, /*#__PURE__*/_react.default.createElement(_Box.default, {
+    sx: {
+      order: 1,
+      flexGrow: 1
+    }
+  }, IconComponent && /*#__PURE__*/_react.default.createElement(IconComponent, {
+    className: "TextInput-icon"
+  }), /*#__PURE__*/_react.default.createElement(_UnstyledTextInput.default, _extends({
+    ref: combinedInputRef,
+    disabled: disabled,
+    onFocus: handleInputFocus,
+    onBlur: handleInputBlur,
+    onKeyDown: handleInputKeyDown,
+    type: "text",
+    sx: {
+      height: '100%'
+    }
+  }, inputPropsRest))), TokenComponent ? visibleTokens.map(({
+    id,
+    ...tokenRest
+  }, i) => /*#__PURE__*/_react.default.createElement(TokenComponent, _extends({
+    key: id,
+    onFocus: handleTokenFocus(i),
+    onBlur: handleTokenBlur,
+    onKeyUp: handleTokenKeyUp,
+    onClick: preventTokenClickPropagation,
+    isSelected: selectedTokenIndex === i,
+    onRemove: () => {
+      handleTokenRemove(id);
+    },
+    hideRemoveButton: hideTokenRemoveButtons,
+    size: size,
+    tabIndex: 0
+  }, tokenRest))) : null, tokensAreTruncated ? /*#__PURE__*/_react.default.createElement(_Text.default, {
+    color: "fg.muted",
+    fontSize: size && overflowCountFontSizeMap[size]
+  }, "+", tokens.length - visibleTokens.length) : null));
+}
+
+TextInputWithTokensInnerComponent.displayName = "TextInputWithTokensInnerComponent";
+
+const TextInputWithTokens = /*#__PURE__*/_react.default.forwardRef(TextInputWithTokensInnerComponent);
+
+TextInputWithTokens.defaultProps = {
+  tokenComponent: _Token.default,
+  size: 'extralarge',
+  hideTokenRemoveButtons: false,
+  preventTokenWrapping: false
+};
+TextInputWithTokens.displayName = 'TextInputWithTokens';
+var _default = TextInputWithTokens;
+exports.default = _default;

package/lib/ThemeProvider.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+export declare type Theme = {
+    [key: string]: any;
+};
+declare type ColorMode = 'day' | 'night';
+declare type ColorModeWithAuto = ColorMode | 'auto';
+export declare type ThemeProviderProps = {
+    theme?: Theme;
+    colorMode?: ColorModeWithAuto;
+    dayScheme?: string;
+    nightScheme?: string;
+};
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare function useTheme(): {
+    theme?: Theme | undefined;
+    colorScheme?: string | undefined;
+    colorMode?: ColorModeWithAuto | undefined;
+    resolvedColorMode?: ColorMode | undefined;
+    dayScheme?: string | undefined;
+    nightScheme?: string | undefined;
+    setColorMode: React.Dispatch<React.SetStateAction<ColorModeWithAuto>>;
+    setDayScheme: React.Dispatch<React.SetStateAction<string>>;
+    setNightScheme: React.Dispatch<React.SetStateAction<string>>;
+};
+export declare function useColorSchemeVar(values: Partial<Record<string, string>>, fallback: string): string;
+export default ThemeProvider;

package/lib/ThemeProvider.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTheme = useTheme;
+exports.useColorSchemeVar = useColorSchemeVar;
+exports.default = exports.ThemeProvider = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = require("styled-components");
+
+var _theme = _interopRequireDefault(require("./theme"));
+
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const defaultColorMode = 'day';
+const defaultDayScheme = 'light';
+const defaultNightScheme = 'dark'; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+const ThemeContext = /*#__PURE__*/_react.default.createContext({
+  setColorMode: () => null,
+  setDayScheme: () => null,
+  setNightScheme: () => null
+});
+
+const ThemeProvider = ({
+  children,
+  ...props
+}) => {
+  var _ref, _props$theme, _ref2, _props$colorMode, _ref3, _props$dayScheme, _ref4, _props$nightScheme;
+
+  // Get fallback values from parent ThemeProvider (if exists)
+  const {
+    theme: fallbackTheme,
+    colorMode: fallbackColorMode,
+    dayScheme: fallbackDayScheme,
+    nightScheme: fallbackNightScheme
+  } = useTheme(); // Initialize state
+
+  const theme = (_ref = (_props$theme = props.theme) !== null && _props$theme !== void 0 ? _props$theme : fallbackTheme) !== null && _ref !== void 0 ? _ref : _theme.default;
+
+  const [colorMode, setColorMode] = _react.default.useState((_ref2 = (_props$colorMode = props.colorMode) !== null && _props$colorMode !== void 0 ? _props$colorMode : fallbackColorMode) !== null && _ref2 !== void 0 ? _ref2 : defaultColorMode);
+
+  const [dayScheme, setDayScheme] = _react.default.useState((_ref3 = (_props$dayScheme = props.dayScheme) !== null && _props$dayScheme !== void 0 ? _props$dayScheme : fallbackDayScheme) !== null && _ref3 !== void 0 ? _ref3 : defaultDayScheme);
+
+  const [nightScheme, setNightScheme] = _react.default.useState((_ref4 = (_props$nightScheme = props.nightScheme) !== null && _props$nightScheme !== void 0 ? _props$nightScheme : fallbackNightScheme) !== null && _ref4 !== void 0 ? _ref4 : defaultNightScheme);
+
+  const systemColorMode = useSystemColorMode();
+  const resolvedColorMode = resolveColorMode(colorMode, systemColorMode);
+  const colorScheme = chooseColorScheme(resolvedColorMode, dayScheme, nightScheme);
+
+  const resolvedTheme = _react.default.useMemo(() => applyColorScheme(theme, colorScheme), [theme, colorScheme]); // Update state if props change
+
+
+  _react.default.useEffect(() => {
+    var _ref5, _props$colorMode2;
+
+    setColorMode((_ref5 = (_props$colorMode2 = props.colorMode) !== null && _props$colorMode2 !== void 0 ? _props$colorMode2 : fallbackColorMode) !== null && _ref5 !== void 0 ? _ref5 : defaultColorMode);
+  }, [props.colorMode, fallbackColorMode]);
+
+  _react.default.useEffect(() => {
+    var _ref6, _props$dayScheme2;
+
+    setDayScheme((_ref6 = (_props$dayScheme2 = props.dayScheme) !== null && _props$dayScheme2 !== void 0 ? _props$dayScheme2 : fallbackDayScheme) !== null && _ref6 !== void 0 ? _ref6 : defaultDayScheme);
+  }, [props.dayScheme, fallbackDayScheme]);
+
+  _react.default.useEffect(() => {
+    var _ref7, _props$nightScheme2;
+
+    setNightScheme((_ref7 = (_props$nightScheme2 = props.nightScheme) !== null && _props$nightScheme2 !== void 0 ? _props$nightScheme2 : fallbackNightScheme) !== null && _ref7 !== void 0 ? _ref7 : defaultNightScheme);
+  }, [props.nightScheme, fallbackNightScheme]);
+
+  return /*#__PURE__*/_react.default.createElement(ThemeContext.Provider, {
+    value: {
+      theme: resolvedTheme,
+      colorScheme,
+      colorMode,
+      resolvedColorMode,
+      dayScheme,
+      nightScheme,
+      setColorMode,
+      setDayScheme,
+      setNightScheme
+    }
+  }, /*#__PURE__*/_react.default.createElement(_styledComponents.ThemeProvider, {
+    theme: resolvedTheme
+  }, children));
+};
+
+exports.ThemeProvider = ThemeProvider;
+ThemeProvider.displayName = "ThemeProvider";
+
+function useTheme() {
+  return _react.default.useContext(ThemeContext);
+}
+
+function useColorSchemeVar(values, fallback) {
+  var _values$colorScheme;
+
+  const {
+    colorScheme = ''
+  } = useTheme();
+  return (_values$colorScheme = values[colorScheme]) !== null && _values$colorScheme !== void 0 ? _values$colorScheme : fallback;
+}
+
+function useSystemColorMode() {
+  const [systemColorMode, setSystemColorMode] = _react.default.useState(getSystemColorMode);
+
+  _react.default.useEffect(() => {
+    var _window, _window$matchMedia;
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    const media = (_window = window) === null || _window === void 0 ? void 0 : (_window$matchMedia = _window.matchMedia) === null || _window$matchMedia === void 0 ? void 0 : _window$matchMedia.call(_window, '(prefers-color-scheme: dark)');
+
+    function handleChange(event) {
+      const isNight = event.matches;
+      setSystemColorMode(isNight ? 'night' : 'day');
+    } // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+
+    if (media) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (media.addEventListener !== undefined) {
+        media.addEventListener('change', handleChange);
+        return function cleanup() {
+          media.removeEventListener('change', handleChange);
+        };
+      } // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      else if (media.addListener !== undefined) {
+        media.addListener(handleChange);
+        return function cleanup() {
+          media.removeListener(handleChange);
+        };
+      }
+    }
+  }, []);
+
+  return systemColorMode;
+}
+
+function getSystemColorMode() {
+  var _window$matchMedia2, _window2, _window$matchMedia2$c;
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (typeof window !== 'undefined' && (_window$matchMedia2 = (_window2 = window).matchMedia) !== null && _window$matchMedia2 !== void 0 && (_window$matchMedia2$c = _window$matchMedia2.call(_window2, '(prefers-color-scheme: dark)')) !== null && _window$matchMedia2$c !== void 0 && _window$matchMedia2$c.matches) {
+    return 'night';
+  }
+
+  return 'day';
+}
+
+function resolveColorMode(colorMode, systemColorMode) {
+  switch (colorMode) {
+    case 'auto':
+      return systemColorMode;
+
+    default:
+      return colorMode;
+  }
+}
+
+function chooseColorScheme(colorMode, dayScheme, nightScheme) {
+  switch (colorMode) {
+    case 'day':
+      return dayScheme;
+
+    case 'night':
+      return nightScheme;
+  }
+}
+
+function applyColorScheme(theme, colorScheme) {
+  if (!theme.colorSchemes) {
+    return theme;
+  }
+
+  if (!theme.colorSchemes[colorScheme]) {
+    // eslint-disable-next-line no-console
+    console.error(`\`${colorScheme}\` scheme not defined in \`theme.colorSchemes\``); // Apply the first defined color scheme
+
+    const defaultColorScheme = Object.keys(theme.colorSchemes)[0];
+    return (0, _deepmerge.default)(theme, theme.colorSchemes[defaultColorScheme]);
+  }
+
+  return (0, _deepmerge.default)(theme, theme.colorSchemes[colorScheme]);
+}
+
+var _default = ThemeProvider;
+exports.default = _default;

package/lib/Timeline.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { SxProp } from './sx';
+import { ComponentProps } from './utils/types';
+declare const Timeline: import("styled-components").StyledComponent<"div", any, {
+    clipSidebar?: boolean | undefined;
+} & SxProp, never>;
+declare const TimelineItem: import("styled-components").StyledComponent<"div", any, {
+    condensed?: boolean | undefined;
+} & SxProp, never>;
+export declare type TimelineBadgeProps = {
+    children?: React.ReactNode;
+} & SxProp;
+declare const TimelineBody: import("styled-components").StyledComponent<"div", any, SxProp, never>;
+declare const TimelineBreak: import("styled-components").StyledComponent<"div", any, SxProp, never>;
+export declare type TimelineProps = ComponentProps<typeof Timeline>;
+export declare type TimelineItemsProps = ComponentProps<typeof TimelineItem>;
+export declare type TimelineBodyProps = ComponentProps<typeof TimelineBody>;
+export declare type TimelineBreakProps = ComponentProps<typeof TimelineBreak>;
+declare const _default: string & import("styled-components").StyledComponentBase<"div", any, {
+    clipSidebar?: boolean | undefined;
+} & SxProp, never> & import("hoist-non-react-statics").NonReactStatics<never, {}> & {
+    Item: import("styled-components").StyledComponent<"div", any, {
+        condensed?: boolean | undefined;
+    } & SxProp, never>;
+    Badge: {
+        (props: TimelineBadgeProps): JSX.Element;
+        displayName: string;
+    };
+    Body: import("styled-components").StyledComponent<"div", any, SxProp, never>;
+    Break: import("styled-components").StyledComponent<"div", any, SxProp, never>;
+};
+export default _default;