amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/ConfirmBox.js

@@ -0,0 +1,129 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __read, __awaiter, __generator } from 'tslib';
+import React__default from 'react';
+import FinalModal from './Modal.js';
+import Button from './Button.js';
+import Drawer from './Drawer.js';
+import { localeable, themeable } from 'amis-core';
+import Spinner from './Spinner.js';
+import PopUp from './PopUp.js';
+import { findDOMNode } from 'react-dom';
+
+function ConfirmBox(_a) {
+    var _this = this;
+    var type = _a.type, size = _a.size, closeOnEsc = _a.closeOnEsc, show = _a.show, onCancel = _a.onCancel, title = _a.title, showTitle = _a.showTitle, headerClassName = _a.headerClassName, __ = _a.translate, children = _a.children, showFooter = _a.showFooter, onConfirm = _a.onConfirm, beforeConfirm = _a.beforeConfirm, popOverContainer = _a.popOverContainer, position = _a.position, resizable = _a.resizable, cx = _a.classnames, className = _a.className, bodyClassName = _a.bodyClassName, footerClassName = _a.footerClassName, mobileUI = _a.mobileUI, disabled = _a.disabled, testIdBuilder = _a.testIdBuilder, onEntered = _a.onEntered, onExited = _a.onExited;
+    var _b = __read(React__default.useState(), 2), loading = _b[0], setLoading = _b[1];
+    var _c = __read(React__default.useState(), 2), error = _c[0], setError = _c[1];
+    var bodyRef = React__default.useRef();
+    var bodyDomRef = React__default.useRef();
+    var getPopOverContainer = React__default.useCallback(function () {
+        var dom = bodyDomRef.current && !bodyDomRef.current.nodeType
+            ? findDOMNode(bodyDomRef.current)
+            : null;
+        return dom === null || dom === void 0 ? void 0 : dom.parentElement;
+    }, []);
+    var handleConfirm = React__default.useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var ret, _a, e_1;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    setError('');
+                    setLoading(true);
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 7, 8, 9]);
+                    if (!beforeConfirm) return [3 /*break*/, 3];
+                    return [4 /*yield*/, (beforeConfirm === null || beforeConfirm === void 0 ? void 0 : beforeConfirm(bodyRef.current))];
+                case 2:
+                    _a = _d.sent();
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, ((_c = (_b = bodyRef.current) === null || _b === void 0 ? void 0 : _b.submit) === null || _c === void 0 ? void 0 : _c.call(_b))];
+                case 4:
+                    _a = _d.sent();
+                    _d.label = 5;
+                case 5:
+                    ret = _a;
+                    if (ret === false) {
+                        return [2 /*return*/];
+                    }
+                    else if (typeof ret === 'string') {
+                        setError(ret);
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, (onConfirm === null || onConfirm === void 0 ? void 0 : onConfirm(ret))];
+                case 6:
+                    _d.sent();
+                    return [3 /*break*/, 9];
+                case 7:
+                    e_1 = _d.sent();
+                    setError(e_1.message);
+                    return [3 /*break*/, 9];
+                case 8:
+                    setLoading(false);
+                    setTimeout(function () { return setError(''); }, 5000);
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/];
+            }
+        });
+    }); }, [onConfirm, beforeConfirm]);
+    React__default.useEffect(function () {
+        show && setError('');
+    }, [show]);
+    function renderDialog() {
+        return mobileUI ? (React__default.createElement(PopUp, { isShow: show, showConfirm: true, onConfirm: handleConfirm, onHide: onCancel, container: popOverContainer, onEntered: onEntered, onExited: onExited }, typeof children === 'function'
+            ? children({
+                bodyRef: bodyRef,
+                loading: loading,
+                popOverContainer: getPopOverContainer,
+                onConfirm: handleConfirm
+            })
+            : children)) : (React__default.createElement(FinalModal, { size: size, closeOnEsc: closeOnEsc, show: show, onHide: onCancel, container: popOverContainer, className: className, onEntered: onEntered, onExited: onExited },
+            showTitle !== false && title ? (React__default.createElement(FinalModal.Header, { onClose: onCancel, className: headerClassName }, title)) : null,
+            React__default.createElement(FinalModal.Body, { ref: bodyDomRef, className: bodyClassName }, typeof children === 'function'
+                ? children({
+                    bodyRef: bodyRef,
+                    loading: loading,
+                    onConfirm: handleConfirm,
+                    popOverContainer: getPopOverContainer
+                })
+                : children),
+            (showFooter !== null && showFooter !== void 0 ? showFooter : true) ? (React__default.createElement(FinalModal.Footer, { className: footerClassName },
+                loading || error ? (React__default.createElement("div", { className: cx('Dialog-info') },
+                    React__default.createElement(Spinner, { size: "sm", key: "info", show: loading }),
+                    error ? (React__default.createElement("span", { className: cx('Dialog-error') }, error)) : null)) : null,
+                React__default.createElement(Button, { disabled: loading, onClick: onCancel, testIdBuilder: testIdBuilder === null || testIdBuilder === void 0 ? void 0 : testIdBuilder.getChild('cancel') }, __('cancel')),
+                React__default.createElement(Button, { disabled: loading || disabled, onClick: handleConfirm, level: "primary", testIdBuilder: testIdBuilder === null || testIdBuilder === void 0 ? void 0 : testIdBuilder.getChild('confirm') }, __('confirm')))) : null));
+    }
+    function renderDrawer() {
+        return (React__default.createElement(Drawer, { size: size, closeOnEsc: closeOnEsc, show: show, onHide: onCancel, container: popOverContainer, position: position, resizable: resizable, showCloseButton: false, className: className },
+            showTitle !== false && title ? (React__default.createElement("div", { className: cx('Drawer-header', headerClassName) },
+                React__default.createElement("div", { className: cx('Drawer-title') }, title))) : null,
+            React__default.createElement("div", { ref: bodyDomRef, className: cx('Drawer-body', bodyClassName) }, typeof children === 'function'
+                ? children({
+                    bodyRef: bodyRef,
+                    loading: loading,
+                    popOverContainer: getPopOverContainer,
+                    onConfirm: handleConfirm
+                })
+                : children),
+            (showFooter !== null && showFooter !== void 0 ? showFooter : true) ? (React__default.createElement("div", { className: cx('Drawer-footer', footerClassName) },
+                loading || error ? (React__default.createElement("div", { className: cx('Drawer-info') },
+                    React__default.createElement(Spinner, { size: "sm", key: "info", show: loading }),
+                    error ? (React__default.createElement("span", { className: cx('Drawer-error') }, error)) : null)) : null,
+                React__default.createElement(Button, { onClick: handleConfirm, level: "primary" }, __('confirm')),
+                React__default.createElement(Button, { onClick: onCancel }, __('cancel')))) : null));
+    }
+    return type === 'drawer' ? renderDrawer() : renderDialog();
+}
+ConfirmBox.defaultProps = {
+    type: 'dialog',
+    position: 'right'
+};
+var ConfirmBox$1 = localeable(themeable(ConfirmBox));
+
+export { ConfirmBox, ConfirmBox$1 as default };

