@primer/components 0.0.0-202192219616 → 0.0.0-2021922204627

package/lib-esm/DatePicker/Month.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { FontSizeProps } from 'styled-system';
+import { SystemCommonProps, SystemLayoutProps } from '../constants';
+import { SxProp } from '../sx';
+export interface MonthProps extends FontSizeProps, SystemCommonProps, SxProp, SystemLayoutProps {
+    month: number;
+    year: number;
+}
+export declare const Month: React.FC<MonthProps>;

package/lib-esm/DatePicker/Month.js

@@ -0,0 +1,74 @@
+import { format, isEqual, lastDayOfMonth, getDaysInMonth, eachDayOfInterval, startOfWeek, endOfWeek } from 'date-fns';
+import React, { useMemo, useState } from 'react';
+import styled from 'styled-components';
+import Box from '../Box';
+import Text from '../Text';
+import { get } from '../constants';
+import { BlankDay, Day } from './Day';
+const MonthComponent = styled(Box).withConfig({
+  displayName: "Month__MonthComponent",
+  componentId: "l6j7o0-0"
+})(["display:grid;grid-auto-rows:min-content;grid-template-columns:repeat(1fr,7);grid-template-rows:1fr;gap:0px 0px;grid-template-areas:'month month month month month month month' 'sunday monday tuesday wednesday thursday friday saturday';justify-items:stretch;align-items:stretch;"]);
+const MonthTitle = styled(Text).withConfig({
+  displayName: "Month__MonthTitle",
+  componentId: "l6j7o0-1"
+})(["font-size:", ";font-weight:", ";grid-area:month;justify-self:center;"], get('fontSizes.1'), get('fontWeights.bold'));
+const WeekdayHeader = styled(Text).withConfig({
+  displayName: "Month__WeekdayHeader",
+  componentId: "l6j7o0-2"
+})(["color:", ";font-family:", ";font-size:", ";justify-self:center;padding:", " 0 ", ";"], get('colors.fg.subtle'), get('fonts.mono'), get('fontSizes.0'), get('space.3'), get('space.2'));
+export const Month = ({
+  month,
+  year
+}) => {
+  const [selectedDay, setSelectedDay] = useState(null);
+  const getTitle = useMemo(() => `${format(new Date(year, month), 'MMMM yyyy')}`, [month, year]);
+  const weekdayHeaders = useMemo(() => {
+    const now = new Date(year, month);
+    return eachDayOfInterval({
+      start: startOfWeek(now),
+      end: endOfWeek(now)
+    }).map(d => /*#__PURE__*/React.createElement(WeekdayHeader, {
+      key: `weekday-${d}-header`
+    }, format(d, 'EEEEEE')));
+  }, [month, year]);
+
+  const dayAction = date => {
+    setSelectedDay(date);
+  };
+
+  const dayComponents = useMemo(() => {
+    const components = [];
+    const firstDay = new Date(year, month, 1);
+
+    for (let i = 0; i < firstDay.getDay(); i++) {
+      components.push( /*#__PURE__*/React.createElement(BlankDay, {
+        key: `month-pre-blank-${i}`
+      }));
+    }
+
+    for (let i = 1; i <= getDaysInMonth(firstDay); i++) {
+      const date = new Date(year, month, i);
+      components.push( /*#__PURE__*/React.createElement(Day, {
+        key: `day-component-${date.toString()}`,
+        date: date,
+        selected: selectedDay ? isEqual(date, selectedDay) : false,
+        onAction: dayAction
+      }));
+    }
+
+    const lastDay = lastDayOfMonth(firstDay);
+
+    for (let i = 6; i > lastDay.getDay(); i--) {
+      components.push( /*#__PURE__*/React.createElement(BlankDay, {
+        key: `month-post-blank-${i}`
+      }));
+    }
+
+    return components;
+  }, [month, selectedDay, year]);
+  return /*#__PURE__*/React.createElement(MonthComponent, {
+    role: "grid"
+  }, /*#__PURE__*/React.createElement(MonthTitle, null, getTitle), weekdayHeaders, dayComponents);
+};
+Month.displayName = "Month";

