@amboss/design-system 1.15.2 → 1.15.3

package/build/esm/src/components/Form/Select/Select.js

@@ -0,0 +1,284 @@
+import _extends from '@babel/runtime/helpers/extends';
+import _styled from '@emotion/styled/base';
+import React, { useState, useMemo, useRef, useCallback, useEffect } from 'react';
+import { useKeyboard } from '../../../shared/useKeyboard.js';
+import { useAutoPosition } from '../../../shared/useAutoPosition.js';
+import { FormField } from '../FormField/FormField.js';
+import { VirtualScrollList } from '../../VirtualScrollList/VirtualScrollList.js';
+import { InputRaw, Input } from '../Input/Input.js';
+import { Text } from '../../Typography/Text/Text.js';
+import { Box } from '../../Box/Box.js';
+
+const StyledContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "el6d4lv4"
+} : {
+  target: "el6d4lv4",
+  label: "StyledContainer"
+})(() => ({
+  position: "relative"
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Select.tsx"],"names":[],"mappings":"AAqBwB","file":"Select.tsx","sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"]} */");
+const StyledInputWrap = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "el6d4lv3"
+} : {
+  target: "el6d4lv3",
+  label: "StyledInputWrap"
+})(() => ({
+  zIndex: 0,
+  position: "absolute",
+  pointerEvents: "none",
+  width: "100%",
+  bottom: 0,
+  left: 0
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Select.tsx"],"names":[],"mappings":"AAyBwB","file":"Select.tsx","sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"]} */");
+const StyledDropdown = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "el6d4lv2"
+} : {
+  target: "el6d4lv2",
+  label: "StyledDropdown"
+})(_ref => {
+  let {
+    theme,
+    dropdownPosition
+  } = _ref;
+  return {
+    backgroundColor: theme.values.color.background.primary.default,
+    position: "absolute",
+    fontSize: theme.variables.size.font.text.s,
+    zIndex: 2,
+    width: "100%",
+    margin: `${theme.variables.size.spacing.xs} 0`,
+    cursor: "pointer",
+    borderRadius: theme.variables.size.borderRadius.dropdown.m,
+    overflow: "hidden",
+    boxShadow: theme.variables.shadow.card.b,
+    boxSizing: "border-box",
+    ...(dropdownPosition === "down" && {
+      top: "100%"
+    }),
+    ...(dropdownPosition === "up" && {
+      bottom: "100%"
+    })
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Select.tsx"],"names":[],"mappings":"AAkCuB","file":"Select.tsx","sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"]} */");
+const StyledDropdownItem = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "el6d4lv1"
+} : {
+  target: "el6d4lv1",
+  label: "StyledDropdownItem"
+})(_ref2 => {
+  let {
+    theme,
+    active
+  } = _ref2;
+  return {
+    padding: theme.variables.size.spacing.xs,
+    borderRadius: theme.variables.size.borderRadius.dropdown.s,
+    ...(active && {
+      backgroundColor: theme.values.color.background.secondary.hover,
+      borderRadius: 0
+    }),
+    "&:hover": {
+      backgroundColor: theme.values.color.background.secondary.hover,
+      borderRadius: 0
+    }
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Select.tsx"],"names":[],"mappings":"AAwD2B","file":"Select.tsx","sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"]} */");
+const HiddenSelectInput = /*#__PURE__*/_styled("select", process.env.NODE_ENV === "production" ? {
+  target: "el6d4lv0"
+} : {
+  target: "el6d4lv0",
+  label: "HiddenSelectInput"
+})(() => ({
+  display: "none"
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Select.tsx"],"names":[],"mappings":"AAuE0B","file":"Select.tsx","sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"]} */");
+const defaultFilterMethod = (option, value) => option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;
+function Select(_ref3) {
+  let {
+    options = [],
+    name,
+    value,
+    placeholder,
+    emptyStateMessage,
+    hasError,
+    filterMethod = defaultFilterMethod,
+    onChange = () => null,
+    onBlur = () => null,
+    onFocus = () => null,
+    maxHeight = 230,
+    autoComplete = "on",
+    ...rest
+  } = _ref3;
+  const {
+    disabled
+  } = rest;
+  const [isOpen, setIsOpen] = useState(false);
+  const [innerValue, setInnerValue] = useState("");
+  const [preselectedIndex, setPreselectedIndex] = useState(-1);
+  const initialValueOption = useMemo(() => options.find(option => option.value === value) || {
+    value: "",
+    label: ""
+  }, [options, value]);
+  const [fakeSelectedOption, setFakeSelectedOption] = useState(initialValueOption);
+  const fakeSelectRef = useRef(null);
+  const dropDownRef = useRef(null);
+  const innerInputRef = useRef(null);
+  const currentValueRef = useRef(value);
+  currentValueRef.current = value;
+  const forceChangeFakeSelect = useCallback(selectedOption => {
+    if (fakeSelectedOption.value !== selectedOption.value) {
+      setFakeSelectedOption(selectedOption);
+    }
+  }, [fakeSelectedOption]);
+  const [verticalPosition] = useAutoPosition(fakeSelectRef, dropDownRef, isOpen);
+  const closeDropdown = useCallback(function () {
+    let noSelect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    setIsOpen(false);
+    if (!noSelect) {
+      const selectedOption = options.find(option => option.label.toLowerCase().trim() === innerValue.toLowerCase().trim());
+      if (selectedOption) {
+        forceChangeFakeSelect(selectedOption);
+      }
+    }
+    setInnerValue("");
+    setPreselectedIndex(-1);
+    onBlur();
+  }, [onBlur, forceChangeFakeSelect, innerValue, options]);
+  useEffect(() => {
+    if (fakeSelectRef.current && currentValueRef.current !== fakeSelectedOption.value) {
+      fakeSelectRef.current.dispatchEvent(new Event("change", {
+        bubbles: true
+      }));
+    }
+  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);
+
+  // force updating the hidden select if a new initial value gets passed down
+  // without it, there would be a mismatch of selected value and the hidden select,
+  // which would cause the first value to not be selectable
+  useEffect(() => {
+    forceChangeFakeSelect(initialValueOption);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [initialValueOption]);
+  const filteredOptions = useMemo(() => {
+    if (!innerValue) {
+      return options;
+    }
+    return options.filter(option => filterMethod(option, innerValue));
+  }, [options, filterMethod, innerValue]);
+  const displayValue = useMemo(() => options.some(option => option.value === value) ? options.find(option => option.value === value).label : "", [value, options]);
+  useEffect(() => {
+    setPreselectedIndex(-1);
+  }, [filteredOptions]);
+  useKeyboard({
+    Escape: () => closeDropdown(true),
+    Enter: () => {
+      if (filteredOptions[preselectedIndex]) {
+        forceChangeFakeSelect(filteredOptions[preselectedIndex]);
+        closeDropdown(true);
+        return;
+      }
+      closeDropdown();
+    },
+    ArrowUp: () => {
+      setPreselectedIndex(Math.max(preselectedIndex - 1, 0));
+    },
+    ArrowDown: () => {
+      setPreselectedIndex(Math.min(preselectedIndex + 1, filteredOptions.length - 1));
+    }
+  }, innerInputRef, isOpen && !disabled);
+  useKeyboard({
+    "ArrowUp ArrowDown": () => {
+      setIsOpen(true);
+    }
+  }, innerInputRef, !isOpen && !disabled);
+  return /*#__PURE__*/React.createElement(FormField, _extends({
+    "data-ds-id": "Select"
+  }, rest), /*#__PURE__*/React.createElement(StyledContainer, {
+    onBlur: () => {
+      closeDropdown(true);
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      zIndex: 1
+    }
+  }, /*#__PURE__*/React.createElement(InputRaw, {
+    areaLabel: rest.label,
+    name: `${name}-innerInput`,
+    value: innerValue,
+    privateProps: {
+      isTransparent: !(isOpen && innerValue)
+    },
+    icon: isOpen ? "chevron-up" : "chevron-down",
+    hasError: hasError,
+    disabled: disabled,
+    onFocus: () => {
+      setIsOpen(true);
+      onFocus();
+    },
+    onClick: () => {
+      setIsOpen(true);
+    },
+    onChange: e => {
+      if (e.currentTarget.value) {
+        setIsOpen(true);
+      }
+      setInnerValue(e.currentTarget.value);
+    },
+    ref: innerInputRef,
+    autoComplete: autoComplete
+  })), /*#__PURE__*/React.createElement(StyledInputWrap, null, /*#__PURE__*/React.createElement(Input, {
+    name: name,
+    value: displayValue,
+    onChange: () => null,
+    icon: isOpen ? "chevron-up" : "chevron-down",
+    placeholder: placeholder,
+    tabIndex: -1,
+    autoComplete: "off"
+  })), isOpen &&
+  /*#__PURE__*/
+  // eslint-disable-next-line jsx-a11y/no-static-element-interactions
+  React.createElement(StyledDropdown, {
+    dropdownPosition: verticalPosition,
+    ref: dropDownRef
+    // this is to prevent known bug of Chrome when element
+    // loses focus on click on the scrollbar
+    ,
+    onMouseDown: e => e.preventDefault()
+  }, /*#__PURE__*/React.createElement(VirtualScrollList, {
+    maxHeight: maxHeight,
+    itemHeight: 36,
+    itemAmount: filteredOptions.length,
+    emptyState: () => /*#__PURE__*/React.createElement(Box, {
+      space: "xs"
+    }, /*#__PURE__*/React.createElement(Text, null, emptyStateMessage || "🤷🏻‍♀️")),
+    itemInView: preselectedIndex,
+    itemTemplate: index => {
+      const option = filteredOptions[index];
+      return (
+        /*#__PURE__*/
+        // eslint-disable-next-line jsx-a11y/no-static-element-interactions
+        React.createElement(StyledDropdownItem, {
+          key: option.value,
+          active: preselectedIndex === index || value === option.value,
+          onMouseDown: () => {
+            forceChangeFakeSelect(option);
+            closeDropdown(true);
+          }
+        }, /*#__PURE__*/React.createElement(Text, {
+          weight: "bold",
+          color: "primary",
+          size: "s"
+        }, option.label))
+      );
+    }
+  })), /*#__PURE__*/React.createElement(HiddenSelectInput, {
+    onChange: onChange,
+    value: fakeSelectedOption.value,
+    ref: fakeSelectRef,
+    autoComplete: "off"
+  }, /*#__PURE__*/React.createElement("option", {
+    value: fakeSelectedOption.value
+  }, fakeSelectedOption.label))));
+}
+
+export { Select };
+//# sourceMappingURL=Select.js.map

package/build/esm/src/components/Form/Select/Select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Select.js","sources":["../../../../../../src/components/Form/Select/Select.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, {\n  useState,\n  useRef,\n  useMemo,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { useKeyboard } from \"../../../shared/useKeyboard\";\nimport {\n  useAutoPosition,\n  VerticalPosition,\n} from \"../../../shared/useAutoPosition\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\nimport { VirtualScrollList } from \"../../VirtualScrollList/VirtualScrollList\";\nimport { Input, InputRaw } from \"../Input/Input\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Box } from \"../../Box/Box\";\n\nconst StyledContainer = styled.div(() => ({\n  position: \"relative\",\n}));\n\nconst StyledInputWrap = styled.div(() => ({\n  zIndex: 0,\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  width: \"100%\",\n  bottom: 0,\n  left: 0,\n}));\n\nconst StyledDropdown = styled.div<{ dropdownPosition: VerticalPosition }>(\n  ({ theme, dropdownPosition }) => ({\n    backgroundColor: theme.values.color.background.primary.default,\n    position: \"absolute\",\n    fontSize: theme.variables.size.font.text.s,\n    zIndex: 2,\n    width: \"100%\",\n    margin: `${theme.variables.size.spacing.xs} 0`,\n    cursor: \"pointer\",\n    borderRadius: theme.variables.size.borderRadius.dropdown.m,\n    overflow: \"hidden\",\n    boxShadow: theme.variables.shadow.card.b,\n    boxSizing: \"border-box\",\n    ...(dropdownPosition === \"down\" && {\n      top: \"100%\",\n    }),\n    ...(dropdownPosition === \"up\" && {\n      bottom: \"100%\",\n    }),\n  })\n);\n\nconst StyledDropdownItem = styled.div<{ active: boolean }>(\n  ({ theme, active }) => ({\n    padding: theme.variables.size.spacing.xs,\n    borderRadius: theme.variables.size.borderRadius.dropdown.s,\n    ...(active && {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    }),\n    \"&:hover\": {\n      backgroundColor: theme.values.color.background.secondary.hover,\n      borderRadius: 0,\n    },\n  })\n);\n\nconst HiddenSelectInput = styled.select(() => ({\n  display: \"none\",\n}));\n\ntype SelectOption = {\n  value: string;\n  label: string;\n} & Record<string, unknown>;\n\nexport type SelectProps = {\n  name: string;\n  value: string;\n  placeholder?: string;\n  emptyStateMessage?: string;\n  hasError?: boolean;\n  disabled?: boolean;\n  options?: SelectOption[];\n  filterMethod?: (options: SelectOption, value: string) => boolean;\n  onChange?: (e: React.FormEvent<HTMLSelectElement>) => void;\n  onBlur?: () => void;\n  onFocus?: () => void;\n  maxHeight?: number;\n  autoComplete?: string;\n} & FormFieldProps;\n\nconst defaultFilterMethod = (option: SelectOption, value: string): boolean =>\n  option.label.toLowerCase().indexOf(value.toLowerCase()) > -1;\n\nexport function Select({\n  options = [],\n  name,\n  value,\n  placeholder,\n  emptyStateMessage,\n  hasError,\n  filterMethod = defaultFilterMethod,\n  onChange = () => null,\n  onBlur = () => null,\n  onFocus = () => null,\n  maxHeight = 230,\n  autoComplete = \"on\",\n  ...rest\n}: SelectProps): React.ReactElement {\n  const { disabled } = rest;\n  const [isOpen, setIsOpen] = useState(false);\n  const [innerValue, setInnerValue] = useState(\"\");\n  const [preselectedIndex, setPreselectedIndex] = useState(-1);\n  const initialValueOption = useMemo(\n    () =>\n      options.find((option) => option.value === value) || {\n        value: \"\",\n        label: \"\",\n      },\n    [options, value]\n  );\n  const [fakeSelectedOption, setFakeSelectedOption] =\n    useState(initialValueOption);\n  const fakeSelectRef = useRef(null);\n\n  const dropDownRef = useRef(null);\n  const innerInputRef = useRef(null);\n\n  const currentValueRef = useRef(value);\n  currentValueRef.current = value;\n\n  const forceChangeFakeSelect = useCallback(\n    (selectedOption: SelectOption) => {\n      if (fakeSelectedOption.value !== selectedOption.value) {\n        setFakeSelectedOption(selectedOption);\n      }\n    },\n    [fakeSelectedOption]\n  );\n\n  const [verticalPosition] = useAutoPosition(\n    fakeSelectRef,\n    dropDownRef,\n    isOpen\n  );\n\n  const closeDropdown = useCallback(\n    (noSelect = false) => {\n      setIsOpen(false);\n      if (!noSelect) {\n        const selectedOption = options.find(\n          (option) =>\n            option.label.toLowerCase().trim() ===\n            innerValue.toLowerCase().trim()\n        );\n        if (selectedOption) {\n          forceChangeFakeSelect(selectedOption);\n        }\n      }\n      setInnerValue(\"\");\n      setPreselectedIndex(-1);\n      onBlur();\n    },\n    [onBlur, forceChangeFakeSelect, innerValue, options]\n  );\n\n  useEffect(() => {\n    if (\n      fakeSelectRef.current &&\n      currentValueRef.current !== fakeSelectedOption.value\n    ) {\n      fakeSelectRef.current.dispatchEvent(\n        new Event(\"change\", { bubbles: true })\n      );\n    }\n  }, [fakeSelectedOption, fakeSelectRef, currentValueRef]);\n\n  // force updating the hidden select if a new initial value gets passed down\n  // without it, there would be a mismatch of selected value and the hidden select,\n  // which would cause the first value to not be selectable\n  useEffect(() => {\n    forceChangeFakeSelect(initialValueOption);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialValueOption]);\n\n  const filteredOptions = useMemo(() => {\n    if (!innerValue) {\n      return options;\n    }\n\n    return options.filter((option) => filterMethod(option, innerValue));\n  }, [options, filterMethod, innerValue]);\n\n  const displayValue = useMemo(\n    () =>\n      options.some((option) => option.value === value)\n        ? options.find((option) => option.value === value).label\n        : \"\",\n    [value, options]\n  );\n\n  useEffect(() => {\n    setPreselectedIndex(-1);\n  }, [filteredOptions]);\n\n  useKeyboard(\n    {\n      Escape: () => closeDropdown(true),\n      Enter: () => {\n        if (filteredOptions[preselectedIndex]) {\n          forceChangeFakeSelect(filteredOptions[preselectedIndex]);\n          closeDropdown(true);\n          return;\n        }\n        closeDropdown();\n      },\n      ArrowUp: () => {\n        setPreselectedIndex(Math.max(preselectedIndex - 1, 0));\n      },\n      ArrowDown: () => {\n        setPreselectedIndex(\n          Math.min(preselectedIndex + 1, filteredOptions.length - 1)\n        );\n      },\n    },\n    innerInputRef,\n    isOpen && !disabled\n  );\n\n  useKeyboard(\n    {\n      \"ArrowUp ArrowDown\": () => {\n        setIsOpen(true);\n      },\n    },\n    innerInputRef,\n    !isOpen && !disabled\n  );\n\n  return (\n    <FormField data-ds-id=\"Select\" {...(rest as FormFieldProps)}>\n      <StyledContainer\n        onBlur={() => {\n          closeDropdown(true);\n        }}\n      >\n        <div style={{ zIndex: 1 }}>\n          <InputRaw\n            areaLabel={rest.label}\n            name={`${name}-innerInput`}\n            value={innerValue}\n            privateProps={{ isTransparent: !(isOpen && innerValue) }}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            hasError={hasError}\n            disabled={disabled}\n            onFocus={() => {\n              setIsOpen(true);\n              onFocus();\n            }}\n            onClick={() => {\n              setIsOpen(true);\n            }}\n            onChange={(e) => {\n              if (e.currentTarget.value) {\n                setIsOpen(true);\n              }\n              setInnerValue(e.currentTarget.value);\n            }}\n            ref={innerInputRef}\n            autoComplete={autoComplete}\n          />\n        </div>\n\n        <StyledInputWrap>\n          <Input\n            name={name}\n            value={displayValue}\n            onChange={() => null}\n            icon={isOpen ? \"chevron-up\" : \"chevron-down\"}\n            placeholder={placeholder}\n            tabIndex={-1}\n            autoComplete=\"off\"\n          />\n        </StyledInputWrap>\n\n        {isOpen && (\n          // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n          <StyledDropdown\n            dropdownPosition={verticalPosition}\n            ref={dropDownRef}\n            // this is to prevent known bug of Chrome when element\n            // loses focus on click on the scrollbar\n            onMouseDown={(e) => e.preventDefault()}\n          >\n            <VirtualScrollList\n              maxHeight={maxHeight}\n              itemHeight={36}\n              itemAmount={filteredOptions.length}\n              emptyState={() => (\n                <Box space=\"xs\">\n                  <Text>{emptyStateMessage || \"🤷🏻‍♀️\"}</Text>\n                </Box>\n              )}\n              itemInView={preselectedIndex}\n              itemTemplate={(index: number) => {\n                const option: SelectOption = filteredOptions[index];\n                return (\n                  // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n                  <StyledDropdownItem\n                    key={option.value}\n                    active={\n                      preselectedIndex === index || value === option.value\n                    }\n                    onMouseDown={() => {\n                      forceChangeFakeSelect(option);\n                      closeDropdown(true);\n                    }}\n                  >\n                    <Text weight=\"bold\" color=\"primary\" size=\"s\">\n                      {option.label}\n                    </Text>\n                  </StyledDropdownItem>\n                );\n              }}\n            />\n          </StyledDropdown>\n        )}\n\n        <HiddenSelectInput\n          onChange={onChange}\n          value={fakeSelectedOption.value}\n          ref={fakeSelectRef}\n          autoComplete=\"off\"\n        >\n          <option value={fakeSelectedOption.value}>\n            {fakeSelectedOption.label}\n          </option>\n        </HiddenSelectInput>\n      </StyledContainer>\n    </FormField>\n  );\n}\n"],"names":["StyledContainer","_styled","process","env","NODE_ENV","target","label","position","StyledInputWrap","zIndex","pointerEvents","width","bottom","left","StyledDropdown","_ref","theme","dropdownPosition","backgroundColor","values","color","background","primary","default","fontSize","variables","size","font","text","s","margin","spacing","xs","cursor","borderRadius","dropdown","m","overflow","boxShadow","shadow","card","b","boxSizing","top","StyledDropdownItem","_ref2","active","padding","secondary","hover","HiddenSelectInput","display","defaultFilterMethod","option","value","toLowerCase","indexOf","Select","_ref3","options","name","placeholder","emptyStateMessage","hasError","filterMethod","onChange","onBlur","onFocus","maxHeight","autoComplete","rest","disabled","isOpen","setIsOpen","useState","innerValue","setInnerValue","preselectedIndex","setPreselectedIndex","initialValueOption","useMemo","find","fakeSelectedOption","setFakeSelectedOption","fakeSelectRef","useRef","dropDownRef","innerInputRef","currentValueRef","current","forceChangeFakeSelect","useCallback","selectedOption","verticalPosition","useAutoPosition","closeDropdown","noSelect","arguments","length","undefined","trim","useEffect","dispatchEvent","Event","bubbles","filteredOptions","filter","displayValue","some","useKeyboard","Escape","Enter","ArrowUp","Math","max","ArrowDown","min","ArrowUp ArrowDown","React","createElement","FormField","_extends","style","InputRaw","areaLabel","privateProps","isTransparent","icon","onClick","e","currentTarget","ref","Input","tabIndex","onMouseDown","preventDefault","VirtualScrollList","itemHeight","itemAmount","emptyState","Box","space","Text","itemInView","itemTemplate","index","key","weight"],"mappings":"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"}

package/build/esm/src/components/Form/Textarea/Textarea.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { FormFieldProps } from "../FormField/FormField";
+export declare type TextareaProps = {
+    name: string;
+    value: string;
+    /**
+     * Set to true to toggle error state
+     */
+    hasError?: boolean;
+    placeholder?: string;
+    /**
+     * Set to true to disabled input
+     */
+    disabled?: boolean;
+    onChange?: (e: React.FormEvent<HTMLTextAreaElement>) => void;
+    onClick?: (e: React.FormEvent<HTMLTextAreaElement>) => void;
+    onBlur?: (e: React.FormEvent<HTMLTextAreaElement>) => void;
+    onFocus?: (e: React.FormEvent<HTMLTextAreaElement>) => void;
+    areaLabel?: string;
+    tabIndex?: number;
+    autoComplete?: string;
+    rows?: number;
+    maxLength?: number;
+    resize?: "none" | "horizontal" | "vertical" | "both";
+} & FormFieldProps;
+export declare function Textarea({ name, value, placeholder, hasError, onChange, onClick, onBlur, onFocus, tabIndex, areaLabel, autoComplete, rows, maxLength, resize, ...rest }: TextareaProps): React.ReactElement;

package/build/esm/src/components/Form/Textarea/Textarea.js

@@ -0,0 +1,86 @@
+import _extends from '@babel/runtime/helpers/extends';
+import _styled from '@emotion/styled/base';
+import React from 'react';
+import { FormField } from '../FormField/FormField.js';
+
+const StyledTextarea = /*#__PURE__*/_styled("textarea", process.env.NODE_ENV === "production" ? {
+  target: "e1u5324b1"
+} : {
+  target: "e1u5324b1",
+  label: "StyledTextarea"
+})(_ref => {
+  let {
+    theme,
+    resize,
+    hasError
+  } = _ref;
+  return {
+    fontFamily: theme.variables.fontFamily.lato,
+    fontSize: theme.variables.size.font.text.m,
+    lineHeight: theme.variables.size.lineHeight.text.m,
+    minHeight: theme.variables.size.dimension.textarea.minHeight.m,
+    borderRadius: theme.variables.size.borderRadius.textarea.s,
+    border: "1px solid",
+    width: "100%",
+    padding: theme.variables.size.spacing.xs,
+    boxSizing: "border-box",
+    color: theme.values.color.text.primary.default,
+    borderColor: hasError ? theme.values.color.border.error.default : theme.values.color.border.primary.default,
+    backgroundColor: theme.values.color.background.primary.default,
+    resize
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIlRleHRhcmVhLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2QnVCIiwiZmlsZSI6IlRleHRhcmVhLnRzeCIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIHJlYWN0L2pzeC1wcm9wcy1uby1zcHJlYWRpbmcgKi9cbmltcG9ydCBSZWFjdCBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCBzdHlsZWQgZnJvbSBcIkBlbW90aW9uL3N0eWxlZFwiO1xuaW1wb3J0IHsgRm9ybUZpZWxkLCBGb3JtRmllbGRQcm9wcyB9IGZyb20gXCIuLi9Gb3JtRmllbGQvRm9ybUZpZWxkXCI7XG5cbmV4cG9ydCB0eXBlIFRleHRhcmVhUHJvcHMgPSB7XG4gIG5hbWU6IHN0cmluZztcbiAgdmFsdWU6IHN0cmluZztcbiAgLyoqXG4gICAqIFNldCB0byB0cnVlIHRvIHRvZ2dsZSBlcnJvciBzdGF0ZVxuICAgKi9cbiAgaGFzRXJyb3I/OiBib29sZWFuO1xuICBwbGFjZWhvbGRlcj86IHN0cmluZztcbiAgLyoqXG4gICAqIFNldCB0byB0cnVlIHRvIGRpc2FibGVkIGlucHV0XG4gICAqL1xuICBkaXNhYmxlZD86IGJvb2xlYW47XG4gIG9uQ2hhbmdlPzogKGU6IFJlYWN0LkZvcm1FdmVudDxIVE1MVGV4dEFyZWFFbGVtZW50PikgPT4gdm9pZDtcbiAgb25DbGljaz86IChlOiBSZWFjdC5Gb3JtRXZlbnQ8SFRNTFRleHRBcmVhRWxlbWVudD4pID0+IHZvaWQ7XG4gIG9uQmx1cj86IChlOiBSZWFjdC5Gb3JtRXZlbnQ8SFRNTFRleHRBcmVhRWxlbWVudD4pID0+IHZvaWQ7XG4gIG9uRm9jdXM/OiAoZTogUmVhY3QuRm9ybUV2ZW50PEhUTUxUZXh0QXJlYUVsZW1lbnQ+KSA9PiB2b2lkO1xuICBhcmVhTGFiZWw/OiBzdHJpbmc7XG4gIHRhYkluZGV4PzogbnVtYmVyO1xuICBhdXRvQ29tcGxldGU/OiBzdHJpbmc7XG4gIHJvd3M/OiBudW1iZXI7XG4gIG1heExlbmd0aD86IG51bWJlcjtcbiAgcmVzaXplPzogXCJub25lXCIgfCBcImhvcml6b250YWxcIiB8IFwidmVydGljYWxcIiB8IFwiYm90aFwiO1xufSAmIEZvcm1GaWVsZFByb3BzO1xuXG5jb25zdCBTdHlsZWRUZXh0YXJlYSA9IHN0eWxlZC50ZXh0YXJlYTxQYXJ0aWFsPFRleHRhcmVhUHJvcHM+PihcbiAgKHsgdGhlbWUsIHJlc2l6ZSwgaGFzRXJyb3IgfSkgPT4gKHtcbiAgICBmb250RmFtaWx5OiB0aGVtZS52YXJpYWJsZXMuZm9udEZhbWlseS5sYXRvLFxuICAgIGZvbnRTaXplOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5mb250LnRleHQubSxcbiAgICBsaW5lSGVpZ2h0OiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5saW5lSGVpZ2h0LnRleHQubSxcbiAgICBtaW5IZWlnaHQ6IHRoZW1lLnZhcmlhYmxlcy5zaXplLmRpbWVuc2lvbi50ZXh0YXJlYS5taW5IZWlnaHQubSxcbiAgICBib3JkZXJSYWRpdXM6IHRoZW1lLnZhcmlhYmxlcy5zaXplLmJvcmRlclJhZGl1cy50ZXh0YXJlYS5zLFxuICAgIGJvcmRlcjogXCIxcHggc29saWRcIixcbiAgICB3aWR0aDogXCIxMDAlXCIsXG4gICAgcGFkZGluZzogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54cyxcbiAgICBib3hTaXppbmc6IFwiYm9yZGVyLWJveFwiLFxuICAgIGNvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IudGV4dC5wcmltYXJ5LmRlZmF1bHQsXG4gICAgYm9yZGVyQ29sb3I6IGhhc0Vycm9yXG4gICAgICA/IHRoZW1lLnZhbHVlcy5jb2xvci5ib3JkZXIuZXJyb3IuZGVmYXVsdFxuICAgICAgOiB0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnByaW1hcnkuZGVmYXVsdCxcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci5iYWNrZ3JvdW5kLnByaW1hcnkuZGVmYXVsdCxcbiAgICByZXNpemUsXG4gIH0pXG4pO1xuXG5jb25zdCBTdHlsZWRDb250YWluZXIgPSBzdHlsZWQuZGl2KCgpID0+ICh7XG4gIHdpZHRoOiBcIjEwMCVcIixcbiAgZGlzcGxheTogXCJmbGV4XCIsXG4gIGFsaWduSXRlbXM6IFwiY2VudGVyXCIsXG4gIGZsZXhEaXJlY3Rpb246IFwicm93XCIsXG4gIHBvc2l0aW9uOiBcInJlbGF0aXZlXCIsXG4gIHpJbmRleDogMSxcbn0pKTtcblxuZXhwb3J0IGZ1bmN0aW9uIFRleHRhcmVhKHtcbiAgbmFtZSxcbiAgdmFsdWUsXG4gIHBsYWNlaG9sZGVyLFxuICBoYXNFcnJvciA9IGZhbHNlLFxuICBvbkNoYW5nZSxcbiAgb25DbGljayxcbiAgb25CbHVyLFxuICBvbkZvY3VzLFxuICB0YWJJbmRleCxcbiAgYXJlYUxhYmVsLFxuICBhdXRvQ29tcGxldGUgPSBcIm9uXCIsXG4gIHJvd3MgPSA1LFxuICBtYXhMZW5ndGggPSAyNTYsXG4gIHJlc2l6ZSA9IFwibm9uZVwiLFxuICAuLi5yZXN0XG59OiBUZXh0YXJlYVByb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50IHtcbiAgcmV0dXJuIChcbiAgICA8Rm9ybUZpZWxkIGRhdGEtZHMtaWQ9XCJUZXh0YXJlYVwiIHsuLi4ocmVzdCBhcyBGb3JtRmllbGRQcm9wcyl9PlxuICAgICAgPFN0eWxlZENvbnRhaW5lcj5cbiAgICAgICAgPFN0eWxlZFRleHRhcmVhXG4gICAgICAgICAgbmFtZT17bmFtZX1cbiAgICAgICAgICBkaXNhYmxlZD17cmVzdC5kaXNhYmxlZH1cbiAgICAgICAgICBwbGFjZWhvbGRlcj17cGxhY2Vob2xkZXJ9XG4gICAgICAgICAgaGFzRXJyb3I9e2hhc0Vycm9yfVxuICAgICAgICAgIG9uQ2xpY2s9e29uQ2xpY2t9XG4gICAgICAgICAgb25DaGFuZ2U9e29uQ2hhbmdlfVxuICAgICAgICAgIG9uQmx1cj17b25CbHVyfVxuICAgICAgICAgIG9uRm9jdXM9e29uRm9jdXN9XG4gICAgICAgICAgYXJpYS1sYWJlbD17YXJlYUxhYmVsfVxuICAgICAgICAgIHRhYkluZGV4PXt0YWJJbmRleH1cbiAgICAgICAgICBhdXRvQ29tcGxldGU9e2F1dG9Db21wbGV0ZX1cbiAgICAgICAgICByb3dzPXtyb3dzfVxuICAgICAgICAgIG1heExlbmd0aD17bWF4TGVuZ3RofVxuICAgICAgICAgIGRlZmF1bHRWYWx1ZT17dmFsdWV9XG4gICAgICAgICAgcmVzaXplPXtyZXNpemV9XG4gICAgICAgIC8+XG4gICAgICA8L1N0eWxlZENvbnRhaW5lcj5cbiAgICA8L0Zvcm1GaWVsZD5cbiAgKTtcbn1cbiJdfQ== */");
+const StyledContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1u5324b0"
+} : {
+  target: "e1u5324b0",
+  label: "StyledContainer"
+})(() => ({
+  width: "100%",
+  display: "flex",
+  alignItems: "center",
+  flexDirection: "row",
+  position: "relative",
+  zIndex: 1
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+function Textarea(_ref2) {
+  let {
+    name,
+    value,
+    placeholder,
+    hasError = false,
+    onChange,
+    onClick,
+    onBlur,
+    onFocus,
+    tabIndex,
+    areaLabel,
+    autoComplete = "on",
+    rows = 5,
+    maxLength = 256,
+    resize = "none",
+    ...rest
+  } = _ref2;
+  return /*#__PURE__*/React.createElement(FormField, _extends({
+    "data-ds-id": "Textarea"
+  }, rest), /*#__PURE__*/React.createElement(StyledContainer, null, /*#__PURE__*/React.createElement(StyledTextarea, {
+    name: name,
+    disabled: rest.disabled,
+    placeholder: placeholder,
+    hasError: hasError,
+    onClick: onClick,
+    onChange: onChange,
+    onBlur: onBlur,
+    onFocus: onFocus,
+    "aria-label": areaLabel,
+    tabIndex: tabIndex,
+    autoComplete: autoComplete,
+    rows: rows,
+    maxLength: maxLength,
+    defaultValue: value,
+    resize: resize
+  })));
+}
+
+export { Textarea };
+//# sourceMappingURL=Textarea.js.map

package/build/esm/src/components/Form/Textarea/Textarea.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Textarea.js","sources":["../../../../../../src/components/Form/Textarea/Textarea.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React from \"react\";\nimport styled from \"@emotion/styled\";\nimport { FormField, FormFieldProps } from \"../FormField/FormField\";\n\nexport type TextareaProps = {\n  name: string;\n  value: string;\n  /**\n   * Set to true to toggle error state\n   */\n  hasError?: boolean;\n  placeholder?: string;\n  /**\n   * Set to true to disabled input\n   */\n  disabled?: boolean;\n  onChange?: (e: React.FormEvent<HTMLTextAreaElement>) => void;\n  onClick?: (e: React.FormEvent<HTMLTextAreaElement>) => void;\n  onBlur?: (e: React.FormEvent<HTMLTextAreaElement>) => void;\n  onFocus?: (e: React.FormEvent<HTMLTextAreaElement>) => void;\n  areaLabel?: string;\n  tabIndex?: number;\n  autoComplete?: string;\n  rows?: number;\n  maxLength?: number;\n  resize?: \"none\" | \"horizontal\" | \"vertical\" | \"both\";\n} & FormFieldProps;\n\nconst StyledTextarea = styled.textarea<Partial<TextareaProps>>(\n  ({ theme, resize, hasError }) => ({\n    fontFamily: theme.variables.fontFamily.lato,\n    fontSize: theme.variables.size.font.text.m,\n    lineHeight: theme.variables.size.lineHeight.text.m,\n    minHeight: theme.variables.size.dimension.textarea.minHeight.m,\n    borderRadius: theme.variables.size.borderRadius.textarea.s,\n    border: \"1px solid\",\n    width: \"100%\",\n    padding: theme.variables.size.spacing.xs,\n    boxSizing: \"border-box\",\n    color: theme.values.color.text.primary.default,\n    borderColor: hasError\n      ? theme.values.color.border.error.default\n      : theme.values.color.border.primary.default,\n    backgroundColor: theme.values.color.background.primary.default,\n    resize,\n  })\n);\n\nconst StyledContainer = styled.div(() => ({\n  width: \"100%\",\n  display: \"flex\",\n  alignItems: \"center\",\n  flexDirection: \"row\",\n  position: \"relative\",\n  zIndex: 1,\n}));\n\nexport function Textarea({\n  name,\n  value,\n  placeholder,\n  hasError = false,\n  onChange,\n  onClick,\n  onBlur,\n  onFocus,\n  tabIndex,\n  areaLabel,\n  autoComplete = \"on\",\n  rows = 5,\n  maxLength = 256,\n  resize = \"none\",\n  ...rest\n}: TextareaProps): React.ReactElement {\n  return (\n    <FormField data-ds-id=\"Textarea\" {...(rest as FormFieldProps)}>\n      <StyledContainer>\n        <StyledTextarea\n          name={name}\n          disabled={rest.disabled}\n          placeholder={placeholder}\n          hasError={hasError}\n          onClick={onClick}\n          onChange={onChange}\n          onBlur={onBlur}\n          onFocus={onFocus}\n          aria-label={areaLabel}\n          tabIndex={tabIndex}\n          autoComplete={autoComplete}\n          rows={rows}\n          maxLength={maxLength}\n          defaultValue={value}\n          resize={resize}\n        />\n      </StyledContainer>\n    </FormField>\n  );\n}\n"],"names":["StyledTextarea","_styled","process","env","NODE_ENV","target","label","_ref","theme","resize","hasError","fontFamily","variables","lato","fontSize","size","font","text","m","lineHeight","minHeight","dimension","textarea","borderRadius","s","border","width","padding","spacing","xs","boxSizing","color","values","primary","default","borderColor","error","backgroundColor","background","StyledContainer","display","alignItems","flexDirection","position","zIndex","Textarea","_ref2","name","value","placeholder","onChange","onClick","onBlur","onFocus","tabIndex","areaLabel","autoComplete","rows","maxLength","rest","React","createElement","FormField","_extends","disabled","defaultValue"],"mappings":"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"}