@primer/components 0.0.0-202111023322 → 0.0.0-2021111104725

package/lib-esm/TextInputWithTokens.js

@@ -0,0 +1,291 @@
+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); }
+
+import React, { useRef, useState } from 'react';
+import { omit } from '@styled-system/props';
+import { FocusKeys } from './behaviors/focusZone';
+import { useCombinedRefs } from './hooks/useCombinedRefs';
+import { useFocusZone } from './hooks/useFocusZone';
+import Token from './Token/Token';
+import { useProvidedRefOrCreate } from './hooks';
+import UnstyledTextInput from './_UnstyledTextInput';
+import TextInputWrapper from './_TextInputWrapper';
+import Box from './Box';
+import Text from './Text';
+import { isFocusable } from './utils/iterateFocusableElements'; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+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
+  } = omit(rest);
+  const ref = useProvidedRefOrCreate(externalRef);
+  const localInputRef = useRef(null);
+  const combinedInputRef = useCombinedRefs(localInputRef, ref);
+  const [selectedTokenIndex, setSelectedTokenIndex] = useState();
+  const [tokensAreTruncated, setTokensAreTruncated] = useState(Boolean(visibleTokenCount));
+  const {
+    containerRef
+  } = useFocusZone({
+    focusOutBehavior: 'wrap',
+    bindKeys: FocusKeys.ArrowHorizontal | 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 && isFocusable(nextElementToFocus) ? nextElementToFocus : Array.from(((_containerRef$current3 = containerRef.current) === null || _containerRef$current3 === void 0 ? void 0 : _containerRef$current3.children) || []).find(el => 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.createElement(TextInputWrapper, {
+    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.createElement(Box, {
+    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.createElement(Box, {
+    sx: {
+      order: 1,
+      flexGrow: 1
+    }
+  }, IconComponent && /*#__PURE__*/React.createElement(IconComponent, {
+    className: "TextInput-icon"
+  }), /*#__PURE__*/React.createElement(UnstyledTextInput, _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.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.createElement(Text, {
+    color: "fg.muted",
+    fontSize: size && overflowCountFontSizeMap[size]
+  }, "+", tokens.length - visibleTokens.length) : null));
+}
+
+TextInputWithTokensInnerComponent.displayName = "TextInputWithTokensInnerComponent";
+const TextInputWithTokens = /*#__PURE__*/React.forwardRef(TextInputWithTokensInnerComponent);
+TextInputWithTokens.defaultProps = {
+  tokenComponent: Token,
+  size: 'extralarge',
+  hideTokenRemoveButtons: false,
+  preventTokenWrapping: false
+};
+TextInputWithTokens.displayName = 'TextInputWithTokens';
+export default TextInputWithTokens;

package/lib-esm/ThemeProvider.js

@@ -0,0 +1,161 @@
+import React from 'react';
+import { ThemeProvider as SCThemeProvider } from 'styled-components';
+import defaultTheme from './theme';
+import deepmerge from 'deepmerge';
+const defaultColorMode = 'day';
+const defaultDayScheme = 'light';
+const defaultNightScheme = 'dark'; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+const ThemeContext = /*#__PURE__*/React.createContext({
+  setColorMode: () => null,
+  setDayScheme: () => null,
+  setNightScheme: () => null
+});
+export 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 : defaultTheme;
+  const [colorMode, setColorMode] = React.useState((_ref2 = (_props$colorMode = props.colorMode) !== null && _props$colorMode !== void 0 ? _props$colorMode : fallbackColorMode) !== null && _ref2 !== void 0 ? _ref2 : defaultColorMode);
+  const [dayScheme, setDayScheme] = React.useState((_ref3 = (_props$dayScheme = props.dayScheme) !== null && _props$dayScheme !== void 0 ? _props$dayScheme : fallbackDayScheme) !== null && _ref3 !== void 0 ? _ref3 : defaultDayScheme);
+  const [nightScheme, setNightScheme] = React.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.useMemo(() => applyColorScheme(theme, colorScheme), [theme, colorScheme]); // Update state if props change
+
+  React.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.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.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.createElement(ThemeContext.Provider, {
+    value: {
+      theme: resolvedTheme,
+      colorScheme,
+      colorMode,
+      resolvedColorMode,
+      dayScheme,
+      nightScheme,
+      setColorMode,
+      setDayScheme,
+      setNightScheme
+    }
+  }, /*#__PURE__*/React.createElement(SCThemeProvider, {
+    theme: resolvedTheme
+  }, children));
+};
+ThemeProvider.displayName = "ThemeProvider";
+export function useTheme() {
+  return React.useContext(ThemeContext);
+}
+export 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.useState(getSystemColorMode);
+  React.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 deepmerge(theme, theme.colorSchemes[defaultColorScheme]);
+  }
+
+  return deepmerge(theme, theme.colorSchemes[colorScheme]);
+}
+
+export default ThemeProvider;

package/lib-esm/Timeline.js

@@ -1,112 +1,57 @@
-import _styled from "styled-components";
-
-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); }
-
 import classnames from 'classnames';
-import PropTypes from 'prop-types';
 import React from 'react';
 import styled, { css } from 'styled-components';
-import Box from './Box';
-import { COMMON, get } from './constants';
-import Flex from './Flex';
-import { Relative } from './Position';
+import { Box } from '.';
+import { get } from './constants';
 import sx from './sx';
-import theme from './theme';
-const Timeline = styled(Flex).withConfig({
+const Timeline = styled.div.withConfig({
   displayName: "Timeline",
   componentId: "c4dq2e-0"
-})(["flex-direction:column;", " ", ";"], props => props.clipSidebar && css([".Timeline-Item:first-child{padding-top:0;}.Timeline-Item:last-child{padding-bottom:0;}"]), sx);
-const TimelineItem = styled(Flex).attrs(props => ({
+})(["display:flex;flex-direction:column;", " ", ";"], props => props.clipSidebar && css([".Timeline-Item:first-child{padding-top:0;}.Timeline-Item:last-child{padding-bottom:0;}"]), sx);
+const TimelineItem = styled.div.attrs(props => ({
   className: classnames('Timeline-Item', props.className)
 })).withConfig({
   displayName: "Timeline__TimelineItem",
   componentId: "c4dq2e-1"
-})(["position:relative;padding:", " 0;margin-left:", ";&::before{position:absolute;top:0;bottom:0;left:0;display:block;width:2px;content:'';background-color:", ";}", " ", ";", ";"], get('space.3'), get('space.3'), get('colors.gray.2'), props => props.condensed && css(["padding-top:", ";padding-bottom:0;&:last-child{padding-bottom:", ";}.TimelineItem-Badge{height:16px;margin-top:", ";margin-bottom:", ";color:", ";background-color:", ";border:0;}"], get('space.1'), get('space.3'), get('space.2'), get('space.2'), get('colors.gray.4'), get('colors.white')), COMMON, sx);
-
-var _StyledFlex = styled(Flex).withConfig({
-  displayName: "Timeline___StyledFlex",
-  componentId: "c4dq2e-2"
-})(["border-radius:50%;border:2px solid ", ";"], p => p._css);
+})(["display:flex;position:relative;padding:", " 0;margin-left:", ";&::before{position:absolute;top:0;bottom:0;left:0;display:block;width:2px;content:'';background-color:", ";}", " ", ";"], get('space.3'), get('space.3'), get('colors.border.muted'), props => props.condensed && css(["padding-top:", ";padding-bottom:0;&:last-child{padding-bottom:", ";}.TimelineItem-Badge{height:16px;margin-top:", ";margin-bottom:", ";color:", ";background-color:", ";border:0;}"], get('space.1'), get('space.3'), get('space.2'), get('space.2'), get('colors.fg.muted'), get('colors.canvas.default')), sx);
 
 const TimelineBadge = props => {
-  return /*#__PURE__*/React.createElement(Relative, {
+  return /*#__PURE__*/React.createElement(Box, {
+    position: "relative",
     zIndex: 1
-  }, /*#__PURE__*/React.createElement(_StyledFlex, _extends({
-    className: classnames(props.className, 'TimelineItem-Badge'),
+  }, /*#__PURE__*/React.createElement(Box, {
+    display: "flex",
+    className: "TimelineItem-Badge",
     flexShrink: 0,
+    borderRadius: "50%",
+    borderWidth: "2px",
+    borderStyle: "solid",
+    borderColor: "canvas.default",
     overflow: "hidden",
-    color: "gray.7",
-    bg: "gray.2",
+    color: "fg.muted",
+    bg: "timeline.badgeBg",
     width: "32px",
     height: "32px",
     mr: 2,
     ml: "-15px",
     alignItems: "center",
-    justifyContent: "center"
-  }, props, {
-    _css: get('colors.white')
-  }), props.children));
+    justifyContent: "center",
+    sx: props.sx
+  }, props.children));
 };
 
 TimelineBadge.displayName = "TimelineBadge";
-const TimelineBody = styled(Box).withConfig({
+const TimelineBody = styled.div.withConfig({
   displayName: "Timeline__TimelineBody",
-  componentId: "c4dq2e-3"
-})(["min-width:0;max-width:100%;margin-top:", ";color:", ";flex:auto;font-size:", ";", ";"], get('space.1'), get('colors.gray.7'), get('fontSizes.1'), sx);
-const TimelineBreak = styled(Relative).withConfig({
+  componentId: "c4dq2e-2"
+})(["min-width:0;max-width:100%;margin-top:", ";color:", ";flex:auto;font-size:", ";", ";"], get('space.1'), get('colors.fg.muted'), get('fontSizes.1'), sx);
+const TimelineBreak = styled.div.withConfig({
   displayName: "Timeline__TimelineBreak",
-  componentId: "c4dq2e-4"
-})(["z-index:1;height:24px;margin:0;margin-bottom:-", ";margin-left:0;background-color:", ";border:0;border-top:", " solid ", ";", ";"], get('space.3'), get('colors.white'), get('space.1'), get('colors.gray.2'), sx);
-Timeline.defaultProps = {
-  theme
-};
-Timeline.propTypes = {
-  children: PropTypes.node,
-  clipSidebar: PropTypes.bool,
-  theme: PropTypes.object,
-  ...Flex.propTypes,
-  ...sx.propTypes
-};
-TimelineItem.defaultProps = {
-  theme
-};
-TimelineItem.propTypes = {
-  children: PropTypes.node,
-  condensed: PropTypes.bool,
-  theme: PropTypes.object,
-  ...Flex.propTypes,
-  ...sx.propTypes
-};
+  componentId: "c4dq2e-3"
+})(["position:relative z-index:1;height:24px;margin:0;margin-bottom:-", ";margin-left:0;background-color:", ";border:0;border-top:", " solid ", ";", ";"], get('space.3'), get('colors.canvas.default'), get('space.1'), get('colors.border.default'), sx);
 TimelineItem.displayName = 'Timeline.Item';
-TimelineBadge.defaultProps = {
-  theme
-};
-TimelineBadge.propTypes = {
-  children: PropTypes.node,
-  theme: PropTypes.object,
-  ...Flex.propTypes,
-  ...sx.propTypes
-};
 TimelineBadge.displayName = 'Timeline.Badge';
-TimelineBody.defaultProps = {
-  theme
-};
-TimelineBody.propTypes = {
-  children: PropTypes.node,
-  theme: PropTypes.object,
-  ...Box.propTypes,
-  ...sx.propTypes
-};
 TimelineBody.displayName = 'Timeline.Body';
-TimelineBreak.defaultProps = {
-  theme
-};
-TimelineBreak.propTypes = {
-  children: PropTypes.node,
-  theme: PropTypes.object,
-  ...Box.propTypes,
-  ...sx.propTypes
-};
 TimelineBreak.displayName = 'Timeline.Break';
 export default Object.assign(Timeline, {
   Item: TimelineItem,

package/lib-esm/Token/AvatarToken.js

@@ -0,0 +1,43 @@
+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); }
+
+import React, { forwardRef } from 'react';
+import styled from 'styled-components';
+import { get } from '../constants';
+import { defaultTokenSize, tokenSizes } from './TokenBase';
+import Token from './Token';
+import { Avatar } from '..';
+const AvatarContainer = styled.span.withConfig({
+  displayName: "AvatarToken__AvatarContainer",
+  componentId: "ubyudc-0"
+})(["--spacing:calc(", " * 2);display:block;height:", ";width:", ";"], get('space.1'), props => `calc(${tokenSizes[props.avatarSize]} - var(--spacing))`, props => `calc(${tokenSizes[props.avatarSize]} - var(--spacing))`);
+const AvatarToken = /*#__PURE__*/forwardRef(({
+  avatarSrc,
+  id,
+  size,
+  ...rest
+}, forwardedRef) => {
+  return /*#__PURE__*/React.createElement(Token, _extends({
+    leadingVisual: () => /*#__PURE__*/React.createElement(AvatarContainer, {
+      avatarSize: size || defaultTokenSize
+    }, /*#__PURE__*/React.createElement(Avatar, {
+      src: avatarSrc,
+      size: parseInt(tokenSizes[size || defaultTokenSize], 10),
+      sx: {
+        width: '100%',
+        height: '100%'
+      }
+    })),
+    size: size,
+    id: id === null || id === void 0 ? void 0 : id.toString(),
+    sx: {
+      paddingLeft: get('space.1')
+    }
+  }, rest, {
+    ref: forwardedRef
+  }));
+});
+AvatarToken.defaultProps = {
+  size: defaultTokenSize
+};
+AvatarToken.displayName = 'AvatarToken';
+export default AvatarToken;