amis-rev-ui 6.13.0

package/esm/components/PickerColumn.js

@@ -0,0 +1,276 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __read, __assign } from 'tslib';
+import React__default, { forwardRef, useRef, useMemo, useCallback, useEffect, useImperativeHandle } from 'react';
+import isObject from 'lodash/isObject';
+import cloneDeep from 'lodash/cloneDeep';
+import { themeable, uncontrollable, range, highlight, labelToString } from 'amis-rev-core';
+import useSetState from '../hooks/use-set-state.js';
+import useUpdateEffect from '../hooks/use-update-effect.js';
+import useTouch from '../hooks/use-touch.js';
+import 'lodash/pick';
+
+var DEFAULT_DURATION = 200;
+var MOMENTUM_LIMIT_TIME = 300;
+var MOMENTUM_LIMIT_DISTANCE = 15;
+function getElementTranslateY(element) {
+    if (!element) {
+        return 0;
+    }
+    var style = window.getComputedStyle(element);
+    var transform = style.transform || style.webkitTransform;
+    // 格式如：matrix( scaleX(), skewY(), skewX(), scaleY(), translateX(), translateY() );
+    var translateY = transform.slice(7, transform.length - 1).split(', ')[5];
+    return Number(translateY);
+}
+function isOptionDisabled(option) {
+    return isObject(option) && option.disabled;
+}
+var PickerColumn = forwardRef(function (props, ref) {
+    var _a = props.visibleItemCount, visibleItemCount = _a === void 0 ? 5 : _a, _b = props.itemHeight, itemHeight = _b === void 0 ? 48 : _b, value = props.value, _c = props.valueField, valueField = _c === void 0 ? 'value' : _c, _d = props.swipeDuration, swipeDuration = _d === void 0 ? 1000 : _d, _e = props.labelField, labelField = _e === void 0 ? 'text' : _e, _f = props.highlightTxt, highlightTxt = _f === void 0 ? '' : _f, _g = props.options, options = _g === void 0 ? [] : _g, cx = props.classnames;
+    var root = useRef(null);
+    var menuItemRef = useRef(null);
+    var wrapper = useRef(null);
+    var moving = useRef(false);
+    var startOffset = useRef(0);
+    var transitionEndTrigger = useRef(null);
+    var touchStartTime = useRef(0);
+    var momentumOffset = useRef(0);
+    var touch = useTouch();
+    var count = options.length;
+    var getOptionText = function (option) {
+        if (isObject(option) && labelField in option) {
+            //@ts-ignore
+            return labelToString(option[labelField]);
+        }
+        return labelToString(option);
+    };
+    var getOptionValue = function (option) {
+        if (isObject(option) && valueField in option) {
+            //@ts-ignore
+            return option[valueField];
+        }
+        return option;
+    };
+    var defaultIndex = options.findIndex(function (item) { return getOptionValue(item) === value; });
+    var baseOffset = useMemo(function () {
+        // 默认转入第一个选项的位置
+        return (itemHeight * (+visibleItemCount - 1)) / 2;
+    }, [itemHeight, visibleItemCount]);
+    var adjustIndex = function (index) {
+        index = range(index, 0, count);
+        if (!options) {
+            return;
+        }
+        for (var i = index; i < count; i += 1) {
+            if (!isOptionDisabled(options[i]))
+                return i;
+        }
+        for (var i = index - 1; i >= 0; i -= 1) {
+            if (!isOptionDisabled(options[i]))
+                return i;
+        }
+        return null;
+    };
+    var _h = __read(useSetState({
+        index: adjustIndex(defaultIndex) || 0,
+        offset: 0,
+        duration: 0,
+        options: cloneDeep(options)
+    }), 2), state = _h[0], updateState = _h[1];
+    /**
+     *
+     * @param index 索引
+     * @param emitChange 是否派发变动消息
+     * @param confirm 是否为确认类型，为真时触发value改变
+     */
+    var setIndex = function (index, emitChange, confirm) {
+        index = adjustIndex(index) || 0;
+        var offset = -index * itemHeight;
+        var trigger = function () {
+            updateState({ index: index });
+            if (emitChange && props.onChange) {
+                requestAnimationFrame(function () {
+                    var _a;
+                    (_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, getOptionValue(options[index]), index, confirm);
+                });
+            }
+        };
+        // trigger the change event after transitionend when moving
+        if (moving.current && offset !== state.offset) {
+            //@ts-ignore
+            transitionEndTrigger.current = trigger;
+        }
+        else {
+            trigger();
+        }
+        updateState({ offset: offset });
+    };
+    var setOptions = function (options) {
+        if (JSON.stringify(options) !== JSON.stringify(state.options)) {
+            updateState({ options: options });
+            var index = options.findIndex(function (item) { return getOptionValue(item) === value; }) || 0;
+            setIndex(index, true, true);
+        }
+    };
+    var onClickItem = function (index) {
+        if (moving.current || props.readonly) {
+            return;
+        }
+        transitionEndTrigger.current = null;
+        updateState({ duration: DEFAULT_DURATION });
+        setIndex(index, true, true);
+    };
+    var getIndexByOffset = function (offset) {
+        return range(Math.round(-offset / itemHeight), 0, count - 1);
+    };
+    var momentum = function (distance, duration) {
+        var speed = Math.abs(distance / duration);
+        distance = state.offset + (speed / 0.003) * (distance < 0 ? -1 : 1);
+        var index = getIndexByOffset(distance);
+        updateState({ duration: +swipeDuration });
+        setIndex(index, true);
+    };
+    var stopMomentum = function () {
+        moving.current = false;
+        updateState({ duration: 0 });
+        if (transitionEndTrigger.current) {
+            //@ts-ignore
+            transitionEndTrigger.current();
+            transitionEndTrigger.current = null;
+        }
+    };
+    var onTouchStart = function (event) {
+        if (props.readonly) {
+            return;
+        }
+        touch.start(event);
+        var offset = state.offset;
+        if (moving.current) {
+            var translateY = getElementTranslateY(wrapper.current);
+            offset = Math.min(0, translateY - baseOffset);
+            startOffset.current = offset;
+        }
+        else {
+            startOffset.current = offset;
+        }
+        updateState({ duration: 0, offset: offset });
+        touchStartTime.current = Date.now();
+        momentumOffset.current = startOffset.current;
+        transitionEndTrigger.current = null;
+    };
+    var onTouchMove = function (event) {
+        if (props.readonly) {
+            return;
+        }
+        touch.move(event);
+        if (touch.isVertical()) {
+            moving.current = true;
+        }
+        var offset = range(startOffset.current + touch.deltaY, -(count * itemHeight), itemHeight);
+        updateState({
+            offset: offset
+        });
+        var now = Date.now();
+        if (now - touchStartTime.current > MOMENTUM_LIMIT_TIME) {
+            touchStartTime.current = now;
+            momentumOffset.current = offset;
+        }
+    };
+    var onTouchEnd = function () {
+        if (props.readonly) {
+            return;
+        }
+        var distance = state.offset - momentumOffset.current;
+        var duration = Date.now() - touchStartTime.current;
+        var allowMomentum = duration < MOMENTUM_LIMIT_TIME &&
+            Math.abs(distance) > MOMENTUM_LIMIT_DISTANCE;
+        if (allowMomentum) {
+            momentum(distance, duration);
+            return;
+        }
+        var index = getIndexByOffset(state.offset);
+        updateState({ duration: DEFAULT_DURATION });
+        setIndex(index, true);
+        // compatible with desktop scenario
+        // use setTimeout to skip the click event triggered after touchstart
+        setTimeout(function () {
+            moving.current = false;
+        }, 0);
+    };
+    var renderOptions = function () {
+        var style = {
+            height: "".concat(itemHeight, "px"),
+            lineHeight: "".concat(itemHeight, "px")
+        };
+        return state.options.map(function (option, index) {
+            var text = getOptionText(option);
+            var disabled = isOptionDisabled(option);
+            var data = {
+                role: 'button',
+                key: index,
+                style: style,
+                tabIndex: disabled ? -1 : 0,
+                className: props.classnames("PickerColumns-columnItem", {
+                    'is-disabled': disabled,
+                    'is-selected': index === state.index
+                }),
+                onClick: function () {
+                    onClickItem(index);
+                }
+            };
+            var childData = {
+                className: 'text-ellipsis',
+                children: (highlightTxt
+                    ? highlight(text, highlightTxt, cx('Select-option-hl'))
+                    : text)
+            };
+            return (React__default.createElement("li", __assign({}, data, { ref: menuItemRef }), props.optionRender ? (props.optionRender(option, { index: index, checked: state.index === index })) : (React__default.createElement("div", __assign({}, childData)))));
+        });
+    };
+    var setValue = function (value) {
+        var options = state.options;
+        for (var i = 0; i < options.length; i += 1) {
+            if (options[i] === value) {
+                return setIndex(i);
+            }
+        }
+        return null;
+    };
+    var getValue = useCallback(function () { return state.options[state.index]; }, [state.index, state.options]);
+    useEffect(function () {
+        setIndex(defaultIndex);
+    }, [defaultIndex]);
+    useUpdateEffect(function () {
+        setOptions(cloneDeep(options));
+    }, [options]);
+    useImperativeHandle(ref, function () { return ({
+        state: state,
+        setIndex: setIndex,
+        getValue: getValue,
+        setValue: setValue,
+        setOptions: setOptions,
+        stopMomentum: stopMomentum
+    }); });
+    var wrapperStyle = {
+        transform: "translate3d(0, ".concat(state.offset + baseOffset, "px, 0)"),
+        transitionDuration: "".concat(state.duration, "ms"),
+        transitionProperty: state.duration ? 'all' : 'none'
+    };
+    return (React__default.createElement("div", { ref: root, className: props.classnames('PickerColumns', props.className), onTouchStart: onTouchStart, onTouchMove: onTouchMove, onTouchEnd: onTouchEnd, onTouchCancel: onTouchEnd },
+        React__default.createElement("ul", { ref: wrapper, style: wrapperStyle, className: props.classnames('PickerColumns-columnWrapper'), onTransitionEnd: stopMomentum }, renderOptions())));
+});
+PickerColumn.defaultProps = {
+    options: [],
+    visibleItemCount: 5,
+    swipeDuration: 1000,
+    itemHeight: 48
+};
+var Column = themeable(uncontrollable(PickerColumn, {
+    value: 'onChange'
+}));
+
+export { Column as default };

