@moysklad/uikit 28.1.0

package/dist/components/Modal/context/ModalContextProvider.d.ts

@@ -0,0 +1,14 @@
+import { type PropsWithChildren } from 'react';
+interface IModalContext {
+    modals: string[];
+    activeModalId: string;
+    addItem: (id: string) => void;
+    deleteItem: (id: string) => void;
+}
+export declare const ModalContext: import("react").Context<IModalContext>;
+export declare const useModalContext: () => IModalContext;
+type ModalContextProviderProps = PropsWithChildren<{
+    portalElement?: Element;
+}>;
+export declare const ModalContextProvider: ({ portalElement, children, }: ModalContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Modal/context/ModalContextProvider.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useState } from "react";
+import { createPortal } from "react-dom";
+const ModalContext = /*#__PURE__*/ createContext({
+    modals: [],
+    activeModalId: '',
+    addItem: ()=>null,
+    deleteItem: ()=>null
+});
+const useModalContext = ()=>{
+    const context = useContext(ModalContext);
+    if (!context) throw new Error('Modal component must be wrapped by ModalContextProvider');
+    return context;
+};
+const ModalContextProvider = ({ portalElement = document.body, children })=>{
+    const [modals, setModals] = useState([]);
+    const handleAddItem = useCallback((id)=>{
+        setModals((prev)=>prev.concat(id));
+    }, []);
+    const handleDeleteItem = useCallback((id)=>{
+        setModals((prev)=>prev.filter((itemId)=>itemId !== id));
+    }, []);
+    const value = useMemo(()=>({
+            modals,
+            activeModalId: modals.length ? modals[modals.length - 1] : '',
+            addItem: handleAddItem,
+            deleteItem: handleDeleteItem
+        }), [
+        modals,
+        handleAddItem,
+        handleDeleteItem
+    ]);
+    return /*#__PURE__*/ jsx(ModalContext.Provider, {
+        value: value,
+        children: /*#__PURE__*/ createPortal(children, portalElement)
+    });
+};
+export { ModalContext, ModalContextProvider, useModalContext };

package/dist/components/Modal/hooks.d.ts

@@ -0,0 +1,4 @@
+import { type RefObject } from 'react';
+export declare const useEscapeListener: (escapeHandler: () => void, enabled: boolean) => void;
+export declare const useFocus: (isVisible: boolean, sentinelRef: RefObject<HTMLDivElement>) => void;
+export declare const useMaxWidth: (maxWidth?: number) => number | undefined;

package/dist/components/Modal/hooks.js

@@ -0,0 +1,27 @@
+import { useEffect, useMemo } from "react";
+const useEscapeListener = (escapeHandler, enabled)=>{
+    useEffect(()=>{
+        const handleEscape = (e)=>{
+            if ('Escape' === e.key) escapeHandler();
+        };
+        if (enabled) window.addEventListener('keydown', handleEscape);
+        return ()=>window.removeEventListener('keydown', handleEscape);
+    }, [
+        enabled
+    ]);
+};
+const useFocus = (isVisible, sentinelRef)=>{
+    useEffect(()=>{
+        if (isVisible && sentinelRef.current) sentinelRef.current.focus();
+    }, [
+        isVisible
+    ]);
+};
+const DEFAULT_MAX_WIDTH = 600;
+const useMaxWidth = (maxWidth)=>useMemo(()=>{
+        if (void 0 !== maxWidth && maxWidth > window.innerWidth) return DEFAULT_MAX_WIDTH;
+        return maxWidth;
+    }, [
+        maxWidth
+    ]);
+export { useEscapeListener, useFocus, useMaxWidth };

package/dist/components/Multiselect/AsyncDropdownContext/AsyncDropdownContextProvider.d.ts

@@ -0,0 +1,16 @@
+import { type FC, type Key, type PropsWithChildren } from 'react';
+import type { InputValue } from '../types';
+export interface AsyncDropdownContextValues {
+    cachedInputValue: string;
+    cachedItems: InputValue[];
+    selectedValues: InputValue[];
+    changeCachedInputValue: (value: string) => void;
+    changeCachedItems: (value: InputValue[]) => void;
+}
+export interface AsyncDropdownContextProviderProps extends PropsWithChildren {
+    values: Key[];
+    initialItems?: InputValue[];
+    isAsync: boolean;
+}
+export declare const AsyncDropdownContextProvider: FC<AsyncDropdownContextProviderProps>;
+export declare const useAsyncDropdownContext: () => AsyncDropdownContextValues | null;

