npm - @dfds-ui/react-select - Versions diffs - 2.2.0-alpha.8d87a90d → 2.2.0-alpha.c35ceba3 - Mend

@dfds-ui/react-select 2.2.0-alpha.8d87a90d → 2.2.0-alpha.c35ceba3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/ReactSelect.d.ts ADDED Viewed

@@ -0,0 +1,70 @@
+import React from 'react';
+import Select, { createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select';
+import { BaseFieldProps } from '@dfds-ui/forms/types';
+export declare type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>;
+export declare type Size = 'small' | 'medium' | 'large';
+export declare const ReactSelectWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+} & {
+    error?: boolean | undefined;
+    size?: string | undefined;
+    arrow?: boolean | undefined;
+    selected?: boolean | undefined;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Menu: (props: any) => React.JSX.Element;
+export declare type SelectFieldProps<T> = BaseFieldProps & {
+    defaultValue?: SingleValue<T>;
+    className?: string;
+    components?: any;
+    value?: SingleValue<T>;
+    visualSize?: Size;
+    options?: OptionsOrGroups<T, GroupBase<T>>;
+    isSearchable?: boolean;
+    onSelect?: (value: SingleValue<T>) => void;
+    onChange?: (value: SingleValue<T>) => void;
+    onBlur?: (value: any) => void;
+    menuIsOpen?: boolean;
+    placeholder?: string;
+    assistiveText?: string;
+    errorMessage?: string;
+    /**
+     * Configuration object passed to react-select createFilter function to create [custom filter
+     * logic](https://react-select.com/advanced#custom-filter-logic)
+     * @param ignoreCase - boolean (optional)
+     * @param ignoreAccents - boolean (optional)
+     * @param stringify (obj: any) => string (optional)
+     * @param trim - boolean (optional)
+     * @param matchForm - 'any' | 'start'
+     */
+    filterConfig?: Parameters<typeof createFilter>[0];
+};
+/** @deprecated Use dfds-ui/forms */
+export declare const ReactSelect: React.ForwardRefExoticComponent<BaseFieldProps & {
+    defaultValue?: unknown;
+    className?: string | undefined;
+    components?: any;
+    value?: unknown;
+    visualSize?: Size | undefined;
+    options?: OptionsOrGroups<unknown, GroupBase<unknown>> | undefined;
+    isSearchable?: boolean | undefined;
+    onSelect?: ((value: unknown) => void) | undefined;
+    onChange?: ((value: unknown) => void) | undefined;
+    onBlur?: ((value: any) => void) | undefined;
+    menuIsOpen?: boolean | undefined;
+    placeholder?: string | undefined;
+    assistiveText?: string | undefined;
+    errorMessage?: string | undefined;
+    /**
+     * Configuration object passed to react-select createFilter function to create [custom filter
+     * logic](https://react-select.com/advanced#custom-filter-logic)
+     * @param ignoreCase - boolean (optional)
+     * @param ignoreAccents - boolean (optional)
+     * @param stringify (obj: any) => string (optional)
+     * @param trim - boolean (optional)
+     * @param matchForm - 'any' | 'start'
+     */
+    filterConfig?: Parameters<typeof createFilter>[0];
+} & React.RefAttributes<any>>;
+/** @deprecated Use dfds-ui/forms */
+export default ReactSelect;

package/ReactSelect.js ADDED Viewed

@@ -0,0 +1,190 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import _styled from "@emotion/styled/base";
+var _excluded = ["name", "label", "defaultValue", "value", "placeholder", "onSelect", "onChange", "isSearchable", "onBlur", "assistiveText", "options", "errorMessage", "disabled", "visualSize", "filterConfig"],
+  _excluded2 = ["ref"];
+var _templateObject;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) { ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } } return n; }, _extends.apply(null, arguments); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) { o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) { if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } } return t; }
+function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import { css } from '@emotion/react';
+import { media, theme } from '@dfds-ui/theme';
+import { Drawer } from '@dfds-ui/react-components';
+import Select, { components, createFilter } from 'react-select';
+import { ChevronDown } from '@dfds-ui/icons/system';
+import { Label } from '@dfds-ui/forms';
+import AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText';
+import ErrorText from '@dfds-ui/forms/error-text/ErrorText';
+import { FlexBox } from '@dfds-ui/react-components/flexbox';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+export var ReactSelectWrapper = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1dgfjeh0"
+} : {
+  target: "e1dgfjeh0",
+  label: "ReactSelectWrapper"
+})("position:relative;margin-top:", theme.spacing.xxs, ";margin-bottom:", theme.spacing.xxs, ";&:focus-within{outline:none;}svg{color:", theme.colors.text.dark.secondary, ";}.react-select__control{border:1px solid ", theme.colors.text.dark.secondary, ";height:", function (p) {
+  return p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px';
+}, ";min-height:", function (p) {
+  return p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px';
+}, ";border-color:", function (p) {
+  return p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary;
+}, ";box-shadow:inset 0 0 0 ", function (p) {
+  return p.error ? 1 : 0;
+}, "px ", theme.colors.status.alert, ";padding-left:5px;border-radius:0;font-size:14px;appearance:none;cursor:pointer;", media.lessThanEqual('m')(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      font-size: 16px;\n    "]))), ";}.react-select__menu{margin-top:0;margin-bottom:0;z-index:500000;}.react-select__control--is-focused,.react-select__control--menu-is-open{border:1px solid ", function (p) {
+  return p.error ? theme.colors.status.alert : theme.colors.secondary.main;
+}, ";box-shadow:inset 0 0 0 1px ", function (p) {
+  return p.error ? theme.colors.status.alert : theme.colors.secondary.main;
+}, ";outline:0;&:hover{border-color:", function (p) {
+  return p.error ? theme.colors.status.alert : theme.colors.secondary.light;
+}, ";}svg{color:", function (p) {
+  return p.error ? theme.colors.status.alert : theme.colors.secondary.dark;
+}, ";}}.react-select__option{color:", theme.colors.primary.main, ";background-color:white;position:relative;", function (props) {
+  return props.selected && /*#__PURE__*/css("color:", theme.colors.text.secondary.primary, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:ReactSelectWrapper;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AAyES","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */");
+}, ";", function (props) {
+  return theme.states.overlay(props.selected);
+}, ";&--is-focused{&:after{opacity:0.16;background-color:", theme.colors.secondary.light, ";}}&--is-disabled{opacity:0.3;}&--is-selected{&:after{opacity:0.12;background-color:", theme.colors.secondary.dark, ";}}}.react-select__menu>div::before,.react-select__menu>div>::before{", function (p) {
+  return !p.arrow && "display: none";
+}, ";}.react-select__indicator-separator{display:none;}.react-select__menu-list{padding:0;}.react-select--is-disabled{.react-select__control{pointer-events:none;border:1px solid ", theme.colors.text.dark.disabled, ";background:", theme.colors.surface.primary, ";}.react-select__placeholder{color:", theme.colors.text.dark.disabled, ";}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AAiBqH","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */"));
+var _ref3 = process.env.NODE_ENV === "production" ? {
+  name: "1rmdj93",
+  styles: "bottom:auto;left:auto;position:relative;right:auto;top:auto"
+} : {
+  name: "1l1u776-Menu",
+  styles: "bottom:auto;left:auto;position:relative;right:auto;top:auto;label:Menu;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AAgIgB","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+export var Menu = function Menu(props) {
+  return ___EmotionJSX(components.Menu, props, ___EmotionJSX(Drawer, {
+    showArrow: false,
+    verticalPosition: props.placement,
+    css: _ref3
+  }, props.children));
+};
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "82a6rk",
+  styles: "flex:1"
+} : {
+  name: "1l9bct2-ReactSelectInner",
+  styles: "flex:1;label:ReactSelectInner;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AA4NoB","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+var _ref2 = process.env.NODE_ENV === "production" ? {
+  name: "s5xdrg",
+  styles: "display:flex;align-items:center"
+} : {
+  name: "1l4z3ql-ReactSelectInner",
+  styles: "display:flex;align-items:center;label:ReactSelectInner;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AAoNkB","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+var _ref5 = process.env.NODE_ENV === "production" ? {
+  name: "rrel8y",
+  styles: "width:24px;height:24px"
+} : {
+  name: "1jm3yf4-children",
+  styles: "width:24px;height:24px;label:children;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AAgM8B","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+function ReactSelectInner(_ref4, ref) {
+  var name = _ref4.name,
+    label = _ref4.label,
+    defaultValue = _ref4.defaultValue,
+    value = _ref4.value,
+    placeholder = _ref4.placeholder,
+    onSelect = _ref4.onSelect,
+    _onChange = _ref4.onChange,
+    isSearchable = _ref4.isSearchable,
+    _onBlur = _ref4.onBlur,
+    assistiveText = _ref4.assistiveText,
+    options = _ref4.options,
+    errorMessage = _ref4.errorMessage,
+    disabled = _ref4.disabled,
+    _ref4$visualSize = _ref4.visualSize,
+    visualSize = _ref4$visualSize === void 0 ? 'medium' : _ref4$visualSize,
+    filterConfig = _ref4.filterConfig,
+    rest = _objectWithoutProperties(_ref4, _excluded);
+  var DropdownIndicator = function DropdownIndicator(props) {
+    var _props$children = props.children,
+      children = _props$children === void 0 ? ___EmotionJSX(ChevronDown, {
+        css: _ref5
+      }) : _props$children,
+      _props$innerProps = props.innerProps,
+      ref = _props$innerProps.ref,
+      restInnerProps = _objectWithoutProperties(_props$innerProps, _excluded2);
+    return ___EmotionJSX("div", _extends({}, restInnerProps, {
+      ref: ref
+    }), ___EmotionJSX("div", {
+      style: {
+        padding: "0 ".concat(theme.spacing.xxs)
+      }
+    }, children));
+  };
+  return ___EmotionJSX(FlexBox, {
+    directionColumn: true,
+    css: /*#__PURE__*/css("margin-bottom:", !assistiveText && !errorMessage ? '1.5rem' : '0.5rem', ";" + (process.env.NODE_ENV === "production" ? "" : ";label:ReactSelectInner;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactSelect.tsx"],"names":[],"mappings":"AA8Mc","file":"../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */")
+  }, label && ___EmotionJSX(Label, {
+    css: _ref2,
+    visualSize: visualSize === 'small' ? 'small' : 'medium',
+    disabled: disabled
+  }, ___EmotionJSX("span", {
+    css: _ref
+  }, label)), ___EmotionJSX(ReactSelectWrapper, {
+    error: errorMessage && errorMessage.length > 0 || undefined,
+    size: visualSize,
+    arrow: true
+  }, ___EmotionJSX(Select, _extends({
+    value: value,
+    defaultValue: defaultValue,
+    name: name,
+    isSearchable: isSearchable,
+    menuPlacement: 'auto',
+    styles: {
+      option: function option(provided) {
+        return _objectSpread(_objectSpread({}, provided), {}, {
+          ':active': {
+            backgroundColor: 'transparent'
+          }
+        });
+      }
+    },
+    options: options,
+    onChange: function onChange(e) {
+      _onChange && _onChange(e);
+      onSelect && onSelect(e);
+    },
+    onBlur: function onBlur(e) {
+      return _onBlur && _onBlur(e);
+    },
+    "aria-invalid": errorMessage && errorMessage.length > 0 || false,
+    placeholder: placeholder,
+    isDisabled: disabled,
+    isClearable: false,
+    classNamePrefix: "react-select",
+    className: 'select-field',
+    components: _objectSpread(_objectSpread({}, components), {}, {
+      DropdownIndicator: DropdownIndicator
+    }),
+    filterOption: filterConfig && createFilter(filterConfig)
+  }, rest, {
+    ref: ref
+  }))), assistiveText && !errorMessage && ___EmotionJSX(AssistiveText, {
+    id: name + '_aria'
+  }, assistiveText), errorMessage && ___EmotionJSX(ErrorText, {
+    id: name + '_aria'
+  }, errorMessage));
+}
+/** @deprecated Use dfds-ui/forms */
+export var ReactSelect = /*#__PURE__*/React.forwardRef(ReactSelectInner);
+/** @deprecated Use dfds-ui/forms */
+export default ReactSelect;