package/lib-esm/DatePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { DatePicker } from './DatePicker';
+export type { DatePickerProps } from './DatePicker';

package/lib-esm/DatePicker/index.js

@@ -0,0 +1 @@
+export { DatePicker } from './DatePicker';

package/lib-esm/DatePicker/useDatePicker.d.ts

@@ -0,0 +1,69 @@
+import React from 'react';
+export declare type AnchorVariant = 'input' | 'button' | 'icon-only';
+export declare type DateFormat = 'short' | 'long' | string;
+export declare type SelectionVariant = 'single' | 'multi' | 'range';
+export interface DatePickerConfiguration {
+    anchorVariant?: AnchorVariant;
+    blockedDates?: Array<Date>;
+    confirmation?: boolean;
+    contiguousSelection?: boolean;
+    dateFormat?: DateFormat;
+    dimWeekends?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    placeholder?: string;
+    rangeIncrement?: number;
+    selection?: SelectionVariant;
+    view?: '1-month' | '2-month';
+}
+export declare type RangeSelection = {
+    from: Date;
+    to: Date | null;
+};
+export declare type StringRangeSelection = {
+    from: string;
+    to: string;
+};
+export interface DatePickerContext {
+    disabled?: boolean;
+    configuration: DatePickerConfiguration;
+    selection?: Selection;
+    softSelection?: Partial<RangeSelection> | null;
+    selectionActive?: boolean;
+    formattedDate: string;
+    onSelection: (date: Date) => void;
+    onDayFocus: (date: Date) => void;
+    onDayBlur: (date: Date) => void;
+    revertValue: () => void;
+}
+export declare type Selection = Date | Array<Date> | RangeSelection | null;
+export declare type StringSelection = string | Array<string> | {
+    to: string;
+    from: string;
+} | null;
+export declare type DaySelection = boolean | 'start' | 'middle' | 'end';
+declare const useDatePicker: (date?: Date | undefined) => {
+    blocked: boolean | undefined;
+    disabled: boolean;
+    selected: DaySelection;
+    configuration: DatePickerConfiguration;
+    selection?: Selection | undefined;
+    softSelection?: Partial<RangeSelection> | null | undefined;
+    selectionActive?: boolean | undefined;
+    formattedDate: string;
+    onSelection: (date: Date) => void;
+    onDayFocus: (date: Date) => void;
+    onDayBlur: (date: Date) => void;
+    revertValue: () => void;
+};
+export default useDatePicker;
+export interface DatePickerProviderProps {
+    closePicker?: () => void;
+    configuration?: DatePickerConfiguration;
+    value?: Selection | StringSelection;
+}
+export declare function isSingleSelection(selection: Selection): selection is Date;
+export declare function isMultiSelection(selection: Selection | StringSelection): selection is Array<Date> | Array<string>;
+export declare function isRangeSelection(selection: Selection | StringSelection): selection is RangeSelection | StringRangeSelection;
+export declare function isStringRangeSelection(selection: StringSelection): selection is StringRangeSelection;
+export declare const DatePickerProvider: React.FC<DatePickerProviderProps>;

package/lib-esm/DatePicker/useDatePicker.js

