@via-profit/ui-kit 0.1.0-rc.7 → 0.1.0-rc.70

package/Autocomplete/AutocompleteContainer.d.ts

@@ -0,0 +1,85 @@
+import React from 'react';
+import { Value, OnRequestClose, GetOptionSelected } from '../Menu';
+import { AutocompleteTextFieldProps } from './AutocompleteTextField';
+import type { AnchorPos } from '../Popper';
+import type { MenuItemCommonProps } from '../Menu/MenuItem';
+export interface AutocompleteProps<T, Multiple extends boolean | undefined = undefined> extends Omit<AutocompleteTextFieldProps, 'value' | 'onChange' | 'children' | 'overrides'> {
+    readonly items: readonly T[];
+    readonly value: Value<T, Multiple>;
+    /**
+     * Array of items. If will be array of objects or array of strings
+     */
+    readonly multiple?: Multiple;
+    /**
+     * Menu open state\
+     * If `true` then menu is open, otherwise - closed
+     */
+    readonly isOpen?: boolean;
+    /**
+     * Loading indicator visiblility\
+     * If `true` then visible, otherwise - hidden
+     */
+    /**
+     * Anchor position\
+     * \
+     * Default: `auto-start-end`
+     */
+    readonly anchorPos?: AnchorPos;
+    /**
+     * Text field loading state\
+     * If `true` then text field has been contained the loading indicator, otherwise - nop
+     */
+    readonly isLoading?: boolean;
+    /**
+     * Should the autocomplete element be cleared when blur and if no element is selected
+     */
+    readonly clearIfNotSelected?: boolean;
+    /**
+     * Show clear button if clearable is true
+     */
+    readonly clearable?: boolean;
+    /**
+     * should the Menu component opening when input focused\
+     * **Default:** `true`
+     */
+    readonly openOnFocus?: boolean;
+    /**
+     * items render function
+     */
+    readonly children: Children<T>;
+    readonly filterItems?: FilterItems<T>;
+    readonly onChange?: OnChange<T, Multiple>;
+    readonly selectedItemToString: ItemToString<T, Multiple>;
+    readonly getOptionSelected?: GetOptionSelected<T>;
+    readonly onRequestClose?: OnRequestClose;
+    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement>;
+    readonly onRequestOpen?: (event: React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement> | React.FocusEvent<HTMLInputElement, Element> | React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Overridable components map
+     */
+    readonly overrides?: AutocompleteOverrides;
+}
+export interface AutocompleteOverrides {
+    /**
+     * Element wrapper
+     */
+    readonly TextField?: React.ForwardRefExoticComponent<AutocompleteTextFieldProps & React.RefAttributes<HTMLDivElement>>;
+}
+export type Children<T> = (data: {
+    item: T;
+    index: number;
+    inputValue: string;
+}, itemProps: MenuItemCommonProps) => React.ReactNode;
+export type ItemToString<T, Multiple extends boolean | undefined = undefined> = (item: Multiple extends undefined ? T : readonly T[]) => string;
+export type OnChange<T, Multiple extends boolean | undefined = undefined> = (item: Value<T, Multiple>) => void;
+export type FilterItems<T> = (items: readonly T[], data: {
+    readonly query: string;
+    readonly inputValue: string;
+}) => readonly T[];
+export type AutocompleteRef = {
+    clear: () => void;
+};
+declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: AutocompleteProps<T, Multiple> & {
+    ref?: React.Ref<AutocompleteRef> | undefined;
+}) => JSX.Element;
+export default _default;

package/Autocomplete/AutocompleteContainer.js

