@broxus/react-uikit 0.1.1 → 0.1.2

package/dist/cjs/components/DescriptionList/DescriptionList.js

@@ -0,0 +1,38 @@
+"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 });
+exports.DescriptionList = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+function DescriptionList(props) {
+    const { className, divided, ...restProps } = props;
+    return (React.createElement("dl", { className: (0, classnames_1.default)('uk-description-list', {
+            'uk-description-list-divider': divided,
+        }, className), ...restProps }));
+}
+exports.DescriptionList = DescriptionList;

package/dist/cjs/components/DescriptionList/Term.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+declare type Props = React.HTMLAttributes<HTMLElement>;
+export declare function Term(props: Props): JSX.Element;
+export declare namespace Term {
+    var displayName: string;
+}
+export {};

package/dist/cjs/components/DescriptionList/Term.js

@@ -0,0 +1,34 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Term = void 0;
+const React = __importStar(require("react"));
+function Term(props) {
+    return React.createElement("dt", { ...props });
+}
+exports.Term = Term;
+if (process.env.NODE_ENV !== 'production') {
+    Term.displayName = 'DescriptionList.Term';
+}

package/dist/cjs/components/DescriptionList/index.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Description } from './Description';
+import { Term } from './Term';
+import type { DescriptionListProps } from './DescriptionList';
+import './index.scss';
+export type { DescriptionListProps };
+export interface CompoundedDescriptionList extends React.FunctionComponent<DescriptionListProps> {
+    Description: typeof Description;
+    Term: typeof Term;
+}
+export declare const DescriptionList: CompoundedDescriptionList;

package/dist/cjs/components/DescriptionList/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptionList = void 0;
+const DescriptionList_1 = require("./DescriptionList");
+const Description_1 = require("./Description");
+const Term_1 = require("./Term");
+require("./index.scss");
+exports.DescriptionList = DescriptionList_1.DescriptionList;
+exports.DescriptionList.Description = Description_1.Description;
+exports.DescriptionList.Term = Term_1.Term;

package/dist/cjs/components/Divider/index.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import './index.scss';
+export interface DividerProps extends Omit<React.HTMLAttributes<HTMLHRElement>, 'children'> {
+    icon?: boolean;
+    small?: boolean;
+    vertical?: boolean;
+}
+export declare function Divider(props: DividerProps): JSX.Element;

package/dist/cjs/components/Divider/index.js

@@ -0,0 +1,41 @@
+"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 });
+exports.Divider = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+require("./index.scss");
+function Divider(props) {
+    const { className, icon, small, vertical, ...restProps } = props;
+    return (React.createElement("hr", { className: (0, classnames_1.default)({
+            'uk-divider-icon': icon && !small && !vertical,
+            'uk-divider-small': small && !icon && !vertical,
+            'uk-divider-vertical': vertical && !icon && !small,
+        }, className), ...restProps }));
+}
+exports.Divider = Divider;

package/dist/cjs/components/Dotnav/Dotnav.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface DotnavProps extends React.HTMLAttributes<HTMLUListElement> {
+    vertical?: boolean;
+}
+export declare function Dotnav(props: DotnavProps): JSX.Element;

package/dist/cjs/components/Dotnav/Dotnav.js

@@ -0,0 +1,38 @@
+"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 });
+exports.Dotnav = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+function Dotnav(props) {
+    const { className, vertical, ...restProps } = props;
+    return (React.createElement("ul", { className: (0, classnames_1.default)('uk-dotnav', {
+            'uk-dotnav-vertical': vertical,
+        }, className), ...restProps }));
+}
+exports.Dotnav = Dotnav;

package/dist/cjs/components/Dotnav/Item.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface DotnavItemProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'children'> {
+    isActive?: boolean;
+}
+export declare function Item(props: DotnavItemProps): JSX.Element;
+export declare namespace Item {
+    var displayName: string;
+}

package/dist/cjs/components/Dotnav/Item.js

@@ -0,0 +1,43 @@
+"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 });
+exports.Item = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+const Button_1 = require("../Button/Button");
+function Item(props) {
+    const { className, isActive, onClick, ...restProps } = props;
+    return (React.createElement("li", { className: (0, classnames_1.default)({
+            'uk-active': isActive,
+        }, className), ...restProps },
+        React.createElement(Button_1.Button, { type: "text", onClick: onClick })));
+}
+exports.Item = Item;
+if (process.env.NODE_ENV !== 'production') {
+    Item.displayName = 'Dotnav.Item';
+}