package/dist/components/Multiselect/AsyncDropdownContext/AsyncDropdownContextProvider.js

@@ -0,0 +1,69 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+const AsyncDropdownContext = /*#__PURE__*/ createContext({
+    cachedInputValue: '',
+    cachedItems: [],
+    selectedValues: [],
+    changeCachedInputValue: ()=>{},
+    changeCachedItems: ()=>{}
+});
+const getItemsMap = (items)=>{
+    const map = new Map();
+    items.forEach((item)=>{
+        map.set(item.value, item);
+    });
+    return map;
+};
+const AsyncDropdownContextProvider = ({ children, values, isAsync, initialItems })=>{
+    const [cachedInputValue, setCachedInputValue] = useState('');
+    const [cachedItems, setCachedItems] = useState(initialItems ?? []);
+    const [cachedItemsIncludesSelected, setCachedItemsIncludesSelected] = useState([]);
+    const selectedValues = useMemo(()=>cachedItemsIncludesSelected.filter((item)=>values.includes(item.value)), [
+        cachedItemsIncludesSelected,
+        values
+    ]);
+    const addSelectedItemsToActual = ({ newItems, oldItems, values })=>{
+        const result = newItems.concat();
+        const oldItemsMap = getItemsMap(oldItems);
+        const newItemsMap = getItemsMap(newItems);
+        values.forEach((value)=>{
+            if (!newItemsMap.has(value)) {
+                const valueFromOldItems = oldItemsMap.get(value);
+                if (valueFromOldItems) result.push(valueFromOldItems);
+            }
+        });
+        return result;
+    };
+    const valuesRef = useRef(values);
+    valuesRef.current = values;
+    const changeCachedItems = useCallback((items)=>{
+        setCachedItems(items);
+        setCachedItemsIncludesSelected((oldItems)=>{
+            const resultMap = addSelectedItemsToActual({
+                oldItems,
+                newItems: items,
+                values: valuesRef.current
+            });
+            return resultMap;
+        });
+    }, []);
+    const value = useMemo(()=>isAsync ? {
+            cachedInputValue,
+            cachedItems,
+            selectedValues,
+            changeCachedInputValue: setCachedInputValue,
+            changeCachedItems
+        } : null, [
+        cachedInputValue,
+        cachedItems,
+        changeCachedItems,
+        isAsync,
+        selectedValues
+    ]);
+    return /*#__PURE__*/ jsx(AsyncDropdownContext.Provider, {
+        value: value,
+        children: children
+    });
+};
+const useAsyncDropdownContext = ()=>useContext(AsyncDropdownContext);
+export { AsyncDropdownContextProvider, useAsyncDropdownContext };

package/dist/components/Multiselect/DropdownContent/MultiselectDropdownContent.d.ts