package/esm/components/ContextMenu.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="hoist-non-react-statics" />
+import { ClassNamesFn } from 'amis-core';
+import React from 'react';
+import type { DebouncedFunc } from 'lodash';
+interface ContextMenuProps {
+    className?: string;
+    classPrefix: string;
+    classnames: ClassNamesFn;
+    container?: HTMLElement | null | (() => HTMLElement);
+}
+export type MenuItem = {
+    id?: string;
+    label: string | React.ReactNode;
+    icon?: string;
+    disabled?: boolean;
+    children?: Array<MenuItem | MenuDivider>;
+    data?: any;
+    className?: string;
+    selected?: boolean;
+    onSelect?: (data: any) => void;
+    onHighlight?: (isHiglight: boolean, data: any) => void;
+};
+export type MenuDivider = '|';
+interface ContextMenuState {
+    isOpened: boolean;
+    menus: Array<MenuItem | MenuDivider> | (() => JSX.Element);
+    x: number;
+    y: number;
+    cursorX: number;
+    cursorY: number;
+    align?: 'left' | 'right';
+    onClose?: (ctx: ContextMenu) => void;
+    contentClassName?: string;
+    preventClose?: (e?: Event) => boolean;
+}
+export declare class ContextMenu extends React.Component<ContextMenuProps, ContextMenuState> {
+    static instance: any;
+    debounceCalculatePosition: DebouncedFunc<(menu: HTMLElement) => void>;
+    static getInstance(): Promise<any>;
+    state: ContextMenuState;
+    menuRef: React.RefObject<HTMLDivElement>;
+    contentRef: React.RefObject<HTMLDivElement>;
+    originInstance: this | null;
+    prevInfo: {
+        x: number;
+        y: number;
+    } | null;
+    unmount: boolean;
+    menuEntered: boolean;
+    constructor(props: ContextMenuProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    openContextMenus(info: {
+        x: number;
+        y: number;
+    }, menus: Array<MenuItem>, onClose?: (ctx: ContextMenu) => void, options?: {
+        contentClassName?: string;
+        preventClose?: (e?: Event) => boolean;
+    }): void;
+    close(e?: Event): void;
+    handleOutClick(e: Event): void;
+    handleClick(item: MenuItem): void;
+    handleKeyDown(e: KeyboardEvent): void;
+    handleMouseEnter(item: MenuItem): void;
+    handleMouseLeave(item: MenuItem): void;
+    resizeObserver: null | ResizeObserver;
+    handleEnter(menu: HTMLElement): void;
+    handleEntered(menu: HTMLElement): void;
+    autoCalculatePosition(menu: HTMLElement): void;
+    handleSelfContextMenu(e: React.MouseEvent): void;
+    renderMenus(menus: Array<MenuItem | MenuDivider>): React.JSX.Element[];
+    render(): React.JSX.Element;
+}
+export declare const ThemedContextMenu: {
+    new (props: Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<ContextMenuProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof ContextMenu>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof ContextMenu, {}> & {
+    ComposedComponent: typeof ContextMenu;
+};
+export default ThemedContextMenu;
+export declare function openContextMenus(info: Event | {
+    x: number;
+    y: number;
+}, menus: Array<MenuItem | MenuDivider> | (() => React.ReactNode), onClose?: (ctx: ContextMenu) => void, options?: {
+    contentClassName?: string;
+    preventClose?: (e?: Event) => boolean;
+}): Promise<any>;
+export declare function closeContextMenus(): Promise<any>;

package/esm/components/ContextMenu.js

@@ -0,0 +1,310 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __awaiter, __generator, __decorate, __metadata } from 'tslib';
+import { calculatePosition, autobind, themeable } from 'amis-core';
+import React__default from 'react';
+import { render } from 'react-dom';
+import Transition, { ENTERING, ENTERED, EXITING } from 'react-transition-group/Transition';
+import debounce from 'lodash/debounce';
+
+var _a;
+// import {createRoot} from 'react-dom/client';
+var fadeStyles = (_a = {},
+    _a[ENTERING] = 'in',
+    _a[ENTERED] = 'in',
+    _a[EXITING] = 'out',
+    _a);
+var ContextMenu = /** @class */ (function (_super) {
+    __extends(ContextMenu, _super);
+    function ContextMenu(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isOpened: false,
+            menus: [],
+            x: -99999,
+            y: -99999,
+            cursorX: -99999,
+            cursorY: -99999
+        };
+        _this.menuRef = React__default.createRef();
+        _this.contentRef = React__default.createRef();
+        _this.unmount = false;
+        _this.menuEntered = false;
+        _this.resizeObserver = null;
+        _this.originInstance = ContextMenu.instance;
+        ContextMenu.instance = _this;
+        _this.debounceCalculatePosition = debounce(_this.autoCalculatePosition.bind(_this), 200);
+        return _this;
+    }
+    ContextMenu.getInstance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var container, div;
+            return __generator(this, function (_a) {
+                if (!ContextMenu.instance || ContextMenu.instance.unmount) {
+                    container = document.body;
+                    div = document.createElement('div');
+                    container.appendChild(div);
+                    // if (parseInt(version.split('.')[0], 10) >= 18) {
+                    //   const root = createRoot(div);
+                    //   await new Promise<void>(resolve =>
+                    //     root.render(<ThemedContextMenu ref={() => resolve()} />)
+                    //   );
+                    // } else {
+                    render(React__default.createElement(ThemedContextMenu, null), div);
+                    // }
+                }
+                return [2 /*return*/, ContextMenu.instance];
+            });
+        });
+    };
+    ContextMenu.prototype.componentDidMount = function () {
+        document.body.addEventListener('click', this.handleOutClick, true);
+        document.addEventListener('keydown', this.handleKeyDown);
+    };
+    ContextMenu.prototype.componentWillUnmount = function () {
+        this.unmount = true;
+        this.debounceCalculatePosition.cancel();
+        ContextMenu.instance = this.originInstance;
+        document.body.removeEventListener('click', this.handleOutClick, true);
+        document.removeEventListener('keydown', this.handleKeyDown);
+        // @ts-ignore
+        delete this.originInstance;
+    };
+    ContextMenu.prototype.openContextMenus = function (info, menus, onClose, options) {
+        var _this = this;
+        if (this.state.isOpened) {
+            var _a = this.state, x = _a.x, y = _a.y;
+            var cursorX = x + (info.x - (this.prevInfo && this.prevInfo.x ? this.prevInfo.x : 0));
+            var cursorY = y + (info.y - (this.prevInfo && this.prevInfo.y ? this.prevInfo.y : 0));
+            // 避免 二次触发未进行智能定位 导致遮挡问题
+            this.setState({
+                x: cursorX,
+                y: cursorY,
+                cursorX: cursorX,
+                cursorY: cursorY,
+                menus: menus,
+                onClose: onClose,
+                contentClassName: options === null || options === void 0 ? void 0 : options.contentClassName,
+                preventClose: options === null || options === void 0 ? void 0 : options.preventClose
+            }, function () {
+                _this.handleEnter(_this.menuRef.current);
+            });
+        }
+        else {
+            this.setState({
+                isOpened: true,
+                x: info.x,
+                y: info.y,
+                cursorX: info.x,
+                cursorY: info.y,
+                menus: menus,
+                onClose: onClose,
+                contentClassName: options === null || options === void 0 ? void 0 : options.contentClassName,
+                preventClose: options === null || options === void 0 ? void 0 : options.preventClose
+            });
+        }
+        this.prevInfo = info;
+    };
+    ContextMenu.prototype.close = function (e) {
+        var _this = this;
+        var _a, _b, _c, _d;
+        if ((_b = (_a = this.state).preventClose) === null || _b === void 0 ? void 0 : _b.call(_a, e)) {
+            return;
+        }
+        (_c = e === null || e === void 0 ? void 0 : e.preventDefault) === null || _c === void 0 ? void 0 : _c.call(e);
+        this.menuEntered = false;
+        (_d = this.resizeObserver) === null || _d === void 0 ? void 0 : _d.disconnect();
+        var onClose = this.state.onClose;
+        this.setState({
+            isOpened: false,
+            x: -99999,
+            y: -99999,
+            cursorX: -99999,
+            cursorY: -99999,
+            menus: [],
+            contentClassName: '',
+            preventClose: undefined
+        }, function () {
+            onClose === null || onClose === void 0 ? void 0 : onClose(_this);
+        });
+    };
+    ContextMenu.prototype.handleOutClick = function (e) {
+        if (!this.menuEntered ||
+            !e.target ||
+            !this.menuRef.current ||
+            this.menuRef.current.contains(e.target)) {
+            return;
+        }
+        if (this.state.isOpened) {
+            this.close(e);
+        }
+    };
+    ContextMenu.prototype.handleClick = function (item) {
+        var _this = this;
+        var onClose = this.state.onClose;
+        item.disabled ||
+            (Array.isArray(item.children) && item.children.length) ||
+            this.setState({
+                isOpened: false,
+                x: -99999,
+                y: -99999,
+                cursorX: -99999,
+                cursorY: -99999,
+                menus: []
+            }, function () {
+                var _a;
+                (_a = item.onSelect) === null || _a === void 0 ? void 0 : _a.call(item, item.data);
+                onClose === null || onClose === void 0 ? void 0 : onClose(_this);
+            });
+    };
+    ContextMenu.prototype.handleKeyDown = function (e) {
+        if (e.keyCode === 27 && this.state.isOpened) {
+            this.close(e);
+        }
+    };
+    ContextMenu.prototype.handleMouseEnter = function (item) {
+        item.disabled || !item.onHighlight || item.onHighlight(true, item.data);
+    };
+    ContextMenu.prototype.handleMouseLeave = function (item) {
+        item.disabled || !item.onHighlight || item.onHighlight(false, item.data);
+    };
+    ContextMenu.prototype.handleEnter = function (menu) {
+        this.autoCalculatePosition(menu);
+    };
+    ContextMenu.prototype.handleEntered = function (menu) {
+        var _this = this;
+        this.menuEntered = true;
+        if (!this.contentRef.current || !window.ResizeObserver) {
+            return;
+        }
+        // 监听菜单大小变化，并自动重新计算位置
+        this.resizeObserver = new ResizeObserver(function (entries) {
+            entries.length && _this.debounceCalculatePosition(menu);
+        });
+        this.resizeObserver.observe(this.contentRef.current);
+    };
+    ContextMenu.prototype.autoCalculatePosition = function (menu) {
+        var lastChild = menu.lastChild;
+        // 因为 debounce 的原因，可能menu 已经被卸载了。
+        if (!(lastChild === null || lastChild === void 0 ? void 0 : lastChild.offsetWidth)) {
+            return;
+        }
+        // 智能定位，选择一个合适的对齐方式。
+        var info = calculatePosition('asContextMenu', lastChild, menu.children[1], menu.children[0]);
+        var align = info.positionLeft + 300 < window.innerWidth ? 'right' : 'left';
+        this.setState({
+            x: info.positionLeft,
+            y: info.positionTop,
+            align: align
+        });
+    };
+    ContextMenu.prototype.handleSelfContextMenu = function (e) {
+        e.preventDefault();
+    };
+    ContextMenu.prototype.renderMenus = function (menus) {
+        var _this = this;
+        var cx = this.props.classnames;
+        return menus.map(function (item, index) {
+            if (item === '|') {
+                return React__default.createElement("li", { key: index, className: cx('ContextMenu-divider') });
+            }
+            var hasChildren = Array.isArray(item.children) && item.children.length;
+            return (React__default.createElement("li", { key: "".concat(item.label, "-").concat(index), className: cx('ContextMenu-item', item.className, {
+                    'has-child': hasChildren,
+                    'is-disabled': item.disabled,
+                    'is-active': item.selected
+                }) },
+                React__default.createElement("a", { onClick: _this.handleClick.bind(_this, item), onMouseEnter: _this.handleMouseEnter.bind(_this, item), onMouseLeave: _this.handleMouseLeave.bind(_this, item) },
+                    item.icon ? (React__default.createElement("span", { className: cx('ContextMenu-itemIcon', item.icon) })) : null,
+                    item.label,
+                    hasChildren ? React__default.createElement("i", { className: "fas fa-chevron-right" }) : null,
+                    item.selected ? React__default.createElement("i", { className: "fas fa-check" }) : null),
+                hasChildren ? (React__default.createElement("ul", { className: cx('ContextMenu-subList') }, _this.renderMenus(item.children))) : null));
+        });
+    };
+    ContextMenu.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, className = _a.className; _a.container; var cx = _a.classnames;
+        return (React__default.createElement(Transition, { mountOnEnter: true, unmountOnExit: true, onEnter: this.handleEnter, in: this.state.isOpened, timeout: 500, onEntered: this.handleEntered }, function (status) { return (React__default.createElement("div", { ref: _this.menuRef, role: "contextmenu", className: cx('ContextMenu', {
+                'ContextMenu--left': _this.state.align === 'left'
+            }, className, _this.state.contentClassName), onContextMenu: _this.handleSelfContextMenu },
+            React__default.createElement("div", { className: cx("ContextMenu-overlay", fadeStyles[status]) }),
+            React__default.createElement("div", { className: cx("ContextMenu-cursor"), style: {
+                    left: "".concat(_this.state.cursorX, "px"),
+                    top: "".concat(_this.state.cursorY, "px")
+                } }),
+            React__default.createElement("div", { ref: _this.contentRef, style: { left: "".concat(_this.state.x, "px"), top: "".concat(_this.state.y, "px") }, className: cx("ContextMenu-menu", fadeStyles[status]) }, typeof _this.state.menus === 'function' ? (_this.state.menus()) : (React__default.createElement("ul", { className: cx('ContextMenu-list') }, _this.renderMenus(_this.state.menus)))))); }));
+    };
+    ContextMenu.instance = null;
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Array, Function, Object]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "openContextMenus", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Event]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Event]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "handleOutClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [KeyboardEvent]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "handleKeyDown", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [HTMLElement]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "handleEnter", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [HTMLElement]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "handleEntered", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [HTMLElement]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "autoCalculatePosition", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], ContextMenu.prototype, "handleSelfContextMenu", null);
+    return ContextMenu;
+}(React__default.Component));
+var ThemedContextMenu = themeable(ContextMenu);
+function openContextMenus(info, menus, onClose, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, ContextMenu.getInstance().then(function (instance) {
+                    return instance.openContextMenus(info, menus, onClose, options);
+                })];
+        });
+    });
+}
+function closeContextMenus() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, ContextMenu.getInstance().then(function (instance) { return instance === null || instance === void 0 ? void 0 : instance.close(); })];
+        });
+    });
+}
+
+export { ContextMenu, ThemedContextMenu, closeContextMenus, ThemedContextMenu as default, openContextMenus };