package/dist/cjs/components/Dotnav/index.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { Item } from './Item';
+import type { DotnavProps } from './Dotnav';
+import './index.scss';
+export type { DotnavProps };
+export interface CompoundedDotnav extends React.FunctionComponent<DotnavProps> {
+    Item: typeof Item;
+}
+export declare const Dotnav: CompoundedDotnav;

package/dist/cjs/components/Dotnav/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dotnav = void 0;
+const Dotnav_1 = require("./Dotnav");
+const Item_1 = require("./Item");
+require("./index.scss");
+exports.Dotnav = Dotnav_1.Dotnav;
+exports.Dotnav.Item = Item_1.Item;

package/dist/cjs/components/Drawer/index.d.ts

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import type { GetContainer } from 'rc-util/lib/PortalWrapper';
+import type { Direction } from '../../types';
+import './index.scss';
+declare type DrawerRef = {
+    push(): void;
+    pull(): void;
+};
+declare type EventType = React.KeyboardEvent | React.MouseEvent;
+declare type LevelMove = number | [number, number];
+declare const PlacementTypes: ["top", "right", "bottom", "left"];
+declare type PlacementType = typeof PlacementTypes[number];
+declare const SizeTypes: ["default", "large"];
+declare type SizeType = typeof SizeTypes[number];
+declare type TriggerArguments = {
+    collapse: () => void;
+    expand: () => void;
+    isOpen: boolean;
+};
+export interface PushState {
+    distance: string | number;
+}
+export interface DrawerProps {
+    afterVisibleChange?: (visible: boolean) => void;
+    animation?: 'push' | 'reveal';
+    autoFocus?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    closable?: boolean;
+    closeIcon?: React.ReactNode;
+    defaultOpen?: boolean;
+    destroyOnClose?: boolean;
+    direction?: Direction;
+    duration?: string;
+    ease?: string;
+    forceRender?: boolean;
+    getContainer?: GetContainer;
+    handler?: React.ReactElement | null | false;
+    height?: number | string;
+    keyboard?: boolean;
+    level?: string | string[] | null;
+    levelMove?: LevelMove | ((event: {
+        target: HTMLElement;
+        open: boolean;
+    }) => LevelMove);
+    maskClosable?: boolean;
+    maskStyle?: React.CSSProperties;
+    open?: boolean;
+    placement?: PlacementType;
+    prefixCls?: string;
+    push?: boolean | PushState;
+    showMask?: boolean;
+    size?: SizeType;
+    style?: React.CSSProperties;
+    trigger?: (args: TriggerArguments) => JSX.Element;
+    width?: number | string;
+    wrapperClassName?: string;
+    zIndex?: number;
+    onClose?: (event: EventType) => void;
+}
+export declare const Drawer: React.ForwardRefExoticComponent<DrawerProps & React.RefAttributes<DrawerRef>>;
+export {};

package/dist/cjs/components/Drawer/index.js