package/esm/components/PickerContainer.js

@@ -0,0 +1,157 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __spreadArray, __read, __awaiter, __generator, __assign, __rest, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { isObject, autobind, themeable, localeable } from 'amis-rev-core';
+import ConfirmBox from './ConfirmBox.js';
+
+var PickerContainer = /** @class */ (function (_super) {
+    __extends(PickerContainer, _super);
+    function PickerContainer() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.state = {
+            isOpened: false,
+            value: _this.props.value
+        };
+        return _this;
+    }
+    PickerContainer.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (props.value !== prevProps.value) {
+            this.setState({
+                value: props.value
+            });
+        }
+    };
+    PickerContainer.prototype.handleClick = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, _a;
+            var _this = this;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = [{ value: this.props.value }];
+                        return [4 /*yield*/, ((_c = (_b = this.props).onPickerOpen) === null || _c === void 0 ? void 0 : _c.call(_b, this.props))];
+                    case 1:
+                        state = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_d.sent())])), { isOpened: true }]);
+                        this.setState(state, function () { var _a, _b; return (_b = (_a = _this.props).onFocus) === null || _b === void 0 ? void 0 : _b.call(_a); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PickerContainer.prototype.close = function (e, callback) {
+        var _this = this;
+        this.setState({
+            isOpened: false
+        }, function () {
+            var _a, _b, _c, _d;
+            (_b = (_a = _this.props).onClose) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (callback) {
+                callback();
+                return;
+            }
+            (_d = (_c = _this.props).onCancel) === null || _d === void 0 ? void 0 : _d.call(_c);
+        });
+    };
+    PickerContainer.prototype.handleChange = function (value) {
+        this.setState({
+            value: value
+        });
+    };
+    PickerContainer.prototype.beforeConfirm = function (form) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onConfirm, beforeConfirm, ret, _b, state;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = this.props, onConfirm = _a.onConfirm, beforeConfirm = _a.beforeConfirm;
+                        if (!beforeConfirm) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (beforeConfirm === null || beforeConfirm === void 0 ? void 0 : beforeConfirm(form))];
+                    case 1:
+                        _b = _e.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, ((_c = form === null || form === void 0 ? void 0 : form.submit) === null || _c === void 0 ? void 0 : _c.call(form))];
+                    case 3:
+                        _b = _e.sent();
+                        _e.label = 4;
+                    case 4:
+                        ret = _b;
+                        state = {
+                            isOpened: false
+                        };
+                        // beforeConfirm 返回 false 则阻止后续动作
+                        if (ret === false) {
+                            return [2 /*return*/, false];
+                        }
+                        else if (isObject(ret)) {
+                            state.value = ret;
+                        }
+                        return [4 /*yield*/, (onConfirm === null || onConfirm === void 0 ? void 0 : onConfirm((_d = state.value) !== null && _d !== void 0 ? _d : this.state.value))];
+                    case 5:
+                        _e.sent();
+                        this.setState(state);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PickerContainer.prototype.updateState = function (state) {
+        if (state === void 0) { state = {}; }
+        state.isOpened; var rest = __rest(state, ["isOpened"]);
+        this.setState(__assign(__assign({}, this.state), rest));
+    };
+    PickerContainer.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, children = _a.children, popOverRender = _a.bodyRender, title = _a.title, showTitle = _a.showTitle, headerClassName = _a.headerClassName, bodyClassName = _a.bodyClassName, className = _a.className, __ = _a.translate, size = _a.size, showFooter = _a.showFooter, closeOnEsc = _a.closeOnEsc, popOverContainer = _a.popOverContainer, mobileUI = _a.mobileUI, disabled = _a.disabled, testIdBuilder = _a.testIdBuilder;
+        return (React__default.createElement(React__default.Fragment, null,
+            children({
+                isOpened: this.state.isOpened,
+                onClick: this.handleClick,
+                setState: this.updateState
+            }),
+            React__default.createElement(ConfirmBox, { type: "dialog", size: size, closeOnEsc: closeOnEsc, show: this.state.isOpened, onCancel: this.close, title: title || __('Select.placeholder'), showTitle: showTitle, headerClassName: headerClassName, bodyClassName: bodyClassName, className: className, showFooter: showFooter, beforeConfirm: this.beforeConfirm, popOverContainer: popOverContainer, mobileUI: mobileUI, disabled: disabled, testIdBuilder: testIdBuilder === null || testIdBuilder === void 0 ? void 0 : testIdBuilder.getChild('confirm-box') }, function (_a) {
+                var popOverContainer = _a.popOverContainer, loading = _a.loading, onConfirm = _a.onConfirm, bodyRef = _a.bodyRef;
+                return popOverRender === null || popOverRender === void 0 ? void 0 : popOverRender(__assign(__assign({}, _this.state), { ref: bodyRef, setState: _this.updateState, onClose: _this.close, onChange: _this.handleChange, onConfirm: onConfirm, popOverContainer: popOverContainer, loading: loading }));
+            })));
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], PickerContainer.prototype, "handleClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", void 0)
+    ], PickerContainer.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PickerContainer.prototype, "handleChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], PickerContainer.prototype, "beforeConfirm", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PickerContainer.prototype, "updateState", null);
+    return PickerContainer;
+}(React__default.Component));
+var PickerContainer$1 = themeable(localeable(PickerContainer));
+
+export { PickerContainer, PickerContainer$1 as default };

