@ultraviolet/ui 1.55.3 → 1.56.0

package/dist/components/SearchInput/index.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+/**
+ * SearchInput is a component that allows users to search for items. It is a combination of a TextInputV2 and a Popup. The Popup is used to display search results.
+ * Children of the SearchInput component can be a function that receives an object with the following properties:
+ * - `searchTerms`: the current search terms
+ * - `isOpen`: a boolean indicating if the popup is open
+ * - `toggleIsOpen`: a function to toggle the popup
+ */
+export declare const SearchInput: import("react").ForwardRefExoticComponent<{
+    popupPlacement?: import("../Popup/helpers").PopupPlacement | undefined;
+    threshold?: number | undefined;
+    children: import("react").ReactNode | import("./types").SearchBarChildrenFunctionProps;
+    onSearch: (value: string) => void;
+    onClose?: (() => void) | undefined;
+    "data-testid"?: string | undefined;
+} & Pick<{
+    className?: string | undefined;
+    clearable?: boolean | undefined;
+    'data-testid'?: string | undefined;
+    error?: string | undefined;
+    helper?: import("react").ReactNode;
+    label?: string | undefined;
+    labelDescription?: import("react").ReactNode;
+    loading?: boolean | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    onRandomize?: (() => void) | undefined;
+    onChange?: ((newValue: string) => void) | undefined;
+    prefix?: import("react").ReactNode;
+    size?: "large" | "medium" | "small" | undefined;
+    success?: string | boolean | undefined;
+    suffix?: import("react").ReactNode;
+    tooltip?: string | undefined;
+    type?: "text" | "email" | "password" | "url" | undefined;
+    value?: string | undefined;
+} & Pick<import("react").InputHTMLAttributes<HTMLInputElement>, "autoFocus" | "id" | "tabIndex" | "aria-label" | "aria-labelledby" | "onFocus" | "onBlur" | "onKeyDown" | "name" | "disabled" | "autoComplete" | "placeholder" | "readOnly" | "required"> & import("react").RefAttributes<HTMLInputElement>, "label" | "size" | "loading" | "placeholder" | "suffix"> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/SearchInput/index.js

