@via-profit/ui-kit 0.1.0-rc.2 → 0.1.0-rc.21

package/Menu/index.d.ts

@@ -0,0 +1,196 @@
+import React from 'react';
+import { VariableSizeList as VirtualizedList } from 'react-window';
+import options from './popper-options';
+export interface MenuProps<T, Multiple extends boolean | undefined = undefined> {
+    /**
+     * List of items
+     */
+    readonly items: readonly T[];
+    /**
+     * Current value\
+     * If `Menu` component has `multiple` property then value must be an array of items
+     */
+    readonly value: Value<T, Multiple> | null;
+    /**
+     * Estimated item height. Need to calculate menu height\
+     * \
+     * **Default**: `50`
+     */
+    readonly estimatedItemSize?: number;
+    /**
+     * Menu open state
+     */
+    readonly isOpen?: boolean;
+    /**
+     * The threshold is the number of items from the end of the list,
+     * upon reaching which the additional loading of new items will begin\
+     * \
+     * **Default**: `10`
+     */
+    readonly endThreshold?: number;
+    /**
+     * The thresholdPercent is the persont of items from the end of the list in percents value\
+     * Dependent of `onEndReached` property\
+     * \
+     * **Default**: `30`
+     */
+    readonly thresholdPercent?: number;
+    /**
+     * Autofocus list after menu open\
+     * Dependent of `onEndReached` property\
+     * \
+     * **Default**: `true`
+     */
+    readonly autofocus?: boolean;
+    /**
+     * tabindex property for the list. Tabindex is required to be able to set focus on a list item\
+     * \
+     * **Default**: `-1`
+     */
+    readonly tabIndex?: number;
+    /**
+     * The delay in milliseconds before the focus moves to the list at the time of its opening.\
+     * Used only if `autofocus` property is true\
+     * \
+     * **Default**: `250`
+     */
+    readonly autofocusDelay?: number;
+    /**
+     * The number of items to render outside of the visible area. This property can be important for two reasons:
+     *
+     * - Overscanning by one row allows the tab key to focus on the next (not yet visible) item.
+     * - Overscanning slightly can reduce or prevent a flash of empty space when a user first starts scrolling.
+     *
+     * Note that overscanning too much can negatively impact performance.\
+     * \
+     * **Default**: `1`
+     */
+    readonly overscanCount?: number;
+    /**
+     * An HTML element. It's used to set the position of the menu.
+     */
+    readonly anchorElement: HTMLElement | null;
+    /**
+     * Close list if click outside of list\
+     * \
+     * **Default**: `true`
+     */
+    readonly closeOutsideClick?: boolean;
+    /**
+     * Allow the multiple selection
+     */
+    readonly multiple?: Multiple;
+    /**
+     * z-index property\
+     * \
+     * **Default**: `1`
+     */
+    readonly zIndex?: number;
+    /**
+     * @popperjs/core component options\
+     * \
+     * **Default**: used special preset
+     */
+    readonly popperOptions?: typeof options;
+    /**
+     * An element for the React.createPortal node\
+     * \
+     * **Default**: `document.body`
+     */
+    readonly portalNode?: (() => HTMLElement) | HTMLElement;
+    /**
+     * The reference of the outer list HTML element
+     */
+    readonly outerRef?: React.MutableRefObject<OuterListType | null>;
+    /**
+     * The API reference of the virtualized list
+     */
+    readonly listRef?: React.MutableRefObject<VirtualizedListType<T> | null>;
+    /**
+     * A function that determines which of the elements is currently selected
+     */
+    readonly getOptionSelected?: GetOptionSelected<T>;
+    /**
+     * The function that will be called when the list reaches the end
+     */
+    readonly onEndReached?: () => void;
+    /**
+     * Called when item selected
+     */
+    readonly onSelectItem?: OnSelectItem<T, Multiple>;
+    /**
+     * A function that renders each list item
+     */
+    readonly renderItem?: RenderItem<T>;
+    /**
+     * The function that will be called at the moment when you want to close the menu
+     */
+    readonly onRequestClose: OnRequestClose;
+}
+export type MenuRef<T> = {
+    /**
+     * Scroll to specified item index
+     */
+    scrollToItem: VirtualizedListType<T>['scrollToItem'];
+    /**
+     * Scroll by offset (px)
+     */
+    scrollTo: VirtualizedListType<T>['scrollTo'];
+    /**
+     * Scroll list to first of selected item
+     */
+    scrollToFirstSelected: () => void;
+    /**
+     * Select specified item by index
+     */
+    selectItem: (index: number) => void;
+    /**
+     * Hightlight specified item by index
+     */
+    highlightIndex: (index: number) => void;
+    /**
+     * Highlight the previous item relative to the currently highlighted one
+     */
+    hightlightPrevItem: () => void;
+    /**
+     * Highlight the next item relative to the currently highlighted one
+     */
+    hightlightNextItem: () => void;
+    /**
+     * Highlight the first item in list
+     */
+    hightlightFirstItem: () => void;
+    /**
+     * Highlight the last item in list
+     */
+    hightlightLastItem: () => void;
+    /**
+     * Select hightlighted item
+     */
+    selectHightlightedItem: () => void;
+    /**
+     * Force re-render popper element
+     */
+    updatePopper: () => void;
+    /**
+     * Force set focus to list
+     */
+    focus: () => void;
+};
+export type VirtualizedListType<T> = VirtualizedList<T>;
+export type OuterListType = HTMLDivElement;
+export type Value<T, Multiple> = Multiple extends undefined | undefined ? T : readonly T[];
+export type GetOptionSelected<T> = (payload: {
+    readonly item: T;
+    readonly value: T;
+}) => boolean;
+export type RenderItem<T> = (payload: {
+    readonly item: T;
+    readonly index: number;
+}) => React.ReactNode;
+export type OnSelectItem<T, Multiple extends boolean | undefined = undefined> = (value: Value<T, Multiple>) => void;
+export type OnRequestClose = (event?: React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement> | KeyboardEvent | MouseEvent) => void;
+declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: MenuProps<T, Multiple> & {
+    ref?: React.Ref<MenuRef<T>> | undefined;
+}) => JSX.Element;
+export default _default;