@@ -0,0 +1,308 @@
+import { format, isEqual, isAfter, isBefore } from 'date-fns';
+import deepmerge from 'deepmerge';
+import React, { createContext, useCallback, useContext, useMemo, useEffect, useState } from 'react';
+const DatePickerContext = /*#__PURE__*/createContext(null);
+
+const useDatePicker = date => {
+  const value = useContext(DatePickerContext);
+
+  if (!value) {
+    throw new Error('useDatePicker must be used inside a DatePickerProvider');
+  }
+
+  let selected = false;
+  let blocked,
+      disabled = false;
+
+  if (date) {
+    if (value.selection) {
+      if (isMultiSelection(value.selection)) {
+        selected = !!value.selection.find(d => isEqual(d, date));
+      } else if (isRangeSelection(value.selection)) {
+        if (isEqual(date, value.selection.from)) {
+          selected = 'start';
+        } else if (value.selection.to && isEqual(date, value.selection.to)) {
+          selected = 'end';
+        } else if (isAfter(date, value.selection.from) && value.selection.to && isBefore(date, value.selection.to)) {
+          selected = 'middle';
+        } else {
+          selected = false;
+        }
+      } else {
+        selected = isEqual(date, value.selection);
+      }
+    } // Determine if date is blocked out
+
+
+    if (value.configuration.blockedDates) {
+      blocked = !!value.configuration.blockedDates.find(d => isEqual(d, date));
+    } // Determine if date is disabled
+
+
+    if (value.configuration.minDate || value.configuration.maxDate) {
+      disabled = (value.configuration.minDate ? isBefore(date, value.configuration.minDate) : false) || (value.configuration.maxDate ? isAfter(date, value.configuration.maxDate) : false);
+    }
+  }
+
+  return { ...value,
+    blocked,
+    disabled,
+    selected
+  };
+};
+
+export default useDatePicker;
+export function isSingleSelection(selection) {
+  return selection instanceof Date;
+}
+export function isMultiSelection(selection) {
+  return Array.isArray(selection);
+}
+export function isRangeSelection(selection) {
+  return !!selection.from;
+}
+export function isStringRangeSelection(selection) {
+  return !!selection.from;
+}
+
+function parseSelection(selection, variant) {
+  if (!selection) return;
+
+  if (variant === 'multi') {
+    if (isMultiSelection(selection)) {
+      const parsedSelection = [];
+
+      for (const d of selection) {
+        parsedSelection.push(new Date(new Date(d).toDateString()));
+      }
+
+      return parsedSelection.sort((a, b) => a.getTime() - b.getTime());
+    } else if (selection instanceof Date) {
+      return [new Date(new Date(selection).toDateString())];
+    } else if (isRangeSelection(selection)) {
+      const parsedSelection = [];
+      parsedSelection.push(new Date(new Date(selection.from).toDateString()));
+
+      if (selection.to) {
+        parsedSelection.push(new Date(new Date(selection.to).toDateString()));
+      }
+
+      return parsedSelection.sort((a, b) => a.getTime() - b.getTime());
+    }
+  } else if (variant === 'range') {
+    if (isRangeSelection(selection)) {
+      return {
+        from: new Date(new Date(selection.from).toDateString()),
+        to: selection.to ? new Date(new Date(selection.to).toDateString()) : null
+      };
+    } else if (isMultiSelection(selection)) {
+      return {
+        from: new Date(new Date(selection[0]).toDateString()),
+        to: selection[1] ? new Date(new Date(selection[1]).toDateString()) : null
+      };
+    } else if (selection instanceof Date) {
+      return {
+        from: new Date(new Date(selection).toDateString()),
+        to: null
+      };
+    }
+  } else {
+    if (selection instanceof Date) {
+      return new Date(new Date(selection).toDateString());
+    } else if (isMultiSelection(selection)) {
+      return new Date(new Date(selection[0]).toDateString());
+    } else if (isRangeSelection(selection)) {
+      return new Date(new Date(selection.from).toDateString());
+    } else {
+      return;
+    }
+  }
+}
+
+const defaultConfiguration = {
+  anchorVariant: 'button',
+  confirmation: false,
+  contiguousSelection: false,
+  dimWeekends: false,
+  placeholder: 'Select a Date...',
+  selection: 'single',
+  view: '2-month'
+};
+export const DatePickerProvider = ({
+  configuration: externalConfig = {},
+  children,
+  closePicker,
+  value
+}) => {
+  const [configuration, setConfiguration] = useState(deepmerge(defaultConfiguration, externalConfig));
+  const [previousSelection, setPreviousSelection] = useState(parseSelection(value, configuration.selection));
+  const [selection, setSelection] = useState(parseSelection(value, configuration.selection));
+  const [hoverRange, setHoverRange] = useState(null);
+  useEffect(() => {
+    setConfiguration(deepmerge(defaultConfiguration, externalConfig));
+    setSelection(parseSelection(selection, configuration.selection)); // Don't want this to run every time selection gets updated
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [configuration.selection, externalConfig]);
+  const getFormattedDate = useMemo(() => {
+    if (!selection) {
+      return configuration.placeholder;
+    }
+
+    let template = 'MMM d';
+
+    if (configuration.dateFormat) {
+      switch (configuration.dateFormat) {
+        case 'short':
+          template = 'MMM d';
+          break;
+
+        case 'long':
+          template = 'MMM d, yyyy';
+          break;
+
+        default:
+          template = configuration.dateFormat;
+          break;
+      }
+    }
+
+    switch (configuration.selection) {
+      case 'single':
+        {
+          if (selection instanceof Date) {
+            return format(selection, template);
+          } else if (Array.isArray(selection)) {
+            return format(selection[0], template);
+          } else if (isRangeSelection(selection)) {
+            return format(selection.from, template);
+          } else {
+            return 'Invalid Selection';
+          }
+        }
+
+      case 'multi':
+        {
+          if (Array.isArray(selection)) {
+            if (selection.length > 3) return `${selection.length} Selected`;
+            const formatted = selection.map(d => format(d, template)).join(', ');
+            return formatted;
+          } else if (selection instanceof Date) {
+            return [selection].map(d => format(d, template)).join(', ');
+          } else if (isRangeSelection(selection)) {
+            return [selection.to, selection.from].map(d => d ? format(d, template) : '').join(', ');
+          } else {
+            return 'Invalid Selection';
+          }
+        }
+
+      case 'range':
+        {
+          if (isRangeSelection(selection)) {
+            return Object.entries(selection).map(([_, date]) => date ? format(date, template) : '').join(' - ');
+          } else if (selection instanceof Date) {
+            return Object.entries({
+              from: selection,
+              to: null
+            }).map(([_, date]) => date ? format(date, template) : '').join(' - ');
+          } else if (Array.isArray(selection)) {
+            return Object.entries({
+              from: selection[0],
+              to: selection[1]
+            }) // to date can still be null
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            .map(([_, date]) => date ? format(date, template) : '').join(' - ');
+          } else {
+            return 'Invalid Selection';
+          }
+        }
+
+      default:
+        {
+          return 'Invalid Configuration';
+        }
+    }
+  }, [configuration.dateFormat, configuration.placeholder, configuration.selection, selection]);
+  const handleSave = useCallback(updatedSelection => {
+    setPreviousSelection(updatedSelection);
+    closePicker === null || closePicker === void 0 ? void 0 : closePicker();
+  }, [closePicker]);
+  const selectionHandler = useCallback(date => {
+    if (configuration.selection === 'multi') {
+      const selections = [...selection];
+      const existingIndex = selections.findIndex(s => isEqual(s, date));
+
+      if (existingIndex > -1) {
+        selections.splice(existingIndex, 1);
+        setSelection(selections.sort((a, b) => a.getTime() - b.getTime()));
+      } else {
+        setSelection([...selections, date].sort((a, b) => a.getTime() - b.getTime()));
+      }
+    } else if (configuration.selection === 'range') {
+      if (selection && isRangeSelection(selection) && !selection.to) {
+        const updatedSelection = isBefore(date, selection.from) ? {
+          from: date,
+          to: selection.from
+        } : {
+          from: selection.from,
+          to: date
+        };
+        setSelection(updatedSelection);
+
+        if (!configuration.confirmation) {
+          handleSave(updatedSelection);
+        }
+      } else {
+        setSelection({
+          from: date,
+          to: null
+        });
+      }
+    } else {
+      setSelection(date);
+
+      if (!configuration.confirmation) {
+        handleSave(date);
+      }
+    }
+  }, [configuration.confirmation, configuration.selection, handleSave, selection]);
+  const focusHnadler = useCallback(date => {
+    if (!selection) return;
+
+    if (configuration.selection === 'range' && isRangeSelection(selection)) {
+      setHoverRange(isBefore(date, selection.from) ? {
+        from: date,
+        to: selection.from
+      } : {
+        from: selection.from,
+        to: date
+      });
+    }
+  }, [configuration.selection, selection]);
+  const blurHnadler = useCallback(date => {
+    if (!selection || !hoverRange) return;
+
+    if (configuration.selection === 'range' && isRangeSelection(selection) && (hoverRange.from === date || hoverRange.to === date)) {
+      setHoverRange(null);
+    }
+  }, [configuration.selection, hoverRange, selection]);
+  const revertValue = useCallback(() => {
+    setSelection(previousSelection);
+  }, [previousSelection]);
+  const datePickerCtx = useMemo(() => {
+    return {
+      configuration,
+      disabled: false,
+      formattedDate: getFormattedDate,
+      onDayBlur: blurHnadler,
+      onDayFocus: focusHnadler,
+      onSelection: selectionHandler,
+      revertValue,
+      selectionActive: false,
+      selection
+    };
+  }, [blurHnadler, configuration, focusHnadler, getFormattedDate, revertValue, selection, selectionHandler]);
+  return /*#__PURE__*/React.createElement(DatePickerContext.Provider, {
+    value: datePickerCtx
+  }, children);
+};
+DatePickerProvider.displayName = "DatePickerProvider";

package/lib-esm/SelectMenu/SelectMenu.d.ts

@@ -32,12 +32,14 @@ declare const _default: React.ForwardRefExoticComponent<Pick<SelectMenuInternalP
     Divider: import("styled-components").StyledComponent<"div", any, SystemCommonProps & SxProp, never>;
     Filter: React.ForwardRefExoticComponent<Pick<{
         value?: string | undefined;
-    } & Pick<Omit<Pick<{
+    } & 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-esm/TextInputWithTokens.d.ts

@@ -32,16 +32,14 @@ declare const TextInputWithTokens: React.ForwardRefExoticComponent<Pick<{
      * Whether the remove buttons should be rendered in the tokens
      */
     hideTokenRemoveButtons?: boolean | undefined;
-    /**
-     * The number of tokens to display before truncating
-     */
-    visibleTokenCount?: number | undefined;
-} & Pick<Omit<Pick<{
+} & 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-esm/TextInputWithTokens.js

@@ -9,16 +9,9 @@ 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'; // 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
+import Box from './Box'; // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
+// using forwardRef is important so that other components (ex. Autocomplete) can use the ref
 function TextInputWithTokensInnerComponent({
   icon: IconComponent,
   contrast,
@@ -38,11 +31,9 @@ function TextInputWithTokensInnerComponent({
   minWidth: minWidthProp,
   maxWidth: maxWidthProp,
   variant: variantProp,
-  visibleTokenCount,
   ...rest
 }, externalRef) {
   const {
-    onBlur,
     onFocus,
     onKeyDown,
     ...inputPropsRest
@@ -51,7 +42,6 @@ function TextInputWithTokensInnerComponent({
   const localInputRef = useRef(null);
   const combinedInputRef = useCombinedRefs(localInputRef, ref);
   const [selectedTokenIndex, setSelectedTokenIndex] = useState();
-  const [tokensAreTruncated, setTokensAreTruncated] = useState(Boolean(visibleTokenCount));
   const {
     containerRef
   } = useFocusZone({
@@ -101,45 +91,20 @@ function TextInputWithTokensInnerComponent({
   };
 
   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$current3;
-
-      if (!((_containerRef$current3 = containerRef.current) !== null && _containerRef$current3 !== void 0 && _containerRef$current3.contains(document.activeElement)) && visibleTokenCount) {
-        setTokensAreTruncated(true);
-      }
-    }, 0);
+    setSelectedTokenIndex(undefined);
   };
 
-  const handleTokenKeyUp = event => {
-    if (event.key === 'Escape') {
+  const handleTokenKeyUp = e => {
+    if (e.key === 'Escape') {
       var _ref$current;
 
       (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
     }
   };
 
-  const handleInputFocus = event => {
-    onFocus && onFocus(event);
+  const handleInputFocus = e => {
+    onFocus && onFocus(e);
     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$current4;
-
-      if (!((_containerRef$current4 = containerRef.current) !== null && _containerRef$current4 !== void 0 && _containerRef$current4.contains(document.activeElement)) && visibleTokenCount) {
-        setTokensAreTruncated(true);
-      }
-    }, 0);
   };
 
   const handleInputKeyDown = e => {
@@ -177,17 +142,6 @@ function TextInputWithTokensInnerComponent({
     }
   };
 
-  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,
@@ -200,7 +154,6 @@ function TextInputWithTokensInnerComponent({
     maxWidth: maxWidthProp,
     variant: variantProp,
     ref: containerRef,
-    onClick: focusInput,
     sx: {
       alignItems: 'center',
       flexWrap: preventTokenWrapping ? 'nowrap' : 'wrap',
@@ -232,13 +185,12 @@ function TextInputWithTokensInnerComponent({
     ref: combinedInputRef,
     disabled: disabled,
     onFocus: handleInputFocus,
-    onBlur: handleInputBlur,
     onKeyDown: handleInputKeyDown,
     type: "text",
     sx: {
       height: '100%'
     }
-  }, inputPropsRest))), TokenComponent ? visibleTokens.map(({
+  }, inputPropsRest))), tokens.length && TokenComponent ? tokens.map(({
     id,
     ...tokenRest
   }, i) => /*#__PURE__*/React.createElement(TokenComponent, _extends({
@@ -246,7 +198,6 @@ function TextInputWithTokensInnerComponent({
     onFocus: handleTokenFocus(i),
     onBlur: handleTokenBlur,
     onKeyUp: handleTokenKeyUp,
-    onClick: preventTokenClickPropagation,
     isSelected: selectedTokenIndex === i,
     onRemove: () => {
       handleTokenRemove(id);
@@ -254,10 +205,7 @@ function TextInputWithTokensInnerComponent({
     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);
+  }, tokenRest))) : null);
 }
 
 TextInputWithTokensInnerComponent.displayName = "TextInputWithTokensInnerComponent";

package/lib-esm/_TextInputWrapper.js

@@ -21,7 +21,7 @@ const sizeVariants = variant({
 const TextInputWrapper = styled.span.withConfig({
   displayName: "_TextInputWrapper__TextInputWrapper",
   componentId: "sc-5vfcis-0"
-})(["display:inline-flex;align-items:stretch;min-height:34px;font-size:", ";line-height:20px;color:", ";vertical-align:middle;background-repeat:no-repeat;background-position:right 8px center;border:1px solid ", ";border-radius:", ";outline:none;box-shadow:", ";cursor:text;", " .TextInput-icon{align-self:center;color:", ";margin:0 ", ";flex-shrink:0;}&:focus-within{border-color:", ";box-shadow:", ";}", " ", " ", " @media (min-width:", "){font-size:", ";}", " ", " ", " ", " ", ";"], get('fontSizes.1'), get('colors.fg.default'), get('colors.border.default'), get('radii.2'), get('shadows.primer.shadow.inset'), props => {
+})(["display:inline-flex;align-items:stretch;min-height:34px;font-size:", ";line-height:20px;color:", ";vertical-align:middle;background-repeat:no-repeat;background-position:right 8px center;border:1px solid ", ";border-radius:", ";outline:none;box-shadow:", ";", " .TextInput-icon{align-self:center;color:", ";margin:0 ", ";flex-shrink:0;}&:focus-within{border-color:", ";box-shadow:", ";}", " ", " ", " @media (min-width:", "){font-size:", ";}", " ", " ", " ", " ", ";"], get('fontSizes.1'), get('colors.fg.default'), get('colors.border.default'), get('radii.2'), get('shadows.primer.shadow.inset'), props => {
   if (props.hasIcon) {
     return css(["padding:0;"]);
   } else {

package/lib-esm/theme-preval.js

@@ -515,7 +515,7 @@ module.exports = {
           }
         }
       },
-      "light_protanopia": {
+      "light_colorblind": {
         "colors": {
           "canvasDefaultTransparent": "rgba(255,255,255,0)",
           "marketingIcon": {
@@ -2456,7 +2456,7 @@ module.exports = {
           }
         }
       },
-      "dark_protanopia": {
+      "dark_colorblind": {
         "colors": {
           "canvasDefaultTransparent": "rgba(13,17,23,0)",
           "marketingIcon": {