@@ -0,0 +1,98 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { Icon } from "@ultraviolet/icons";
+import { forwardRef, useRef, useState, useReducer, useEffect } from "react";
+import { Popup } from "../Popup/index.js";
+import { TextInputV2 } from "../TextInputV2/index.js";
+const StyledPopup = /* @__PURE__ */ _styled(Popup, process.env.NODE_ENV === "production" ? {
+  target: "eefux4u0"
+} : {
+  target: "eefux4u0",
+  label: "StyledPopup"
+})("width:100%;text-align:initial;min-width:610px;padding:", ({
+  theme
+}) => `${theme.space["2"]} ${theme.space["1"]}`, ";background:", ({
+  theme
+}) => theme.colors.neutral.background, ";box-shadow:", ({
+  theme
+}) => theme.shadows.modal, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const SearchInput = forwardRef(({
+  placeholder,
+  label,
+  loading,
+  size,
+  suffix,
+  popupPlacement,
+  threshold = 0,
+  children,
+  onSearch,
+  onClose,
+  "data-testid": dataTestId
+}, ref) => {
+  const focusedLinkIndex = useRef(0);
+  const popupRef = useRef(null);
+  const [containerWidth, setContainerWidth] = useState(0);
+  const [searchTerms, setSearchTerms] = useState("");
+  const [isOpen, toggleIsOpen] = useReducer((state) => !state, false);
+  const content = typeof children === "function" ? children({
+    searchTerms,
+    isOpen,
+    toggleIsOpen
+  }) : children;
+  const resizeSearchBar = () => {
+    if (popupRef.current) {
+      setContainerWidth(popupRef.current.getBoundingClientRect().width);
+    }
+  };
+  const handleNavigation = (event) => {
+    const links = [...popupRef.current?.querySelectorAll("a") ?? []];
+    if (links.length > 0 && focusedLinkIndex.current >= 0 && focusedLinkIndex.current <= links.length) {
+      if (event.key === "ArrowUp") {
+        if (focusedLinkIndex.current - 1 < 0) {
+          focusedLinkIndex.current = links.length - 1;
+        } else {
+          focusedLinkIndex.current -= 1;
+        }
+        links[focusedLinkIndex.current]?.focus();
+      }
+      if (event.key === "ArrowDown") {
+        if (focusedLinkIndex.current + 1 >= links.length) {
+          focusedLinkIndex.current = 0;
+        } else {
+          focusedLinkIndex.current += 1;
+        }
+        links[focusedLinkIndex.current]?.focus();
+      }
+    }
+  };
+  useEffect(() => {
+    document.addEventListener("keyup", handleNavigation);
+    return () => document.removeEventListener("keyup", handleNavigation);
+  }, []);
+  useEffect(() => {
+    resizeSearchBar();
+    window.addEventListener("resize", resizeSearchBar);
+    return () => window.removeEventListener("resize", resizeSearchBar);
+  }, []);
+  const onSearchCallback = (value) => {
+    setSearchTerms(value);
+    try {
+      onSearch(value);
+      if (value.length >= threshold && !isOpen) {
+        toggleIsOpen();
+      }
+    } catch {
+      toggleIsOpen();
+    }
+  };
+  const onCloseCallback = () => {
+    onClose?.();
+    if (isOpen) {
+      toggleIsOpen();
+    }
+  };
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(StyledPopup, { "data-testid": `popup-${dataTestId}`, role: "dialog", visible: isOpen, onClose: onCloseCallback, placement: popupPlacement, maxWidth: containerWidth, hideOnClickOutside: true, hasArrow: false, innerRef: popupRef, text: content, maxHeight: 410, debounceDelay: 0, children: /* @__PURE__ */ jsx(TextInputV2, { ref, prefix: /* @__PURE__ */ jsx(Icon, { name: "search" }), suffix, "data-testid": dataTestId, value: searchTerms, size, label, placeholder, loading, onChange: onSearchCallback, clearable: true }) }) });
+});
+export {
+  SearchInput
+};

package/dist/components/SearchInput/types.d.ts

@@ -0,0 +1,17 @@
+import type { Popup, TextInputV2 } from '@ultraviolet/ui';
+import type { ComponentProps, DispatchWithoutAction, ReactNode } from 'react';
+type ChildrenProps = {
+    searchTerms: string;
+    isOpen: boolean;
+    toggleIsOpen: DispatchWithoutAction;
+};
+export type SearchBarChildrenFunctionProps = ({ searchTerms, isOpen, toggleIsOpen, }: ChildrenProps) => ReactNode;
+export type SearchInputProps = {
+    popupPlacement?: ComponentProps<typeof Popup>['placement'];
+    threshold?: number;
+    children: SearchBarChildrenFunctionProps | ReactNode;
+    onSearch: (value: string) => void;
+    onClose?: () => void;
+    ['data-testid']?: string;
+} & Pick<ComponentProps<typeof TextInputV2>, 'placeholder' | 'size' | 'label' | 'loading' | 'suffix'>;
+export {};

package/dist/components/SelectInputV2/SelectBar.cjs

