@ultraviolet/ui 1.51.1 → 1.51.3

package/dist/components/SelectInput/index.js

@@ -0,0 +1,516 @@
+import { jsx, jsxs, Fragment } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { css, useTheme } from "@emotion/react";
+import { Icon } from "@ultraviolet/icons";
+import React, { forwardRef, useState, useId, useMemo, Children, useEffect } from "react";
+import Select, { components } from "react-select";
+import isJSONString from "../../helpers/isJSON.js";
+import * as animations from "../../utils/animations.js";
+import { Expandable } from "../Expandable/index.js";
+import { Separator } from "../Separator/index.js";
+import { Stack } from "../Stack/index.js";
+import { Text } from "../Text/index.js";
+const StyledSeparator = /* @__PURE__ */ _styled(Separator, process.env.NODE_ENV === "production" ? {
+  target: "e11gt5pw5"
+} : {
+  target: "e11gt5pw5",
+  label: "StyledSeparator"
+})("background-color:", ({
+  theme
+}) => theme.colors.neutral.border, ";height:100%;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AAuCyC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const getControlColor = ({
+  state,
+  error,
+  theme
+}) => {
+  if (state.isDisabled)
+    return theme.colors.neutral.textDisabled;
+  if (error)
+    return theme.colors.danger.text;
+  return theme.colors.neutral.text;
+};
+const getPlaceholderColor = ({
+  state,
+  error,
+  theme
+}) => {
+  if (state.isDisabled)
+    return theme.colors.neutral.textDisabled;
+  if (error)
+    return theme.colors.danger.text;
+  return theme.colors.neutral.textWeak;
+};
+const getOptionColor = ({
+  state,
+  theme
+}) => {
+  let color = theme.colors.neutral.text;
+  let backgroundColor = theme.colors.neutral.backgroundWeakElevated;
+  if (state.isDisabled) {
+    backgroundColor = theme.colors.neutral.backgroundDisabled;
+    color = theme.colors.neutral.textDisabled;
+  } else if (state.isSelected) {
+    backgroundColor = theme.colors.primary.backgroundStrong;
+    color = theme.colors.primary.textStrong;
+  } else if (state.isFocused) {
+    backgroundColor = theme.colors.primary.background;
+  }
+  return {
+    backgroundColor,
+    color
+  };
+};
+const getSelectStyles = ({
+  error,
+  customStyle,
+  animation,
+  animationDuration,
+  noTopLabel,
+  theme
+}) => ({
+  control: (provided, state) => ({
+    ...provided,
+    backgroundColor: state.isDisabled ? theme.colors.neutral.backgroundDisabled : theme.colors.neutral.background,
+    borderColor: error ? theme.colors.danger.border : theme.colors.neutral.border,
+    borderRadius: "4px",
+    borderStyle: "solid",
+    borderWidth: "1px",
+    boxShadow: "none",
+    color: getControlColor({
+      error,
+      state,
+      theme
+    }),
+    fontSize: "16px",
+    fontWeight: 500,
+    lineHeight: "24px",
+    minHeight: "48px",
+    transition: "border-color 200ms ease, box-shadow 200ms ease",
+    cursor: state.isDisabled ? "not-allowed" : "pointer",
+    ...!state.isDisabled && {
+      ":focus-within": {
+        borderColor: error ? theme.colors.danger.border : theme.colors.primary.border,
+        boxShadow: error ? theme.shadows.focusDanger : theme.shadows.focusPrimary
+      },
+      ":hover": {
+        borderColor: error ? theme.colors.danger.borderHover : theme.colors.primary.borderHover
+      }
+    },
+    ...customStyle(state)?.["control"] || {},
+    animation: animation ? `${animationDuration}ms ${animations[animation]}` : "none"
+  }),
+  indicatorsContainer: (provided) => ({
+    ...provided,
+    maxHeight: "48px"
+  }),
+  indicatorSeparator: (provided, state) => ({
+    ...provided,
+    backgroundColor: theme.colors.neutral.border,
+    display: "none",
+    ...customStyle(state)?.["indicatorSeparator"] || {}
+  }),
+  input: (provided) => ({
+    ...provided,
+    flexGrow: 1,
+    marginLeft: 0,
+    paddingTop: noTopLabel ? 0 : 11
+  }),
+  menu: (provided, state) => ({
+    ...provided,
+    ...customStyle(state)?.["menu"] || {},
+    boxShadow: theme.shadows.menu
+  }),
+  menuList: (provided, state) => ({
+    ...provided,
+    backgroundColor: theme.colors.neutral.backgroundWeak,
+    maxHeight: "225px",
+    ...customStyle(state)?.["menuList"] || {}
+  }),
+  menuPortal: (provided, state) => ({
+    ...provided,
+    zIndex: 1e4,
+    ...customStyle(state)?.["menuPortal"] || {}
+  }),
+  multiValue: (provided, state) => ({
+    ...provided,
+    alignItems: "center",
+    backgroundColor: theme.colors.neutral.backgroundDisabled,
+    borderRadius: "4px",
+    color: theme.colors.neutral.text,
+    fontSize: "14px",
+    fontWeight: 500,
+    height: "24px",
+    justifyContent: "center",
+    marginTop: theme.space[noTopLabel ? "0.5" : "2"],
+    textOverflow: "ellipsis",
+    ...customStyle(state)?.["multiValue"] || {}
+  }),
+  multiValueLabel: (provided, state) => ({
+    ...provided,
+    color: state.isDisabled ? theme.colors.neutral.textDisabled : theme.colors.neutral.text,
+    fontSize: "14px",
+    fontWeight: "normal",
+    lineHeight: "20px",
+    ...customStyle(state)?.["multiValueLabel"] || {}
+  }),
+  multiValueRemove: (provided, state) => ({
+    ...provided,
+    ...state.isDisabled ? {
+      color: theme.colors.neutral.textDisabled,
+      cursor: "none",
+      pointerEvents: "none"
+    } : {
+      color: theme.colors.primary.text
+    },
+    ":hover": {
+      color: state.isDisabled ? theme.colors.neutral.textDisabled : theme.colors.primary.text,
+      cursor: state.isDisabled ? "none" : "pointer",
+      pointerEvents: state.isDisabled ? "none" : "fill"
+    },
+    ...customStyle(state)?.["multiValueRemove"] || {}
+  }),
+  option: (provided, state) => ({
+    ...provided,
+    ...getOptionColor({
+      state,
+      theme
+    }),
+    cursor: state.isDisabled ? "not-allowed" : "pointer",
+    ":active": {
+      backgroundColor: state.isDisabled ? theme.colors.neutral.backgroundDisabled : theme.colors.primary.background,
+      color: state.isDisabled ? theme.colors.neutral.textDisabled : theme.colors.primary.text
+    },
+    ":hover": {
+      backgroundColor: state.isDisabled ? theme.colors.neutral.backgroundDisabled : theme.colors.primary.background,
+      color: state.isDisabled ? theme.colors.neutral.textDisabled : theme.colors.neutral.text
+    },
+    ...customStyle(state)?.["option"] || {}
+  }),
+  placeholder: (provided, state) => ({
+    ...provided,
+    color: getPlaceholderColor({
+      error,
+      state,
+      theme
+    }),
+    ...customStyle(state)?.["placeholder"] || {}
+  }),
+  singleValue: (provided, state) => ({
+    ...provided,
+    color: state.isDisabled ? theme.colors.neutral.textDisabled : theme.colors.neutral.text,
+    marginLeft: state.hasValue ? 0 : void 0,
+    marginRight: state.hasValue ? 0 : void 0,
+    marginTop: !state.hasValue || noTopLabel ? 0 : "5px",
+    paddingLeft: state.hasValue ? 0 : void 0,
+    ...customStyle(state)?.["singleValue"] || {}
+  }),
+  valueContainer: (provided, state) => ({
+    ...provided,
+    ...customStyle(state)?.["valueContainer"] || {},
+    cursor: state.isDisabled ? "not-allowed" : void 0,
+    height: "100%",
+    label: {
+      display: noTopLabel ? "none" : "initial"
+    },
+    paddingTop: 0
+  })
+});
+const StyledContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["isDisabled", "additionalStyles"].includes(prop),
+  target: "e11gt5pw4"
+} : {
+  shouldForwardProp: (prop) => !["isDisabled", "additionalStyles"].includes(prop),
+  target: "e11gt5pw4",
+  label: "StyledContainer"
+})("width:100%;", ({
+  isDisabled
+}) => isDisabled && `pointer-events: initial;`, ";", ({
+  additionalStyles
+}) => /* @__PURE__ */ css(additionalStyles, process.env.NODE_ENV === "production" ? "" : ";label:StyledContainer;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AAkU8B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AA+TwB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const StyledError = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e11gt5pw3"
+} : {
+  target: "e11gt5pw3",
+  label: "StyledError"
+})("font-size:12px;color:", ({
+  theme
+}) => theme.colors.danger.text, ";padding-top:", ({
+  theme
+}) => theme.space["0.25"], ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AAqU8B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const SelectContainer = (props) => {
+  const {
+    children,
+    getStyles,
+    innerProps: {
+      onKeyDown
+    } = {},
+    isDisabled = false,
+    className,
+    selectProps: {
+      name = "",
+      error,
+      className: selectPropsClassName
+    } = {}
+  } = props;
+  return /* @__PURE__ */ jsxs(StyledContainer, { "data-testid": `select-input-${name}`, additionalStyles: getStyles?.("container", props), isDisabled, className: [className, selectPropsClassName].filter(Boolean).join(" "), onKeyDown, children: [
+    children,
+    /* @__PURE__ */ jsx(Expandable, { opened: !!error, children: /* @__PURE__ */ jsx(StyledError, { children: error }) })
+  ] });
+};
+const StyledPlaceholder = /* @__PURE__ */ _styled("label", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["error", "hasValue", "isDisabled", "isMulti"].includes(prop),
+  target: "e11gt5pw2"
+} : {
+  shouldForwardProp: (prop) => !["error", "hasValue", "isDisabled", "isMulti"].includes(prop),
+  target: "e11gt5pw2",
+  label: "StyledPlaceholder"
+})("position:absolute;left:0;font-weight:400;pointer-events:none;color:", ({
+  theme,
+  error
+}) => error ? theme.colors.danger.text : theme.colors.neutral.text, ";white-space:nowrap;width:100%;height:100%;font-size:16px;transition:transform 250ms ease;opacity:0;", ({
+  hasValue
+}) => hasValue && `
+    transform: translate(0, -8px) scale(0.8);
+    transform-origin: left;
+    padding-left: 8px;
+    left: 0;
+    top: 2px;
+    opacity: 1;
+  `, " ", ({
+  isDisabled,
+  hasValue
+}) => hasValue && isDisabled && "opacity: 0.5", ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AAiX0B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const StyledText = /* @__PURE__ */ _styled(Text, process.env.NODE_ENV === "production" ? {
+  target: "e11gt5pw1"
+} : {
+  target: "e11gt5pw1",
+  label: "StyledText"
+})("margin-left:", ({
+  theme
+}) => theme.space["1"], ";color:", ({
+  isSelectedAndNotFocused,
+  theme
+}) => isSelectedAndNotFocused ? theme.colors.primary.textStrong : void 0, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AA2YqE","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const MaxLineStyledText = /* @__PURE__ */ _styled(StyledText, process.env.NODE_ENV === "production" ? {
+  target: "e11gt5pw0"
+} : {
+  target: "e11gt5pw0",
+  label: "MaxLineStyledText"
+})("-webkit-line-clamp:3;margin-top:", ({
+  theme
+}) => theme.space["2"], ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AAiZ4C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */"));
+const ValueContainer = ({
+  isDisabled,
+  children,
+  selectProps: {
+    error,
+    labelId,
+    inputId,
+    ...selectProps
+  },
+  isMulti,
+  hasValue,
+  clearValue,
+  getStyles,
+  getValue,
+  getClassNames,
+  isRtl,
+  cx,
+  options,
+  selectOption,
+  setValue,
+  theme,
+  className,
+  innerProps
+}) => /* @__PURE__ */ jsx(components.ValueContainer, { clearValue, getStyles, getValue, isRtl, cx, options, selectOption, setValue, theme, className, innerProps, selectProps, isMulti, hasValue, isDisabled, getClassNames, children: /* @__PURE__ */ jsxs(Fragment, { children: [
+  selectProps.placeholder ? /* @__PURE__ */ jsx(StyledPlaceholder, { as: "label", id: labelId, htmlFor: inputId, "aria-live": "assertive", error, isMulti, isDisabled, hasValue, children: selectProps.placeholder }) : null,
+  children
+] }) });
+const inputStyles = ({
+  isMulti
+}) => /* @__PURE__ */ css("margin-left:0px;", !isMulti && "caret-color: transparent", ";" + (process.env.NODE_ENV === "production" ? "" : ";label:inputStyles;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx"],"names":[],"mappings":"AA+c8D","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInput/index.tsx","sourcesContent":["import type { CSSObject, Theme, keyframes } from '@emotion/react'\nimport { css, useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type {\n  ComponentProps,\n  ForwardRefExoticComponent,\n  ForwardedRef,\n  JSX,\n  ReactNode,\n} from 'react'\nimport React, {\n  Children,\n  forwardRef,\n  useEffect,\n  useId,\n  useMemo,\n  useState,\n} from 'react'\nimport type {\n  ClearIndicatorProps,\n  CommonProps,\n  ContainerProps,\n  DropdownIndicatorProps,\n  GroupBase,\n  InputProps,\n  MultiValueProps,\n  OptionProps,\n  Props,\n  ValueContainerProps,\n} from 'react-select'\nimport Select, { components } from 'react-select'\nimport isJSONString from '../../helpers/isJSON'\nimport * as animations from '../../utils/animations'\nimport { Expandable } from '../Expandable'\nimport { Separator } from '../Separator'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\n\nconst StyledSeparator = styled(Separator)`\n  background-color: ${({ theme }) => theme.colors.neutral.border};\n  height: 100%;\n`\n\nexport type SelectOption = {\n  value: string\n  label: ReactNode\n  disabled?: boolean\n  description?: string\n  inlineDescription?: string\n}\n\ntype SelectStyleGetterProps = {\n  state: SelectProps & OptionProps\n  error?: string\n  theme: Theme\n}\n\nconst getControlColor = ({ state, error, theme }: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.text\n}\n\nconst getPlaceholderColor = ({\n  state,\n  error,\n  theme,\n}: SelectStyleGetterProps) => {\n  if (state.isDisabled) return theme.colors.neutral.textDisabled\n  if (error) return theme.colors.danger.text\n\n  return theme.colors.neutral.textWeak\n}\n\nconst getOptionColor = ({ state, theme }: SelectStyleGetterProps) => {\n  let color: string = theme.colors.neutral.text\n  let backgroundColor: string = theme.colors.neutral.backgroundWeakElevated\n  if (state.isDisabled) {\n    backgroundColor = theme.colors.neutral.backgroundDisabled\n    color = theme.colors.neutral.textDisabled\n  } else if (state.isSelected) {\n    backgroundColor = theme.colors.primary.backgroundStrong\n    color = theme.colors.primary.textStrong\n  } else if (state.isFocused) {\n    backgroundColor = theme.colors.primary.background\n  }\n\n  return { backgroundColor, color }\n}\n\ntype SelectStyleFactory = (\n  provided: CSSObject,\n  state: SelectProps & OptionProps & WithSelectProps,\n) => CSSObject\n\ntype SelectStyleMap = Record<string, SelectStyleFactory>\n\ntype SelectStyleProps = {\n  error?: string\n  /**\n   * Custom styles of the SelectInput. See [React select documentation](https://react-select.com/styles)\n   */\n  customStyle: (\n    state: SelectProps & WithSelectProps,\n  ) => Record<string, CSSObject>\n  animation?: string\n  /**\n   * Time of the animation\n   */\n  animationDuration: number\n  /**\n   * Show/hide the label inside the component\n   */\n  noTopLabel?: boolean\n  theme: Theme\n}\n\nconst getSelectStyles = ({\n  error,\n  customStyle,\n  animation,\n  animationDuration,\n  noTopLabel,\n  theme,\n}: SelectStyleProps): SelectStyleMap => ({\n  control: (provided, state) => ({\n    ...provided,\n    backgroundColor: state.isDisabled\n      ? theme.colors.neutral.backgroundDisabled\n      : theme.colors.neutral.background,\n    borderColor: error\n      ? theme.colors.danger.border\n      : theme.colors.neutral.border,\n    borderRadius: '4px',\n    borderStyle: 'solid',\n    borderWidth: '1px',\n    boxShadow: 'none',\n    color: getControlColor({ error, state, theme }),\n    fontSize: '16px',\n    fontWeight: 500,\n    lineHeight: '24px',\n    minHeight: '48px',\n    transition: 'border-color 200ms ease, box-shadow 200ms ease',\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n\n    ...(!state.isDisabled && {\n      ':focus-within': {\n        borderColor: error\n          ? theme.colors.danger.border\n          : theme.colors.primary.border,\n        boxShadow: error\n          ? theme.shadows.focusDanger\n          : theme.shadows.focusPrimary,\n      },\n      ':hover': {\n        borderColor: error\n          ? theme.colors.danger.borderHover\n          : theme.colors.primary.borderHover,\n      },\n    }),\n    ...(customStyle(state)?.['control'] || {}),\n    animation: animation\n      ? `${animationDuration}ms ${\n          (animations as Record<string, ReturnType<typeof keyframes>>)[\n            animation\n          ]\n        }`\n      : 'none',\n  }),\n  indicatorsContainer: provided => ({\n    ...provided,\n    maxHeight: '48px',\n  }),\n  indicatorSeparator: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.border,\n    display: 'none',\n    ...(customStyle(state)?.['indicatorSeparator'] || {}),\n  }),\n  input: provided => ({\n    ...provided,\n    flexGrow: 1,\n    marginLeft: 0,\n    paddingTop: noTopLabel ? 0 : 11,\n  }),\n  menu: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['menu'] || {}),\n    boxShadow: theme.shadows.menu,\n  }),\n  menuList: (provided, state) => ({\n    ...provided,\n    backgroundColor: theme.colors.neutral.backgroundWeak,\n    maxHeight: '225px',\n    ...(customStyle(state)?.['menuList'] || {}),\n  }),\n  menuPortal: (provided, state) => ({\n    ...provided,\n    zIndex: 10000,\n    ...(customStyle(state)?.['menuPortal'] || {}),\n  }),\n  multiValue: (provided, state) => ({\n    ...provided,\n    alignItems: 'center',\n    backgroundColor: theme.colors.neutral.backgroundDisabled,\n    borderRadius: '4px',\n    color: theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 500,\n    height: '24px',\n    justifyContent: 'center',\n    marginTop: theme.space[noTopLabel ? '0.5' : '2'],\n    textOverflow: 'ellipsis',\n    ...(customStyle(state)?.['multiValue'] || {}),\n  }),\n  multiValueLabel: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    fontSize: '14px',\n    fontWeight: 'normal',\n    lineHeight: '20px',\n    ...(customStyle(state)?.['multiValueLabel'] || {}),\n  }),\n  multiValueRemove: (provided, state) => ({\n    ...provided,\n    ...(state.isDisabled\n      ? {\n          color: theme.colors.neutral.textDisabled,\n          cursor: 'none',\n          pointerEvents: 'none',\n        }\n      : {\n          color: theme.colors.primary.text,\n        }),\n    ':hover': {\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n      cursor: state.isDisabled ? 'none' : 'pointer',\n      pointerEvents: state.isDisabled ? 'none' : 'fill',\n    },\n    ...(customStyle(state)?.['multiValueRemove'] || {}),\n  }),\n  option: (provided, state) => ({\n    ...provided,\n    ...getOptionColor({ state, theme }),\n    cursor: state.isDisabled ? 'not-allowed' : 'pointer',\n    ':active': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.primary.text,\n    },\n    ':hover': {\n      backgroundColor: state.isDisabled\n        ? theme.colors.neutral.backgroundDisabled\n        : theme.colors.primary.background,\n      color: state.isDisabled\n        ? theme.colors.neutral.textDisabled\n        : theme.colors.neutral.text,\n    },\n    ...(customStyle(state)?.['option'] || {}),\n  }),\n  placeholder: (provided, state) => ({\n    ...provided,\n    color: getPlaceholderColor({ error, state, theme }),\n    ...(customStyle(state)?.['placeholder'] || {}),\n  }),\n  singleValue: (provided, state) => ({\n    ...provided,\n    color: state.isDisabled\n      ? theme.colors.neutral.textDisabled\n      : theme.colors.neutral.text,\n    marginLeft: state.hasValue ? 0 : undefined,\n    marginRight: state.hasValue ? 0 : undefined,\n    marginTop: !state.hasValue || noTopLabel ? 0 : '5px',\n    paddingLeft: state.hasValue ? 0 : undefined,\n    ...(customStyle(state)?.['singleValue'] || {}),\n  }),\n  valueContainer: (provided, state) => ({\n    ...provided,\n    ...(customStyle(state)?.['valueContainer'] || {}),\n    cursor: state.isDisabled ? 'not-allowed' : undefined,\n    height: '100%',\n    label: {\n      display: noTopLabel ? 'none' : 'initial',\n    },\n    paddingTop: 0,\n  }),\n})\n\ntype WithSelectProps = {\n  selectProps: SelectProps\n}\n\ntype SelectProps = StyledContainerProps &\n  Omit<Props<SelectOption>, 'value'> &\n  CommonProps<SelectOption, boolean, GroupBase<SelectOption>> & {\n    value?: string | SelectOption\n    checked?: boolean\n    error?: string\n    labelId?: string\n    required?: boolean\n    time?: boolean\n  }\n\ntype StyledContainerProps = {\n  isDisabled?: boolean\n  additionalStyles?: Parameters<typeof css>[0]\n}\n\nconst StyledContainer = styled('div', {\n  shouldForwardProp: prop => !['isDisabled', 'additionalStyles'].includes(prop),\n})<StyledContainerProps>`\n  width: 100%;\n  ${({ isDisabled }) => isDisabled && `pointer-events: initial;`};\n  ${({ additionalStyles }) => css(additionalStyles)}\n`\n\nconst StyledError = styled.div`\n  font-size: 12px;\n  color: ${({ theme }) => theme.colors.danger.text};\n  padding-top: ${({ theme }) => theme.space['0.25']};\n`\n\nconst SelectContainer = (\n  props: ContainerProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    children,\n    getStyles,\n    innerProps: { onKeyDown } = {},\n    isDisabled = false,\n    className,\n    selectProps: { name = '', error, className: selectPropsClassName } = {},\n  } = props\n\n  return (\n    <StyledContainer\n      data-testid={`select-input-${name}`}\n      additionalStyles={getStyles?.('container', props)}\n      isDisabled={isDisabled}\n      className={[className, selectPropsClassName].filter(Boolean).join(' ')}\n      onKeyDown={onKeyDown}\n    >\n      {children}\n      <Expandable opened={!!error}>\n        <StyledError>{error}</StyledError>\n      </Expandable>\n    </StyledContainer>\n  )\n}\n\ntype StyledPlaceholderProps = {\n  error?: string\n  isMulti: boolean\n  isDisabled?: boolean\n  hasValue: boolean\n}\n\nconst StyledPlaceholder = styled('label', {\n  shouldForwardProp: prop =>\n    !['error', 'hasValue', 'isDisabled', 'isMulti'].includes(prop),\n})<StyledPlaceholderProps>`\n  position: absolute;\n  left: 0;\n  font-weight: 400;\n  pointer-events: none;\n  color: ${({ theme, error }) =>\n    error ? theme.colors.danger.text : theme.colors.neutral.text};\n  white-space: nowrap;\n  width: 100%;\n  height: 100%;\n  font-size: 16px;\n  transition: transform 250ms ease;\n  opacity: 0;\n  ${({ hasValue }) =>\n    hasValue &&\n    `\n    transform: translate(0, -8px) scale(0.8);\n    transform-origin: left;\n    padding-left: 8px;\n    left: 0;\n    top: 2px;\n    opacity: 1;\n  `}\n  ${({ isDisabled, hasValue }) => hasValue && isDisabled && 'opacity: 0.5'}\n`\n\nconst StyledText = styled(Text)<{ isSelectedAndNotFocused: boolean }>`\n  margin-left: ${({ theme }) => theme.space['1']};\n  color: ${({ isSelectedAndNotFocused, theme }) =>\n    isSelectedAndNotFocused ? theme.colors.primary.textStrong : undefined};\n`\n\nconst MaxLineStyledText = styled(StyledText)`\n  -webkit-line-clamp: 3;\n  margin-top: ${({ theme }) => theme.space['2']};\n`\n\nconst ValueContainer = ({\n  isDisabled,\n  children,\n  selectProps: { error, labelId, inputId, ...selectProps },\n  isMulti,\n  hasValue,\n  clearValue,\n  getStyles,\n  getValue,\n  getClassNames,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  innerProps,\n}: ValueContainerProps<SelectOption> & WithSelectProps) => (\n  <components.ValueContainer\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    innerProps={innerProps}\n    selectProps={selectProps}\n    isMulti={isMulti}\n    hasValue={hasValue}\n    isDisabled={isDisabled}\n    getClassNames={getClassNames}\n  >\n    <>\n      {selectProps.placeholder ? (\n        <StyledPlaceholder\n          as=\"label\"\n          id={labelId}\n          htmlFor={inputId}\n          aria-live=\"assertive\"\n          error={error}\n          isMulti={isMulti}\n          isDisabled={isDisabled}\n          hasValue={hasValue}\n        >\n          {selectProps.placeholder}\n        </StyledPlaceholder>\n      ) : null}\n      {children}\n    </>\n  </components.ValueContainer>\n)\n\nconst inputStyles = ({ isMulti }: Partial<SelectProps>) => css`\n  margin-left: 0px;\n  ${!isMulti && 'caret-color: transparent'};\n`\n\nconst Input = ({\n  isMulti,\n  hasValue,\n  selectProps: { inputId, labelId, placeholder, ...selectProps },\n  clearValue,\n  getStyles,\n  getValue,\n  isRtl,\n  cx,\n  options,\n  selectOption,\n  setValue,\n  theme,\n  className,\n  isHidden,\n  ...props\n}: InputProps<SelectOption> & WithSelectProps) => (\n  <components.Input\n    {...props}\n    css={inputStyles({ isMulti })}\n    id={inputId}\n    aria-controls={labelId}\n    hasValue={hasValue}\n    isMulti={isMulti}\n    clearValue={clearValue}\n    getStyles={getStyles}\n    getValue={getValue}\n    isRtl={isRtl}\n    cx={cx}\n    options={options}\n    selectOption={selectOption}\n    setValue={setValue}\n    theme={theme}\n    className={className}\n    isHidden={isHidden}\n    selectProps={\n      { ...selectProps, placeholder } as InputProps<SelectOption>['selectProps']\n    }\n  />\n)\n\nconst Option = ({\n  selectProps,\n  value,\n  label,\n  children,\n  data: { inlineDescription, description },\n  isSelected,\n  data,\n  ...props\n}: OptionProps<SelectOption> & SelectOption) => {\n  const [isFocused, setIsFocused] = useState(false)\n\n  return (\n    <div\n      data-testid={`option-${selectProps.name || ''}-${\n        isJSONString(value) ? label : value\n      }`}\n      onMouseOver={() => setIsFocused(true)}\n      onFocus={() => setIsFocused(true)}\n      onMouseOut={() => setIsFocused(false)}\n      onBlur={() => setIsFocused(false)}\n    >\n      <components.Option\n        {...props}\n        selectProps={selectProps}\n        label={label}\n        data={data}\n        isSelected={isSelected}\n      >\n        {children}\n        {inlineDescription ? (\n          <StyledText\n            as=\"span\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {inlineDescription}\n          </StyledText>\n        ) : null}\n        {description ? (\n          <MaxLineStyledText\n            as=\"p\"\n            variant=\"bodySmall\"\n            isSelectedAndNotFocused={isSelected && !isFocused}\n          >\n            {description}\n          </MaxLineStyledText>\n        ) : null}\n      </components.Option>\n    </div>\n  )\n}\n\nconst DropdownIndicator = (\n  props: DropdownIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { isDisabled, time, required },\n  } = props\n\n  return (\n    <components.DropdownIndicator {...props}>\n      <Stack gap={1} direction=\"row\" alignItems=\"center\">\n        {required ? <Icon name=\"asterisk\" size={10} color=\"danger\" /> : null}\n        {time ? <StyledSeparator direction=\"vertical\" /> : null}\n        <Icon\n          name={time ? 'clock-outline' : 'arrow-down'}\n          size={time ? 24 : 16}\n          disabled={isDisabled}\n        />\n      </Stack>\n    </components.DropdownIndicator>\n  )\n}\n\nconst ClearIndicator = (\n  props: ClearIndicatorProps<SelectOption> & WithSelectProps,\n) => {\n  const {\n    selectProps: { checked, error },\n    innerProps: { ref, ...restInnerProps },\n  } = props\n\n  return (\n    <components.ClearIndicator {...props}>\n      <Icon\n        {...restInnerProps}\n        name=\"close\"\n        cursor=\"pointer\"\n        color={(checked && 'primary') || (error && 'danger') || 'neutral'}\n      />\n    </components.ClearIndicator>\n  )\n}\n\nconst MultiValueContainer = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueContainer {...props} />\n)\n\nconst MultiValueLabel = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueLabel {...props} />\n)\n\nconst MultiValueRemove = (props: MultiValueProps<SelectOption>) => (\n  <components.MultiValueRemove {...props}>\n    <Icon name=\"close\" size={16} />\n  </components.MultiValueRemove>\n)\n\ntype SelectComponents = SelectProps['components']\n\ntype StateManagedSelect = typeof Select\n\ntype SelectInputProps = SelectProps &\n  SelectStyleProps & {\n    /**\n     * Name of the animation\n     */\n    animation?: string\n    /**\n     * Play the animation when the value change\n     */\n    animationOnChange?: boolean\n    disabled?: boolean\n    readOnly?: boolean\n    innerRef?: ForwardedRef<StateManagedSelect>\n    /**\n     * Custom components of the SelectInput. See [React select documentation](https://react-select.com/components)\n     */\n    customComponents?: SelectProps['components']\n    children: ReactNode\n    emptyState?: ComponentProps<Select>['noOptionsMessage']\n    'data-testid'?: string\n  }\n\nconst defaultCustomStyle = () => ({})\n\nconst FwdSelectInput = ({\n  animation = 'pulse',\n  animationDuration = 1000,\n  animationOnChange = false,\n  children,\n  className,\n  customComponents,\n  customStyle = defaultCustomStyle,\n  disabled = false,\n  error,\n  innerRef,\n  inputId: inputIdProp,\n  isClearable = false,\n  isMulti = false,\n  isSearchable = true,\n  menuPortalTarget,\n  noTopLabel = false,\n  onBlur,\n  onChange,\n  onFocus,\n  options,\n  placeholder,\n  readOnly = false,\n  value,\n  name,\n  id: idProp,\n  time,\n  isLoading,\n  required,\n  emptyState,\n  'data-testid': dataTestId,\n}: Partial<SelectInputProps>) => {\n  const id = useId()\n  const inputId = inputIdProp ?? id\n  const theme = useTheme()\n  const [isAnimated, setIsAnimated] = useState(false)\n  const currentValue = (value as SelectOption)?.value\n\n  // Options need to keep the same reference otherwise react-select doesn't focus the selected option\n  const selectOptions = useMemo(\n    () =>\n      options ||\n      Children.toArray(children).reduce<SelectOption[]>((acc, child) => {\n        if (React.isValidElement<{ children: string; value: string }>(child)) {\n          return [\n            ...acc,\n            {\n              ...child.props,\n              label: child.props.children,\n            },\n          ]\n        }\n\n        return acc\n      }, []),\n    [options, children],\n  )\n\n  useEffect(() => {\n    if (animationOnChange) {\n      setIsAnimated(true)\n      setTimeout(() => setIsAnimated(false), animationDuration)\n    }\n  }, [setIsAnimated, animationOnChange, animationDuration, currentValue])\n\n  return (\n    <Select\n      components={\n        {\n          ClearIndicator,\n          DropdownIndicator,\n          Input,\n          MultiValueContainer,\n          MultiValueLabel,\n          MultiValueRemove,\n          Option,\n          SelectContainer,\n          ValueContainer,\n          ...customComponents,\n        } as SelectComponents\n      }\n      placeholder={placeholder}\n      className={className}\n      isDisabled={disabled || readOnly}\n      isOptionDisabled={option => !!option.disabled}\n      styles={getSelectStyles({\n        animation: isAnimated ? animation : undefined,\n        animationDuration,\n        customStyle,\n        error,\n        noTopLabel,\n        theme,\n      })}\n      options={selectOptions}\n      menuPortalTarget={menuPortalTarget || undefined}\n      isSearchable={isSearchable}\n      isClearable={isClearable}\n      isMulti={isMulti}\n      onBlur={onBlur}\n      onChange={onChange}\n      onFocus={onFocus}\n      value={value as SelectOption}\n      maxMenuHeight={250}\n      inputId={inputId}\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      ref={innerRef as any}\n      name={name}\n      id={idProp}\n      // @ts-expect-error time prop doesn't exist in react-select but is used\n      time={time}\n      isLoading={isLoading}\n      required={required}\n      noOptionsMessage={emptyState}\n      data-testid={dataTestId}\n    />\n  )\n}\n\ntype OptionComponent = (\n  props: Partial<OptionProps<SelectOption> & SelectOption>,\n) => JSX.Element\n\n/**\n * SelectInput component is a wrapper around [react-select](https://react-select.com) component.\n * It provides a styled select input with a label and an error message.\n * @deprecated use SelectInputV2 component instead\n */\nexport const SelectInput = forwardRef(\n  (props: SelectInputProps, ref: ForwardedRef<StateManagedSelect>) => (\n    <FwdSelectInput innerRef={ref} {...props} />\n  ),\n) as ForwardRefExoticComponent<Partial<SelectInputProps>> & {\n  Option: OptionComponent\n}\n\nSelectInput.displayName = 'SelectInput'\n\nSelectInput.Option = Option as OptionComponent\n"]} */");
+const Input = ({
+  isMulti,
+  hasValue,
+  selectProps: {
+    inputId,
+    labelId,
+    placeholder,
+    ...selectProps
+  },
+  clearValue,
+  getStyles,
+  getValue,
+  isRtl,
+  cx,
+  options,
+  selectOption,
+  setValue,
+  theme,
+  className,
+  isHidden,
+  ...props
+}) => /* @__PURE__ */ jsx(components.Input, { ...props, css: inputStyles({
+  isMulti
+}), id: inputId, "aria-controls": labelId, hasValue, isMulti, clearValue, getStyles, getValue, isRtl, cx, options, selectOption, setValue, theme, className, isHidden, selectProps: {
+  ...selectProps,
+  placeholder
+} });
+const Option = ({
+  selectProps,
+  value,
+  label,
+  children,
+  data: {
+    inlineDescription,
+    description
+  },
+  isSelected,
+  data,
+  ...props
+}) => {
+  const [isFocused, setIsFocused] = useState(false);
+  return /* @__PURE__ */ jsx("div", { "data-testid": `option-${selectProps.name || ""}-${isJSONString(value) ? label : value}`, onMouseOver: () => setIsFocused(true), onFocus: () => setIsFocused(true), onMouseOut: () => setIsFocused(false), onBlur: () => setIsFocused(false), children: /* @__PURE__ */ jsxs(components.Option, { ...props, selectProps, label, data, isSelected, children: [
+    children,
+    inlineDescription ? /* @__PURE__ */ jsx(StyledText, { as: "span", variant: "bodySmall", isSelectedAndNotFocused: isSelected && !isFocused, children: inlineDescription }) : null,
+    description ? /* @__PURE__ */ jsx(MaxLineStyledText, { as: "p", variant: "bodySmall", isSelectedAndNotFocused: isSelected && !isFocused, children: description }) : null
+  ] }) });
+};
+const DropdownIndicator = (props) => {
+  const {
+    selectProps: {
+      isDisabled,
+      time,
+      required
+    }
+  } = props;
+  return /* @__PURE__ */ jsx(components.DropdownIndicator, { ...props, children: /* @__PURE__ */ jsxs(Stack, { gap: 1, direction: "row", alignItems: "center", children: [
+    required ? /* @__PURE__ */ jsx(Icon, { name: "asterisk", size: 10, color: "danger" }) : null,
+    time ? /* @__PURE__ */ jsx(StyledSeparator, { direction: "vertical" }) : null,
+    /* @__PURE__ */ jsx(Icon, { name: time ? "clock-outline" : "arrow-down", size: time ? 24 : 16, disabled: isDisabled })
+  ] }) });
+};
+const ClearIndicator = (props) => {
+  const {
+    selectProps: {
+      checked,
+      error
+    },
+    innerProps: {
+      ref,
+      ...restInnerProps
+    }
+  } = props;
+  return /* @__PURE__ */ jsx(components.ClearIndicator, { ...props, children: /* @__PURE__ */ jsx(Icon, { ...restInnerProps, name: "close", cursor: "pointer", color: checked && "primary" || error && "danger" || "neutral" }) });
+};
+const MultiValueContainer = (props) => /* @__PURE__ */ jsx(components.MultiValueContainer, { ...props });
+const MultiValueLabel = (props) => /* @__PURE__ */ jsx(components.MultiValueLabel, { ...props });
+const MultiValueRemove = (props) => /* @__PURE__ */ jsx(components.MultiValueRemove, { ...props, children: /* @__PURE__ */ jsx(Icon, { name: "close", size: 16 }) });
+const defaultCustomStyle = () => ({});
+const FwdSelectInput = ({
+  animation = "pulse",
+  animationDuration = 1e3,
+  animationOnChange = false,
+  children,
+  className,
+  customComponents,
+  customStyle = defaultCustomStyle,
+  disabled = false,
+  error,
+  innerRef,
+  inputId: inputIdProp,
+  isClearable = false,
+  isMulti = false,
+  isSearchable = true,
+  menuPortalTarget,
+  noTopLabel = false,
+  onBlur,
+  onChange,
+  onFocus,
+  options,
+  placeholder,
+  readOnly = false,
+  value,
+  name,
+  id: idProp,
+  time,
+  isLoading,
+  required,
+  emptyState,
+  "data-testid": dataTestId
+}) => {
+  const id = useId();
+  const inputId = inputIdProp ?? id;
+  const theme = useTheme();
+  const [isAnimated, setIsAnimated] = useState(false);
+  const currentValue = value?.value;
+  const selectOptions = useMemo(() => options || Children.toArray(children).reduce((acc, child) => {
+    if (React.isValidElement(child)) {
+      return [...acc, {
+        ...child.props,
+        label: child.props.children
+      }];
+    }
+    return acc;
+  }, []), [options, children]);
+  useEffect(() => {
+    if (animationOnChange) {
+      setIsAnimated(true);
+      setTimeout(() => setIsAnimated(false), animationDuration);
+    }
+  }, [setIsAnimated, animationOnChange, animationDuration, currentValue]);
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      components: {
+        ClearIndicator,
+        DropdownIndicator,
+        Input,
+        MultiValueContainer,
+        MultiValueLabel,
+        MultiValueRemove,
+        Option,
+        SelectContainer,
+        ValueContainer,
+        ...customComponents
+      },
+      placeholder,
+      className,
+      isDisabled: disabled || readOnly,
+      isOptionDisabled: (option) => !!option.disabled,
+      styles: getSelectStyles({
+        animation: isAnimated ? animation : void 0,
+        animationDuration,
+        customStyle,
+        error,
+        noTopLabel,
+        theme
+      }),
+      options: selectOptions,
+      menuPortalTarget: menuPortalTarget || void 0,
+      isSearchable,
+      isClearable,
+      isMulti,
+      onBlur,
+      onChange,
+      onFocus,
+      value,
+      maxMenuHeight: 250,
+      inputId,
+      ref: innerRef,
+      name,
+      id: idProp,
+      time,
+      isLoading,
+      required,
+      noOptionsMessage: emptyState,
+      "data-testid": dataTestId
+    }
+  );
+};
+const SelectInput = forwardRef((props, ref) => /* @__PURE__ */ jsx(FwdSelectInput, { innerRef: ref, ...props }));
+SelectInput.displayName = "SelectInput";
+SelectInput.Option = Option;
+export {
+  SelectInput
+};