cbvirtua 1.0.4 → 1.0.6

package/v2/components/Popper.js

@@ -0,0 +1,1011 @@
+import { autoPlacement, computePosition, offset, shift, flip, arrow, getScrollParents, size, } from '../floating-ui/dom/';
+import { supportsPassive, isIOS } from '../util/env';
+import { placements } from '../util/popper';
+import { SHOW_EVENT_MAP, HIDE_EVENT_MAP } from '../util/events';
+import { removeFromArray } from '../util/lang';
+import { nextFrame } from '../util/frame';
+import { getDefaultConfig, getAllParentThemes } from '../config';
+const shownPoppers = [];
+let hidingPopper = null;
+const shownPoppersByTheme = {};
+function getShownPoppersByTheme(theme) {
+    let list = shownPoppersByTheme[theme];
+    if (!list) {
+        list = shownPoppersByTheme[theme] = [];
+    }
+    return list;
+}
+let Element = function () { };
+if (typeof window !== 'undefined') {
+    Element = window.Element;
+}
+function defaultPropFactory(prop) {
+    return function () {
+        const props = this.$props;
+        return getDefaultConfig(props.theme, prop);
+    };
+}
+const PROVIDE_KEY = '__floating-vue__popper';
+export default () => ({
+    name: 'VPopper',
+    props: {
+        theme: {
+            type: String,
+            required: true,
+        },
+        targetNodes: {
+            type: Function,
+            required: true,
+        },
+        referenceNode: {
+            type: Function,
+            required: true,
+        },
+        popperNode: {
+            type: Function,
+            required: true,
+        },
+        shown: {
+            type: Boolean,
+            default: false,
+        },
+        showGroup: {
+            type: String,
+            default: null,
+        },
+        // eslint-disable-next-line vue/require-prop-types
+        ariaId: {
+            default: null,
+        },
+        disabled: {
+            type: Boolean,
+            default: defaultPropFactory('disabled'),
+        },
+        positioningDisabled: {
+            type: Boolean,
+            default: defaultPropFactory('positioningDisabled'),
+        },
+        placement: {
+            type: String,
+            default: defaultPropFactory('placement'),
+            validator: value => placements.includes(value),
+        },
+        delay: {
+            type: [String, Number, Object],
+            default: defaultPropFactory('delay'),
+        },
+        distance: {
+            type: [Number, String],
+            default: defaultPropFactory('distance'),
+        },
+        skidding: {
+            type: [Number, String],
+            default: defaultPropFactory('skidding'),
+        },
+        triggers: {
+            type: Array,
+            default: defaultPropFactory('triggers'),
+        },
+        showTriggers: {
+            type: [Array, Function],
+            default: defaultPropFactory('showTriggers'),
+        },
+        hideTriggers: {
+            type: [Array, Function],
+            default: defaultPropFactory('hideTriggers'),
+        },
+        popperTriggers: {
+            type: Array,
+            default: defaultPropFactory('popperTriggers'),
+        },
+        popperShowTriggers: {
+            type: [Array, Function],
+            default: defaultPropFactory('popperShowTriggers'),
+        },
+        popperHideTriggers: {
+            type: [Array, Function],
+            default: defaultPropFactory('popperHideTriggers'),
+        },
+        container: {
+            type: [String, Object, Element, Boolean],
+            default: defaultPropFactory('container'),
+        },
+        boundary: {
+            type: [String, Element],
+            default: defaultPropFactory('boundary'),
+        },
+        strategy: {
+            type: String,
+            validator: value => ['absolute', 'fixed'].includes(value),
+            default: defaultPropFactory('strategy'),
+        },
+        autoHide: {
+            type: [Boolean, Function],
+            default: defaultPropFactory('autoHide'),
+        },
+        handleResize: {
+            type: Boolean,
+            default: defaultPropFactory('handleResize'),
+        },
+        instantMove: {
+            type: Boolean,
+            default: defaultPropFactory('instantMove'),
+        },
+        eagerMount: {
+            type: Boolean,
+            default: defaultPropFactory('eagerMount'),
+        },
+        popperClass: {
+            type: [String, Array, Object],
+            default: defaultPropFactory('popperClass'),
+        },
+        computeTransformOrigin: {
+            type: Boolean,
+            default: defaultPropFactory('computeTransformOrigin'),
+        },
+        /**
+         * @deprecated
+         */
+        autoMinSize: {
+            type: Boolean,
+            default: defaultPropFactory('autoMinSize'),
+        },
+        autoSize: {
+            type: [Boolean, String],
+            default: defaultPropFactory('autoSize'),
+        },
+        /**
+         * @deprecated
+         */
+        autoMaxSize: {
+            type: Boolean,
+            default: defaultPropFactory('autoMaxSize'),
+        },
+        autoBoundaryMaxSize: {
+            type: Boolean,
+            default: defaultPropFactory('autoBoundaryMaxSize'),
+        },
+        preventOverflow: {
+            type: Boolean,
+            default: defaultPropFactory('preventOverflow'),
+        },
+        overflowPadding: {
+            type: [Number, String],
+            default: defaultPropFactory('overflowPadding'),
+        },
+        arrowPadding: {
+            type: [Number, String],
+            default: defaultPropFactory('arrowPadding'),
+        },
+        arrowOverflow: {
+            type: Boolean,
+            default: defaultPropFactory('arrowOverflow'),
+        },
+        flip: {
+            type: Boolean,
+            default: defaultPropFactory('flip'),
+        },
+        shift: {
+            type: Boolean,
+            default: defaultPropFactory('shift'),
+        },
+        shiftCrossAxis: {
+            type: Boolean,
+            default: defaultPropFactory('shiftCrossAxis'),
+        },
+        noAutoFocus: {
+            type: Boolean,
+            default: defaultPropFactory('noAutoFocus'),
+        },
+    },
+    provide() {
+        return {
+            [PROVIDE_KEY]: {
+                parentPopper: this,
+            },
+        };
+    },
+    inject: {
+        [PROVIDE_KEY]: { default: null },
+    },
+    data() {
+        return {
+            isShown: false,
+            isMounted: false,
+            skipTransition: false,
+            classes: {
+                showFrom: false,
+                showTo: false,
+                hideFrom: false,
+                hideTo: true,
+            },
+            result: {
+                x: 0,
+                y: 0,
+                placement: '',
+                strategy: this.strategy,
+                arrow: {
+                    x: 0,
+                    y: 0,
+                    centerOffset: 0,
+                },
+                transformOrigin: null,
+            },
+            shownChildren: new Set(),
+            lastAutoHide: true,
+        };
+    },
+    computed: {
+        popperId() {
+            return this.ariaId != null ? this.ariaId : this.randomId;
+        },
+        shouldMountContent() {
+            return this.eagerMount || this.isMounted;
+        },
+        slotData() {
+            return {
+                popperId: this.popperId,
+                isShown: this.isShown,
+                shouldMountContent: this.shouldMountContent,
+                skipTransition: this.skipTransition,
+                autoHide: typeof this.autoHide === 'function' ? this.lastAutoHide : this.autoHide,
+                show: this.show,
+                hide: this.hide,
+                handleResize: this.handleResize,
+                onResize: this.onResize,
+                classes: {
+                    ...this.classes,
+                    popperClass: this.popperClass,
+                },
+                result: this.positioningDisabled ? null : this.result,
+            };
+        },
+        parentPopper() {
+            var _a;
+            return (_a = this[PROVIDE_KEY]) === null || _a === void 0 ? void 0 : _a.parentPopper;
+        },
+        hasPopperShowTriggerHover() {
+            var _a, _b;
+            return ((_a = this.popperTriggers) === null || _a === void 0 ? void 0 : _a.includes('hover')) || ((_b = this.popperShowTriggers) === null || _b === void 0 ? void 0 : _b.includes('hover'));
+        },
+    },
+    watch: {
+        shown: '$_autoShowHide',
+        disabled(value) {
+            if (value) {
+                this.dispose();
+            }
+            else {
+                this.init();
+            }
+        },
+        async container() {
+            if (this.isShown) {
+                this.$_ensureTeleport();
+                await this.$_computePosition();
+            }
+        },
+        ...[
+            'triggers',
+            'positioningDisabled',
+        ].reduce((acc, prop) => {
+            acc[prop] = '$_refreshListeners';
+            return acc;
+        }, {}),
+        ...[
+            'placement',
+            'distance',
+            'skidding',
+            'boundary',
+            'strategy',
+            'overflowPadding',
+            'arrowPadding',
+            'preventOverflow',
+            'shift',
+            'shiftCrossAxis',
+            'flip',
+        ].reduce((acc, prop) => {
+            acc[prop] = '$_computePosition';
+            return acc;
+        }, {}),
+    },
+    created() {
+        this.$_isDisposed = true;
+        this.randomId = `popper_${[Math.random(), Date.now()].map(n => n.toString(36).substring(2, 10)).join('_')}`;
+        if (this.autoMinSize) {
+            console.warn('[floating-vue] `autoMinSize` option is deprecated. Use `autoSize="min"` instead.');
+        }
+        if (this.autoMaxSize) {
+            console.warn('[floating-vue] `autoMaxSize` option is deprecated. Use `autoBoundaryMaxSize` instead.');
+        }
+    },
+    mounted() {
+        this.init();
+        this.$_detachPopperNode();
+    },
+    activated() {
+        this.$_autoShowHide();
+    },
+    deactivated() {
+        this.hide();
+    },
+    beforeDestroy() {
+        this.dispose();
+    },
+    methods: {
+        show({ event = null, skipDelay = false, force = false } = {}) {
+            var _a, _b;
+            if (((_a = this.parentPopper) === null || _a === void 0 ? void 0 : _a.lockedChild) && this.parentPopper.lockedChild !== this)
+                return;
+            this.$_pendingHide = false;
+            if (force || !this.disabled) {
+                if (((_b = this.parentPopper) === null || _b === void 0 ? void 0 : _b.lockedChild) === this) {
+                    this.parentPopper.lockedChild = null;
+                }
+                this.$_scheduleShow(event, skipDelay);
+                this.$emit('show');
+                // Prevent hiding with global handler
+                this.$_showFrameLocked = true;
+                requestAnimationFrame(() => {
+                    this.$_showFrameLocked = false;
+                });
+            }
+            this.$emit('update:shown', true);
+        },
+        hide({ event = null, skipDelay = false, skipAiming = false } = {}) {
+            var _a;
+            if (this.$_hideInProgress)
+                return;
+            // Abort if child is shown
+            if (this.shownChildren.size > 0) {
+                this.$_pendingHide = true;
+                return;
+            }
+            // Abort if aiming for the popper
+            if (!skipAiming && this.hasPopperShowTriggerHover && this.$_isAimingPopper()) {
+                if (this.parentPopper) {
+                    this.parentPopper.lockedChild = this;
+                    clearTimeout(this.parentPopper.lockedChildTimer);
+                    this.parentPopper.lockedChildTimer = setTimeout(() => {
+                        if (this.parentPopper.lockedChild === this) {
+                            this.parentPopper.lockedChild.hide({ skipDelay });
+                            this.parentPopper.lockedChild = null;
+                        }
+                    }, 1000);
+                }
+                return;
+            }
+            if (((_a = this.parentPopper) === null || _a === void 0 ? void 0 : _a.lockedChild) === this) {
+                this.parentPopper.lockedChild = null;
+            }
+            this.$_pendingHide = false;
+            this.$_scheduleHide(event, skipDelay);
+            this.$emit('hide');
+            this.$emit('update:shown', false);
+        },
+        init() {
+            if (!this.$_isDisposed)
+                return;
+            this.$_isDisposed = false;
+            this.isMounted = false;
+            this.$_events = [];
+            this.$_preventShow = false;
+            // Nodes
+            this.$_referenceNode = this.referenceNode();
+            this.$_targetNodes = this.targetNodes().filter(e => e.nodeType === e.ELEMENT_NODE);
+            this.$_popperNode = this.popperNode();
+            this.$_innerNode = this.$_popperNode.querySelector('.v-popper__inner');
+            this.$_arrowNode = this.$_popperNode.querySelector('.v-popper__arrow-container');
+            this.$_swapTargetAttrs('title', 'data-original-title');
+            this.$_detachPopperNode();
+            if (this.triggers.length) {
+                this.$_addEventListeners();
+            }
+            if (this.shown) {
+                this.show();
+            }
+        },
+        dispose() {
+            if (this.$_isDisposed)
+                return;
+            this.$_isDisposed = true;
+            this.$_removeEventListeners();
+            this.hide({ skipDelay: true });
+            this.$_detachPopperNode();
+            this.isMounted = false;
+            this.isShown = false;
+            this.$_updateParentShownChildren(false);
+            this.$_swapTargetAttrs('data-original-title', 'title');
+            this.$emit('dispose');
+        },
+        async onResize() {
+            if (this.isShown) {
+                await this.$_computePosition();
+                this.$emit('resize');
+            }
+        },
+        async $_computePosition() {
+            var _a;
+            if (this.$_isDisposed || this.positioningDisabled)
+                return;
+            const options = {
+                strategy: this.strategy,
+                middleware: [],
+            };
+            // Offset
+            if (this.distance || this.skidding) {
+                options.middleware.push(offset({
+                    mainAxis: this.distance,
+                    crossAxis: this.skidding,
+                }));
+            }
+            // Placement
+            const isPlacementAuto = this.placement.startsWith('auto');
+            if (isPlacementAuto) {
+                options.middleware.push(autoPlacement({
+                    alignment: (_a = this.placement.split('-')[1]) !== null && _a !== void 0 ? _a : '',
+                }));
+            }
+            else {
+                options.placement = this.placement;
+            }
+            if (this.preventOverflow) {
+                // Shift
+                if (this.shift) {
+                    options.middleware.push(shift({
+                        padding: this.overflowPadding,
+                        boundary: this.boundary,
+                        crossAxis: this.shiftCrossAxis,
+                    }));
+                }
+                // Flip
+                if (!isPlacementAuto && this.flip) {
+                    options.middleware.push(flip({
+                        padding: this.overflowPadding,
+                        boundary: this.boundary,
+                    }));
+                }
+            }
+            // Arrow
+            options.middleware.push(arrow({
+                element: this.$_arrowNode,
+                padding: this.arrowPadding,
+            }));
+            // Arrow overflow
+            if (this.arrowOverflow) {
+                options.middleware.push({
+                    name: 'arrowOverflow',
+                    fn: ({ placement, rects, middlewareData }) => {
+                        let overflow;
+                        const { centerOffset } = middlewareData.arrow;
+                        if (placement.startsWith('top') || placement.startsWith('bottom')) {
+                            overflow = Math.abs(centerOffset) > rects.reference.width / 2;
+                        }
+                        else {
+                            overflow = Math.abs(centerOffset) > rects.reference.height / 2;
+                        }
+                        return {
+                            data: {
+                                overflow,
+                            },
+                        };
+                    },
+                });
+            }
+            // Auto min size for the popper inner
+            if (this.autoMinSize || this.autoSize) {
+                const autoSize = this.autoSize ? this.autoSize : this.autoMinSize ? 'min' : null;
+                options.middleware.push({
+                    name: 'autoSize',
+                    fn: ({ rects, placement, middlewareData }) => {
+                        var _a;
+                        if ((_a = middlewareData.autoSize) === null || _a === void 0 ? void 0 : _a.skip) {
+                            return {};
+                        }
+                        let width;
+                        let height;
+                        if (placement.startsWith('top') || placement.startsWith('bottom')) {
+                            width = rects.reference.width;
+                        }
+                        else {
+                            height = rects.reference.height;
+                        }
+                        // Apply and re-compute
+                        this.$_innerNode.style[autoSize === 'min' ? 'minWidth' : autoSize === 'max' ? 'maxWidth' : 'width'] = width != null ? `${width}px` : null;
+                        this.$_innerNode.style[autoSize === 'min' ? 'minHeight' : autoSize === 'max' ? 'maxHeight' : 'height'] = height != null ? `${height}px` : null;
+                        return {
+                            data: {
+                                skip: true,
+                            },
+                            reset: {
+                                rects: true,
+                            },
+                        };
+                    },
+                });
+            }
+            // Auto max size for the popper inner
+            if (this.autoMaxSize || this.autoBoundaryMaxSize) {
+                // Reset size to bestFit strategy can apply
+                this.$_innerNode.style.maxWidth = null;
+                this.$_innerNode.style.maxHeight = null;
+                options.middleware.push(size({
+                    boundary: this.boundary,
+                    padding: this.overflowPadding,
+                    apply: ({ width, height }) => {
+                        // Apply and re-compute
+                        this.$_innerNode.style.maxWidth = width != null ? `${width}px` : null;
+                        this.$_innerNode.style.maxHeight = height != null ? `${height}px` : null;
+                    },
+                }));
+            }
+            const data = await computePosition(this.$_referenceNode, this.$_popperNode, options);
+            Object.assign(this.result, {
+                x: data.x,
+                y: data.y,
+                placement: data.placement,
+                strategy: data.strategy,
+                arrow: {
+                    ...data.middlewareData.arrow,
+                    ...data.middlewareData.arrowOverflow,
+                },
+            });
+        },
+        $_scheduleShow(event = null, skipDelay = false) {
+            this.$_updateParentShownChildren(true);
+            this.$_hideInProgress = false;
+            clearTimeout(this.$_scheduleTimer);
+            if (hidingPopper && this.instantMove && hidingPopper.instantMove && hidingPopper !== this.parentPopper) {
+                hidingPopper.$_applyHide(true);
+                this.$_applyShow(true);
+                return;
+            }
+            if (skipDelay) {
+                this.$_applyShow();
+            }
+            else {
+                this.$_scheduleTimer = setTimeout(this.$_applyShow.bind(this), this.$_computeDelay('show'));
+            }
+        },
+        $_scheduleHide(event = null, skipDelay = false) {
+            if (this.shownChildren.size > 0) {
+                this.$_pendingHide = true;
+                return;
+            }
+            this.$_updateParentShownChildren(false);
+            this.$_hideInProgress = true;
+            clearTimeout(this.$_scheduleTimer);
+            if (this.isShown) {
+                hidingPopper = this;
+            }
+            if (skipDelay) {
+                this.$_applyHide();
+            }
+            else {
+                this.$_scheduleTimer = setTimeout(this.$_applyHide.bind(this), this.$_computeDelay('hide'));
+            }
+        },
+        $_computeDelay(type) {
+            const delay = this.delay;
+            return parseInt((delay && delay[type]) || delay || 0);
+        },
+        async $_applyShow(skipTransition = false) {
+            clearTimeout(this.$_disposeTimer);
+            clearTimeout(this.$_scheduleTimer);
+            this.skipTransition = skipTransition;
+            // Already shown
+            if (this.isShown) {
+                return;
+            }
+            this.$_ensureTeleport();
+            await nextFrame();
+            await this.$_computePosition();
+            await this.$_applyShowEffect();
+            // Scroll
+            if (!this.positioningDisabled) {
+                this.$_registerEventListeners([
+                    ...getScrollParents(this.$_referenceNode),
+                    ...getScrollParents(this.$_popperNode),
+                ], 'scroll', () => {
+                    this.$_computePosition();
+                });
+            }
+        },
+        async $_applyShowEffect() {
+            if (this.$_hideInProgress)
+                return;
+            // Advanced animations
+            if (this.computeTransformOrigin) {
+                const bounds = this.$_referenceNode.getBoundingClientRect();
+                const popperWrapper = this.$_popperNode.querySelector('.v-popper__wrapper');
+                const parentBounds = popperWrapper.parentNode.getBoundingClientRect();
+                const x = (bounds.x + bounds.width / 2) - (parentBounds.left + popperWrapper.offsetLeft);
+                const y = (bounds.y + bounds.height / 2) - (parentBounds.top + popperWrapper.offsetTop);
+                this.result.transformOrigin = `${x}px ${y}px`;
+            }
+            this.isShown = true;
+            this.$_applyAttrsToTarget({
+                'aria-describedby': this.popperId,
+                'data-popper-shown': '',
+            });
+            const showGroup = this.showGroup;
+            if (showGroup) {
+                let popover;
+                for (let i = 0; i < shownPoppers.length; i++) {
+                    popover = shownPoppers[i];
+                    if (popover.showGroup !== showGroup) {
+                        popover.hide();
+                        popover.$emit('close-group');
+                    }
+                }
+            }
+            shownPoppers.push(this);
+            document.body.classList.add('v-popper--some-open');
+            for (const theme of getAllParentThemes(this.theme)) {
+                getShownPoppersByTheme(theme).push(this);
+                document.body.classList.add(`v-popper--some-open--${theme}`);
+            }
+            this.$emit('apply-show');
+            // Advanced classes
+            this.classes.showFrom = true;
+            this.classes.showTo = false;
+            this.classes.hideFrom = false;
+            this.classes.hideTo = false;
+            await nextFrame();
+            this.classes.showFrom = false;
+            this.classes.showTo = true;
+            if (!this.noAutoFocus)
+                this.$_popperNode.focus();
+        },
+        async $_applyHide(skipTransition = false) {
+            if (this.shownChildren.size > 0) {
+                this.$_pendingHide = true;
+                this.$_hideInProgress = false;
+                return;
+            }
+            clearTimeout(this.$_scheduleTimer);
+            // Already hidden
+            if (!this.isShown) {
+                return;
+            }
+            this.skipTransition = skipTransition;
+            removeFromArray(shownPoppers, this);
+            if (shownPoppers.length === 0) {
+                document.body.classList.remove('v-popper--some-open');
+            }
+            for (const theme of getAllParentThemes(this.theme)) {
+                const list = getShownPoppersByTheme(theme);
+                removeFromArray(list, this);
+                if (list.length === 0) {
+                    document.body.classList.remove(`v-popper--some-open--${theme}`);
+                }
+            }
+            if (hidingPopper === this) {
+                hidingPopper = null;
+            }
+            this.isShown = false;
+            this.$_applyAttrsToTarget({
+                'aria-describedby': undefined,
+                'data-popper-shown': undefined,
+            });
+            clearTimeout(this.$_disposeTimer);
+            const disposeTime = getDefaultConfig(this.theme, 'disposeTimeout');
+            if (disposeTime !== null) {
+                this.$_disposeTimer = setTimeout(() => {
+                    if (this.$_popperNode) {
+                        // Don't remove popper instance, just the HTML element
+                        this.$_detachPopperNode();
+                        this.isMounted = false;
+                    }
+                }, disposeTime);
+            }
+            this.$_removeEventListeners('scroll');
+            this.$emit('apply-hide');
+            // Advanced classes
+            this.classes.showFrom = false;
+            this.classes.showTo = false;
+            this.classes.hideFrom = true;
+            this.classes.hideTo = false;
+            await nextFrame();
+            this.classes.hideFrom = false;
+            this.classes.hideTo = true;
+        },
+        $_autoShowHide() {
+            if (this.shown) {
+                this.show();
+            }
+            else {
+                this.hide();
+            }
+        },
+        $_ensureTeleport() {
+            if (this.$_isDisposed)
+                return;
+            let container = this.container;
+            // if container is a query, get the relative element
+            if (typeof container === 'string') {
+                container = window.document.querySelector(container);
+            }
+            else if (container === false) {
+                // if container is `false`, set it to reference parent
+                container = this.$_targetNodes[0].parentNode;
+            }
+            if (!container) {
+                throw new Error('No container for popover: ' + this.container);
+            }
+            container.appendChild(this.$_popperNode);
+            this.isMounted = true;
+        },
+        $_addEventListeners() {
+            // Add trigger show events
+            const handleShow = event => {
+                if (this.isShown && !this.$_hideInProgress) {
+                    return;
+                }
+                event.usedByTooltip = true;
+                // Prevent open on mobile touch in global close
+                !this.$_preventShow && this.show({ event });
+            };
+            this.$_registerTriggerListeners(this.$_targetNodes, SHOW_EVENT_MAP, this.triggers, this.showTriggers, handleShow);
+            this.$_registerTriggerListeners([this.$_popperNode], SHOW_EVENT_MAP, this.popperTriggers, this.popperShowTriggers, handleShow);
+            // Add trigger hide events
+            const handleHide = (skipAiming) => event => {
+                if (event.usedByTooltip) {
+                    return;
+                }
+                this.hide({ event, skipAiming });
+            };
+            this.$_registerTriggerListeners(this.$_targetNodes, HIDE_EVENT_MAP, this.triggers, this.hideTriggers, handleHide(false));
+            this.$_registerTriggerListeners([this.$_popperNode], HIDE_EVENT_MAP, this.popperTriggers, this.popperHideTriggers, handleHide(true));
+        },
+        $_registerEventListeners(targetNodes, eventType, handler) {
+            this.$_events.push({ targetNodes, eventType, handler });
+            targetNodes.forEach(node => node.addEventListener(eventType, handler, supportsPassive
+                ? {
+                    passive: true,
+                }
+                : undefined));
+        },
+        $_registerTriggerListeners(targetNodes, eventMap, commonTriggers, customTrigger, handler) {
+            let triggers = commonTriggers;
+            if (customTrigger != null) {
+                triggers = typeof customTrigger === 'function' ? customTrigger(triggers) : customTrigger;
+            }
+            triggers.forEach(trigger => {
+                const eventType = eventMap[trigger];
+                if (eventType) {
+                    this.$_registerEventListeners(targetNodes, eventType, handler);
+                }
+            });
+        },
+        $_removeEventListeners(filterEventType) {
+            const newList = [];
+            this.$_events.forEach(listener => {
+                const { targetNodes, eventType, handler } = listener;
+                if (!filterEventType || filterEventType === eventType) {
+                    targetNodes.forEach(node => node.removeEventListener(eventType, handler));
+                }
+                else {
+                    newList.push(listener);
+                }
+            });
+            this.$_events = newList;
+        },
+        $_refreshListeners() {
+            if (!this.$_isDisposed) {
+                this.$_removeEventListeners();
+                this.$_addEventListeners();
+            }
+        },
+        $_handleGlobalClose(event, touch = false) {
+            if (this.$_showFrameLocked)
+                return;
+            this.hide({ event: event });
+            if (event.closePopover) {
+                this.$emit('close-directive');
+            }
+            else {
+                this.$emit('auto-hide');
+            }
+            if (touch) {
+                this.$_preventShow = true;
+                setTimeout(() => {
+                    this.$_preventShow = false;
+                }, 300);
+            }
+        },
+        $_detachPopperNode() {
+            this.$_popperNode.parentNode && this.$_popperNode.parentNode.removeChild(this.$_popperNode);
+        },
+        $_swapTargetAttrs(attrFrom, attrTo) {
+            for (const el of this.$_targetNodes) {
+                const value = el.getAttribute(attrFrom);
+                if (value) {
+                    el.removeAttribute(attrFrom);
+                    el.setAttribute(attrTo, value);
+                }
+            }
+        },
+        $_applyAttrsToTarget(attrs) {
+            for (const el of this.$_targetNodes) {
+                for (const n in attrs) {
+                    const value = attrs[n];
+                    if (value == null) {
+                        el.removeAttribute(n);
+                    }
+                    else {
+                        el.setAttribute(n, value);
+                    }
+                }
+            }
+        },
+        $_updateParentShownChildren(value) {
+            let parent = this.parentPopper;
+            while (parent) {
+                if (value) {
+                    parent.shownChildren.add(this.randomId);
+                }
+                else {
+                    parent.shownChildren.delete(this.randomId);
+                    if (parent.$_pendingHide) {
+                        parent.hide();
+                    }
+                }
+                parent = parent.parentPopper;
+            }
+        },
+        $_isAimingPopper() {
+            const referenceBounds = this.$el.getBoundingClientRect();
+            if (mouseX >= referenceBounds.left && mouseX <= referenceBounds.right && mouseY >= referenceBounds.top && mouseY <= referenceBounds.bottom) {
+                const popperBounds = this.$_popperNode.getBoundingClientRect();
+                const vectorX = mouseX - mousePreviousX;
+                const vectorY = mouseY - mousePreviousY;
+                const distance = (popperBounds.left + popperBounds.width / 2) - mousePreviousX + (popperBounds.top + popperBounds.height / 2) - mousePreviousY;
+                // Make the vector long enough to be sure that it can intersect with the popper
+                const newVectorLength = distance + popperBounds.width + popperBounds.height;
+                const edgeX = mousePreviousX + vectorX * newVectorLength;
+                const edgeY = mousePreviousY + vectorY * newVectorLength;
+                // Check for collision between the vector and the popper bounds
+                return (lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.left, popperBounds.bottom) || // Left edge
+                    lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.right, popperBounds.top) || // Top edge
+                    lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.right, popperBounds.top, popperBounds.right, popperBounds.bottom) || // Right edge
+                    lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.bottom, popperBounds.right, popperBounds.bottom) // Bottom edge
+                );
+            }
+            return false;
+        },
+    },
+    render() {
+        return this.$scopedSlots.default(this.slotData)[0];
+    },
+});
+if (typeof document !== 'undefined' && typeof window !== 'undefined') {
+    if (isIOS) {
+        document.addEventListener('touchstart', handleGlobalMousedown, supportsPassive
+            ? {
+                passive: true,
+                capture: true,
+            }
+            : true);
+        document.addEventListener('touchend', handleGlobalTouchend, supportsPassive
+            ? {
+                passive: true,
+                capture: true,
+            }
+            : true);
+    }
+    else {
+        window.addEventListener('mousedown', handleGlobalMousedown, true);
+        window.addEventListener('click', handleGlobalClick, true);
+    }
+    window.addEventListener('resize', computePositionAllShownPoppers);
+}
+function handleGlobalMousedown(event) {
+    for (let i = 0; i < shownPoppers.length; i++) {
+        const popper = shownPoppers[i];
+        try {
+            const popperContent = popper.popperNode();
+            popper.$_mouseDownContains = popperContent.contains(event.target);
+        }
+        catch (e) {
+            // noop
+        }
+    }
+}
+function handleGlobalClick(event) {
+    handleGlobalClose(event);
+}
+function handleGlobalTouchend(event) {
+    handleGlobalClose(event, true);
+}
+function handleGlobalClose(event, touch = false) {
+    const preventClose = {};
+    for (let i = shownPoppers.length - 1; i >= 0; i--) {
+        const popper = shownPoppers[i];
+        try {
+            const contains = popper.$_containsGlobalTarget = isContainingEventTarget(popper, event);
+            popper.$_pendingHide = false;
+            // Delay so that close directive has time to set values (closeAllPopover, closePopover)
+            requestAnimationFrame(() => {
+                popper.$_pendingHide = false;
+                if (preventClose[popper.randomId])
+                    return;
+                if (shouldAutoHide(popper, contains, event)) {
+                    popper.$_handleGlobalClose(event, touch);
+                    // Only close child popper
+                    if (!event.closeAllPopover && event.closePopover && contains) {
+                        let parent = popper.parentPopper;
+                        while (parent) {
+                            preventClose[parent.randomId] = true;
+                            parent = parent.parentPopper;
+                        }
+                        return;
+                    }
+                    // Auto hide parents
+                    let parent = popper.parentPopper;
+                    while (parent) {
+                        if (shouldAutoHide(parent, parent.$_containsGlobalTarget, event)) {
+                            parent.$_handleGlobalClose(event, touch);
+                        }
+                        else {
+                            break;
+                        }
+                        parent = parent.parentPopper;
+                    }
+                }
+            });
+        }
+        catch (e) {
+            // noop
+        }
+    }
+}
+function isContainingEventTarget(popper, event) {
+    const popperContent = popper.popperNode();
+    return popper.$_mouseDownContains || popperContent.contains(event.target);
+}
+function shouldAutoHide(popper, contains, event) {
+    return event.closeAllPopover || (event.closePopover && contains) || (getAutoHideResult(popper, event) && !contains);
+}
+function getAutoHideResult(popper, event) {
+    if (typeof popper.autoHide === 'function') {
+        const result = popper.autoHide(event);
+        popper.lastAutoHide = result;
+        return result;
+    }
+    return popper.autoHide;
+}
+function computePositionAllShownPoppers(event) {
+    for (let i = 0; i < shownPoppers.length; i++) {
+        const popper = shownPoppers[i];
+        popper.$_computePosition(event);
+    }
+}
+export function hideAllPoppers() {
+    for (let i = 0; i < shownPoppers.length; i++) {
+        const popper = shownPoppers[i];
+        popper.hide();
+    }
+}
+// Track mouse movement to detect aiming at the popper
+let mousePreviousX = 0;
+let mousePreviousY = 0;
+let mouseX = 0;
+let mouseY = 0;
+if (typeof window !== 'undefined') {
+    window.addEventListener('mousemove', event => {
+        mousePreviousX = mouseX;
+        mousePreviousY = mouseY;
+        mouseX = event.clientX;
+        mouseY = event.clientY;
+    }, supportsPassive
+        ? {
+            passive: true,
+        }
+        : undefined);
+}
+function lineIntersectsLine(x1, y1, x2, y2, x3, y3, x4, y4) {
+    const uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+    const uB = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+    return (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1);
+}