package/Menu/index.js

@@ -0,0 +1,452 @@
+"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 __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 react_dom_1 = __importDefault(require("react-dom"));
+const react_window_1 = require("react-window");
+const react_popper_1 = require("react-popper");
+const popper_options_1 = __importDefault(require("./popper-options"));
+const MenuItem_1 = __importDefault(require("./MenuItem"));
+const MenuWrapper_1 = __importDefault(require("./MenuWrapper"));
+const reducer_1 = __importStar(require("./reducer"));
+const Menu = react_1.default.forwardRef((props, ref) => {
+    const { items, value, isOpen, estimatedItemSize = 30, endThreshold = 10, thresholdPercent = 30, autofocusDelay = 250, autofocus = true, closeOutsideClick = true, overscanCount = 1, zIndex = 1, tabIndex = -1, portalNode = typeof window !== 'undefined' ? window.document.body : undefined, outerRef, listRef, anchorElement, multiple, popperOptions, onSelectItem, onEndReached, getOptionSelected, renderItem, onRequestClose, } = props;
+    const getSelectedIndexes = react_1.default.useCallback(() => {
+        const idx = new Set();
+        if (typeof value === 'object' && value !== null) {
+            if (typeof getOptionSelected === 'function') {
+                if (Array.isArray(value)) {
+                    value.forEach(v => {
+                        idx.add(items.findIndex(item => getOptionSelected({ item, value: v })));
+                    });
+                }
+                if (!Array.isArray(value)) {
+                    idx.add(items.findIndex(item => getOptionSelected({ item, value: value })));
+                }
+            }
+            if (Array.isArray(value)) {
+                value.forEach(v => {
+                    idx.add(items.findIndex(item => JSON.stringify(item) === JSON.stringify(v)));
+                });
+            }
+            else {
+                idx.add(items.findIndex(item => JSON.stringify(item) === JSON.stringify(value)));
+            }
+        }
+        return [...idx];
+    }, [getOptionSelected, items, value]);
+    const [domLoaded, setDomLoaded] = react_1.default.useState(false);
+    const [menuIsOpen, setMenuOpen] = react_1.default.useState(Boolean(isOpen));
+    const [currentAnchorElement, setAnchorElement] = react_1.default.useState(anchorElement);
+    const isOpenRef = react_1.default.useRef(menuIsOpen);
+    const dimensionsRef = react_1.default.useRef({ width: 0, height: 0 });
+    const sizeMapRef = react_1.default.useRef(new Map());
+    const listVirtRef = react_1.default.useRef(null);
+    const listOuterRef = react_1.default.useRef(null);
+    const menuWrapperRef = react_1.default.useRef(null);
+    const [{ selectedIndexes, markedIndex, hoveredIndex }, dispatch] = react_1.default.useReducer(reducer_1.default, Object.assign(Object.assign({}, reducer_1.defaultState), { selectedIndexes: getSelectedIndexes(), markedIndex: -1 }));
+    const selectedIndexesRef = react_1.default.useRef(selectedIndexes);
+    const [popperElement, setPopperElement] = react_1.default.useState(null);
+    const timeoutRef = react_1.default.useRef(null);
+    const { styles, attributes, forceUpdate } = (0, react_popper_1.usePopper)(currentAnchorElement, popperElement, popperOptions || popper_options_1.default);
+    /**
+     * Client render detection
+     */
+    react_1.default.useEffect(() => {
+        setDomLoaded(true);
+    }, []);
+    /**
+     * Scroll to first of selected item
+     */
+    const scrollToFirstSelected = react_1.default.useCallback(() => {
+        var _a;
+        const indexes = getSelectedIndexes();
+        // Sort array of indexes by DESC and get the index
+        const index = indexes.length ? [...indexes.sort()][0] : -1;
+        dispatch({
+            type: 'setMenuState',
+            payload: {
+                markedIndex: index,
+            },
+        });
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index);
+    }, [getSelectedIndexes]);
+    /**
+     * Select specified item by index
+     */
+    const selectItem = react_1.default.useCallback((index) => {
+        const item = items[index];
+        if (!item) {
+            return;
+        }
+        if (typeof onSelectItem === 'function') {
+            // For multiple
+            if (multiple && Array.isArray(value)) {
+                const selItems = new Set(value);
+                if (selectedIndexes.includes(index)) {
+                    selItems.delete(item);
+                }
+                else {
+                    selItems.add(item);
+                }
+                onSelectItem([...selItems]);
+            }
+            else {
+                // For single
+                onSelectItem(item);
+            }
+        }
+    }, [items, onSelectItem, selectedIndexes, value, multiple]);
+    /**
+     * Highlight specified item by index
+     */
+    const highlightIndex = react_1.default.useCallback((index) => {
+        dispatch({
+            type: 'setMenuState',
+            payload: {
+                markedIndex: items[index] ? index : -1,
+            },
+        });
+    }, [items]);
+    const hightlightPrevItem = react_1.default.useCallback(() => {
+        var _a;
+        const index = Math.max(markedIndex - 1, 0);
+        highlightIndex(index);
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index);
+    }, [markedIndex, highlightIndex]);
+    const hightlightNextItem = react_1.default.useCallback(() => {
+        var _a;
+        const index = Math.min(markedIndex + 1, items.length);
+        highlightIndex(index);
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index);
+    }, [markedIndex, items.length, highlightIndex]);
+    const hightlightFirstItem = react_1.default.useCallback(() => {
+        var _a;
+        const index = 0;
+        highlightIndex(index);
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index);
+    }, [highlightIndex]);
+    const hightlightLastItem = react_1.default.useCallback(() => {
+        var _a;
+        const index = items.length - 1;
+        highlightIndex(index);
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index);
+    }, [highlightIndex, items.length]);
+    const selectHightlightedItem = react_1.default.useCallback(() => {
+        if (markedIndex > -1) {
+            selectItem(markedIndex);
+        }
+    }, [markedIndex, selectItem]);
+    /**
+     * API
+     */
+    react_1.default.useImperativeHandle(ref, () => ({
+        focus: () => { var _a; return (_a = menuWrapperRef.current) === null || _a === void 0 ? void 0 : _a.focus(); },
+        scrollToItem: (index, align) => { var _a; return (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(index, align); },
+        scrollTo: (scrollOffset) => { var _a; return (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollTo(scrollOffset); },
+        scrollToFirstSelected,
+        selectItem: selectItem,
+        updatePopper: () => typeof forceUpdate === 'function' && forceUpdate(),
+        highlightIndex,
+        hightlightPrevItem,
+        hightlightNextItem,
+        hightlightFirstItem,
+        hightlightLastItem,
+        selectHightlightedItem,
+    }), [
+        scrollToFirstSelected,
+        selectItem,
+        highlightIndex,
+        hightlightPrevItem,
+        hightlightNextItem,
+        hightlightFirstItem,
+        hightlightLastItem,
+        selectHightlightedItem,
+        forceUpdate,
+    ]);
+    /**
+     * To write row height (size in px) into the cached map
+     * and fire re-render action of virtualized list
+     */
+    const setRowHeight = react_1.default.useCallback((index, height) => {
+        var _a;
+        sizeMapRef.current.set(index, height);
+        (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.resetAfterIndex(index);
+    }, []);
+    /**
+     * Update achnor
+     */
+    react_1.default.useEffect(() => {
+        if (anchorElement !== currentAnchorElement) {
+            setAnchorElement(anchorElement);
+        }
+    }, [anchorElement, currentAnchorElement]);
+    const dimensions = react_1.default.useMemo(() => {
+        const dimensions = Object.assign({}, dimensionsRef.current);
+        menuIsOpen;
+        const MAX_HEIGHT = 360;
+        const MIN_WIDTH = 200;
+        let size = 0;
+        for (let index = 0; index < items.length; index++) {
+            if (index > 60) {
+                break;
+            }
+            size += sizeMapRef.current.get(index) || estimatedItemSize;
+        }
+        if (size > 0) {
+            dimensions.height = Math.min(size, MAX_HEIGHT);
+        }
+        if (currentAnchorElement) {
+            dimensions.width = Math.max(currentAnchorElement.getBoundingClientRect().width, MIN_WIDTH);
+        }
+        dimensionsRef.current = dimensions;
+        return dimensions;
+    }, [currentAnchorElement, items, estimatedItemSize, menuIsOpen]);
+    const onScroll = react_1.default.useCallback(({ scrollOffset, scrollDirection }) => {
+        if (typeof onEndReached !== 'function') {
+            return;
+        }
+        // Detect the end of the reached
+        if (listOuterRef.current && scrollDirection === 'forward') {
+            // The threshold is the number of items from the end of the list,
+            // upon reaching which the additional loading of new items will begin
+            const threshold = (endThreshold / 100) * thresholdPercent;
+            // const threshold = 10;
+            const offset = listOuterRef.current.scrollHeight - listOuterRef.current.clientHeight;
+            const lastItemsHeight = Array.from(items)
+                .slice(-threshold)
+                .reduce((totalHeight, _edge, index) => totalHeight + (sizeMapRef.current.get(index) || estimatedItemSize), 0);
+            if (scrollOffset >= offset - lastItemsHeight) {
+                onEndReached();
+            }
+        }
+    }, [onEndReached, endThreshold, thresholdPercent, items, estimatedItemSize]);
+    /**
+     * Keyboard events of menu list container.
+     * Note: Moved selection up and down while keys pressed
+     */
+    const listKeydownEvent = react_1.default.useCallback((event) => {
+        if (!menuIsOpen) {
+            return;
+        }
+        switch (event.code) {
+            case 'Enter':
+            case 'NumpadEnter':
+            case 'Tab':
+                event.preventDefault();
+                if (markedIndex > -1) {
+                    selectItem(markedIndex);
+                }
+                break;
+            case 'ArrowUp':
+                {
+                    event.preventDefault();
+                    hightlightPrevItem();
+                }
+                break;
+            case 'ArrowDown':
+                {
+                    event.preventDefault();
+                    hightlightNextItem();
+                }
+                break;
+            case 'Home':
+                {
+                    event.preventDefault();
+                    hightlightFirstItem();
+                }
+                break;
+            case 'End':
+                {
+                    event.preventDefault();
+                    hightlightLastItem();
+                }
+                break;
+            case 'PageUp':
+            case 'PageDown':
+            case 'Space':
+                event.preventDefault();
+                break;
+            case 'Escape':
+                event.preventDefault();
+                onRequestClose(event);
+                break;
+            default:
+                // do nothing
+                break;
+        }
+    }, [
+        markedIndex,
+        menuIsOpen,
+        onRequestClose,
+        selectItem,
+        hightlightPrevItem,
+        hightlightNextItem,
+        hightlightFirstItem,
+        hightlightLastItem,
+    ]);
+    /**
+     * Invoked `renderItem` function if that passed,
+     * otherwise used another render method
+     */
+    const renderItemFn = react_1.default.useCallback(item => (typeof renderItem === 'function' ? renderItem(item) : JSON.stringify(item)), [renderItem]);
+    // eslint-disable-next-line arrow-body-style
+    react_1.default.useEffect(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    react_1.default.useEffect(() => {
+        const windowResizeEvent = (_event) => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+            timeoutRef.current = setTimeout(() => {
+                if (forceUpdate) {
+                    forceUpdate();
+                }
+            }, 100);
+        };
+        const mouseDownEvent = (event) => {
+            if (!menuIsOpen) {
+                return;
+            }
+            let parentElem = event.target;
+            let needToClose = true;
+            while (parentElem && 'parentNode' in parentElem) {
+                if (parentElem === popperElement) {
+                    needToClose = false;
+                    break;
+                }
+                parentElem = parentElem.parentNode;
+            }
+            if (needToClose) {
+                onRequestClose(event);
+            }
+        };
+        if (closeOutsideClick) {
+            window.document.addEventListener('mousedown', mouseDownEvent);
+        }
+        window.document.addEventListener('resize', windowResizeEvent);
+        return () => {
+            if (closeOutsideClick) {
+                window.document.removeEventListener('mousedown', mouseDownEvent);
+            }
+            window.document.removeEventListener('resize', windowResizeEvent);
+        };
+    }, [forceUpdate, menuIsOpen, popperElement, onRequestClose, closeOutsideClick]);
+    /**
+     * Toggle menu open
+     */
+    react_1.default.useEffect(() => {
+        var _a;
+        if (isOpenRef.current !== isOpen) {
+            isOpenRef.current = Boolean(isOpen);
+            setMenuOpen(Boolean(isOpen));
+            if (isOpen) {
+                scrollToFirstSelected();
+                if (autofocus) {
+                    setTimeout(() => {
+                        var _a;
+                        (_a = menuWrapperRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+                    }, autofocusDelay);
+                }
+            }
+            // Reset indexes
+            if (!isOpen) {
+                (_a = listVirtRef.current) === null || _a === void 0 ? void 0 : _a.scrollToItem(0);
+                dispatch({
+                    type: 'setMenuState',
+                    payload: {
+                        markedIndex: -1,
+                        hoveredIndex: -1,
+                    },
+                });
+            }
+        }
+    }, [
+        getSelectedIndexes,
+        scrollToFirstSelected,
+        isOpen,
+        autofocus,
+        popperElement,
+        autofocusDelay,
+    ]);
+    /**
+     * Mark selected items by values
+     */
+    react_1.default.useEffect(() => {
+        const indexes = getSelectedIndexes();
+        // If elements in selectedIndexesRef and indexes are not equale
+        if ((selectedIndexesRef.current.length === indexes.length &&
+            selectedIndexesRef.current.every(value => indexes.includes(value))) === false) {
+            selectedIndexesRef.current = indexes;
+            dispatch({
+                type: 'setMenuState',
+                payload: {
+                    selectedIndexes: indexes,
+                },
+            });
+        }
+    }, [value, getSelectedIndexes]);
+    return !domLoaded
+        ? null
+        : react_dom_1.default.createPortal(react_1.default.createElement("div", Object.assign({}, attributes.popper, { ref: setPopperElement, style: Object.assign(Object.assign({}, styles.popper), { zIndex }) }), menuIsOpen && (react_1.default.createElement(MenuWrapper_1.default, { isOpen: menuIsOpen, ref: menuWrapperRef, tabIndex: tabIndex, dimensions: dimensions, onKeyDown: listKeydownEvent },
+            react_1.default.createElement(react_window_1.VariableSizeList, { onScroll: onScroll, width: 300, height: 350, itemCount: items.length, overscanCount: overscanCount, itemSize: index => sizeMapRef.current.get(index) || estimatedItemSize, estimatedItemSize: estimatedItemSize, ref: elem => {
+                    listVirtRef.current = elem;
+                    if (listRef) {
+                        listRef.current = elem;
+                    }
+                }, outerRef: elem => {
+                    listOuterRef.current = elem;
+                    if (outerRef) {
+                        outerRef.current = elem;
+                    }
+                } }, ({ index, style }) => {
+                const item = items[index];
+                return (react_1.default.createElement(MenuItem_1.default, { index: index, style: style, setRowHeight: setRowHeight, selected: selectedIndexes.includes(index), hovered: hoveredIndex === index || markedIndex === index, onMouseEnter: () => {
+                        if (index !== hoveredIndex) {
+                            dispatch({
+                                type: 'setMenuState',
+                                payload: { hoveredIndex: index, markedIndex: -1 },
+                            });
+                        }
+                    }, onMouseLeave: () => {
+                        if (index === hoveredIndex) {
+                            dispatch({
+                                type: 'setMenuState',
+                                payload: { hoveredIndex: -1, markedIndex: -1 },
+                            });
+                        }
+                    }, onClick: () => selectItem(index) }, renderItemFn({ item, index })));
+            })))), typeof portalNode === 'function' ? portalNode() : portalNode || window.document.body);
+});
+Menu.displayName = 'Menu';
+exports.default = Menu;

package/Menu/popper-options.d.ts

@@ -0,0 +1,4 @@
+import type { usePopper } from 'react-popper';
+export type PopperOptions = Parameters<typeof usePopper>[2];
+export declare const popperOptions: PopperOptions;
+export default popperOptions;

package/Menu/popper-options.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.popperOptions = void 0;
+exports.popperOptions = {
+    placement: 'bottom',
+    modifiers: [
+        {
+            name: 'offset',
+            options: {
+                offset: [0, 8],
+            },
+        },
+        {
+            name: 'flip',
+            enabled: true,
+            options: {
+                altBoundary: true,
+                padding: 8,
+            },
+        },
+        {
+            name: 'preventOverflow',
+            enabled: true,
+            options: {
+                altAxis: true,
+                altBoundary: true,
+                tether: true,
+                padding: 8,
+            },
+        },
+    ],
+};
+exports.default = exports.popperOptions;

package/Menu/reducer.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface MenuState {
+    readonly selectedIndexes: readonly number[];
+    readonly markedIndex: number;
+    readonly hoveredIndex: number;
+}
+export type Actions = ActionSetMenuState;
+interface ActionSetMenuState {
+    readonly type: 'setMenuState';
+    readonly payload: Partial<MenuState>;
+}
+export declare const defaultState: MenuState;
+export declare const reducer: React.Reducer<MenuState, Actions>;
+export default reducer;