package/esm/components/PopOverContainer.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+export type OverlayAlignType = 'left' | 'center' | 'right';
+export interface PopOverOverlay {
+    width?: string | number;
+    align?: OverlayAlignType;
+}
+export interface PopOverContainerProps {
+    show?: boolean;
+    children: (props: {
+        disabled?: boolean;
+        onClick: (e: React.MouseEvent) => void;
+        isOpened: boolean;
+        ref: any;
+    }) => JSX.Element;
+    disabled?: boolean;
+    /** 弹出层打开时触发的事件 */
+    onOpen?: () => void;
+    popOverRender: (props: {
+        onClose: () => void;
+    }) => JSX.Element;
+    popOverContainer?: any;
+    popOverClassName?: string;
+    mobileUI?: boolean;
+    placement?: string;
+    overlayWidth?: number | string;
+    overlayWidthField?: 'minWidth' | 'width';
+    showConfirm?: boolean;
+    align?: OverlayAlignType;
+    /** Popover层隐藏前触发的事件 */
+    onBeforeHide?: () => void;
+    /** Popover层隐藏后触发的事件 */
+    onAfterHide?: () => void;
+    onConfirm?: () => void;
+}
+export interface PopOverContainerState {
+    isOpened: boolean;
+}
+export declare class PopOverContainer extends React.Component<PopOverContainerProps, PopOverContainerState> {
+    static alignPlacementMap: {
+        left: string;
+        right: string;
+        center: string;
+    };
+    state: PopOverContainerState;
+    target: any;
+    targetRef(target: any): void;
+    handleClick(e?: React.MouseEvent): void;
+    close(): void;
+    getTarget(): any;
+    getParent(): any;
+    onConfirm(): void;
+    static calcOverlayWidth(overlay: PopOverOverlay, targetWidth: number): string | number | undefined;
+    static alignToPlacement(overlay?: PopOverOverlay): string;
+    getOverlayStyle(): {
+        [x: string]: string | number;
+    };
+    render(): React.JSX.Element;
+}
+export default PopOverContainer;