@@ -0,0 +1,69 @@
+import React, { type Key, type KeyboardEventHandler, type ReactNode, type Ref } from 'react';
+import { type DropdownItem, type RenderSelectedItem } from '../types';
+export interface RenderContentParams {
+    options: ReactNode;
+    input: ReactNode;
+    chips: ReactNode;
+    createButton: ReactNode;
+}
+export interface MultiselectDropdownContentProps<T extends Key, DTO = any> {
+    items: DropdownItem<T>[];
+    values: T[];
+    onChange?: (values: T[]) => void;
+    testId?: string;
+    /**
+     *
+     * коллбэк для определения текста чипса, отображаемого в дропдауне под строкой поиска
+     * при выборе большого количества элементов
+     *
+     * @param itemsCount количество выбранных элементов
+     * @example (count) => `выбрано ${count} элементов`
+     */
+    getManyItemsChipText?: (itemsCount: number) => string;
+    /**
+     *
+     * коллбэк для определения текста, отображаемого при остутствии элемента при фильтрации
+     *
+     * @param inputValue значение из строки поиска
+     * @example (inputValue) => `элемент ${inputValue} не найден`
+     */
+    getNotFoundText?: (inputValue: string) => string;
+    showCreateButton?: boolean;
+    getCreateButtonText?: (inputValue: string) => string;
+    onCreateButtonClick?: (inputValue: string) => void;
+    createButtonIcon?: ReactNode;
+    showSelectAllCheckbox?: boolean;
+    selectAllCheckboxText?: string;
+    /**
+     * ограничение отображаемых в dropdown элементов
+     */
+    limit?: number;
+    /**
+     *
+     * коллбэк для определения текста об ограничении показанных элементов
+     *
+     * @param displayedItemsCount количество показанных в данный момент элементов
+     * @example (count) => `показаны ${count} элементов,\n воспользуйтесь поиском чтобы отобразить больше`
+     */
+    getLimitText?: (displayedItemsCount: number) => string;
+    /**
+     * Текст, отображаемый во время загрузки опций, если передан onSearch
+     */
+    loadingText?: string;
+    /**
+     * асинхронный коллбэк, вызываемый при изменении input, возвращает список отфильтрованных опций
+     */
+    onSearch?: (value: string) => Promise<DropdownItem<T>[]>;
+    searchDebounce?: number;
+    tooltipDelay?: number;
+    renderItem?: (item: DropdownItem<T, DTO>) => ReactNode;
+    inputClassName?: string;
+    optionsClassName?: string;
+    chipsContainerClassName?: string;
+    optionsListWrapperClassName?: string;
+    renderContent?: (params: RenderContentParams) => React.JSX.Element;
+    searchInputRef?: Ref<HTMLInputElement>;
+    onInputKeydown?: KeyboardEventHandler<HTMLInputElement>;
+    renderSelectedItem?: RenderSelectedItem;
+}
+export declare const MultiselectDropdownContent: <T extends Key>(props: MultiselectDropdownContentProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Multiselect/DropdownContent/MultiselectDropdownContent.js

@@ -0,0 +1,292 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as external_react_Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import lodash_debounce from "lodash.debounce";
+import { cn } from "../../../common/css/cn.js";
+import { Button } from "../../Button/Button.js";
+import { Checkbox } from "../../Checkbox/Checkbox.js";
+import { Chip } from "../../Chip/Chip.js";
+import { SearchInput } from "../../SearchInput/SearchInput.js";
+import { EmptyState } from "../../Select/EmptyState/EmptyState.js";
+import { Loading } from "../../Select/Loading/Loading.js";
+import { Text, TextColor } from "../../Text/Text.js";
+import { Add16Icon, RemoveClose12Icon } from "../../../icon/index.js";
+import { useAsyncDropdownContext } from "../AsyncDropdownContext/AsyncDropdownContextProvider.js";
+import { minChipsWidth, selectAllCheckboxDefaultText } from "../lib/consts.js";
+import { useChipsKeyDown } from "../lib/useChipsKeyDown.js";
+import { useItemKeyDown } from "../lib/useItemKeyDown.js";
+import { SelectAllCheckbox } from "../SelectAllCheckbox/SelectAllCheckbox.js";
+import { TooltipedChip } from "../TooltipedChip/TooltipedChip.js";
+import { TooltipedOptionText } from "../TooltipedOptionText/TooltipedOptionText.js";
+import MultiselectDropdownContent_module from "./MultiselectDropdownContent.module.js";
+const handleCheck = ()=>{};
+const MultiselectDropdownContent = (props)=>{
+    const asyncDropdownContext = useAsyncDropdownContext();
+    const selectedItems = (asyncDropdownContext?.selectedValues ?? props.items).filter((item)=>props.values.includes(item.value));
+    const [filteredItems, setFilteredItems] = useState(asyncDropdownContext?.cachedItems ?? props.items);
+    const [filteredSelectedItems, setFilteredSelectedItems] = useState(selectedItems);
+    const [searchInputValue, setSearchInputValue] = useState(asyncDropdownContext?.cachedInputValue ?? '');
+    const searchInputValueRef = useRef(searchInputValue);
+    searchInputValueRef.current = searchInputValue;
+    const [isLoading, setIsLoading] = useState(false);
+    const onSearchRef = useRef(props.onSearch);
+    onSearchRef.current = props.onSearch;
+    const handleAsyncSearch = useCallback(async (inputValue)=>{
+        setIsLoading(true);
+        asyncDropdownContext?.changeCachedItems([]);
+        asyncDropdownContext?.changeCachedInputValue(inputValue);
+        const items = await onSearchRef.current?.(inputValue);
+        setIsLoading(false);
+        asyncDropdownContext?.changeCachedItems(items ?? []);
+        setFilteredItems(items ?? []);
+    }, []);
+    const handleAsyncSearchDebounced = useCallback(lodash_debounce(handleAsyncSearch, props.searchDebounce, {
+        leading: true
+    }), []);
+    const handleSearch = (inputValue)=>{
+        setSearchInputValue(inputValue);
+        if (!inputValue.trim()) {
+            setFilteredSelectedItems(selectedItems);
+            if (props.onSearch) {
+                setFilteredItems([]);
+                handleAsyncSearchDebounced(inputValue);
+            } else setFilteredItems(props.items);
+            return;
+        }
+        setFilteredSelectedItems(selectedItems.filter((item)=>item.label.toLowerCase().includes(inputValue.trim().toLowerCase())));
+        if (props.onSearch) {
+            setFilteredItems([]);
+            handleAsyncSearchDebounced(inputValue);
+            return;
+        }
+        setFilteredItems(props.items.filter((item)=>item.label.toLowerCase().includes(inputValue.trim().toLowerCase())));
+    };
+    const updateFilteredSelectedItems = (inputValue)=>{
+        if (!inputValue.trim()) return void setFilteredSelectedItems(selectedItems);
+        setFilteredSelectedItems(selectedItems.filter((item)=>item.label.toLowerCase().includes(inputValue.trim().toLowerCase())));
+    };
+    useEffect(()=>{
+        updateFilteredSelectedItems(searchInputValue);
+    }, [
+        props.values,
+        asyncDropdownContext?.selectedValues
+    ]);
+    useEffect(()=>{
+        if (props.onSearch) return;
+        if (!searchInputValue.trim()) return void setFilteredItems(props.items);
+        setFilteredItems(props.items.filter((item)=>item.label.toLowerCase().includes(searchInputValue.trim().toLowerCase())));
+    }, [
+        props.items
+    ]);
+    useEffect(()=>{
+        if (props.onSearch && !asyncDropdownContext?.cachedItems.length) handleSearch(searchInputValue);
+    }, []);
+    useEffect(()=>()=>{
+            if (props.onSearch && '' !== searchInputValueRef.current.trim()) {
+                asyncDropdownContext?.changeCachedInputValue('');
+                asyncDropdownContext?.changeCachedItems([]);
+            }
+        }, []);
+    const isManySelected = useMemo(()=>filteredSelectedItems.length > 9, [
+        filteredSelectedItems
+    ]);
+    const selectAllCheckboxText = useMemo(()=>props.selectAllCheckboxText ?? selectAllCheckboxDefaultText, [
+        props.selectAllCheckboxText
+    ]);
+    const isShowSelectAllCheckbox = useMemo(()=>{
+        if (!props.showSelectAllCheckbox) return false;
+        return selectAllCheckboxText.toLowerCase().includes(searchInputValue.trim().toLowerCase());
+    }, [
+        props.showSelectAllCheckbox,
+        searchInputValue,
+        selectAllCheckboxText
+    ]);
+    const limitedFilteredItems = useMemo(()=>{
+        if (!props.limit) return filteredItems;
+        return filteredItems.slice(0, props.limit);
+    }, [
+        filteredItems,
+        props.limit
+    ]);
+    const getHighlightedText = (text, searchText)=>{
+        const trimmedSearchText = searchText.trim();
+        if (!trimmedSearchText.length) return /*#__PURE__*/ jsx(Fragment, {
+            children: text
+        });
+        const indexOfSearchString = text.toLowerCase().indexOf(trimmedSearchText.toLowerCase());
+        if (-1 === indexOfSearchString) return /*#__PURE__*/ jsx(Fragment, {
+            children: text
+        });
+        return /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                text.slice(0, indexOfSearchString),
+                /*#__PURE__*/ jsx("span", {
+                    className: MultiselectDropdownContent_module.searchHighlighted,
+                    children: text.slice(indexOfSearchString, indexOfSearchString + trimmedSearchText.length)
+                }),
+                text.slice(indexOfSearchString + trimmedSearchText.length, text.length)
+            ]
+        });
+    };
+    const chipRefs = useRef([]);
+    const handleChipKeyDown = useChipsKeyDown(chipRefs, (item)=>{
+        props.onChange?.(props.values.filter((value)=>value !== item.value));
+    });
+    const itemCheckboxRefs = useRef([]);
+    const handleItemKeyDown = useItemKeyDown(itemCheckboxRefs);
+    const options = /*#__PURE__*/ jsx("div", {
+        className: cn(MultiselectDropdownContent_module.itemsListSpaceAroundContainer, props.optionsClassName),
+        children: /*#__PURE__*/ jsx("div", {
+            className: cn(MultiselectDropdownContent_module.itemsListWrapper, props.optionsListWrapperClassName),
+            children: /*#__PURE__*/ jsxs("ul", {
+                className: MultiselectDropdownContent_module.itemsList,
+                "data-test-id": props.testId ? `${props.testId}-items-list` : '',
+                children: [
+                    isShowSelectAllCheckbox && /*#__PURE__*/ jsx(SelectAllCheckbox, {
+                        values: props.values,
+                        items: asyncDropdownContext?.cachedItems ?? props.items,
+                        onChange: props.onChange,
+                        selectAllCheckboxText: selectAllCheckboxText,
+                        testId: props.testId
+                    }),
+                    limitedFilteredItems.map((item, index)=>{
+                        const isChecked = props.values.includes(item.value);
+                        return /*#__PURE__*/ jsx("label", {
+                            children: /*#__PURE__*/ jsxs("li", {
+                                className: cn(MultiselectDropdownContent_module.item, MultiselectDropdownContent_module.clickable),
+                                children: [
+                                    /*#__PURE__*/ jsx(Checkbox, {
+                                        checked: isChecked,
+                                        onChange: handleCheck,
+                                        onClick: ()=>{
+                                            const newValues = isChecked ? props.values.filter((value)=>value !== item.value) : [
+                                                ...props.values,
+                                                item.value
+                                            ];
+                                            props.onChange?.(newValues);
+                                        },
+                                        ref: (element)=>{
+                                            itemCheckboxRefs.current[index] = element;
+                                        },
+                                        onKeyDown: (e)=>handleItemKeyDown(e, index),
+                                        testId: props.testId ? `${props.testId}-item-${index}` : ''
+                                    }),
+                                    /*#__PURE__*/ jsx(TooltipedOptionText, {
+                                        testId: props.testId ? `${props.testId}-item-text-${index}` : '',
+                                        children: props.renderItem ? props.renderItem(item) : getHighlightedText(item.label, searchInputValue)
+                                    })
+                                ]
+                            })
+                        }, item.value);
+                    }),
+                    isLoading && /*#__PURE__*/ jsx("li", {
+                        children: /*#__PURE__*/ jsx(Loading, {
+                            testId: props.testId ? `${props.testId}-loading` : '',
+                            text: props.loadingText ?? 'Загрузка...'
+                        })
+                    }),
+                    !isLoading && !limitedFilteredItems.length && /*#__PURE__*/ jsx("li", {
+                        children: /*#__PURE__*/ jsx(EmptyState, {
+                            text: props.getNotFoundText?.(searchInputValue) ?? 'Не найдено'
+                        })
+                    }),
+                    !!props.limit && limitedFilteredItems.length < filteredItems.length && /*#__PURE__*/ jsx(Text.Caption, {
+                        className: MultiselectDropdownContent_module.limitText,
+                        colorToken: TextColor.tertiary,
+                        children: (props.getLimitText?.(limitedFilteredItems.length) ?? `Показаны первые ${limitedFilteredItems.length} результатов.\n
+                      Воспользуйтесь поиском, чтобы увидеть остальные.`).split('\n').map((text)=>text.trim()).filter(Boolean).map((textPart, index)=>/*#__PURE__*/ jsxs(external_react_Fragment, {
+                                children: [
+                                    textPart,
+                                    /*#__PURE__*/ jsx("br", {})
+                                ]
+                            }, index))
+                    })
+                ]
+            })
+        })
+    });
+    const input = /*#__PURE__*/ jsx(SearchInput, {
+        ref: props.searchInputRef,
+        autoFocus: true,
+        testId: `${props.testId}-search-input`,
+        containerClassName: props.inputClassName,
+        className: MultiselectDropdownContent_module.searchInput,
+        value: searchInputValue,
+        onKeyDown: props.onInputKeydown,
+        onChange: (e)=>{
+            const { value } = e.target;
+            setSearchInputValue(value);
+            handleSearch(value);
+        },
+        onSearch: handleSearch
+    });
+    const createButton = /*#__PURE__*/ jsx("div", {
+        className: MultiselectDropdownContent_module.footerWrapper,
+        children: /*#__PURE__*/ jsx("div", {
+            className: MultiselectDropdownContent_module.footer,
+            children: /*#__PURE__*/ jsxs(Button, {
+                size: "l",
+                variant: "frameless",
+                className: MultiselectDropdownContent_module.createButton,
+                testId: `${props.testId}-create-btn`,
+                onClick: ()=>props.onCreateButtonClick?.(searchInputValue),
+                children: [
+                    props.createButtonIcon ? props.createButtonIcon : /*#__PURE__*/ jsx(Add16Icon, {}),
+                    props.getCreateButtonText?.(searchInputValue) ?? 'Создать элемент'
+                ]
+            })
+        })
+    });
+    const chips = !!filteredSelectedItems.length && /*#__PURE__*/ jsxs("div", {
+        className: cn(MultiselectDropdownContent_module.chipsContainer, props.chipsContainerClassName),
+        children: [
+            !isManySelected && filteredSelectedItems.map((item, index)=>/*#__PURE__*/ jsx(TooltipedChip, {
+                    tooltipDelay: props.tooltipDelay,
+                    ref: (ref)=>chipRefs.current[index] = ref,
+                    minWidth: minChipsWidth,
+                    text: getHighlightedText(item.label, searchInputValue),
+                    testId: `${props.testId}-search-input-chip-${index}`,
+                    onIconClick: ()=>{
+                        props.onChange?.(props.values.filter((value)=>value !== item.value));
+                    },
+                    onKeyDown: (e)=>handleChipKeyDown(e, index, item),
+                    renderSelectedItem: props.renderSelectedItem,
+                    item: item
+                }, item.value)),
+            isManySelected && /*#__PURE__*/ jsx(Chip, {
+                isActive: true,
+                onClick: ()=>{},
+                icon: /*#__PURE__*/ jsx("div", {
+                    className: MultiselectDropdownContent_module.chipsIcon,
+                    onClick: ()=>{
+                        props.onChange?.([]);
+                    },
+                    children: /*#__PURE__*/ jsx(RemoveClose12Icon, {})
+                }),
+                className: cn(MultiselectDropdownContent_module.chip, MultiselectDropdownContent_module.moreElementsChip),
+                testId: `${props.testId}-is-many-selected`,
+                children: props.getManyItemsChipText?.(filteredSelectedItems.length) ?? `Выбрано ${filteredSelectedItems.length} элементов`
+            })
+        ]
+    });
+    if (props.renderContent) return props.renderContent({
+        options,
+        input,
+        chips,
+        createButton
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        className: MultiselectDropdownContent_module.dropdownContainer,
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: MultiselectDropdownContent_module.header,
+                children: [
+                    input,
+                    chips
+                ]
+            }),
+            options,
+            props.showCreateButton && createButton
+        ]
+    });
+};
+export { MultiselectDropdownContent };