package/cjs/ReactSelect.d.ts ADDED Viewed

@@ -0,0 +1,70 @@
+import React from 'react';
+import Select, { createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select';
+import { BaseFieldProps } from '@dfds-ui/forms/types';
+export declare type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>;
+export declare type Size = 'small' | 'medium' | 'large';
+export declare const ReactSelectWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: React.ElementType<any, keyof React.JSX.IntrinsicElements> | undefined;
+} & {
+    error?: boolean | undefined;
+    size?: string | undefined;
+    arrow?: boolean | undefined;
+    selected?: boolean | undefined;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Menu: (props: any) => React.JSX.Element;
+export declare type SelectFieldProps<T> = BaseFieldProps & {
+    defaultValue?: SingleValue<T>;
+    className?: string;
+    components?: any;
+    value?: SingleValue<T>;
+    visualSize?: Size;
+    options?: OptionsOrGroups<T, GroupBase<T>>;
+    isSearchable?: boolean;
+    onSelect?: (value: SingleValue<T>) => void;
+    onChange?: (value: SingleValue<T>) => void;
+    onBlur?: (value: any) => void;
+    menuIsOpen?: boolean;
+    placeholder?: string;
+    assistiveText?: string;
+    errorMessage?: string;
+    /**
+     * Configuration object passed to react-select createFilter function to create [custom filter
+     * logic](https://react-select.com/advanced#custom-filter-logic)
+     * @param ignoreCase - boolean (optional)
+     * @param ignoreAccents - boolean (optional)
+     * @param stringify (obj: any) => string (optional)
+     * @param trim - boolean (optional)
+     * @param matchForm - 'any' | 'start'
+     */
+    filterConfig?: Parameters<typeof createFilter>[0];
+};
+/** @deprecated Use dfds-ui/forms */
+export declare const ReactSelect: React.ForwardRefExoticComponent<BaseFieldProps & {
+    defaultValue?: unknown;
+    className?: string | undefined;
+    components?: any;
+    value?: unknown;
+    visualSize?: Size | undefined;
+    options?: OptionsOrGroups<unknown, GroupBase<unknown>> | undefined;
+    isSearchable?: boolean | undefined;
+    onSelect?: ((value: unknown) => void) | undefined;
+    onChange?: ((value: unknown) => void) | undefined;
+    onBlur?: ((value: any) => void) | undefined;
+    menuIsOpen?: boolean | undefined;
+    placeholder?: string | undefined;
+    assistiveText?: string | undefined;
+    errorMessage?: string | undefined;
+    /**
+     * Configuration object passed to react-select createFilter function to create [custom filter
+     * logic](https://react-select.com/advanced#custom-filter-logic)
+     * @param ignoreCase - boolean (optional)
+     * @param ignoreAccents - boolean (optional)
+     * @param stringify (obj: any) => string (optional)
+     * @param trim - boolean (optional)
+     * @param matchForm - 'any' | 'start'
+     */
+    filterConfig?: Parameters<typeof createFilter>[0];
+} & React.RefAttributes<any>>;
+/** @deprecated Use dfds-ui/forms */
+export default ReactSelect;

package/cjs/ReactSelect.js ADDED Viewed

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ReactSelectWrapper = exports.ReactSelect = exports.Menu = void 0;
+var _base = _interopRequireDefault(require("@emotion/styled/base"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@emotion/react");
+var _theme = require("@dfds-ui/theme");
+var _reactComponents = require("@dfds-ui/react-components");
+var _reactSelect = _interopRequireWildcard(require("react-select"));
+var _system = require("@dfds-ui/icons/system");
+var _forms = require("@dfds-ui/forms");
+var _AssistiveText = _interopRequireDefault(require("@dfds-ui/forms/assistive-text/AssistiveText"));
+var _ErrorText = _interopRequireDefault(require("@dfds-ui/forms/error-text/ErrorText"));
+var _flexbox = require("@dfds-ui/react-components/flexbox");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+const ReactSelectWrapper = /*#__PURE__*/(0, _base.default)("div", process.env.NODE_ENV === "production" ? {
+  target: "e1dgfjeh0"
+} : {
+  target: "e1dgfjeh0",
+  label: "ReactSelectWrapper"
+})("position:relative;margin-top:", _theme.theme.spacing.xxs, ";margin-bottom:", _theme.theme.spacing.xxs, ";&:focus-within{outline:none;}svg{color:", _theme.theme.colors.text.dark.secondary, ";}.react-select__control{border:1px solid ", _theme.theme.colors.text.dark.secondary, ";height:", p => p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px', ";min-height:", p => p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px', ";border-color:", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.text.dark.secondary, ";box-shadow:inset 0 0 0 ", p => p.error ? 1 : 0, "px ", _theme.theme.colors.status.alert, ";padding-left:5px;border-radius:0;font-size:14px;appearance:none;cursor:pointer;", _theme.media.lessThanEqual('m')`
+      font-size: 16px;
+    `, ";}.react-select__menu{margin-top:0;margin-bottom:0;z-index:500000;}.react-select__control--is-focused,.react-select__control--menu-is-open{border:1px solid ", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.main, ";box-shadow:inset 0 0 0 1px ", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.main, ";outline:0;&:hover{border-color:", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.light, ";}svg{color:", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.dark, ";}}.react-select__option{color:", _theme.theme.colors.primary.main, ";background-color:white;position:relative;", props => props.selected && /*#__PURE__*/(0, _react2.css)("color:", _theme.theme.colors.text.secondary.primary, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:ReactSelectWrapper;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AAyES","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */"), ";", props => _theme.theme.states.overlay(props.selected), ";&--is-focused{&:after{opacity:0.16;background-color:", _theme.theme.colors.secondary.light, ";}}&--is-disabled{opacity:0.3;}&--is-selected{&:after{opacity:0.12;background-color:", _theme.theme.colors.secondary.dark, ";}}}.react-select__menu>div::before,.react-select__menu>div>::before{", p => !p.arrow && `display: none`, ";}.react-select__indicator-separator{display:none;}.react-select__menu-list{padding:0;}.react-select--is-disabled{.react-select__control{pointer-events:none;border:1px solid ", _theme.theme.colors.text.dark.disabled, ";background:", _theme.theme.colors.surface.primary, ";}.react-select__placeholder{color:", _theme.theme.colors.text.dark.disabled, ";}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AAiBqH","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */"));
+exports.ReactSelectWrapper = ReactSelectWrapper;
+var _ref3 = process.env.NODE_ENV === "production" ? {
+  name: "1rmdj93",
+  styles: "bottom:auto;left:auto;position:relative;right:auto;top:auto"
+} : {
+  name: "1l1u776-Menu",
+  styles: "bottom:auto;left:auto;position:relative;right:auto;top:auto;label:Menu;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AAgIgB","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const Menu = props => {
+  return (0, _react2.jsx)(_reactSelect.components.Menu, props, (0, _react2.jsx)(_reactComponents.Drawer, {
+    showArrow: false,
+    verticalPosition: props.placement,
+    css: _ref3
+  }, props.children));
+};
+exports.Menu = Menu;
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "82a6rk",
+  styles: "flex:1"
+} : {
+  name: "1l9bct2-ReactSelectInner",
+  styles: "flex:1;label:ReactSelectInner;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AA4NoB","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+var _ref2 = process.env.NODE_ENV === "production" ? {
+  name: "s5xdrg",
+  styles: "display:flex;align-items:center"
+} : {
+  name: "1l4z3ql-ReactSelectInner",
+  styles: "display:flex;align-items:center;label:ReactSelectInner;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AAoNkB","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+var _ref4 = process.env.NODE_ENV === "production" ? {
+  name: "rrel8y",
+  styles: "width:24px;height:24px"
+} : {
+  name: "1jm3yf4-children",
+  styles: "width:24px;height:24px;label:children;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AAgM8B","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+function ReactSelectInner({
+  name,
+  label,
+  defaultValue,
+  value,
+  placeholder,
+  onSelect,
+  onChange,
+  isSearchable,
+  onBlur,
+  assistiveText,
+  options,
+  errorMessage,
+  disabled,
+  visualSize = 'medium',
+  filterConfig,
+  ...rest
+}, ref) {
+  const DropdownIndicator = props => {
+    const {
+      children = (0, _react2.jsx)(_system.ChevronDown, {
+        css: _ref4
+      }),
+      innerProps: {
+        ref,
+        ...restInnerProps
+      }
+    } = props;
+    return (0, _react2.jsx)("div", _extends({}, restInnerProps, {
+      ref: ref
+    }), (0, _react2.jsx)("div", {
+      style: {
+        padding: `0 ${_theme.theme.spacing.xxs}`
+      }
+    }, children));
+  };
+  return (0, _react2.jsx)(_flexbox.FlexBox, {
+    directionColumn: true,
+    css: /*#__PURE__*/(0, _react2.css)("margin-bottom:", !assistiveText && !errorMessage ? '1.5rem' : '0.5rem', ";" + (process.env.NODE_ENV === "production" ? "" : ";label:ReactSelectInner;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ReactSelect.tsx"],"names":[],"mappings":"AA8Mc","file":"../../src/ReactSelect.tsx","sourcesContent":["import React from 'react'\nimport styled from '@emotion/styled'\nimport { css } from '@emotion/react'\nimport { media, theme } from '@dfds-ui/theme'\nimport { Drawer } from '@dfds-ui/react-components'\nimport Select, { components, createFilter, GroupBase, OptionsOrGroups, SingleValue } from 'react-select'\nimport { ChevronDown } from '@dfds-ui/icons/system'\nimport { Label } from '@dfds-ui/forms'\nimport AssistiveText from '@dfds-ui/forms/assistive-text/AssistiveText'\nimport ErrorText from '@dfds-ui/forms/error-text/ErrorText'\nimport { BaseFieldProps } from '@dfds-ui/forms/types'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\n\nexport type BaseReactSelectProps = Omit<React.PropsWithRef<Select>, 'size' | 'css'>\n\nexport type Size = 'small' | 'medium' | 'large'\n\nexport const ReactSelectWrapper = styled.div<{ error?: boolean; size?: string; arrow?: boolean; selected?: boolean }>`\n  position: relative;\n  margin-top: ${theme.spacing.xxs};\n  margin-bottom: ${theme.spacing.xxs};\n\n  &:focus-within {\n    outline: none;\n  }\n\n  svg {\n    color: ${theme.colors.text.dark.secondary};\n  }\n\n  .react-select__control {\n    border: 1px solid ${theme.colors.text.dark.secondary};\n    height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    min-height: ${(p) =>\n      (p.size === 'small' && '32px') || (p.size === 'medium' && '40px') || (p.size === 'large' && '48px')};\n    border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.text.dark.secondary)};\n    box-shadow: inset 0 0 0 ${(p) => (p.error ? 1 : 0)}px ${theme.colors.status.alert};\n    padding-left: 5px;\n    border-radius: 0;\n    font-size: 14px;\n    appearance: none;\n    cursor: pointer;\n\n    ${media.lessThanEqual('m')`\n      font-size: 16px;\n    `}\n  }\n  .react-select__menu {\n    margin-top: 0;\n    margin-bottom: 0;\n    z-index: 500000;\n  }\n  .react-select__control--is-focused,\n  .react-select__control--menu-is-open {\n    border: 1px solid ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    box-shadow: inset 0 0 0 1px ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.main)};\n    outline: 0;\n\n    &:hover {\n      border-color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.light)};\n    }\n\n    svg {\n      color: ${(p) => (p.error ? theme.colors.status.alert : theme.colors.secondary.dark)};\n    }\n  }\n  .react-select__option {\n    color: ${theme.colors.primary.main};\n    background-color: white;\n    position: relative;\n    ${(props) =>\n      props.selected &&\n      css`\n        color: ${theme.colors.text.secondary.primary};\n      `};\n    ${(props) => theme.states.overlay(props.selected)};\n\n    &--is-focused {\n      &:after {\n        opacity: 0.16;\n        background-color: ${theme.colors.secondary.light};\n      }\n    }\n\n    &--is-disabled {\n      opacity: 0.3;\n    }\n\n    &--is-selected {\n      &:after {\n        opacity: 0.12;\n        background-color: ${theme.colors.secondary.dark};\n      }\n    }\n  }\n\n  .react-select__menu > div::before,\n  .react-select__menu > div > ::before {\n    ${(p) => !p.arrow && `display: none`};\n  }\n\n  .react-select__indicator-separator {\n    display: none;\n  }\n\n  .react-select__menu-list {\n    padding: 0;\n  }\n  .react-select--is-disabled {\n    .react-select__control {\n      pointer-events: none;\n\n      border: 1px solid ${theme.colors.text.dark.disabled};\n      background: ${theme.colors.surface.primary};\n    }\n    .react-select__placeholder {\n      color: ${theme.colors.text.dark.disabled};\n    }\n  }\n`\n\nexport const Menu = (props: any) => {\n  return (\n    <components.Menu {...props}>\n      <Drawer\n        showArrow={false}\n        verticalPosition={props.placement}\n        css={css`\n          bottom: auto;\n          left: auto;\n          position: relative;\n          right: auto;\n          top: auto;\n        `}\n      >\n        {props.children}\n      </Drawer>\n    </components.Menu>\n  )\n}\n\nexport type SelectFieldProps<T> = BaseFieldProps & {\n  defaultValue?: SingleValue<T>\n  className?: string\n  components?: any\n  value?: SingleValue<T>\n  visualSize?: Size\n  options?: OptionsOrGroups<T, GroupBase<T>>\n  isSearchable?: boolean\n  onSelect?: (value: SingleValue<T>) => void\n  onChange?: (value: SingleValue<T>) => void\n  onBlur?: (value: any) => void\n  menuIsOpen?: boolean\n  placeholder?: string\n  assistiveText?: string\n  errorMessage?: string\n  /**\n   * Configuration object passed to react-select createFilter function to create [custom filter\n   * logic](https://react-select.com/advanced#custom-filter-logic)\n   * @param ignoreCase - boolean (optional)\n   * @param ignoreAccents - boolean (optional)\n   * @param stringify (obj: any) => string (optional)\n   * @param trim - boolean (optional)\n   * @param matchForm - 'any' | 'start'\n   */\n  filterConfig?: Parameters<typeof createFilter>[0]\n}\n\nfunction ReactSelectInner<T>(\n  {\n    name,\n    label,\n    defaultValue,\n    value,\n    placeholder,\n    onSelect,\n    onChange,\n    isSearchable,\n    onBlur,\n    assistiveText,\n    options,\n    errorMessage,\n    disabled,\n    visualSize = 'medium',\n    filterConfig,\n    ...rest\n  }: SelectFieldProps<T>,\n  ref: React.ForwardedRef<any>\n) {\n  const DropdownIndicator = (props: any) => {\n    const {\n      children = <ChevronDown css={{ width: '24px', height: '24px' }} />,\n      innerProps: { ref, ...restInnerProps },\n    } = props\n\n    return (\n      <div {...restInnerProps} ref={ref}>\n        <div style={{ padding: `0 ${theme.spacing.xxs}` }}>{children}</div>\n      </div>\n    )\n  }\n\n  return (\n    <FlexBox\n      directionColumn\n      css={css`\n        margin-bottom: ${!assistiveText && !errorMessage ? '1.5rem' : '0.5rem'};\n      `}\n    >\n      {label && (\n        <Label\n          css={css`\n            display: flex;\n            align-items: center;\n          `}\n          visualSize={visualSize === 'small' ? 'small' : 'medium'}\n          disabled={disabled}\n        >\n          <span\n            css={css`\n              flex: 1;\n            `}\n          >\n            {label}\n          </span>\n        </Label>\n      )}\n      <ReactSelectWrapper error={(errorMessage && errorMessage.length > 0) || undefined} size={visualSize} arrow={true}>\n        <Select\n          value={value}\n          defaultValue={defaultValue}\n          name={name}\n          isSearchable={isSearchable}\n          menuPlacement={'auto'}\n          styles={{\n            option: (provided) => {\n              return {\n                ...provided,\n                ':active': {\n                  backgroundColor: 'transparent',\n                },\n              }\n            },\n          }}\n          options={options}\n          onChange={(e) => {\n            onChange && onChange(e)\n            onSelect && onSelect(e)\n          }}\n          onBlur={(e) => onBlur && onBlur(e)}\n          aria-invalid={(errorMessage && errorMessage.length > 0) || false}\n          placeholder={placeholder}\n          isDisabled={disabled}\n          isClearable={false}\n          classNamePrefix=\"react-select\"\n          className={'select-field'}\n          components={{ ...components, DropdownIndicator }}\n          filterOption={filterConfig && createFilter(filterConfig)}\n          {...rest}\n          ref={ref}\n        />\n      </ReactSelectWrapper>\n      {assistiveText && !errorMessage && <AssistiveText id={name + '_aria'}>{assistiveText}</AssistiveText>}\n      {errorMessage && <ErrorText id={name + '_aria'}>{errorMessage}</ErrorText>}\n    </FlexBox>\n  )\n}\n/** @deprecated Use dfds-ui/forms */\nexport const ReactSelect = React.forwardRef(ReactSelectInner)\n\n/** @deprecated Use dfds-ui/forms */\nexport default ReactSelect\n"]} */")
+  }, label && (0, _react2.jsx)(_forms.Label, {
+    css: _ref2,
+    visualSize: visualSize === 'small' ? 'small' : 'medium',
+    disabled: disabled
+  }, (0, _react2.jsx)("span", {
+    css: _ref
+  }, label)), (0, _react2.jsx)(ReactSelectWrapper, {
+    error: errorMessage && errorMessage.length > 0 || undefined,
+    size: visualSize,
+    arrow: true
+  }, (0, _react2.jsx)(_reactSelect.default, _extends({
+    value: value,
+    defaultValue: defaultValue,
+    name: name,
+    isSearchable: isSearchable,
+    menuPlacement: 'auto',
+    styles: {
+      option: provided => {
+        return {
+          ...provided,
+          ':active': {
+            backgroundColor: 'transparent'
+          }
+        };
+      }
+    },
+    options: options,
+    onChange: e => {
+      onChange && onChange(e);
+      onSelect && onSelect(e);
+    },
+    onBlur: e => onBlur && onBlur(e),
+    "aria-invalid": errorMessage && errorMessage.length > 0 || false,
+    placeholder: placeholder,
+    isDisabled: disabled,
+    isClearable: false,
+    classNamePrefix: "react-select",
+    className: 'select-field',
+    components: {
+      ..._reactSelect.components,
+      DropdownIndicator
+    },
+    filterOption: filterConfig && (0, _reactSelect.createFilter)(filterConfig)
+  }, rest, {
+    ref: ref
+  }))), assistiveText && !errorMessage && (0, _react2.jsx)(_AssistiveText.default, {
+    id: name + '_aria'
+  }, assistiveText), errorMessage && (0, _react2.jsx)(_ErrorText.default, {
+    id: name + '_aria'
+  }, errorMessage));
+}
+/** @deprecated Use dfds-ui/forms */
+const ReactSelect = /*#__PURE__*/_react.default.forwardRef(ReactSelectInner);
+/** @deprecated Use dfds-ui/forms */
+exports.ReactSelect = ReactSelect;
+var _default = ReactSelect;
+exports.default = _default;

package/cjs/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { default as ReactSelect } from './ReactSelect';

package/cjs/index.js ADDED Viewed

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ReactSelect", {
+  enumerable: true,
+  get: function () {
+    return _ReactSelect.default;
+  }
+});
+var _ReactSelect = _interopRequireDefault(require("./ReactSelect"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { default as ReactSelect } from './ReactSelect';

package/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { default as ReactSelect } from './ReactSelect';

package/package.json CHANGED Viewed

@@ -3,7 +3,7 @@
   "description": "react-selected based components",
   "license": "MIT",
   "private": false,
-  "version": "2.2.0-alpha.8d87a90d",
+  "version": "2.2.0-alpha.c35ceba3",
   "sideEffects": false,
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -12,16 +12,16 @@
   "peerDependencies": {
     "@emotion/react": "11.11.4",
     "@emotion/styled": "11.11.5",
-    "react": ">= 17.0.2",
-    "react-dom": ">= 17.0.2",
+    "react": ">= 18.3.1",
+    "react-dom": ">= 18.3.1",
     "react-select": "^4.0.0"
   },
   "dependencies": {
-    "@dfds-ui/forms": "2.2.0-alpha.8d87a90d",
-    "@dfds-ui/react-components": "2.2.0-alpha.8d87a90d",
-    "@dfds-ui/theme": "2.2.0-alpha.8d87a90d"
+    "@dfds-ui/forms": "2.2.0-alpha.c35ceba3",
+    "@dfds-ui/react-components": "2.2.0-alpha.c35ceba3",
+    "@dfds-ui/theme": "2.2.0-alpha.c35ceba3"
   },
-  "gitHead": "8d87a90d4501dae81cac37ab3b4d9f13a68e2ab3",
+  "gitHead": "c35ceba322ca61db55c51ea1114949091cfc9f7f",
   "publishConfig": {
     "access": "public"
   }