@@ -23,7 +23,7 @@ const StateStack = /* @__PURE__ */ _styled__default.default(index.Stack, process
   label: "StateStack"
 })("padding-right:", ({
   theme
-}) => theme.space["2"], ";display:flex;" + (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/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AAoCgC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid=\"select-bar\"\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */"));
+}) => theme.space["2"], ";display:flex;" + (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/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AAqCgC","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n  'data-testid': string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n  'data-testid': dataTestId,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid={dataTestId}\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */"));
 const StyledInputWrapper = /* @__PURE__ */ _styled__default.default(index.Stack, process.env.NODE_ENV === "production" ? {
   target: "ejy0aca1"
 } : {
@@ -59,7 +59,7 @@ const StyledInputWrapper = /* @__PURE__ */ _styled__default.default(index.Stack,
   theme
 }) => theme.colors.primary.borderHover, ";outline:none;}&[data-dropdownvisible='true']{border-color:", ({
   theme
-}) => theme.colors.primary.borderHover, ";}" + (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/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AA+CE","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid=\"select-bar\"\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */"));
+}) => theme.colors.primary.borderHover, ";}" + (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/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AAgDE","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n  'data-testid': string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n  'data-testid': dataTestId,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid={dataTestId}\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */"));
 const CustomTag = /* @__PURE__ */ _styled__default.default(index$1.Tag, process.env.NODE_ENV === "production" ? {
   target: "ejy0aca0"
 } : {
@@ -71,7 +71,7 @@ const CustomTag = /* @__PURE__ */ _styled__default.default(index$1.Tag, process.
 } : {
   name: "1snt5jp",
   styles: "height:fit-content;width:fit-content",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AAyG6B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid=\"select-bar\"\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx"],"names":[],"mappings":"AA0G6B","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/SelectInputV2/SelectBar.tsx","sourcesContent":["import styled from '@emotion/styled'\nimport { Icon } from '@ultraviolet/icons'\nimport type { RefObject } from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { Button } from '../Button'\nimport { Stack } from '../Stack'\nimport { Tag } from '../Tag'\nimport { Text } from '../Text'\nimport { useSelectInput } from './SelectInputProvider'\nimport { findOptionInOptions } from './findOptionInOptions'\nimport type { DataType, OptionType } from './types'\nimport { INPUT_SIZE_HEIGHT, SIZES_TAG } from './types'\n\ntype SelectBarProps = {\n  size: 'small' | 'medium' | 'large'\n  clearable: boolean\n  disabled: boolean\n  readOnly: boolean\n  placeholder: string\n  success?: string\n  error?: string\n  autoFocus?: boolean\n  innerRef: RefObject<HTMLDivElement>\n  id?: string\n  'data-testid': string\n}\n\ntype DisplayValuesProps = {\n  refTag: RefObject<HTMLDivElement>\n  nonOverflowedValues: OptionType[]\n  disabled: boolean\n  readOnly: boolean\n  overflowed: boolean\n  overflowAmount: number\n  size: 'small' | 'medium' | 'large'\n}\n\nconst StateStack = styled(Stack)`\n  padding-right: ${({ theme }) => theme.space['2']};\n  display: flex;\n`\n\nconst StyledInputWrapper = styled(Stack)<{\n  'data-readonly': boolean\n  'data-disabled': boolean\n  'data-size': 'small' | 'medium' | 'large'\n  'data-state': 'neutral' | 'success' | 'danger'\n  'data-dropdownvisible': boolean\n}>`\n  display: flex;\n  padding: ${({ theme }) => theme.space[1]};\n  padding-right: 0;\n  padding-left: ${({ theme }) => theme.space[2]};\n  cursor: pointer;\n  box-shadow: none;\n  background: ${({ theme }) => theme.colors.neutral.background};\n  border-radius: ${({ theme }) => theme.radii.default};\n\n  &[data-readonly='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundWeak};\n    border-color: ${({ theme }) => theme.colors.neutral.border};\n    cursor: default;\n  }\n\n  &[data-disabled='true'] {\n    background: ${({ theme }) => theme.colors.neutral.backgroundDisabled};\n    border-color: ${({ theme }) => theme.colors.neutral.borderDisabled};\n    cursor: not-allowed;\n  }\n  &[data-size='small'] {\n    height: ${INPUT_SIZE_HEIGHT.small}px;\n  }\n  &[data-size='medium'] {\n    height: ${INPUT_SIZE_HEIGHT.medium}px;\n  }\n  &[data-size='large'] {\n    height: ${INPUT_SIZE_HEIGHT.large}px;\n  }\n  &[data-state='neutral'] {\n    border: 1px solid ${({ theme }) => theme.colors.neutral.border};\n  }\n  &[data-state='success'] {\n    border: 1px solid ${({ theme }) => theme.colors.success.border};\n  }\n  &[data-state='danger'] {\n    border: 1px solid ${({ theme }) => theme.colors.danger.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):hover {\n    border-color: ${({ theme }) => theme.colors.primary.border};\n  }\n\n  &:not([data-disabled='true']):not([data-readonly]):active {\n    box-shadow: ${({ theme }) => theme.shadows.focusPrimary};\n  }\n\n  &:not([data-disabled='true']):hover,\n  :not([data-disabled='true']):focus {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n    outline: none;\n  }\n\n  &[data-dropdownvisible='true'] {\n    border-color: ${({ theme }) => theme.colors.primary.borderHover};\n  }\n`\nconst CustomTag = styled(Tag)`\n  height: fit-content;\n  width: fit-content;\n`\n\nconst isValidSelectedValue = (selectedValue: string, options: DataType) =>\n  !Array.isArray(options)\n    ? Object.keys(options).some(group =>\n        options[group].some(\n          option => option.value === selectedValue && !option.disabled,\n        ),\n      )\n    : options.some(option => option.value === selectedValue && !option.disabled)\n\nconst DisplayValues = ({\n  refTag,\n  nonOverflowedValues,\n  disabled,\n  readOnly,\n  overflowed,\n  overflowAmount,\n  size,\n}: DisplayValuesProps) => {\n  const { multiselect, selectedData, setSelectedData, options, onChange } =\n    useSelectInput()\n\n  return multiselect ? (\n    <Stack\n      direction=\"row\"\n      gap=\"1\"\n      wrap=\"nowrap\"\n      ref={refTag}\n      alignItems=\"center\"\n    >\n      {nonOverflowedValues.map(option => (\n        <CustomTag\n          data-testid=\"selected-options-tags\"\n          key={option?.value}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          onClose={\n            !readOnly\n              ? event => {\n                  event.stopPropagation()\n                  setSelectedData({\n                    type: 'selectOption',\n                    clickedOption: option,\n                  })\n                  const newSelectedValues = selectedData.selectedValues?.filter(\n                    val => val !== option.value,\n                  )\n                  onChange?.(newSelectedValues)\n                }\n              : undefined\n          }\n        >\n          {option?.label}\n        </CustomTag>\n      ))}\n      {overflowed ? (\n        <Tag\n          sentiment=\"neutral\"\n          disabled={disabled}\n          key=\"+\"\n          data-testid=\"plus-tag\"\n          aria-label=\"Plus tag\"\n        >\n          <Icon name=\"plus\" />\n          {overflowAmount}\n        </Tag>\n      ) : null}\n    </Stack>\n  ) : (\n    <Text as=\"p\" variant={size === 'large' ? 'body' : 'bodySmall'}>\n      {selectedData.selectedValues[0]\n        ? findOptionInOptions(options, selectedData.selectedValues[0])?.label\n        : null}\n    </Text>\n  )\n}\n\nexport const SelectBar = ({\n  size,\n  clearable,\n  disabled,\n  readOnly,\n  placeholder,\n  success,\n  error,\n  autoFocus,\n  innerRef,\n  id,\n  'data-testid': dataTestId,\n}: SelectBarProps) => {\n  const {\n    isDropdownVisible,\n    onChange,\n    setIsDropdownVisible,\n    options,\n    selectedData,\n    setSelectedData,\n    multiselect,\n  } = useSelectInput()\n  const openable = !(readOnly || disabled)\n  const refTag = useRef<HTMLDivElement>(null)\n  const width = innerRef.current?.offsetWidth\n  const [overflowed, setOverflowed] = useState(false)\n  const [overflowAmount, setOverflowAmount] = useState(0)\n  const [nonOverflowedValues, setNonOverFlowedValues] = useState<OptionType[]>(\n    () => {\n      if (selectedData.selectedValues[0]) {\n        const firstSelectOption = findOptionInOptions(\n          options,\n          selectedData.selectedValues[0],\n        )\n\n        return firstSelectOption ? [firstSelectOption] : []\n      }\n\n      return []\n    },\n  )\n\n  const state = useMemo(() => {\n    if (error) {\n      return 'danger'\n    }\n    if (success) {\n      return 'success'\n    }\n\n    return 'neutral'\n  }, [error, success])\n\n  useEffect(() => {\n    // When too many items are selected, too avoid overflow, compute the number of tags to display and add a + tag\n    let tagsWidth = 0\n    let computedOverflowAmount = 0\n    let computedNonOverflowedValues: OptionType[] = []\n    const newSelectedValues = selectedData.selectedValues.filter(\n      selectedValue => isValidSelectedValue(selectedValue, options),\n    )\n    for (const selectedValue of newSelectedValues) {\n      const selectedOption = findOptionInOptions(options, selectedValue)\n      if (\n        selectedOption?.label &&\n        width &&\n        isValidSelectedValue(selectedValue, options)\n      ) {\n        const lengthValue = selectedOption.value.length // Find a better way to find the number of displayed characters?\n        const totalTagWidth =\n          SIZES_TAG.tagWidth + SIZES_TAG.letterWidth * lengthValue\n        if (totalTagWidth + tagsWidth > width - 100) {\n          computedOverflowAmount += 1\n          setOverflowAmount(computedOverflowAmount)\n        } else {\n          computedNonOverflowedValues = [\n            ...computedNonOverflowedValues,\n            selectedOption,\n          ]\n          setNonOverFlowedValues(computedNonOverflowedValues)\n          tagsWidth += totalTagWidth\n        }\n      }\n    }\n    if (computedOverflowAmount === 0) {\n      setOverflowed(false)\n    } else {\n      setOverflowed(true)\n    }\n    setOverflowAmount(computedOverflowAmount)\n  }, [options, selectedData.selectedValues, width])\n\n  useEffect(() => {\n    setSelectedData({ type: 'update' })\n  }, [setSelectedData, options])\n\n  return (\n    <StyledInputWrapper\n      role=\"combobox\"\n      id={id}\n      data-disabled={disabled}\n      data-readonly={readOnly}\n      data-size={size}\n      data-dropdownvisible={isDropdownVisible}\n      data-state={state}\n      direction=\"row\"\n      wrap=\"nowrap\"\n      gap=\"1\"\n      justifyContent=\"space-between\"\n      alignItems=\"center\"\n      onClick={\n        openable ? () => setIsDropdownVisible(!isDropdownVisible) : undefined\n      }\n      data-testid={dataTestId}\n      autoFocus={autoFocus}\n      onKeyDown={event => {\n        if (event.key === 'ArrowDown') {\n          if (!isDropdownVisible) {\n            setIsDropdownVisible(true)\n          } else {\n            document.getElementById(`option-0`)?.focus()\n          }\n        }\n\n        return ['Enter', ' '].includes(event.key) && openable\n          ? setIsDropdownVisible(!isDropdownVisible)\n          : null\n      }}\n      ref={innerRef}\n      aria-labelledby=\"select bar\"\n      aria-haspopup=\"listbox\"\n      aria-expanded={isDropdownVisible}\n      tabIndex={0}\n    >\n      {selectedData.selectedValues.length > 0 ? (\n        <DisplayValues\n          refTag={refTag}\n          nonOverflowedValues={nonOverflowedValues}\n          disabled={disabled}\n          readOnly={readOnly}\n          overflowed={overflowed}\n          overflowAmount={overflowAmount}\n          size={size}\n        />\n      ) : (\n        <Text\n          as=\"p\"\n          variant={size === 'large' ? 'body' : 'bodySmall'}\n          sentiment=\"neutral\"\n          disabled={disabled}\n          prominence=\"weak\"\n        >\n          {placeholder}\n        </Text>\n      )}\n      <StateStack direction=\"row\" gap={1} alignItems=\"center\">\n        {error ? <Icon name=\"alert\" sentiment=\"danger\" /> : null}\n        {success && !error ? (\n          <Icon name=\"checkbox-circle-outline\" sentiment=\"success\" />\n        ) : null}\n        {clearable && selectedData.selectedValues.length > 0 ? (\n          <Button\n            aria-label=\"clear value\"\n            disabled={disabled || ![selectedData.selectedValues[0]] || readOnly}\n            variant=\"ghost\"\n            size=\"small\"\n            icon=\"close\"\n            onClick={event => {\n              event.stopPropagation()\n              setSelectedData({ type: 'clearAll' })\n              if (multiselect) {\n                onChange?.([])\n              } else {\n                onChange?.('')\n              }\n            }}\n            sentiment=\"neutral\"\n            data-testid=\"clear-all\"\n          />\n        ) : null}\n        <Icon\n          aria-label=\"show dropdown\"\n          size=\"small\"\n          name=\"arrow-down\"\n          sentiment=\"neutral\"\n          disabled={disabled || readOnly}\n        />\n      </StateStack>\n    </StyledInputWrapper>\n  )\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__
 });
 const isValidSelectedValue = (selectedValue, options) => !Array.isArray(options) ? Object.keys(options).some((group) => options[group].some((option) => option.value === selectedValue && !option.disabled)) : options.some((option) => option.value === selectedValue && !option.disabled);
@@ -117,7 +117,8 @@ const SelectBar = ({
   error,
   autoFocus,
   innerRef,
-  id
+  id,
+  "data-testid": dataTestId
 }) => {
   const {
     isDropdownVisible,
@@ -181,7 +182,7 @@ const SelectBar = ({
       type: "update"
     });
   }, [setSelectedData, options]);
-  return /* @__PURE__ */ jsxRuntime.jsxs(StyledInputWrapper, { role: "combobox", id, "data-disabled": disabled, "data-readonly": readOnly, "data-size": size, "data-dropdownvisible": isDropdownVisible, "data-state": state, direction: "row", wrap: "nowrap", gap: "1", justifyContent: "space-between", alignItems: "center", onClick: openable ? () => setIsDropdownVisible(!isDropdownVisible) : void 0, "data-testid": "select-bar", autoFocus, onKeyDown: (event) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(StyledInputWrapper, { role: "combobox", id, "data-disabled": disabled, "data-readonly": readOnly, "data-size": size, "data-dropdownvisible": isDropdownVisible, "data-state": state, direction: "row", wrap: "nowrap", gap: "1", justifyContent: "space-between", alignItems: "center", onClick: openable ? () => setIsDropdownVisible(!isDropdownVisible) : void 0, "data-testid": dataTestId, autoFocus, onKeyDown: (event) => {
     if (event.key === "ArrowDown") {
       if (!isDropdownVisible) {
         setIsDropdownVisible(true);

package/dist/components/SelectInputV2/SelectBar.d.ts

@@ -10,6 +10,7 @@ type SelectBarProps = {
     autoFocus?: boolean;
     innerRef: RefObject<HTMLDivElement>;
     id?: string;
+    'data-testid': string;
 };
-export declare const SelectBar: ({ size, clearable, disabled, readOnly, placeholder, success, error, autoFocus, innerRef, id, }: SelectBarProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const SelectBar: ({ size, clearable, disabled, readOnly, placeholder, success, error, autoFocus, innerRef, id, "data-testid": dataTestId, }: SelectBarProps) => import("@emotion/react/jsx-runtime").JSX.Element;
 export {};