@@ -0,0 +1,315 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Menu_1 = __importDefault(require("../Menu"));
+const AutocompleteTextField_1 = __importDefault(require("./AutocompleteTextField"));
+const Button_1 = __importDefault(require("../Button"));
+const Spinner_1 = __importDefault(require("../LoadingIndicator/Spinner"));
+const context_1 = __importStar(require("./context"));
+const IconClear_1 = __importDefault(require("./IconClear"));
+const ClickOutside_1 = require("../ClickOutside");
+const Autocomplete = react_1.default.forwardRef((props, ref) => {
+    const { items, value, multiple, isOpen = false, isLoading = false, clearIfNotSelected = true, anchorPos = 'auto-start-end', openOnFocus = true, requiredAsterisk, startIcon, fullWidth, placeholder, label, error, errorText, inputRef, filterItems, children, onChange, selectedItemToString, clearable = true, onInputChange, getOptionSelected, onRequestOpen = () => undefined, onRequestClose = () => undefined, overrides } = props, nativeInputProps = __rest(props, ["items", "value", "multiple", "isOpen", "isLoading", "clearIfNotSelected", "anchorPos", "openOnFocus", "requiredAsterisk", "startIcon", "fullWidth", "placeholder", "label", "error", "errorText", "inputRef", "filterItems", "children", "onChange", "selectedItemToString", "clearable", "onInputChange", "getOptionSelected", "onRequestOpen", "onRequestClose", "overrides"]);
+    const menuRef = react_1.default.useRef(null);
+    const fieldInputRef = react_1.default.useRef(null);
+    const isFocusedRef = react_1.default.useRef(false);
+    const itemsRef = react_1.default.useRef(items);
+    const { state, dispatch } = (0, context_1.default)();
+    const { currentOpen, filteredItems, inputValue, currentValue, anchorElement, currentLoading } = state;
+    const overridesMap = react_1.default.useMemo(() => ({
+        TextField: (overrides === null || overrides === void 0 ? void 0 : overrides.TextField) || AutocompleteTextField_1.default,
+    }), [overrides]);
+    const clear = react_1.default.useCallback(() => {
+        if (onChange) {
+            onChange((multiple ? [] : null));
+        }
+        dispatch((0, context_1.actionSetPartial)({
+            filteredItems: items,
+            currentValue: null,
+            inputValue: '',
+        }));
+        setTimeout(() => {
+            var _a;
+            (_a = fieldInputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }, 15);
+    }, [dispatch, onChange, items, multiple]);
+    /**
+     * API
+     */
+    react_1.default.useImperativeHandle(ref, () => ({
+        clear: () => clear(),
+    }), [clear]);
+    const inputKeydownEvent = react_1.default.useCallback((event) => {
+        var _a, _b, _c, _d, _e;
+        if (!isFocusedRef.current) {
+            return;
+        }
+        switch (event.code) {
+            case 'Enter':
+            case 'NumpadEnter':
+                event.preventDefault();
+                (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.selectHightlightedItem();
+                break;
+            case 'ArrowUp':
+                {
+                    event.preventDefault();
+                    (_b = menuRef.current) === null || _b === void 0 ? void 0 : _b.hightlightPrevItem();
+                }
+                break;
+            case 'ArrowDown':
+                {
+                    event.preventDefault();
+                    if (!currentOpen) {
+                        onRequestOpen(event);
+                    }
+                    if (currentOpen) {
+                        (_c = menuRef.current) === null || _c === void 0 ? void 0 : _c.hightlightNextItem();
+                    }
+                }
+                break;
+            case 'Home':
+                {
+                    event.preventDefault();
+                    (_d = menuRef.current) === null || _d === void 0 ? void 0 : _d.hightlightFirstItem();
+                }
+                break;
+            case 'End':
+                {
+                    event.preventDefault();
+                    (_e = menuRef.current) === null || _e === void 0 ? void 0 : _e.hightlightLastItem();
+                }
+                break;
+            // case 'PageUp':
+            // case 'PageDown':
+            //   event.preventDefault();
+            //   break;
+            case 'Escape':
+            case 'Tab':
+                if (currentOpen) {
+                    onRequestClose(event);
+                }
+                break;
+            default:
+                // do nothing
+                break;
+        }
+    }, [currentOpen, onRequestClose, onRequestOpen]);
+    const applyFilterForItems = react_1.default.useCallback((inputValue, itemList) => {
+        const query = inputValue.toLowerCase().trim();
+        // Apply filter
+        const newItems = typeof filterItems !== 'function' || query.length === 0
+            ? itemList
+            : filterItems(itemList, { query, inputValue });
+        return newItems;
+    }, [filterItems]);
+    /**
+     * Only affected value change action
+     */
+    react_1.default.useEffect(() => {
+        if (value === currentValue) {
+            return;
+        }
+        dispatch((0, context_1.actionSetPartial)({
+            currentValue: value,
+            inputValue: value === null
+                ? ''
+                : selectedItemToString(value),
+        }));
+    }, [value, multiple, currentValue, inputValue, dispatch, selectedItemToString]);
+    react_1.default.useEffect(() => {
+        if (currentOpen && menuRef.current) {
+            menuRef.current.scrollToFirstSelected();
+        }
+    }, [currentOpen]);
+    react_1.default.useEffect(() => {
+        var _a;
+        if (filteredItems.length === 1) {
+            (_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.highlightIndex(0);
+        }
+    }, [filteredItems]);
+    react_1.default.useEffect(() => {
+        if (currentOpen !== isOpen || currentLoading !== isLoading) {
+            // console.debug('Use effect 1', { currentOpen: isOpen, currentLoading: isLoading });
+            dispatch((0, context_1.actionSetPartial)({ currentOpen: isOpen, currentLoading: isLoading }));
+        }
+    }, [isOpen, isLoading, dispatch, currentOpen, currentLoading]);
+    react_1.default.useEffect(() => {
+        if (JSON.stringify(items) !== JSON.stringify(itemsRef.current)) {
+            // console.debug('Use effect 2', { filteredItems: applyFilterForItems(inputValue, items) });
+            itemsRef.current = items;
+            dispatch((0, context_1.actionSetPartial)({ filteredItems: applyFilterForItems(inputValue, items) }));
+        }
+    }, [items, inputValue, applyFilterForItems, dispatch]);
+    react_1.default.useEffect(() => {
+        const mouseDownEvent = (event) => {
+            var _a;
+            let parentElem = event.target;
+            let needToClose = true;
+            while (parentElem && 'parentNode' in parentElem) {
+                if (parentElem === anchorElement || parentElem === ((_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.getListElement())) {
+                    needToClose = false;
+                    break;
+                }
+                parentElem = parentElem.parentNode;
+            }
+            if (needToClose) {
+                onRequestClose(event);
+            }
+        };
+        window.document.addEventListener(ClickOutside_1.mouseEventMap.onMouseDown, mouseDownEvent);
+        return () => {
+            window.document.removeEventListener(ClickOutside_1.mouseEventMap.onMouseDown, mouseDownEvent);
+        };
+    }, [onRequestClose, anchorElement]);
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.useMemo(() => (react_1.default.createElement(overridesMap.TextField, Object.assign({ placeholder: placeholder, label: label, error: error, requiredAsterisk: requiredAsterisk, errorText: errorText, fullWidth: fullWidth, startIcon: startIcon, isLoading: currentLoading, endIcon: clearable ? (react_1.default.createElement(Button_1.default, { iconOnly: true, type: "button", onClick: () => (currentLoading ? 'undefined' : clear()) }, currentLoading ? react_1.default.createElement(Spinner_1.default, null) : react_1.default.createElement(IconClear_1.default, null))) : undefined }, nativeInputProps, { onKeyDown: event => {
+                inputKeydownEvent(event);
+                if (typeof nativeInputProps.onKeyDown === 'function') {
+                    nativeInputProps.onKeyDown(event);
+                }
+            }, ref: el => {
+                if (anchorElement !== el) {
+                    dispatch((0, context_1.actionSetPartial)({ anchorElement: el }));
+                }
+            }, inputRef: el => {
+                fieldInputRef.current = el;
+                if (typeof inputRef === 'function') {
+                    inputRef(el);
+                }
+                if (inputRef && typeof inputRef === 'object') {
+                    inputRef.current = el;
+                }
+            }, value: inputValue, onBlur: event => {
+                isFocusedRef.current = false;
+                if (typeof nativeInputProps.onBlur === 'function') {
+                    nativeInputProps.onBlur(event);
+                }
+            }, onFocus: event => {
+                isFocusedRef.current = true;
+                if (openOnFocus) {
+                    onRequestOpen(event);
+                }
+                if (!openOnFocus && !currentOpen && inputValue !== '') {
+                    onRequestOpen(event);
+                }
+                if (typeof nativeInputProps.onFocus === 'function') {
+                    nativeInputProps.onFocus(event);
+                }
+            }, onClick: event => {
+                // if (isFocusedRef.current) {
+                //   onRequestOpen(event);
+                // }
+                if (typeof nativeInputProps.onClick === 'function') {
+                    nativeInputProps.onClick(event);
+                }
+            }, onChange: event => {
+                if (typeof onInputChange === 'function') {
+                    onInputChange(event);
+                }
+                // If openOnFocus is false, but value is not empty
+                // we should open menu list if is not opened
+                if (!openOnFocus && isFocusedRef.current && !currentOpen) {
+                    onRequestOpen(event);
+                }
+                // console.debug('set filteredItems');
+                dispatch((0, context_1.actionSetPartial)({
+                    filteredItems: applyFilterForItems(event.currentTarget.value, items),
+                    inputValue: event.currentTarget.value,
+                }));
+            } }))), [
+            overridesMap,
+            placeholder,
+            label,
+            error,
+            requiredAsterisk,
+            errorText,
+            fullWidth,
+            startIcon,
+            currentLoading,
+            clearable,
+            nativeInputProps,
+            inputValue,
+            clear,
+            inputKeydownEvent,
+            anchorElement,
+            dispatch,
+            inputRef,
+            openOnFocus,
+            currentOpen,
+            onRequestOpen,
+            onInputChange,
+            applyFilterForItems,
+            items,
+        ]),
+        react_1.default.useMemo(() => (react_1.default.createElement(Menu_1.default, { ref: menuRef, anchorPos: anchorPos, multiple: multiple, items: filteredItems, value: currentValue, isOpen: currentOpen && filteredItems.length > 0, autofocus: false, anchorElement: anchorElement, closeOutsideClick: false, getOptionSelected: getOptionSelected, onSelectItem: item => {
+                if (typeof onChange === 'function') {
+                    onChange(item);
+                }
+            }, closeOnSelect: multiple ? false : true, onRequestClose: evt => {
+                if (clearIfNotSelected) {
+                    dispatch((0, context_1.actionSetPartial)({
+                        inputValue: value !== null
+                            ? selectedItemToString(value)
+                            : '',
+                    }));
+                }
+                if ((evt === null || evt === void 0 ? void 0 : evt.target) !== anchorElement) {
+                    onRequestClose(evt);
+                }
+            } }, ({ index, item }, itemProps) => children({ index, item: item, inputValue }, itemProps))), [
+            anchorPos,
+            multiple,
+            filteredItems,
+            currentValue,
+            currentOpen,
+            anchorElement,
+            getOptionSelected,
+            onChange,
+            clearIfNotSelected,
+            dispatch,
+            value,
+            selectedItemToString,
+            onRequestClose,
+            children,
+            inputValue,
+        ])));
+});
+Autocomplete.displayName = 'Autocomplete';
+exports.default = Autocomplete;

package/Autocomplete/AutocompleteTextField.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { TextFieldProps } from '../TextField';
+export interface AutocompleteTextFieldProps extends TextFieldProps {
+    /**
+     * Text field loading state\
+     * If `true` then text field has been contained the loading indicator, otherwise - nop
+     */
+    readonly isLoading?: boolean;
+    /**
+     * Native <input> element reference
+     */
+    readonly inputRef?: React.MutableRefObject<HTMLInputElement | null> | React.RefCallback<HTMLInputElement>;
+}
+declare const _default: React.ForwardRefExoticComponent<AutocompleteTextFieldProps & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Autocomplete/AutocompleteTextField.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const TextField_1 = __importDefault(require("../TextField"));
+const AutocompleteTextField = (props, ref) => react_1.default.createElement(TextField_1.default, Object.assign({}, props, { ref: ref }));
+exports.default = react_1.default.forwardRef(AutocompleteTextField);

package/Autocomplete/IconClear.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const IconClear = (props, ref) => (react_1.default.createElement("svg", Object.assign({ xmlns: "http://www.w3.org/2000/svg", version: "1.1", width: "1em", height: "1em", viewBox: "0 0 512 512" }, props, { ref: ref }),
+    react_1.default.createElement("path", { d: "m139.86 128.54a16 16 0 0 0-7.1738 4.1406 16 16 0 0 0 0 22.629l100.69 100.69-100.69 100.69a16 16 0 0 0 0 22.629 16 16 0 0 0 22.629 0l100.69-100.69 100.69 100.69a16 16 0 0 0 22.629 0 16 16 0 0 0 0-22.629l-100.69-100.69 100.69-100.69a16 16 0 0 0 0-22.629 16 16 0 0 0-22.629 0l-100.69 100.69-100.69-100.69a16 16 0 0 0-15.455-4.1406z", fill: "currentColor" })));
+exports.default = react_1.default.forwardRef(IconClear);

package/Autocomplete/context.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { AnchorElement } from '../Menu';
+type State = {
+    readonly currentOpen: boolean;
+    readonly currentLoading: boolean;
+    readonly anchorElement: AnchorElement | null;
+    readonly filteredItems: readonly unknown[];
+    readonly inputValue: string;
+    readonly currentValue: unknown | null;
+};
+type Action = ActionSetPartial;
+type ActionSetPartial = {
+    readonly type: 'setPartial';
+    readonly payload: Partial<State>;
+};
+export declare const actionSetPartial: (payload: ActionSetPartial['payload']) => ActionSetPartial;
+export declare const defaultState: State;
+export declare const reducer: React.Reducer<State, Action>;
+interface ContextProviderProps {
+    readonly children: React.ReactNode | readonly React.ReactNode[];
+    readonly initialState?: Partial<State>;
+}
+export declare const ContextProvider: React.FC<ContextProviderProps>;
+export declare const useContext: () => {
+    state: State;
+    dispatch: React.Dispatch<ActionSetPartial>;
+};
+export default useContext;

package/Autocomplete/context.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContext = exports.ContextProvider = exports.reducer = exports.defaultState = exports.actionSetPartial = void 0;
+const react_1 = __importDefault(require("react"));
+const actionSetPartial = (payload) => ({
+    type: 'setPartial',
+    payload,
+});
+exports.actionSetPartial = actionSetPartial;
+exports.defaultState = {
+    currentOpen: false,
+    currentLoading: false,
+    anchorElement: null,
+    filteredItems: [],
+    currentValue: null,
+    inputValue: '',
+};
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'setPartial':
+            return Object.assign(Object.assign({}, state), action.payload);
+        default:
+            return state;
+    }
+};
+exports.reducer = reducer;
+const context = react_1.default.createContext({
+    state: exports.defaultState,
+    dispatch: () => undefined,
+});
+const ContextProvider = props => {
+    const { children, initialState } = props;
+    const [state, dispatch] = react_1.default.useReducer(exports.reducer, Object.assign(Object.assign({}, exports.defaultState), initialState));
+    return react_1.default.createElement(context.Provider, { value: { state, dispatch } }, children);
+};
+exports.ContextProvider = ContextProvider;
+const useContext = () => {
+    const { state, dispatch } = react_1.default.useContext(context);
+    return {
+        state,
+        dispatch,
+    };
+};
+exports.useContext = useContext;
+exports.default = exports.useContext;