@@ -0,0 +1,189 @@
+"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 });
+exports.Drawer = void 0;
+const React = __importStar(require("react"));
+const js_utils_1 = require("@broxus/js-utils");
+const classnames_1 = __importDefault(require("classnames"));
+const rc_drawer_1 = __importDefault(require("rc-drawer"));
+const utils_1 = require("../../utils");
+require("./index.scss");
+const DrawerContext = React.createContext(null);
+const PlacementTypes = (0, js_utils_1.tuple)('top', 'right', 'bottom', 'left');
+const SizeTypes = (0, js_utils_1.tuple)('default', 'large');
+const defaultPushState = { distance: 180 };
+exports.Drawer = React.forwardRef((props, ref) => {
+    const { animation, children, className, defaultOpen, destroyOnClose, direction, duration = 'var(--drawer-transition-duration)', ease = 'var(--ease-in-out-circ)', keyboard = true, level = null, maskClosable = true, open, placement = 'right', prefixCls = 'uk-drawer', push = defaultPushState, showMask = true, size = 'default', style, trigger, wrapperClassName, zIndex, ...restProps } = props;
+    const forceUpdate = (0, utils_1.useForceUpdate)();
+    const parentDrawer = React.useContext(DrawerContext);
+    const destroyClose = React.useRef(false);
+    const [internalPush, setPush] = React.useState(false);
+    const [internalOpen, setOpen] = React.useState(defaultOpen);
+    // eslint-disable-next-line no-param-reassign
+    const mergedOpen = open === undefined ? internalOpen : open;
+    React.useEffect(() => {
+        // fix: delete drawer in child and re-render, no push started.
+        // <Drawer>{show && <Drawer />}</Drawer>
+        if (mergedOpen && parentDrawer) {
+            parentDrawer.push();
+        }
+        return () => {
+            if (parentDrawer) {
+                parentDrawer.pull();
+                // parentDrawer = null
+            }
+        };
+    }, []);
+    React.useEffect(() => {
+        if (parentDrawer) {
+            if (mergedOpen) {
+                parentDrawer.push();
+                forceUpdate();
+            }
+            else {
+                parentDrawer.pull();
+                forceUpdate();
+            }
+        }
+    }, [mergedOpen]);
+    const drawerClassName = React.useMemo(() => (0, classnames_1.default)({
+        [`${prefixCls}-${size}`]: size !== undefined,
+        [`${prefixCls}-${animation}`]: animation !== undefined,
+        [`${prefixCls}-rtl`]: direction === 'rtl',
+        'no-mask': !showMask,
+    }, className), [prefixCls, size, animation, showMask, direction, className]);
+    const drawerWrapperClassName = React.useMemo(() => (0, classnames_1.default)(`${prefixCls}-container`, {
+        [`${prefixCls}-${animation}-container`]: animation !== undefined,
+    }, wrapperClassName), [prefixCls, animation, wrapperClassName]);
+    const operations = React.useMemo(() => ({
+        pull() {
+            if (push) {
+                setPush(false);
+                forceUpdate();
+            }
+        },
+        push() {
+            if (push) {
+                setPush(true);
+                forceUpdate();
+            }
+        },
+    }), [push]);
+    React.useImperativeHandle(ref, () => operations, [operations]);
+    const isDestroyOnClose = destroyOnClose && !mergedOpen;
+    const afterVisibleChange = (visible) => {
+        restProps.afterVisibleChange?.(visible);
+        if (visible) {
+            (0, utils_1.addModalMode)();
+        }
+        else {
+            (0, utils_1.removeModalMode)();
+        }
+    };
+    const getRcDrawerStyle = () => {
+        // get drawer push width or height
+        const getPushTransform = (_placement) => {
+            let distance;
+            // noinspection SuspiciousTypeOfGuard
+            if (typeof push === 'boolean') {
+                distance = push ? defaultPushState.distance : 0;
+            }
+            else {
+                distance = push?.distance;
+            }
+            distance = parseFloat(String(distance || 0));
+            if (_placement === 'left' || _placement === 'right') {
+                return `translateX(${_placement === 'left' ? distance : -distance}px)`;
+            }
+            if (_placement === 'top' || _placement === 'bottom') {
+                return `translateY(${_placement === 'top' ? distance : -distance}px)`;
+            }
+            return '';
+        };
+        return {
+            transform: internalPush ? getPushTransform(placement) : undefined,
+            zIndex,
+            ...style,
+        };
+    };
+    const collapse = () => {
+        setOpen(false);
+    };
+    const expand = () => {
+        setOpen(true);
+    };
+    const onClose = (event) => {
+        setOpen(false);
+        restProps.onClose?.(event);
+    };
+    const onDestroyTransitionEnd = () => {
+        if (!isDestroyOnClose) {
+            return;
+        }
+        if (!mergedOpen) {
+            destroyClose.current = true;
+            forceUpdate();
+        }
+    };
+    const renderBody = () => {
+        if (destroyClose.current && !mergedOpen) {
+            return null;
+        }
+        destroyClose.current = false;
+        const containerStyle = {};
+        if (isDestroyOnClose) {
+            // Increase the opacity transition, delete children after closing.
+            containerStyle.opacity = 0;
+            containerStyle.transition = 'opacity var(--transition-duration)';
+        }
+        return (React.createElement("div", { className: `${prefixCls}-body-wrapper`, style: containerStyle, onTransitionEnd: onDestroyTransitionEnd },
+            React.createElement("div", { className: `${prefixCls}-body` }, children)));
+    };
+    return (React.createElement(DrawerContext.Provider, { value: operations },
+        trigger?.({ collapse, expand, isOpen: !!mergedOpen }),
+        React.createElement(rc_drawer_1.default, { ...{
+                afterVisibleChange,
+                children,
+                className: drawerClassName,
+                defaultOpen,
+                duration,
+                ease,
+                handler: false,
+                keyboard,
+                level: (animation !== undefined && level == null) ? 'all' : level,
+                maskClosable,
+                open: mergedOpen,
+                placement,
+                prefixCls,
+                showMask,
+                style: getRcDrawerStyle(),
+                wrapperClassName: drawerWrapperClassName,
+                ...restProps,
+                onClose,
+            } }, renderBody())));
+});