package/esm/components/PopOverContainer.js

@@ -0,0 +1,148 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __spreadArray, __read, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { findDomCompat, toNumber, Overlay, PopOver, autobind } from 'amis-rev-core';
+import PopUp from './PopUp.js';
+import isNumber from 'lodash/isNumber';
+
+var PopOverContainer = /** @class */ (function (_super) {
+    __extends(PopOverContainer, _super);
+    function PopOverContainer() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.state = {
+            isOpened: false
+        };
+        return _this;
+    }
+    PopOverContainer.prototype.targetRef = function (target) {
+        this.target = target ? findDomCompat(target) : null;
+    };
+    PopOverContainer.prototype.handleClick = function (e) {
+        var _this = this;
+        e === null || e === void 0 ? void 0 : e.preventDefault();
+        this.props.disabled ||
+            this.setState({
+                isOpened: true
+            }, function () {
+                var _a, _b;
+                (_b = (_a = _this.props).onOpen) === null || _b === void 0 ? void 0 : _b.call(_a);
+            });
+    };
+    PopOverContainer.prototype.close = function () {
+        var _a = this.props, onBeforeHide = _a.onBeforeHide, onAfterHide = _a.onAfterHide;
+        if (onBeforeHide && typeof onBeforeHide === 'function') {
+            onBeforeHide === null || onBeforeHide === void 0 ? void 0 : onBeforeHide();
+        }
+        this.setState({
+            isOpened: false
+        });
+        if (onAfterHide && typeof onAfterHide === 'function') {
+            onAfterHide === null || onAfterHide === void 0 ? void 0 : onAfterHide();
+        }
+    };
+    PopOverContainer.prototype.getTarget = function () {
+        return this.target || findDomCompat(this);
+    };
+    PopOverContainer.prototype.getParent = function () {
+        var _a;
+        return (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.parentElement;
+    };
+    PopOverContainer.prototype.onConfirm = function () {
+        var _a, _b;
+        (_b = (_a = this.props).onConfirm) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.close();
+    };
+    PopOverContainer.calcOverlayWidth = function (overlay, targetWidth) {
+        var overlayWidth = overlay && overlay.width;
+        if (!overlayWidth || !isNumber(targetWidth) || targetWidth < 1)
+            return;
+        // 数字字符串需要转化下，否则不生效
+        if (typeof overlayWidth === 'number' || /^\d+$/.test(overlayWidth)) {
+            return toNumber(overlayWidth);
+        }
+        // 带单位，如: 80%、200px、30vw、5rem
+        if (/^\d+(px|%|rem|em|vw)$/.test(overlayWidth)) {
+            return overlayWidth;
+        }
+        // 带单位的相对值
+        // 如: -100px 代表 100% - 100px。+10vw 代表 100% + 10vw
+        if (/^(\+|\-)\d+(px|%|rem|em|vw)$/.test(overlayWidth)) {
+            // 不能使用 calc(100% $1 $2)，需要考虑到 popOverContainer
+            return overlayWidth.replace(/^(\+|\-)(.*)/, "calc(".concat(targetWidth, "px $1 $2)"));
+        }
+        return;
+    };
+    PopOverContainer.alignToPlacement = function (overlay) {
+        var align = overlay && overlay.align;
+        return (align && PopOverContainer.alignPlacementMap[align]) || 'auto';
+    };
+    // 可以自定义下拉框宽度
+    PopOverContainer.prototype.getOverlayStyle = function () {
+        var _a;
+        var _b;
+        var _c = this.props, overlayWidth = _c.overlayWidth, overlayWidthField = _c.overlayWidthField;
+        return _a = {},
+            _a[overlayWidthField || 'minWidth'] = PopOverContainer.calcOverlayWidth({ width: overlayWidth }, (_b = this.target) === null || _b === void 0 ? void 0 : _b.offsetWidth) || (this.target ? Math.max(this.target.offsetWidth, 100) : 'auto'),
+            _a;
+    };
+    PopOverContainer.prototype.render = function () {
+        var _a = this.props, mobileUI = _a.mobileUI, children = _a.children, popOverContainer = _a.popOverContainer, popOverClassName = _a.popOverClassName, dropdownRender = _a.popOverRender, placement = _a.placement, align = _a.align, showConfirm = _a.showConfirm; _a.onConfirm; var disabled = _a.disabled;
+        return (React__default.createElement(React__default.Fragment, null,
+            children({
+                isOpened: this.state.isOpened && this.props.show !== false,
+                onClick: this.handleClick,
+                ref: this.targetRef,
+                disabled: disabled
+            }),
+            mobileUI ? (React__default.createElement(PopUp, { isShow: this.state.isOpened && this.props.show !== false, container: popOverContainer, className: popOverClassName, showConfirm: showConfirm, onHide: this.close, onConfirm: this.onConfirm }, dropdownRender({ onClose: this.close }))) : (React__default.createElement(Overlay, { container: popOverContainer || this.getParent, target: this.getTarget, placement: placement || PopOverContainer.alignToPlacement({ align: align }), show: this.state.isOpened && this.props.show !== false },
+                React__default.createElement(PopOver, { overlay: true, className: popOverClassName, style: this.getOverlayStyle(), onHide: this.close }, dropdownRender({ onClose: this.close }))))));
+    };
+    PopOverContainer.alignPlacementMap = {
+        left: 'left-bottom-left-top',
+        right: 'right-bottom-right-top',
+        center: 'center-bottom-center-top'
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "targetRef", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "handleClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "getTarget", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "getParent", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], PopOverContainer.prototype, "onConfirm", null);
+    return PopOverContainer;
+}(React__default.Component));
+
+export { PopOverContainer, PopOverContainer as default };