@atlaskit/react-select 0.0.2

package/dist/types-ts4.5/state-manager.d.ts

@@ -0,0 +1,17 @@
+import { type ReactElement, type RefAttributes } from 'react';
+import Select from './select';
+import { type GroupBase } from './types';
+import { type StateManagerProps } from './use-state-manager';
+export type { StateManagerProps };
+/**
+ * __StateManagedSelect__
+ *
+ * A state managed select {description}.
+ *
+ * - [Examples](https://atlassian.design/components/{packageName}/examples)
+ * - [Code](https://atlassian.design/components/{packageName}/code)
+ * - [Usage](https://atlassian.design/components/{packageName}/usage)
+ */
+type StateManagedSelect = <Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>>(props: StateManagerProps<Option, IsMulti, Group> & RefAttributes<Select<Option, IsMulti, Group>>) => ReactElement;
+declare const StateManagedSelect: StateManagedSelect;
+export default StateManagedSelect;

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

@@ -0,0 +1,68 @@
+import { type ContainerProps, type IndicatorsContainerProps, type ValueContainerProps } from './components/containers';
+import { type ControlProps } from './components/control';
+import { type GroupHeadingProps, type GroupProps } from './components/group';
+import { type ClearIndicatorProps, type DropdownIndicatorProps, type IndicatorSeparatorProps, type LoadingIndicatorProps } from './components/indicators';
+import { type InputProps } from './components/input';
+import { type MenuListProps, type MenuProps, type NoticeProps, type PortalStyleArgs } from './components/menu';
+import { type MultiValueProps } from './components/multi-value';
+import { type OptionProps } from './components/option';
+import { type PlaceholderProps } from './components/placeholder';
+import { type SingleValueProps } from './components/single-value';
+import { type CSSObjectWithLabel, type GroupBase } from './types';
+export interface StylesProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    clearIndicator: ClearIndicatorProps<Option, IsMulti, Group>;
+    container: ContainerProps<Option, IsMulti, Group>;
+    control: ControlProps<Option, IsMulti, Group>;
+    dropdownIndicator: DropdownIndicatorProps<Option, IsMulti, Group>;
+    group: GroupProps<Option, IsMulti, Group>;
+    groupHeading: GroupHeadingProps<Option, IsMulti, Group>;
+    indicatorsContainer: IndicatorsContainerProps<Option, IsMulti, Group>;
+    indicatorSeparator: IndicatorSeparatorProps<Option, IsMulti, Group>;
+    input: InputProps<Option, IsMulti, Group>;
+    loadingIndicator: LoadingIndicatorProps<Option, IsMulti, Group>;
+    loadingMessage: NoticeProps<Option, IsMulti, Group>;
+    menu: MenuProps<Option, IsMulti, Group>;
+    menuList: MenuListProps<Option, IsMulti, Group>;
+    menuPortal: PortalStyleArgs;
+    multiValue: MultiValueProps<Option, IsMulti, Group>;
+    multiValueLabel: MultiValueProps<Option, IsMulti, Group>;
+    multiValueRemove: MultiValueProps<Option, IsMulti, Group>;
+    noOptionsMessage: NoticeProps<Option, IsMulti, Group>;
+    option: OptionProps<Option, IsMulti, Group>;
+    placeholder: PlaceholderProps<Option, IsMulti, Group>;
+    singleValue: SingleValueProps<Option, IsMulti, Group>;
+    valueContainer: ValueContainerProps<Option, IsMulti, Group>;
+}
+export declare const defaultStyles: {
+    [K in keyof StylesProps<any, any, any>]: (props: StylesProps<unknown, boolean, GroupBase<unknown>>[K], unstyled: boolean) => CSSObjectWithLabel;
+};
+export type StylesConfig<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = {
+    [K in keyof StylesProps<Option, IsMulti, Group>]?: (base: CSSObjectWithLabel, props: StylesProps<Option, IsMulti, Group>[K]) => CSSObjectWithLabel;
+};
+export type ClassNamesConfig<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = {
+    [K in keyof StylesProps<Option, IsMulti, Group>]?: (props: StylesProps<Option, IsMulti, Group>[K]) => string;
+};
+export declare function mergeStyles<Option, IsMulti extends boolean, Group extends GroupBase<Option>>(source: StylesConfig<Option, IsMulti, Group>, target?: StylesConfig<Option, IsMulti, Group>): {
+    clearIndicator?: ((base: CSSObjectWithLabel, props: ClearIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    container?: ((base: CSSObjectWithLabel, props: ContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    control?: ((base: CSSObjectWithLabel, props: ControlProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    dropdownIndicator?: ((base: CSSObjectWithLabel, props: DropdownIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    group?: ((base: CSSObjectWithLabel, props: GroupProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    groupHeading?: ((base: CSSObjectWithLabel, props: GroupHeadingProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    indicatorsContainer?: ((base: CSSObjectWithLabel, props: IndicatorsContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    indicatorSeparator?: ((base: CSSObjectWithLabel, props: IndicatorSeparatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    input?: ((base: CSSObjectWithLabel, props: InputProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    loadingIndicator?: ((base: CSSObjectWithLabel, props: LoadingIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    loadingMessage?: ((base: CSSObjectWithLabel, props: NoticeProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menu?: ((base: CSSObjectWithLabel, props: MenuProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menuList?: ((base: CSSObjectWithLabel, props: MenuListProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menuPortal?: ((base: CSSObjectWithLabel, props: PortalStyleArgs) => CSSObjectWithLabel) | undefined;
+    multiValue?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    multiValueLabel?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    multiValueRemove?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    noOptionsMessage?: ((base: CSSObjectWithLabel, props: NoticeProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    option?: ((base: CSSObjectWithLabel, props: OptionProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    placeholder?: ((base: CSSObjectWithLabel, props: PlaceholderProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    singleValue?: ((base: CSSObjectWithLabel, props: SingleValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    valueContainer?: ((base: CSSObjectWithLabel, props: ValueContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+};

package/dist/types-ts4.5/theme.d.ts

@@ -0,0 +1,27 @@
+import { type Theme } from './types';
+export declare const colors: {
+    primary: string;
+    primary75: string;
+    primary50: string;
+    primary25: string;
+    danger: string;
+    dangerLight: string;
+    neutral0: string;
+    neutral5: string;
+    neutral10: string;
+    neutral20: string;
+    neutral30: string;
+    neutral40: string;
+    neutral50: string;
+    neutral60: string;
+    neutral70: string;
+    neutral80: string;
+    neutral90: string;
+};
+export declare const spacing: {
+    baseUnit: number;
+    controlHeight: number;
+    menuGutter: number;
+};
+export declare const defaultTheme: Theme;
+export type ThemeConfig = Theme | ((theme: Theme) => Theme);

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

@@ -0,0 +1,134 @@
+import { type CSSObject } from '@emotion/react';
+import { type SelectProps } from './select';
+import { type StylesProps } from './styles';
+export interface GroupBase<Option> {
+    readonly options: readonly Option[];
+    readonly label?: string;
+}
+export interface Option {
+    label: string;
+    value: string;
+}
+export type OptionsOrGroups<Option, Group extends GroupBase<Option>> = readonly (Option | Group)[];
+export type Options<Option> = readonly Option[];
+export type SingleValue<Option> = Option | null;
+export type MultiValue<Option> = readonly Option[];
+export type PropsValue<Option> = MultiValue<Option> | SingleValue<Option>;
+export type OnChangeValue<Option, IsMulti extends boolean> = IsMulti extends true ? MultiValue<Option> : SingleValue<Option>;
+export interface Colors {
+    primary: string;
+    primary75: string;
+    primary50: string;
+    primary25: string;
+    danger: string;
+    dangerLight: string;
+    neutral0: string;
+    neutral5: string;
+    neutral10: string;
+    neutral20: string;
+    neutral30: string;
+    neutral40: string;
+    neutral50: string;
+    neutral60: string;
+    neutral70: string;
+    neutral80: string;
+    neutral90: string;
+}
+export interface ThemeSpacing {
+    baseUnit: number;
+    controlHeight: number;
+    menuGutter: number;
+}
+export interface Theme {
+    borderRadius: number;
+    colors: Colors;
+    spacing: ThemeSpacing;
+}
+export type ClassNamesState = {
+    [key: string]: boolean;
+};
+export type CX = (state: ClassNamesState, ...classNames: (string | undefined)[]) => string;
+export type GetStyles<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = <Key extends keyof StylesProps<Option, IsMulti, Group>>(propertyName: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => CSSObjectWithLabel;
+export interface CommonProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    clearValue: () => void;
+    cx: CX;
+    /**
+     * Get the styles of a particular part of the select. Pass in the name of the
+     * property as the first argument, and the current props as the second argument.
+     * See the `styles` object for the properties available.
+     */
+    getStyles: GetStyles<Option, IsMulti, Group>;
+    getClassNames: <Key extends keyof StylesProps<Option, IsMulti, Group>>(propertyName: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => string | undefined;
+    getValue: () => Options<Option>;
+    hasValue: boolean;
+    isMulti: boolean;
+    isRtl: boolean;
+    options: OptionsOrGroups<Option, Group>;
+    selectOption: (newValue: Option) => void;
+    selectProps: SelectProps<Option, IsMulti, Group>;
+    setValue: (newValue: OnChangeValue<Option, IsMulti>, action: SetValueAction, option?: Option) => void;
+    theme: Theme;
+}
+export interface CommonPropsAndClassName<Option, IsMulti extends boolean, Group extends GroupBase<Option>> extends CommonProps<Option, IsMulti, Group> {
+    className?: string | undefined;
+}
+export interface ActionMetaBase<Option> {
+    option?: Option | undefined;
+    removedValue?: Option;
+    removedValues?: Options<Option>;
+    name?: string;
+}
+export interface SelectOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'select-option';
+    option: Option | undefined;
+    name?: string;
+}
+export interface DeselectOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'deselect-option';
+    option: Option | undefined;
+    name?: string;
+}
+export interface RemoveValueActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'remove-value';
+    removedValue: Option;
+    name?: string;
+}
+export interface PopValueActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'pop-value';
+    removedValue: Option;
+    name?: string;
+}
+export interface ClearActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'clear';
+    removedValues: Options<Option>;
+    name?: string;
+}
+export interface CreateOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'create-option';
+    name?: string;
+    option: Option;
+}
+export interface InitialInputFocusedActionMeta<Option, IsMulti extends boolean> extends ActionMetaBase<Option> {
+    action: 'initial-input-focus';
+    value: OnChangeValue<Option, IsMulti>;
+    options?: Options<Option>;
+}
+export type ActionMeta<Option> = SelectOptionActionMeta<Option> | DeselectOptionActionMeta<Option> | RemoveValueActionMeta<Option> | PopValueActionMeta<Option> | ClearActionMeta<Option> | CreateOptionActionMeta<Option>;
+export type SetValueAction = 'select-option' | 'deselect-option';
+export type InputAction = 'set-value' | 'input-change' | 'input-blur' | 'menu-close';
+export interface InputActionMeta {
+    action: InputAction;
+    /**
+     * The previous value of the search input.
+     */
+    prevInputValue: string;
+}
+export type MenuPlacement = 'auto' | 'bottom' | 'top';
+export type CoercedMenuPlacement = 'bottom' | 'top';
+export type MenuPosition = 'absolute' | 'fixed';
+export type FocusDirection = 'up' | 'down' | 'pageup' | 'pagedown' | 'first' | 'last';
+export type GetOptionLabel<Option> = (option: Option) => string;
+export type GetOptionValue<Option> = (option: Option) => string;
+export type CSSObjectWithLabel = CSSObject & {
+    label?: string;
+};

package/dist/types-ts4.5/use-async.d.ts

@@ -0,0 +1,31 @@
+import { type GroupBase, type OptionsOrGroups } from './types';
+import { type StateManagerProps } from './use-state-manager';
+type AsyncManagedPropKeys = 'options' | 'isLoading' | 'onInputChange' | 'filterOption';
+export interface AsyncAdditionalProps<Option, Group extends 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 type AsyncProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = StateManagerProps<Option, IsMulti, Group> & AsyncAdditionalProps<Option, Group>;
+/**
+ * {description}.
+ */
+export default function useAsync<Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>({ defaultOptions: propsDefaultOptions, cacheOptions, loadOptions: propsLoadOptions, options: propsOptions, isLoading: propsIsLoading, onInputChange: propsOnInputChange, filterOption, ...restSelectProps }: AsyncProps<Option, IsMulti, Group> & AdditionalProps): StateManagerProps<Option, IsMulti, Group> & Omit<AdditionalProps, keyof AsyncAdditionalProps<Option, Group> | AsyncManagedPropKeys>;
+export {};

package/dist/types-ts4.5/use-creatable.d.ts

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import { type PublicBaseSelectProps } from './select';
+import { type GetOptionLabel, type GetOptionValue, type GroupBase, type Options, type OptionsOrGroups } from './types';
+export interface Accessors<Option> {
+    getOptionValue: GetOptionValue<Option>;
+    getOptionLabel: GetOptionLabel<Option>;
+}
+export interface CreatableAdditionalProps<Option, Group extends 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;
+}
+type BaseCreatableProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = PublicBaseSelectProps<Option, IsMulti, Group> & CreatableAdditionalProps<Option, Group>;
+/**
+ * {description}.
+ */
+export default function useCreatable<Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ allowCreateWhileLoading, createOptionPosition, formatCreateLabel, isValidNewOption, getNewOptionData, onCreateOption, options: propsOptions, onChange: propsOnChange, ...restSelectProps }: BaseCreatableProps<Option, IsMulti, Group>): PublicBaseSelectProps<Option, IsMulti, Group>;
+export {};

package/dist/types-ts4.5/use-state-manager.d.ts

@@ -0,0 +1,15 @@
+import { type PublicBaseSelectProps } from './select';
+import { type GroupBase, type PropsValue } from './types';
+type StateManagedPropKeys = 'inputValue' | 'menuIsOpen' | 'onChange' | 'onInputChange' | 'onMenuClose' | 'onMenuOpen' | 'value';
+type SelectPropsWithOptionalStateManagedProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = Omit<PublicBaseSelectProps<Option, IsMulti, Group>, StateManagedPropKeys> & Partial<PublicBaseSelectProps<Option, IsMulti, Group>>;
+export interface StateManagerAdditionalProps<Option> {
+    defaultInputValue?: string;
+    defaultMenuIsOpen?: boolean;
+    defaultValue?: PropsValue<Option>;
+}
+export type StateManagerProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = SelectPropsWithOptionalStateManagedProps<Option, IsMulti, Group> & StateManagerAdditionalProps<Option>;
+/**
+ * {description}.
+ */
+export default function useStateManager<Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>({ defaultInputValue, defaultMenuIsOpen, defaultValue, inputValue: propsInputValue, menuIsOpen: propsMenuIsOpen, onChange: propsOnChange, onInputChange: propsOnInputChange, onMenuClose: propsOnMenuClose, onMenuOpen: propsOnMenuOpen, value: propsValue, ...restSelectProps }: StateManagerProps<Option, IsMulti, Group> & AdditionalProps): PublicBaseSelectProps<Option, IsMulti, Group> & Omit<AdditionalProps, keyof StateManagerAdditionalProps<Option> | StateManagedPropKeys>;
+export {};

package/dist/types-ts4.5/utils.d.ts

@@ -0,0 +1,44 @@
+import type { StylesProps } from './styles';
+import type { ClassNamesState, CommonPropsAndClassName, GroupBase, InputActionMeta, MultiValue, OnChangeValue, Option, Options, PropsValue, SingleValue } from './types';
+export declare const noop: () => void;
+export declare const emptyString: () => string;
+export declare function classNames(prefix?: string | null, state?: ClassNamesState, ...classNameList: string[]): string;
+export declare const cleanValue: (value: PropsValue<Option>) => Options<Option>;
+export declare const cleanCommonProps: <Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>(props: Partial<CommonPropsAndClassName<Option, IsMulti, Group>> & AdditionalProps) => Omit<AdditionalProps, keyof CommonPropsAndClassName<Option, IsMulti, Group>>;
+export declare const getStyleProps: <Option, IsMulti extends boolean, Group extends GroupBase<Option>, Key extends keyof StylesProps<Option, IsMulti, Group>>(props: Pick<CommonPropsAndClassName<Option, IsMulti, Group>, 'cx' | 'getStyles' | 'getClassNames' | 'className'> & StylesProps<Option, IsMulti, Group>[Key], name: Key, classNamesState?: ClassNamesState) => {
+    css: import("./types").CSSObjectWithLabel;
+    className: string;
+};
+export declare function handleInputChange(inputValue: string, actionMeta: InputActionMeta, onInputChange?: (newValue: string, actionMeta: InputActionMeta) => string | void): string;
+export declare function isDocumentElement(el: HTMLElement | typeof window): el is typeof window;
+export declare function normalizedHeight(el: HTMLElement | typeof window): number;
+export declare function getScrollTop(el: HTMLElement | typeof window): number;
+export declare function scrollTo(el: HTMLElement | typeof window, top: number): void;
+export declare function getScrollParent(element: HTMLElement): HTMLElement;
+export declare function animatedScrollTo(element: HTMLElement | typeof window, to: number, duration?: number, callback?: (element: HTMLElement | typeof window) => void): void;
+export declare function scrollIntoView(menuEl: HTMLElement, focusedEl: HTMLElement): void;
+export declare function getBoundingClientObj(element: HTMLElement): {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+};
+export interface Rect {
+    left: number;
+    right: number;
+    bottom: number;
+    height: number;
+    width: number;
+}
+export declare function toKey(str: string): string;
+export declare function isTouchCapable(): boolean;
+export declare function isMobileDevice(): boolean;
+export declare const supportsPassiveEvents: boolean;
+export declare function notNullish<T>(item: T | null | undefined): item is T;
+export declare function isArray<T>(arg: unknown): arg is readonly T[];
+export declare function valueTernary<Option, IsMulti extends boolean>(isMulti: IsMulti | undefined, multiValue: MultiValue<Option>, singleValue: SingleValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare function singleValueAsValue<Option, IsMulti extends boolean>(singleValue: SingleValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare function multiValueAsValue<Option, IsMulti extends boolean>(multiValue: MultiValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare const removeProps: <Props extends object, K extends string[]>(propsObj: Props, ...properties: K) => Omit<Props, K[number]>;

package/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "@atlaskit/react-select",
+	"version": "0.0.2",
+	"description": "A forked version of react-select to only be used in atlaskit/select",
+	"author": "Atlassian Pty Ltd",
+	"license": "Apache-2.0",
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org/"
+	},
+	"atlassian": {
+		"team": "Design System Team",
+		"inPublicMirror": false,
+		"releaseModel": "continuous"
+	},
+	"repository": "https://bitbucket.org/atlassian/atlassian-frontend-mirror",
+	"main": "dist/cjs/index.js",
+	"module": "dist/esm/index.js",
+	"module:es2019": "dist/es2019/index.js",
+	"types": "dist/types/index.d.ts",
+	"sideEffects": false,
+	"atlaskit:src": "src/index.tsx",
+	"af:exports": {
+		".": "./src/index.tsx",
+		"./base": "./src/select.tsx",
+		"./async": "./src/async.tsx",
+		"./creatable": "./src/creatable.tsx"
+	},
+	"dependencies": {
+		"@atlaskit/ds-lib": "^2.5.0",
+		"@babel/runtime": "^7.0.0",
+		"@emotion/cache": "^11.10.0",
+		"@emotion/react": "^11.7.1",
+		"@floating-ui/dom": "^1.0.1",
+		"memoize-one": "^6.0.0",
+		"react-dom": "^16.8.0",
+		"use-isomorphic-layout-effect": "^1.1.2"
+	},
+	"peerDependencies": {
+		"react": "^16.8.0"
+	},
+	"devDependencies": {
+		"@af/integration-testing": "*",
+		"@af/visual-regression": "*",
+		"@atlaskit/ssr": "*",
+		"@atlaskit/visual-regression": "*",
+		"@testing-library/react": "^12.1.5",
+		"@testing-library/user-event": "^14.4.3",
+		"jest-in-case": "^1.0.2",
+		"typescript": "~5.4.2",
+		"user-agent-data-types": "^0.4.2",
+		"wait-for-expect": "^1.2.0"
+	},
+	"techstack": {
+		"@atlassian/frontend": {
+			"import-structure": [
+				"atlassian-conventions"
+			],
+			"circular-dependencies": "file-and-folder-level"
+		},
+		"@repo/internal": {
+			"design-system": "v1",
+			"dom-events": "use-bind-event-listener",
+			"analytics": "analytics-next",
+			"ui-components": [
+				"lite-mode"
+			],
+			"deprecation": "no-deprecated-imports",
+			"styling": [
+				"static",
+				"emotion"
+			]
+		}
+	},
+	"homepage": "https://atlassian.design/components",
+	"typesVersions": {
+		">=4.5 <4.9": {
+			"*": [
+				"dist/types-ts4.5/*",
+				"dist/types-ts4.5/index.d.ts"
+			]
+		}
+	}
+}