package/dist/components/Multiselect/DropdownContent/MultiselectDropdownContent.module.js

@@ -0,0 +1,22 @@
+import "./MultiselectDropdownContent_module.css";
+const MultiselectDropdownContent_module = {
+    dropdownContainer: "dropdownContainer-K13NuB",
+    header: "header-UpBA2w",
+    searchInput: "searchInput-uWyjhk",
+    itemsListSpaceAroundContainer: "itemsListSpaceAroundContainer-YgwhzP",
+    itemsListWrapper: "itemsListWrapper-p8OxYi",
+    itemsList: "itemsList-__Ek2b",
+    item: "item-tJG21b",
+    itemText: "itemText-f7BQ6V",
+    limitText: "limitText-Qqq_SB",
+    footerWrapper: "footerWrapper-nevFCR",
+    footer: "footer-it4SDz",
+    createButton: "createButton-lhgWX2",
+    searchHighlighted: "searchHighlighted-asJ0zw",
+    clickable: "clickable-OwWhPP",
+    chipsContainer: "chipsContainer-CRgiAI",
+    chip: "chip-a0M_Hp",
+    moreElementsChip: "moreElementsChip-_rQIQ4",
+    chipsIcon: "chipsIcon-nEmmVY"
+};
+export default MultiselectDropdownContent_module;