package/Autocomplete/index.d.ts

@@ -1,46 +1,9 @@
 import React from 'react';
-import { MenuRef, MenuProps, Value } from '../Menu';
-export type AutocompleteProps<T, Multiple extends boolean | undefined = undefined> = AutocompleteMenuProps<T, Multiple>;
-export type AutocompleteContainerRef = HTMLDivElement;
-type AutocompleteMenuProps<T, Multiple extends boolean | undefined = undefined> = Pick<MenuProps<T, Multiple>, 'items' | 'value' | 'estimatedItemSize' | 'endThreshold' | 'overscanCount' | 'getOptionSelected' | 'onEndReached' | 'onSelectItem' | 'renderItem' | 'multiple' | 'zIndex' | 'onRequestClose' | 'isOpen'> & {
-    readonly containerRef?: React.Ref<AutocompleteContainerRef>;
-    readonly itemToString: ItemToString<T, Multiple>;
-    readonly renderInput: (params: RenderInputProps<T, Multiple>) => React.ReactNode;
-    readonly onRequestOpen: (event?: FocusEvent | KeyboardEvent | MouseEvent | React.FocusEvent | React.KeyboardEvent | React.MouseEvent) => void;
-    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement>;
-    readonly filterItems?: (items: readonly T[], data: {
-        readonly query: string;
-        readonly inputValue: string;
-    }) => readonly T[];
-};
-export type ItemToString<T, Multiple> = Multiple extends undefined | false ? (item: T) => string : undefined;
-export type RenderInputProps<T, Multiple extends boolean | undefined = undefined> = {
-    readonly selected: Value<T, Multiple> | null;
-    readonly value: string;
-    readonly inputRef: React.Ref<HTMLInputElement>;
-    readonly onClick: React.MouseEventHandler<HTMLInputElement>;
-    readonly onFocus: React.FocusEventHandler<HTMLInputElement>;
-    readonly onBlur: React.FocusEventHandler<HTMLInputElement>;
-    readonly onKeyDown: React.KeyboardEventHandler<HTMLInputElement>;
-    readonly onChange: React.ChangeEventHandler<HTMLInputElement>;
-};
-export type AutocompleteRef<T> = Pick<MenuRef<T>, 'scrollToItem' | 'scrollTo' | 'scrollToFirstSelected' | 'selectItem' | 'highlightIndex' | 'hightlightPrevItem' | 'hightlightNextItem' | 'hightlightFirstItem' | 'hightlightLastItem' | 'selectHightlightedItem' | 'updatePopper'> & {
-    readonly clear: () => void;
-    readonly focus: () => void;
-    readonly blur: () => void;
-    readonly clearInput: () => void;
-};
-declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: Pick<MenuProps<T, Multiple>, "zIndex" | "value" | "isOpen" | "estimatedItemSize" | "overscanCount" | "items" | "endThreshold" | "multiple" | "getOptionSelected" | "onEndReached" | "onSelectItem" | "renderItem" | "onRequestClose"> & {
-    readonly containerRef?: React.Ref<HTMLDivElement> | undefined;
-    readonly itemToString: ItemToString<T, Multiple>;
-    readonly renderInput: (params: RenderInputProps<T, Multiple>) => React.ReactNode;
-    readonly onRequestOpen: (event?: MouseEvent | KeyboardEvent | FocusEvent | React.FocusEvent<Element, Element> | React.KeyboardEvent<Element> | React.MouseEvent<Element, MouseEvent> | undefined) => void;
-    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement> | undefined;
-    readonly filterItems?: ((items: readonly T[], data: {
-        readonly query: string;
-        readonly inputValue: string;
-    }) => readonly T[]) | undefined;
-} & {
-    ref?: React.Ref<AutocompleteRef<T>> | undefined;
+import AutocompleteItem from '../Menu/MenuItem';
+import { AutocompleteProps, AutocompleteRef } from './AutocompleteContainer';
+export * from './AutocompleteContainer';
+export { AutocompleteItem };
+declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: AutocompleteProps<T, Multiple> & {
+    ref?: React.Ref<AutocompleteRef> | undefined;
 }) => JSX.Element;
 export default _default;