package/dist/cjs/components/Drop/index.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { TriggerProps } from 'rc-trigger';
+import type { ActionType, AlignType, AnimationType, BuildInPlacements } from 'rc-trigger/lib/interface';
+import './index.scss';
+export interface DropProps extends Pick<TriggerProps, 'children' | 'getPopupContainer' | 'mouseEnterDelay' | 'mouseLeaveDelay'> {
+    align?: AlignType;
+    alignPoint?: boolean;
+    animation?: AnimationType;
+    arrow?: boolean;
+    hideAction?: ActionType[];
+    minOverlayWidthMatchTrigger?: boolean;
+    openClassName?: string;
+    overlay?: (() => React.ReactElement) | React.ReactElement;
+    overlayClassName?: string;
+    overlayStyle?: React.CSSProperties;
+    placement?: string;
+    placements?: BuildInPlacements;
+    prefixCls?: string;
+    showAction?: ActionType[];
+    transitionName?: string;
+    trigger?: ActionType | ActionType[];
+    visible?: boolean;
+    onOverlayClick?: (e: Event) => void;
+    onVisibleChange?: (visible: boolean) => void;
+}
+export declare const Drop: React.ForwardRefExoticComponent<DropProps & React.RefAttributes<unknown>>;

package/dist/cjs/components/Drop/index.js

@@ -0,0 +1,87 @@
+"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 });
+exports.Drop = void 0;
+const React = __importStar(require("react"));
+const classnames_1 = __importDefault(require("classnames"));
+const rc_trigger_1 = __importDefault(require("rc-trigger"));
+const placements_1 = __importDefault(require("./placements"));
+require("./index.scss");
+exports.Drop = React.forwardRef((props, ref) => {
+    const { align, alignPoint, animation, arrow = false, children, getPopupContainer, hideAction, minOverlayWidthMatchTrigger, overlay, overlayClassName, overlayStyle, prefixCls = 'uk-drop', placement = 'bottom-left', placements = placements_1.default, showAction, transitionName = 'uk-motion-slide-up', trigger = ['hover'], visible, onOverlayClick, onVisibleChange, ...restProps } = props;
+    const triggerRef = React.useRef(null);
+    const [triggerVisible, setTriggerVisible] = React.useState();
+    const mergedVisible = 'visible' in restProps ? visible : triggerVisible;
+    const onPopupVisibleChange = (value) => {
+        setTriggerVisible(value);
+        onVisibleChange?.(value);
+    };
+    const getOverlayElement = () => {
+        if (typeof overlay === 'function') {
+            return overlay();
+        }
+        return overlay;
+    };
+    const getDropElement = () => (React.createElement(React.Fragment, null,
+        arrow && React.createElement("div", { className: `${prefixCls}-arrow` }),
+        React.cloneElement(getOverlayElement(), {
+            onClick: onOverlayClick,
+        })));
+    const getDropElementOrLambda = () => {
+        if (typeof overlay === 'function') {
+            return getDropElement;
+        }
+        return getDropElement();
+    };
+    const getMinOverlayWidthMatchTrigger = () => {
+        if (minOverlayWidthMatchTrigger !== undefined) {
+            return minOverlayWidthMatchTrigger;
+        }
+        return !alignPoint;
+    };
+    const renderChildren = () => {
+        const childrenProps = children.props ? children.props : {};
+        const childClassName = (0, classnames_1.default)(childrenProps.className, 'uk-open');
+        return triggerVisible && children
+            ? React.cloneElement(children, {
+                className: childClassName,
+            })
+            : children;
+    };
+    React.useImperativeHandle(ref, () => triggerRef.current);
+    let triggerHideAction = hideAction;
+    if (!triggerHideAction && trigger.indexOf('contextMenu') > -1) {
+        triggerHideAction = ['click'];
+    }
+    return (React.createElement(rc_trigger_1.default, { ref: triggerRef, ...restProps, action: trigger, builtinPlacements: placements, getPopupContainer: getPopupContainer, hideAction: triggerHideAction || [], popup: getDropElementOrLambda(), popupAlign: align, popupAnimation: animation, popupClassName: (0, classnames_1.default)(overlayClassName, {
+            [`${prefixCls}-show-arrow`]: arrow,
+        }), popupPlacement: placement, popupStyle: overlayStyle, popupTransitionName: transitionName, popupVisible: mergedVisible, prefixCls: prefixCls, showAction: showAction, stretch: getMinOverlayWidthMatchTrigger() ? 'minWidth' : '', onPopupVisibleChange: onPopupVisibleChange }, renderChildren()));
+});
+if (process.env.NODE_ENV !== 'production') {
+    exports.Drop.displayName = 'Drop';
+}