@atlaskit/select 16.1.9 → 16.2.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/select
 
+## 16.2.1
+
+### Patch Changes
+
+- [`ffeeae59446`](https://bitbucket.org/atlassian/atlassian-frontend/commits/ffeeae59446) - Migrates unit tests from enzyme to RTL.
+
+## 16.2.0
+
+### Minor Changes
+
+- [`56507598609`](https://bitbucket.org/atlassian/atlassian-frontend/commits/56507598609) - Skip minor dependency bump
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 16.1.9
 
 ### Patch Changes

package/dist/cjs/Select.js

@@ -9,7 +9,7 @@ var _reactSelect = _interopRequireDefault(require("react-select"));
 var _analyticsNext = require("@atlaskit/analytics-next");
 var _createSelect = _interopRequireDefault(require("./createSelect"));
 var packageName = "@atlaskit/select";
-var packageVersion = "16.1.9";
+var packageVersion = "16.2.1";
 var SelectWithoutAnalytics = (0, _createSelect.default)(_reactSelect.default);
 exports.SelectWithoutAnalytics = SelectWithoutAnalytics;
 var createAndFireEventOnAtlaskit = (0, _analyticsNext.createAndFireEvent)('atlaskit');

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/select",
-	"version": "16.1.9",
+	"version": "16.2.1",
 	"sideEffects": false
 }

package/dist/es2019/Select.js

@@ -2,7 +2,7 @@ import Select from 'react-select';
 import { withAnalyticsEvents, withAnalyticsContext, createAndFireEvent } from '@atlaskit/analytics-next';
 import createSelect from './createSelect';
 const packageName = "@atlaskit/select";
-const packageVersion = "16.1.9";
+const packageVersion = "16.2.1";
 export const SelectWithoutAnalytics = createSelect(Select);
 const createAndFireEventOnAtlaskit = createAndFireEvent('atlaskit');
 export default withAnalyticsContext({

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/select",
-	"version": "16.1.9",
+	"version": "16.2.1",
 	"sideEffects": false
 }

package/dist/esm/Select.js

@@ -2,7 +2,7 @@ import Select from 'react-select';
 import { withAnalyticsEvents, withAnalyticsContext, createAndFireEvent } from '@atlaskit/analytics-next';
 import createSelect from './createSelect';
 var packageName = "@atlaskit/select";
-var packageVersion = "16.1.9";
+var packageVersion = "16.2.1";
 export var SelectWithoutAnalytics = createSelect(Select);
 var createAndFireEventOnAtlaskit = createAndFireEvent('atlaskit');
 export default withAnalyticsContext({

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/select",
-	"version": "16.1.9",
+	"version": "16.2.1",
 	"sideEffects": false
 }

package/dist/types/CountrySelect.d.ts

@@ -1,6 +1,6 @@
 import { jsx } from '@emotion/react';
 import { groupedCountries } from './data/countries';
 import { SelectProps } from './types';
-declare type Country = typeof groupedCountries[number]['options'][number];
+declare type Country = (typeof groupedCountries)[number]['options'][number];
 declare const CountrySelect: (props: SelectProps<Country>) => jsx.JSX.Element;
 export default CountrySelect;

package/dist/types-ts4.0/AsyncCreatableSelect.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+declare const _default: {
+    new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/AsyncSelect.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+declare const _default: {
+    new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/CheckboxSelect.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SelectProps, OptionType } from './types';
+declare const CheckboxSelect: ({ components, ...props }: SelectProps<OptionType, true>) => JSX.Element;
+export default CheckboxSelect;

package/dist/types-ts4.0/CountrySelect.d.ts

@@ -0,0 +1,6 @@
+import { jsx } from '@emotion/react';
+import { groupedCountries } from './data/countries';
+import { SelectProps } from './types';
+declare type Country = (typeof groupedCountries)[number]['options'][number];
+declare const CountrySelect: (props: SelectProps<Country>) => jsx.JSX.Element;
+export default CountrySelect;

package/dist/types-ts4.0/CreatableSelect.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+declare const _default: {
+    new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/PopupSelect/PopupSelect.d.ts

@@ -0,0 +1,147 @@
+import React, { PureComponent, ReactNode } from 'react';
+import BaseSelect from 'react-select/base';
+import { PopperProps } from 'react-popper';
+import { OptionType, ActionMeta, ReactSelectProps, StylesConfig, ValueType, ValidationState } from '../types';
+import { UnbindFn } from 'bind-event-listener';
+declare type defaultModifiers = 'offset' | 'preventOverflow';
+declare type PopperPropsNoChildren<Modifiers> = Omit<PopperProps<Modifiers>, 'children'>;
+interface PopupSelectTriggerProps {
+    ref: any;
+    'aria-haspopup': 'true';
+    'aria-expanded': boolean;
+    'aria-controls'?: string;
+}
+export declare type ModifierList = 'offset' | 'computeStyles' | 'preventOverflow' | 'handleFlipStyle' | 'flip' | 'popperOffsets' | 'arrow' | 'hide' | 'eventListeners' | 'applyStyles';
+export interface PopupSelectProps<Option = OptionType, IsMulti extends boolean = false, Modifiers = ModifierList> extends ReactSelectProps<Option, IsMulti> {
+    /**
+     * Defines whether the menu should close when selected. Defaults to "true"
+     */
+    closeMenuOnSelect?: boolean;
+    /**
+     * The footer content shown at the bottom of the Popup, underneath the Select options
+     */
+    footer?: ReactNode;
+    /**
+      The props passed down to React Popper.
+  
+      Use these to override the default positioning strategy, behaviour and placement used by this library.
+      For more information, see the Popper Props section below, or [React Popper documentation](https://popper.js.org/react-popper/v2/render-props).
+  
+     */
+    popperProps?: PopperPropsNoChildren<Modifiers>;
+    /**
+     * The maximum number of options the select can contain without rendering the search field. Defaults to 5.
+     */
+    searchThreshold?: number;
+    /**
+     * If false, renders a select with no search field. If true, renders a search field in the select when the
+     * number of options exceeds the `searchThreshold`. Defaults to true.
+     */
+    isSearchable?: boolean;
+    /**
+     * The maximum width for the popup menu. Can be a number, representing width in pixels,
+     * or a string containing a CSS length datatype.
+     */
+    maxMenuWidth?: number | string;
+    /**
+     * The maximum width for the popup menu. Can be a number, representing width in pixels,
+     * or a string containing a CSS length datatype.
+     */
+    minMenuWidth?: number | string;
+    /**
+      Render props used to anchor the popup to your content.
+  
+      Make this an interactive element, such as an @atlaskit/button component.
+  
+      The provided render props in `options` are detailed below:
+      - `isOpen`: The current state of the popup.
+          Use this to change the appearance of your target based on the state of your component
+      - `ref`: Pass this ref to the element the Popup should be attached to
+      - `aria-haspopup`, `aria-expanded`, `aria-controls`: Spread these onto a target element to
+          ensure your experience is accessible
+     */
+    target?: (options: PopupSelectTriggerProps & {
+        isOpen: boolean;
+    }) => ReactNode;
+    isOpen?: boolean;
+    defaultIsOpen?: boolean;
+    /** The prop indicates if the component has a compacted look */
+    spacing?: string;
+    /** @deprecated Use isInvalid instead. The state of validation if used in a form */
+    validationState?: ValidationState;
+    /** This prop indicates if the component is in an error state */
+    isInvalid?: boolean;
+    testId?: string;
+}
+interface State<Modifiers = string> {
+    focusLockEnabled: boolean;
+    isOpen: boolean;
+    mergedComponents: Object;
+    mergedPopperProps: PopperPropsNoChildren<defaultModifiers | Modifiers>;
+}
+export default class PopupSelect<Option = OptionType, IsMulti extends boolean = false, Modifiers = ModifierList> extends PureComponent<PopupSelectProps<Option, IsMulti, Modifiers>, State> {
+    menuRef: HTMLElement | null;
+    selectRef: BaseSelect<Option, IsMulti> | null;
+    targetRef: HTMLElement | null;
+    unbindWindowClick: UnbindFn | null;
+    unbindWindowKeydown: UnbindFn | null;
+    defaultStyles: StylesConfig<Option, IsMulti>;
+    isOpenControlled: boolean;
+    defaultOpenState: boolean | undefined;
+    state: {
+        focusLockEnabled: boolean;
+        isOpen: boolean;
+        mergedComponents: {
+            Control: React.FC<import("../types").ControlProps<OptionType, boolean>>;
+            DropdownIndicator: () => import("@emotion/react").jsx.JSX.Element;
+            Menu: ({ children, innerProps, ...props }: import("../types").MenuProps<OptionType, boolean>) => import("@emotion/react").jsx.JSX.Element;
+        };
+        mergedPopperProps: PopperPropsNoChildren<string>;
+    };
+    popperWrapperId: string;
+    static defaultProps: {
+        closeMenuOnSelect: boolean;
+        components: {};
+        maxMenuHeight: number;
+        maxMenuWidth: number;
+        minMenuWidth: number;
+        popperProps: {};
+        isSearchable: boolean;
+        searchThreshold: number;
+        styles: {};
+        options: never[];
+    };
+    static getDerivedStateFromProps(props: PopupSelectProps<OptionType>, state: State): Partial<State<string>> | null;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: PopupSelectProps<Option, IsMulti, Modifiers>): void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    handleClick: ({ target }: MouseEvent) => void;
+    handleSelectChange: (value: ValueType<Option, IsMulti>, actionMeta: ActionMeta<Option>) => void;
+    handleFirstPopperUpdate: () => void;
+    /**
+     * Opens the popup
+     *
+     * @param options.controlOverride  - Force the popup to open when it's open state is being controlled
+     */
+    open: (options?: {
+        controlOverride?: boolean | undefined;
+    } | undefined) => void;
+    /**
+     * Closes the popup
+     *
+     * @param options.controlOverride  - Force the popup to close when it's open state is being controlled
+     */
+    close: (options?: {
+        controlOverride?: boolean | undefined;
+    } | undefined) => void;
+    resolveTargetRef: (popperRef: React.Ref<HTMLElement>) => (ref: HTMLElement) => void;
+    resolveMenuRef: (popperRef: React.Ref<HTMLElement>) => (ref: HTMLElement) => void;
+    getSelectRef: (ref: BaseSelect<Option, IsMulti>) => void;
+    getItemCount: () => number;
+    getMaxHeight: () => number | undefined;
+    showSearchControl: () => boolean | undefined;
+    renderSelect: () => JSX.Element | null;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.0/PopupSelect/components.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import { FC, ReactNode, CSSProperties } from 'react';
+import { jsx } from '@emotion/react';
+import { ControlProps, MenuProps, OptionType } from '../types';
+interface MenuDialogProps {
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    style: CSSProperties;
+    children: ReactNode;
+    id: string;
+}
+export declare const MenuDialog: FC<MenuDialogProps>;
+export declare const DummyControl: FC<ControlProps<OptionType, boolean>>;
+export declare const defaultComponents: {
+    Control: FC<ControlProps<OptionType, boolean>>;
+    DropdownIndicator: () => jsx.JSX.Element;
+    Menu: ({ children, innerProps, ...props }: MenuProps<OptionType, boolean>) => jsx.JSX.Element;
+};
+export {};

package/dist/types-ts4.0/PopupSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './PopupSelect';
+export type { PopupSelectProps, ModifierList } from './PopupSelect';

package/dist/types-ts4.0/RadioSelect.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SelectProps, OptionType } from './types';
+declare const RadioSelect: ({ components, ...props }: SelectProps<OptionType>) => JSX.Element;
+export default RadioSelect;

package/dist/types-ts4.0/Select.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="react" />
+export declare const SelectWithoutAnalytics: {
+    new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+declare const _default: {
+    new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/components/index.d.ts

@@ -0,0 +1,6 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { MultiValueRemoveProps } from '../types';
+export { ClearIndicator, DropdownIndicator, LoadingIndicator, } from './indicators';
+export declare const MultiValueRemove: (props: MultiValueRemoveProps<any>) => jsx.JSX.Element;
+export declare const IndicatorSeparator: null;

package/dist/types-ts4.0/components/indicators.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { ClearIndicatorProps, DropdownIndicatorProps, LoadingIndicatorProps } from '../types';
+export declare const ClearIndicator: FC<ClearIndicatorProps<any>>;
+export declare const DropdownIndicator: FC<DropdownIndicatorProps<any>>;
+export declare const LoadingIndicator: FC<LoadingIndicatorProps<any>>;

package/dist/types-ts4.0/components/input-options.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { OptionProps, OptionType } from '../types';
+export declare const CheckboxOption: FC<OptionProps<OptionType, true>>;
+export declare const RadioOption: FC<OptionProps>;

package/dist/types-ts4.0/createSelect.d.ts

@@ -0,0 +1,45 @@
+import React, { ComponentType } from 'react';
+import BaseSelect from 'react-select/base';
+import { SelectProps, SelectComponentsConfig, OptionType, AsyncSelectProps, CreatableSelectProps } from './types';
+export default function createSelect(WrappedComponent: ComponentType<any>): {
+    new <Option = OptionType, IsMulti extends boolean = false>(props: SelectProps<Option, IsMulti>): {
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: BaseSelect | null;
+        UNSAFE_componentWillReceiveProps(nextProps: SelectProps<Option, IsMulti>): void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
+        focus(): void;
+        blur(): void;
+        onSelectRef: (ref: BaseSelect) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    defaultProps: {
+        validationState: string;
+        spacing: string;
+        onClickPreventDefault: boolean;
+        tabSelectsValue: boolean;
+        components: {};
+        styles: {};
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/types-ts4.0/data/countries.d.ts

@@ -0,0 +1,19 @@
+interface Country {
+    abbr: string;
+    code: string;
+    icon: string;
+    name: string;
+    suggested?: boolean;
+}
+export declare const allCountries: Array<Country>;
+export declare const groupedCountries: readonly [
+    {
+        readonly label: "Suggested";
+        readonly options: Country[];
+    },
+    {
+        readonly label: "All Countries";
+        readonly options: Country[];
+    }
+];
+export {};

package/dist/types-ts4.0/entry-points/async-creatable-select.d.ts

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

package/dist/types-ts4.0/entry-points/async-select.d.ts

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

package/dist/types-ts4.0/entry-points/creatable-select.d.ts

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

package/dist/types-ts4.0/entry-points/select.d.ts

@@ -0,0 +1 @@
+export { default, SelectWithoutAnalytics } from '../Select';

package/dist/types-ts4.0/extract-react-types/ert.d.ts

@@ -0,0 +1,2 @@
+import { SelectProps, OptionType } from '../types';
+export default function ertHackForSelect(_: SelectProps<OptionType>): void;

package/dist/types-ts4.0/extract-react-types/react-popper-props.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { Modifier, Options } from '@popperjs/core';
+declare type Placement = 'auto' | 'auto-start' | 'auto-end' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+declare type Strategy = 'absolute' | 'fixed';
+interface NativeReactPopperProps<Name = unknown> {
+    /** Function `(?HTMLElement) => void` that can be used to obtain popper reference */
+    innerRef?: React.Ref<any>;
+    /** One of the accepted placement values listed in the Popper.js documentation.
+     Your popper is going to be placed according to the value of this property.
+    Defaults to bottom.*/
+    placement?: Placement;
+    /** Describes the positioning strategy to use. By default, it is absolute, which in the simplest cases does not
+     * require repositioning of the popper. If your reference element is in a fixed container, use the fixed strategy. */
+    strategy: Strategy;
+    /** An object containing custom settings for the Popper.js modifiers.
+     You can use this property to override their settings or to inject your custom ones.
+    See [Popper Modifiers](https://popper.js.org/docs/v2/modifiers/) for full details. */
+    modifiers?: ReadonlyArray<Modifier<Name, Options>>;
+}
+export default function ertHackForPopper(_: NativeReactPopperProps): void;
+export {};

package/dist/types-ts4.0/extract-react-types/react-select-async.d.ts

@@ -0,0 +1,24 @@
+import { GroupBase, OptionsOrGroups } from 'react-select';
+export interface ReactSelectAsyncProps<Option = unknown, Group extends GroupBase<Option> = GroupBase<Option>> {
+    /**
+     * The default set of options to show before the user starts searching. When
+     * set to `true`, the results for loadOptions('') will be autoloaded.
+     */
+    defaultOptions?: OptionsOrGroups<Option, Group> | boolean;
+    /**
+     * If cacheOptions is truthy, then the loaded data will be cached. The cache
+     * will remain until `cacheOptions` changes value.
+     */
+    cacheOptions?: any;
+    /**
+     * Function that returns a promise, which is the set of options to be used
+     * once the promise resolves.
+     */
+    loadOptions?: (inputValue: string, callback: (options: OptionsOrGroups<Option, Group>) => void) => Promise<OptionsOrGroups<Option, Group>> | void;
+    /**
+     * Will cause the select to be displayed in the loading state, even if the
+     * Async select is not currently waiting for loadOptions to resolve
+     */
+    isLoading?: boolean;
+}
+export default function ertHackForPopper(_: ReactSelectAsyncProps): void;

package/dist/types-ts4.0/extract-react-types/react-select-creatable.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+import { GetOptionLabel, GetOptionValue, GroupBase, Options, OptionsOrGroups } from 'react-select';
+export interface Accessors<Option> {
+    getOptionValue: GetOptionValue<Option>;
+    getOptionLabel: GetOptionLabel<Option>;
+}
+export interface ReactSelectCreatableProps<Option = unknown, Group extends GroupBase<Option> = GroupBase<Option>> {
+    /**
+     * Allow options to be created while the `isLoading` prop is true. Useful to
+     * prevent the "create new ..." option being displayed while async results are
+     * still being loaded.
+     */
+    allowCreateWhileLoading?: boolean;
+    /** Sets the position of the createOption element in your options list. Defaults to 'last' */
+    createOptionPosition?: 'first' | 'last';
+    /**
+     * Gets the label for the "create new ..." option in the menu. Is given the
+     * current input value.
+     */
+    formatCreateLabel?: (inputValue: string) => ReactNode;
+    /**
+     * Determines whether the "create new ..." option should be displayed based on
+     * the current input value, select value and options array.
+     */
+    isValidNewOption?: (inputValue: string, value: Options<Option>, options: OptionsOrGroups<Option, Group>, accessors: Accessors<Option>) => boolean;
+    /**
+     * Returns the data for the new option when it is created. Used to display the
+     * value, and is passed to `onChange`.
+     */
+    getNewOptionData?: (inputValue: string, optionLabel: ReactNode) => Option;
+    /**
+     * If provided, this will be called with the input value when a new option is
+     * created, and `onChange` will **not** be called. Use this when you need more
+     * control over what happens when new options are created.
+     */
+    onCreateOption?: (inputValue: string) => void;
+}
+export default function ertHackForSelect(_: ReactSelectCreatableProps): void;

package/dist/types-ts4.0/extract-react-types/react-select-props.d.ts

@@ -0,0 +1,182 @@
+import { FocusEventHandler, KeyboardEventHandler, ReactNode } from 'react';
+interface FilterOptionOption<Option> {
+    readonly label: string;
+    readonly value: string;
+    readonly data: Option;
+}
+import { StylesConfig } from '../types';
+import { ActionMeta, AriaLiveMessages, FormatOptionLabelMeta, GetOptionLabel, GetOptionValue, GroupBase, InputActionMeta, MenuPlacement, MenuPosition, OnChangeValue, Options, OptionsOrGroups, PropsValue, SelectComponentsConfig, ThemeConfig } from 'react-select';
+interface NativeReactSelectProps<Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>> {
+    /** Aria label (for assistive tech) */
+    'aria-label'?: string;
+    /** HTML ID of an element that should be used as the label (for assistive tech) */
+    'aria-labelledby'?: string;
+    /** Used to set the priority with which screen reader should treat updates to live regions. The possible settings are?: off, polite (default) or assertive */
+    'aria-live'?: 'off' | 'polite' | 'assertive';
+    /** Customize the messages used by the aria-live component. See react-select v5.4.0 documentation for full details */
+    ariaLiveMessages?: AriaLiveMessages<Option, IsMulti, Group>;
+    /** Focus the control when it is mounted */
+    autoFocus?: boolean;
+    /** Remove the currently focused option when the user presses backspace when Select isClearable or isMulti */
+    backspaceRemovesValue?: boolean;
+    /** Remove focus from the input when the user selects an option (handy for dismissing the keyboard on touch devices) */
+    blurInputOnSelect?: boolean;
+    /** When the user reaches the top/bottom of the menu, prevent scroll on the scroll-parent  */
+    captureMenuScroll?: boolean;
+    /** Sets a className attribute on the outer component */
+    className?: string;
+    classNamePrefix?: string | null;
+    /** Close the select menu when the user selects an option */
+    closeMenuOnSelect?: boolean;
+    closeMenuOnScroll?: boolean | EventListener;
+    /**
+     * This complex object includes all the compositional components that are used
+     * in `react-select`. If you wish to overwrite a component, pass in an object
+     * with the appropriate namespace.
+     *
+     * If you only wish to restyle a component, we recommend using the `styles` prop
+     * instead. For a list of the components that can be passed in, and the shape
+     * that will be passed to them, see [the components docs](/components)
+     */
+    components?: SelectComponentsConfig<Option, IsMulti, Group>;
+    /** Whether the value of the select, e.g. SingleValue, should be displayed in the control. */
+    controlShouldRenderValue?: boolean;
+    /** Delimiter used to join multiple values into a single HTML Input value */
+    delimiter?: string;
+    /** Clear all values when the user presses escape AND the menu is closed */
+    escapeClearsValue?: boolean;
+    /** Custom method to filter whether an option should be displayed in the menu */
+    filterOption?: ((option?: FilterOptionOption<Option>, inputValue?: string) => boolean) | null;
+    /**
+     * Formats group labels in the menu as React components
+     *
+     * An example can be found in the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    formatGroupLabel?: (group?: Group) => ReactNode;
+    /** Formats option labels in the menu and control as React components */
+    formatOptionLabel?: (data?: Option, formatOptionLabelMeta?: FormatOptionLabelMeta<Option>) => ReactNode;
+    /**
+     * Resolves option data to a string to be displayed as the label by components
+     *
+     * Note?: Failure to resolve to a string type can interfere with filtering and
+     * screen reader support.
+     */
+    getOptionLabel?: GetOptionLabel<Option>;
+    /** Resolves option data to a string to compare options and specify value attributes */
+    getOptionValue?: GetOptionValue<Option>;
+    /** Hide the selected option from the menu */
+    hideSelectedOptions?: boolean;
+    /** The id to set on the SelectContainer component. */
+    id?: string;
+    /** The value of the search input */
+    inputValue?: string;
+    /** The id of the search input */
+    inputId?: string;
+    /** Define an id prefix for the select components e.g. {your-id}-value */
+    instanceId?: number | string;
+    /** Is the select value clearable */
+    isClearable?: boolean;
+    /** Is the select disabled */
+    isDisabled?: boolean;
+    /** Is the select in a state of loading (async) */
+    isLoading?: boolean;
+    /**
+     * Override the built-in logic to detect whether an option is disabled
+     *
+     * An example can be found in the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    isOptionDisabled?: (option?: Option, selectValue?: Options<Option>) => boolean;
+    /** Override the built-in logic to detect whether an option is selected */
+    isOptionSelected?: (option?: Option, selectValue?: Options<Option>) => boolean;
+    /** Support multiple selected options */
+    isMulti?: IsMulti;
+    /** Is the select direction right-to-left */
+    isRtl?: boolean;
+    /** Whether to enable search functionality */
+    isSearchable?: boolean;
+    /** Async?: Text to display when loading options */
+    loadingMessage?: (obj?: {
+        inputValue?: string;
+    }) => ReactNode;
+    /** Minimum height of the menu before flipping */
+    minMenuHeight?: number;
+    /** Maximum height of the menu before scrolling */
+    maxMenuHeight?: number;
+    /** Whether the menu is open */
+    menuIsOpen?: boolean;
+    /**
+     * Default placement of the menu in relation to the control. 'auto' will flip
+     * when there isn't enough space below the control.
+     */
+    menuPlacement?: MenuPlacement;
+    /** The CSS position value of the menu, when "fixed" extra layout management is required */
+    menuPosition?: MenuPosition;
+    /**
+     * Whether the menu should use a portal, and where it should attach
+     *
+     * An example can be found in the [Portaling](/advanced#portaling) documentation
+     */
+    menuPortalTarget?: HTMLElement | null;
+    /** Whether to block scroll events when the menu is open */
+    menuShouldBlockScroll?: boolean;
+    /** Whether the menu should be scrolled into view when it opens */
+    menuShouldScrollIntoView?: boolean;
+    /** Name of the HTML Input (optional - without this, no input will be rendered) */
+    name?: string;
+    /** Text to display when there are no options */
+    noOptionsMessage?: (obj?: {
+        inputValue?: string;
+    }) => ReactNode;
+    /** Handle blur events on the control */
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    /** Handle change events on the select */
+    onChange?: (newValue?: OnChangeValue<Option, IsMulti>, actionMeta?: ActionMeta<Option>) => void;
+    /** Handle focus events on the control */
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    /** Handle change events on the input */
+    onInputChange?: (newValue?: string, actionMeta?: InputActionMeta) => void;
+    /** Handle key down events on the select */
+    onKeyDown?: KeyboardEventHandler<HTMLDivElement>;
+    /** Handle the menu opening */
+    onMenuOpen?: () => void;
+    /** Handle the menu closing */
+    onMenuClose?: () => void;
+    /** Fired when the user scrolls to the top of the menu */
+    onMenuScrollToTop?: (event?: WheelEvent | TouchEvent) => void;
+    /** Fired when the user scrolls to the bottom of the menu */
+    onMenuScrollToBottom?: (event?: WheelEvent | TouchEvent) => void;
+    /** Allows control of whether the menu is opened when the Select is focused */
+    openMenuOnFocus?: boolean;
+    /** Allows control of whether the menu is opened when the Select is clicked */
+    openMenuOnClick?: boolean;
+    /** Array of options that populate the select menu */
+    options?: OptionsOrGroups<Option, Group>;
+    /** Number of options to jump in menu when page{up|down} keys are used */
+    pageSize?: number;
+    /** Placeholder for the select value */
+    placeholder?: ReactNode;
+    /** Status to relay to screen readers */
+    screenReaderStatus?: (obj?: {
+        count?: number;
+    }) => string;
+    /**
+     * Style modifier methods
+     *
+     * A basic example can be found at the bottom of the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    styles?: StylesConfig;
+    /** Theme modifier method */
+    theme?: ThemeConfig;
+    /** Sets the tabIndex attribute on the input */
+    tabIndex?: number;
+    /** Select the currently focused option when the user presses tab */
+    tabSelectsValue?: boolean;
+    /** The value of the select; reflected by the selected option */
+    value?: PropsValue<Option>;
+    /** Sets the form attribute on the input */
+    form?: string;
+    /** Marks the value-holding input as required for form validation */
+    required?: boolean;
+}
+export default function ertHackForSelect(_: NativeReactSelectProps): void;
+export {};

package/dist/types-ts4.0/index.d.ts

@@ -0,0 +1,19 @@
+export { components, createFilter, mergeStyles } from 'react-select';
+export { useAsync } from 'react-select/async';
+export { useCreatable } from 'react-select/creatable';
+export { CheckboxOption, RadioOption } from './components/input-options';
+export { default, SelectWithoutAnalytics } from './entry-points/select';
+export { default as AsyncSelect } from './entry-points/async-select';
+export { default as CreatableSelect } from './entry-points/creatable-select';
+export { default as AsyncCreatableSelect } from './entry-points/async-creatable-select';
+export { default as CheckboxSelect } from './CheckboxSelect';
+export { default as CountrySelect } from './CountrySelect';
+export { default as RadioSelect } from './RadioSelect';
+export { default as PopupSelect } from './PopupSelect';
+export type { PopupSelectProps, ModifierList } from './PopupSelect';
+export type { SelectInstance, ActionMeta, ControlProps, FormatOptionLabelMeta, InputActionMeta, InputProps, MenuProps, MenuListComponentProps, OptionProps, OptionsType, OptionType, SelectComponentsConfig, SelectProps, StylesConfig, ValueContainerProps, ValueType, GroupedOptionsType, GroupType, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, MultiValueProps, MultiValueRemoveProps, ReactSelectProps, SingleValueProps, NoticeProps, ValidationState, GroupProps, AsyncSelectProps, PlaceholderProps, } from './types';
+/**
+ * Types not exported on the public API, didn't find usages in sourcegraph
+ *
+ * CreatableSelectProps,
+ */

package/dist/types-ts4.0/styles.d.ts

@@ -0,0 +1,2 @@
+import { StylesConfig, ValidationState } from './types';
+export default function baseStyles<Option, IsMulti extends boolean>(validationState: ValidationState, isCompact: boolean | undefined, appearance: 'default' | 'subtle' | 'none'): StylesConfig<Option, IsMulti>;

package/dist/types-ts4.0/types.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="react" />
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { SelectInstance, Props as ReactSelectProps, FormatOptionLabelMeta, OnChangeValue as RSValueType, ActionMeta as RSActionMeta, GroupBase as GroupType, Options as RSOptionsType, SelectComponentsConfig as RSSelectComponentsConfig, StylesConfig as RSStylesConfig, InputActionMeta, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, NoticeProps, ControlProps as RSControlProps, GroupProps as RSGroupProps, InputProps, MenuProps as RSMenuProps, MenuListProps as RSMenuListComponentProps, MultiValueProps, OptionProps as ReactSelectOptionProps, PlaceholderProps as RSPlaceholderProps, SingleValueProps, ValueContainerProps as RSValueContainerProps, MultiValueRemoveProps } from 'react-select';
+import { AsyncProps } from 'react-select/async';
+import { CreatableProps } from 'react-select/creatable';
+export declare type ValidationState = 'default' | 'error' | 'success';
+export interface OptionType {
+    [key: string]: any;
+    label: string;
+    value: string | number;
+}
+export declare type OptionsType<Option = OptionType> = RSOptionsType<Option>;
+export interface OptionProps<Option = OptionType, IsMulti extends boolean = false> extends ReactSelectOptionProps<Option, IsMulti> {
+    [key: string]: any;
+    Icon?: React.ComponentType<{
+        label: string;
+        size?: 'small' | 'medium' | 'large' | 'xlarge';
+        onClick?: (e: MouseEvent) => void;
+        primaryColor?: string;
+        secondaryColor?: string;
+    }>;
+    isDisabled: boolean;
+    isFocused: boolean;
+    isSelected: boolean;
+}
+interface CustomSelectProps extends WithAnalyticsEventsProps {
+    /** This prop affects the height of the select control. Compact is gridSize() * 4, default is gridSize * 5  */
+    spacing?: 'compact' | 'default';
+    /** This prop affects the backgroundColor and border of the Select field. 'subtle' makes these transparent while 'none' removes them completely */
+    appearance?: 'default' | 'subtle' | 'none';
+    /** Prop for testing */
+    testId?: string;
+    /** This prop indicates if the component is in an error state */
+    isInvalid?: boolean;
+    /** @deprecated Use isInvalid instead. The state of validation if used in a form.  */
+    validationState?: ValidationState;
+}
+export interface SelectProps<Option, IsMulti extends boolean = false> extends ReactSelectProps<Option, IsMulti>, CustomSelectProps {
+}
+export interface AsyncSelectProps<Option, IsMulti extends boolean = false> extends AsyncProps<Option, IsMulti, GroupType<Option>>, CustomSelectProps {
+}
+export interface CreatableSelectProps<Option, IsMulti extends boolean = false> extends CreatableProps<Option, IsMulti, GroupType<Option>>, CustomSelectProps {
+}
+export declare type ActionMeta<Option = OptionType> = RSActionMeta<Option>;
+export declare type ControlProps<Option, IsMulti extends boolean = false> = RSControlProps<Option, IsMulti>;
+export declare type ValueType<Option, IsMulti extends boolean = false> = RSValueType<Option, IsMulti>;
+export declare type StylesConfig<Option = OptionType, IsMulti extends boolean = false> = RSStylesConfig<Option, IsMulti>;
+export declare type SelectComponentsConfig<Option, IsMulti extends boolean = false> = RSSelectComponentsConfig<Option, IsMulti, GroupType<Option>>;
+export declare type GroupProps<Option, IsMulti extends boolean = false> = RSGroupProps<Option, IsMulti>;
+export declare type MenuProps<Option, IsMulti extends boolean = false> = RSMenuProps<Option, IsMulti>;
+export declare type MenuListComponentProps<Option, IsMulti extends boolean = false> = RSMenuListComponentProps<Option, IsMulti>;
+export declare type PlaceholderProps<Option, IsMulti extends boolean = false> = RSPlaceholderProps<Option, IsMulti>;
+export declare type ValueContainerProps<Option, IsMulti extends boolean = false> = RSValueContainerProps<Option, IsMulti>;
+export declare type GroupedOptionsType<Option> = ReadonlyArray<GroupType<Option>>;
+export type { SelectInstance, FormatOptionLabelMeta, InputActionMeta, GroupType, InputProps, MultiValueProps, ReactSelectProps, SingleValueProps, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, NoticeProps, MultiValueRemoveProps, };
+declare module 'react-select/dist/declarations/src/Select' {
+    interface Props<Option, IsMulti extends boolean, Group extends GroupType<Option>> {
+        [key: string]: any;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/select",
-  "version": "16.1.9",
+  "version": "16.2.1",
   "description": "Select allows users to make a single selection or multiple selections from a list of options.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -30,12 +30,12 @@
     ".": "./src/index.tsx"
   },
   "dependencies": {
-    "@atlaskit/analytics-next": "^9.0.0",
-    "@atlaskit/icon": "^21.11.0",
-    "@atlaskit/spinner": "^15.4.0",
-    "@atlaskit/theme": "^12.4.0",
-    "@atlaskit/tokens": "^1.2.0",
-    "@atlaskit/visually-hidden": "^1.1.0",
+    "@atlaskit/analytics-next": "^9.1.0",
+    "@atlaskit/icon": "^21.12.0",
+    "@atlaskit/spinner": "^15.5.0",
+    "@atlaskit/theme": "^12.5.0",
+    "@atlaskit/tokens": "^1.3.0",
+    "@atlaskit/visually-hidden": "^1.2.0",
     "@babel/runtime": "^7.0.0",
     "@emotion/react": "^11.7.1",
     "@popperjs/core": "^2.9.1",
@@ -54,17 +54,17 @@
     "react-dom": "^16.8.0"
   },
   "devDependencies": {
-    "@atlaskit/button": "^16.6.0",
-    "@atlaskit/checkbox": "^12.4.0",
+    "@atlaskit/button": "^16.7.0",
+    "@atlaskit/checkbox": "^12.5.0",
     "@atlaskit/docs": "*",
-    "@atlaskit/drawer": "^7.4.0",
-    "@atlaskit/form": "^8.10.0",
-    "@atlaskit/logo": "^13.13.0",
-    "@atlaskit/modal-dialog": "^12.4.0",
-    "@atlaskit/radio": "^5.4.0",
-    "@atlaskit/section-message": "^6.3.0",
+    "@atlaskit/drawer": "^7.5.0",
+    "@atlaskit/form": "^8.11.0",
+    "@atlaskit/logo": "^13.14.0",
+    "@atlaskit/modal-dialog": "^12.5.0",
+    "@atlaskit/radio": "^5.5.0",
+    "@atlaskit/section-message": "^6.4.0",
     "@atlaskit/ssr": "*",
-    "@atlaskit/tooltip": "^17.7.0",
+    "@atlaskit/tooltip": "^17.8.0",
     "@atlaskit/visual-regression": "*",
     "@atlaskit/webdriver-runner": "*",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
@@ -72,7 +72,6 @@
     "@testing-library/react": "^12.1.5",
     "@testing-library/user-event": "^14.4.3",
     "ast-types": "^0.13.3",
-    "enzyme": "^3.10.0",
     "jscodeshift": "^0.13.0",
     "react-dom": "^16.8.0",
     "react-value": "^0.2.0",

package/report.api.md

@@ -323,7 +323,7 @@ export type ControlProps<
 > = ControlProps_2<Option, IsMulti>;
 
 // @public (undocumented)
-type Country = typeof groupedCountries[number]['options'][number];
+type Country = (typeof groupedCountries)[number]['options'][number];
 
 // @public (undocumented)
 interface Country_2 {