2018-02-03 23:45:19 +00:00
|
|
|
/**!
|
|
|
|
* @fileOverview Kickass library to create and place poppers near their reference elements.
|
2020-04-01 22:52:43 +00:00
|
|
|
* @version 1.16.1
|
2018-02-03 23:45:19 +00:00
|
|
|
* @license
|
|
|
|
* Copyright (c) 2016 Federico Zivolo and contributors
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
|
|
* copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
(function (global, factory) {
|
|
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
|
|
(factory((global.PopperUtils = {})));
|
|
|
|
}(this, (function (exports) { 'use strict';
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get CSS computed property of the given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Eement} element
|
|
|
|
* @argument {String} property
|
|
|
|
*/
|
|
|
|
function getStyleComputedProperty(element, property) {
|
|
|
|
if (element.nodeType !== 1) {
|
|
|
|
return [];
|
|
|
|
}
|
|
|
|
// NOTE: 1 DOM access here
|
2019-05-18 08:27:50 +00:00
|
|
|
var window = element.ownerDocument.defaultView;
|
|
|
|
var css = window.getComputedStyle(element, null);
|
2018-02-03 23:45:19 +00:00
|
|
|
return property ? css[property] : css;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the parentNode or the host of the element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Element} parent
|
|
|
|
*/
|
|
|
|
function getParentNode(element) {
|
|
|
|
if (element.nodeName === 'HTML') {
|
|
|
|
return element;
|
|
|
|
}
|
|
|
|
return element.parentNode || element.host;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the scrolling parent of the given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Element} scroll parent
|
|
|
|
*/
|
|
|
|
function getScrollParent(element) {
|
|
|
|
// Return body, `getScroll` will take care to get the correct `scrollTop` from it
|
|
|
|
if (!element) {
|
|
|
|
return document.body;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (element.nodeName) {
|
|
|
|
case 'HTML':
|
|
|
|
case 'BODY':
|
|
|
|
return element.ownerDocument.body;
|
|
|
|
case '#document':
|
|
|
|
return element.body;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Firefox want us to check `-x` and `-y` variations as well
|
|
|
|
|
|
|
|
var _getStyleComputedProp = getStyleComputedProperty(element),
|
|
|
|
overflow = _getStyleComputedProp.overflow,
|
|
|
|
overflowX = _getStyleComputedProp.overflowX,
|
|
|
|
overflowY = _getStyleComputedProp.overflowY;
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
|
2018-02-03 23:45:19 +00:00
|
|
|
return element;
|
|
|
|
}
|
|
|
|
|
|
|
|
return getScrollParent(getParentNode(element));
|
|
|
|
}
|
|
|
|
|
2019-10-21 09:54:16 +00:00
|
|
|
/**
|
|
|
|
* Returns the reference node of the reference object, or the reference object itself.
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Element|Object} reference - the reference element (the popper will be relative to this)
|
|
|
|
* @returns {Element} parent
|
|
|
|
*/
|
|
|
|
function getReferenceNode(reference) {
|
|
|
|
return reference && reference.referenceNode ? reference.referenceNode : reference;
|
|
|
|
}
|
|
|
|
|
|
|
|
var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
|
2018-04-23 00:08:03 +00:00
|
|
|
|
|
|
|
var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
|
|
|
|
var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determines if the browser is Internet Explorer
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Number} version to check
|
|
|
|
* @returns {Boolean} isIE
|
|
|
|
*/
|
|
|
|
function isIE(version) {
|
|
|
|
if (version === 11) {
|
|
|
|
return isIE11;
|
|
|
|
}
|
|
|
|
if (version === 10) {
|
|
|
|
return isIE10;
|
|
|
|
}
|
|
|
|
return isIE11 || isIE10;
|
|
|
|
}
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
/**
|
|
|
|
* Returns the offset parent of the given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Element} offset parent
|
|
|
|
*/
|
|
|
|
function getOffsetParent(element) {
|
2018-04-23 00:08:03 +00:00
|
|
|
if (!element) {
|
|
|
|
return document.documentElement;
|
|
|
|
}
|
|
|
|
|
|
|
|
var noOffsetParent = isIE(10) ? document.body : null;
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
// NOTE: 1 DOM access here
|
2019-05-18 08:27:50 +00:00
|
|
|
var offsetParent = element.offsetParent || null;
|
2018-04-23 00:08:03 +00:00
|
|
|
// Skip hidden elements which don't have an offsetParent
|
|
|
|
while (offsetParent === noOffsetParent && element.nextElementSibling) {
|
|
|
|
offsetParent = (element = element.nextElementSibling).offsetParent;
|
|
|
|
}
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
var nodeName = offsetParent && offsetParent.nodeName;
|
|
|
|
|
|
|
|
if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
|
2018-04-23 00:08:03 +00:00
|
|
|
return element ? element.ownerDocument.documentElement : document.documentElement;
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
|
|
|
|
2019-05-18 08:27:50 +00:00
|
|
|
// .offsetParent will return the closest TH, TD or TABLE in case
|
2018-02-03 23:45:19 +00:00
|
|
|
// no offsetParent is present, I hate this job...
|
2019-05-18 08:27:50 +00:00
|
|
|
if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
|
2018-02-03 23:45:19 +00:00
|
|
|
return getOffsetParent(offsetParent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return offsetParent;
|
|
|
|
}
|
|
|
|
|
|
|
|
function isOffsetContainer(element) {
|
|
|
|
var nodeName = element.nodeName;
|
|
|
|
|
|
|
|
if (nodeName === 'BODY') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Finds the root node (document, shadowDOM root) of the given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} node
|
|
|
|
* @returns {Element} root node
|
|
|
|
*/
|
|
|
|
function getRoot(node) {
|
|
|
|
if (node.parentNode !== null) {
|
|
|
|
return getRoot(node.parentNode);
|
|
|
|
}
|
|
|
|
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Finds the offset parent common to the two provided nodes
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element1
|
|
|
|
* @argument {Element} element2
|
|
|
|
* @returns {Element} common offset parent
|
|
|
|
*/
|
|
|
|
function findCommonOffsetParent(element1, element2) {
|
|
|
|
// This check is needed to avoid errors in case one of the elements isn't defined for any reason
|
|
|
|
if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
|
|
|
|
return document.documentElement;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Here we make sure to give as "start" the element that comes first in the DOM
|
|
|
|
var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
|
|
|
|
var start = order ? element1 : element2;
|
|
|
|
var end = order ? element2 : element1;
|
|
|
|
|
|
|
|
// Get common ancestor container
|
|
|
|
var range = document.createRange();
|
|
|
|
range.setStart(start, 0);
|
|
|
|
range.setEnd(end, 0);
|
|
|
|
var commonAncestorContainer = range.commonAncestorContainer;
|
|
|
|
|
|
|
|
// Both nodes are inside #document
|
|
|
|
|
|
|
|
if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
|
|
|
|
if (isOffsetContainer(commonAncestorContainer)) {
|
|
|
|
return commonAncestorContainer;
|
|
|
|
}
|
|
|
|
|
|
|
|
return getOffsetParent(commonAncestorContainer);
|
|
|
|
}
|
|
|
|
|
|
|
|
// one of the nodes is inside shadowDOM, find which one
|
|
|
|
var element1root = getRoot(element1);
|
|
|
|
if (element1root.host) {
|
|
|
|
return findCommonOffsetParent(element1root.host, element2);
|
|
|
|
} else {
|
|
|
|
return findCommonOffsetParent(element1, getRoot(element2).host);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the scroll value of the given element in the given side (top and left)
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @argument {String} side `top` or `left`
|
|
|
|
* @returns {number} amount of scrolled pixels
|
|
|
|
*/
|
|
|
|
function getScroll(element) {
|
|
|
|
var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
|
|
|
|
|
|
|
|
var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
|
|
|
|
var nodeName = element.nodeName;
|
|
|
|
|
|
|
|
if (nodeName === 'BODY' || nodeName === 'HTML') {
|
|
|
|
var html = element.ownerDocument.documentElement;
|
|
|
|
var scrollingElement = element.ownerDocument.scrollingElement || html;
|
|
|
|
return scrollingElement[upperSide];
|
|
|
|
}
|
|
|
|
|
|
|
|
return element[upperSide];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sum or subtract the element scroll values (left and top) from a given rect object
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Object} rect - Rect object you want to change
|
|
|
|
* @param {HTMLElement} element - The element from the function reads the scroll values
|
|
|
|
* @param {Boolean} subtract - set to true if you want to subtract the scroll values
|
|
|
|
* @return {Object} rect - The modifier rect object
|
|
|
|
*/
|
|
|
|
function includeScroll(rect, element) {
|
|
|
|
var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
|
|
|
|
|
|
var scrollTop = getScroll(element, 'top');
|
|
|
|
var scrollLeft = getScroll(element, 'left');
|
|
|
|
var modifier = subtract ? -1 : 1;
|
|
|
|
rect.top += scrollTop * modifier;
|
|
|
|
rect.bottom += scrollTop * modifier;
|
|
|
|
rect.left += scrollLeft * modifier;
|
|
|
|
rect.right += scrollLeft * modifier;
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper to detect borders of a given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {CSSStyleDeclaration} styles
|
|
|
|
* Result of `getStyleComputedProperty` on the given element
|
|
|
|
* @param {String} axis - `x` or `y`
|
|
|
|
* @return {number} borders - The borders size of the given axis
|
|
|
|
*/
|
|
|
|
|
|
|
|
function getBordersSize(styles, axis) {
|
|
|
|
var sideA = axis === 'x' ? 'Left' : 'Top';
|
|
|
|
var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
|
|
|
|
|
2020-04-01 22:52:43 +00:00
|
|
|
return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function getSize(axis, body, html, computedStyle) {
|
2019-05-18 08:27:50 +00:00
|
|
|
return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
|
|
|
|
2019-05-18 08:27:50 +00:00
|
|
|
function getWindowSizes(document) {
|
2018-02-03 23:45:19 +00:00
|
|
|
var body = document.body;
|
|
|
|
var html = document.documentElement;
|
2018-04-23 00:08:03 +00:00
|
|
|
var computedStyle = isIE(10) && getComputedStyle(html);
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
return {
|
|
|
|
height: getSize('Height', body, html, computedStyle),
|
|
|
|
width: getSize('Width', body, html, computedStyle)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
var _extends = Object.assign || function (target) {
|
|
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
|
|
var source = arguments[i];
|
|
|
|
|
|
|
|
for (var key in source) {
|
|
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
|
|
target[key] = source[key];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return target;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Given element offsets, generate an output similar to getBoundingClientRect
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Object} offsets
|
|
|
|
* @returns {Object} ClientRect like output
|
|
|
|
*/
|
|
|
|
function getClientRect(offsets) {
|
|
|
|
return _extends({}, offsets, {
|
|
|
|
right: offsets.left + offsets.width,
|
|
|
|
bottom: offsets.top + offsets.height
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get bounding client rect of given element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {HTMLElement} element
|
|
|
|
* @return {Object} client rect
|
|
|
|
*/
|
|
|
|
function getBoundingClientRect(element) {
|
|
|
|
var rect = {};
|
|
|
|
|
|
|
|
// IE10 10 FIX: Please, don't ask, the element isn't
|
|
|
|
// considered in DOM in some circumstances...
|
|
|
|
// This isn't reproducible in IE10 compatibility mode of IE11
|
2018-04-23 00:08:03 +00:00
|
|
|
try {
|
|
|
|
if (isIE(10)) {
|
2018-02-03 23:45:19 +00:00
|
|
|
rect = element.getBoundingClientRect();
|
|
|
|
var scrollTop = getScroll(element, 'top');
|
|
|
|
var scrollLeft = getScroll(element, 'left');
|
|
|
|
rect.top += scrollTop;
|
|
|
|
rect.left += scrollLeft;
|
|
|
|
rect.bottom += scrollTop;
|
|
|
|
rect.right += scrollLeft;
|
2018-04-23 00:08:03 +00:00
|
|
|
} else {
|
|
|
|
rect = element.getBoundingClientRect();
|
|
|
|
}
|
|
|
|
} catch (e) {}
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
var result = {
|
|
|
|
left: rect.left,
|
|
|
|
top: rect.top,
|
|
|
|
width: rect.right - rect.left,
|
|
|
|
height: rect.bottom - rect.top
|
|
|
|
};
|
|
|
|
|
|
|
|
// subtract scrollbar size from sizes
|
2019-05-18 08:27:50 +00:00
|
|
|
var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
|
2019-10-21 09:54:16 +00:00
|
|
|
var width = sizes.width || element.clientWidth || result.width;
|
|
|
|
var height = sizes.height || element.clientHeight || result.height;
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
var horizScrollbar = element.offsetWidth - width;
|
|
|
|
var vertScrollbar = element.offsetHeight - height;
|
|
|
|
|
|
|
|
// if an hypothetical scrollbar is detected, we must be sure it's not a `border`
|
|
|
|
// we make this check conditional for performance reasons
|
|
|
|
if (horizScrollbar || vertScrollbar) {
|
|
|
|
var styles = getStyleComputedProperty(element);
|
|
|
|
horizScrollbar -= getBordersSize(styles, 'x');
|
|
|
|
vertScrollbar -= getBordersSize(styles, 'y');
|
|
|
|
|
|
|
|
result.width -= horizScrollbar;
|
|
|
|
result.height -= vertScrollbar;
|
|
|
|
}
|
|
|
|
|
|
|
|
return getClientRect(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
function getOffsetRectRelativeToArbitraryNode(children, parent) {
|
2018-04-23 00:08:03 +00:00
|
|
|
var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
|
|
|
|
|
|
var isIE10 = isIE(10);
|
2018-02-03 23:45:19 +00:00
|
|
|
var isHTML = parent.nodeName === 'HTML';
|
|
|
|
var childrenRect = getBoundingClientRect(children);
|
|
|
|
var parentRect = getBoundingClientRect(parent);
|
|
|
|
var scrollParent = getScrollParent(children);
|
|
|
|
|
|
|
|
var styles = getStyleComputedProperty(parent);
|
2020-04-01 22:52:43 +00:00
|
|
|
var borderTopWidth = parseFloat(styles.borderTopWidth);
|
|
|
|
var borderLeftWidth = parseFloat(styles.borderLeftWidth);
|
2018-02-03 23:45:19 +00:00
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
// In cases where the parent is fixed, we must ignore negative scroll in offset calc
|
2019-05-18 08:27:50 +00:00
|
|
|
if (fixedPosition && isHTML) {
|
2018-04-23 00:08:03 +00:00
|
|
|
parentRect.top = Math.max(parentRect.top, 0);
|
|
|
|
parentRect.left = Math.max(parentRect.left, 0);
|
|
|
|
}
|
2018-02-03 23:45:19 +00:00
|
|
|
var offsets = getClientRect({
|
|
|
|
top: childrenRect.top - parentRect.top - borderTopWidth,
|
|
|
|
left: childrenRect.left - parentRect.left - borderLeftWidth,
|
|
|
|
width: childrenRect.width,
|
|
|
|
height: childrenRect.height
|
|
|
|
});
|
|
|
|
offsets.marginTop = 0;
|
|
|
|
offsets.marginLeft = 0;
|
|
|
|
|
|
|
|
// Subtract margins of documentElement in case it's being used as parent
|
|
|
|
// we do this only on HTML because it's the only element that behaves
|
|
|
|
// differently when margins are applied to it. The margins are included in
|
|
|
|
// the box of the documentElement, in the other cases not.
|
|
|
|
if (!isIE10 && isHTML) {
|
2020-04-01 22:52:43 +00:00
|
|
|
var marginTop = parseFloat(styles.marginTop);
|
|
|
|
var marginLeft = parseFloat(styles.marginLeft);
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
offsets.top -= borderTopWidth - marginTop;
|
|
|
|
offsets.bottom -= borderTopWidth - marginTop;
|
|
|
|
offsets.left -= borderLeftWidth - marginLeft;
|
|
|
|
offsets.right -= borderLeftWidth - marginLeft;
|
|
|
|
|
|
|
|
// Attach marginTop and marginLeft because in some circumstances we may need them
|
|
|
|
offsets.marginTop = marginTop;
|
|
|
|
offsets.marginLeft = marginLeft;
|
|
|
|
}
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
|
2018-02-03 23:45:19 +00:00
|
|
|
offsets = includeScroll(offsets, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return offsets;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getViewportOffsetRectRelativeToArtbitraryNode(element) {
|
2018-04-23 00:08:03 +00:00
|
|
|
var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
var html = element.ownerDocument.documentElement;
|
|
|
|
var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
|
|
|
|
var width = Math.max(html.clientWidth, window.innerWidth || 0);
|
|
|
|
var height = Math.max(html.clientHeight, window.innerHeight || 0);
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
var scrollTop = !excludeScroll ? getScroll(html) : 0;
|
|
|
|
var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
var offset = {
|
|
|
|
top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
|
|
|
|
left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
|
|
|
|
width: width,
|
|
|
|
height: height
|
|
|
|
};
|
|
|
|
|
|
|
|
return getClientRect(offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the given element is fixed or is inside a fixed parent
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @argument {Element} customContainer
|
|
|
|
* @returns {Boolean} answer to "isFixed?"
|
|
|
|
*/
|
|
|
|
function isFixed(element) {
|
|
|
|
var nodeName = element.nodeName;
|
|
|
|
if (nodeName === 'BODY' || nodeName === 'HTML') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (getStyleComputedProperty(element, 'position') === 'fixed') {
|
|
|
|
return true;
|
|
|
|
}
|
2019-05-18 08:27:50 +00:00
|
|
|
var parentNode = getParentNode(element);
|
|
|
|
if (!parentNode) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return isFixed(parentNode);
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
/**
|
|
|
|
* Finds the first parent of an element that has a transformed property defined
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Element} first transformed parent or documentElement
|
|
|
|
*/
|
|
|
|
|
|
|
|
function getFixedPositionOffsetParent(element) {
|
|
|
|
// This check is needed to avoid errors in case one of the elements isn't defined for any reason
|
|
|
|
if (!element || !element.parentElement || isIE()) {
|
|
|
|
return document.documentElement;
|
|
|
|
}
|
|
|
|
var el = element.parentElement;
|
|
|
|
while (el && getStyleComputedProperty(el, 'transform') === 'none') {
|
|
|
|
el = el.parentElement;
|
|
|
|
}
|
|
|
|
return el || document.documentElement;
|
|
|
|
}
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
/**
|
|
|
|
* Computed the boundaries limits and return them
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {HTMLElement} popper
|
|
|
|
* @param {HTMLElement} reference
|
|
|
|
* @param {number} padding
|
|
|
|
* @param {HTMLElement} boundariesElement - Element used to define the boundaries
|
2018-04-23 00:08:03 +00:00
|
|
|
* @param {Boolean} fixedPosition - Is in fixed position mode
|
2018-02-03 23:45:19 +00:00
|
|
|
* @returns {Object} Coordinates of the boundaries
|
|
|
|
*/
|
|
|
|
function getBoundaries(popper, reference, padding, boundariesElement) {
|
2018-04-23 00:08:03 +00:00
|
|
|
var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
|
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
// NOTE: 1 DOM access here
|
2018-04-23 00:08:03 +00:00
|
|
|
|
2018-02-03 23:45:19 +00:00
|
|
|
var boundaries = { top: 0, left: 0 };
|
2019-10-21 09:54:16 +00:00
|
|
|
var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
// Handle viewport case
|
|
|
|
if (boundariesElement === 'viewport') {
|
2018-04-23 00:08:03 +00:00
|
|
|
boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
|
2018-02-03 23:45:19 +00:00
|
|
|
} else {
|
|
|
|
// Handle other cases based on DOM element used as boundaries
|
|
|
|
var boundariesNode = void 0;
|
|
|
|
if (boundariesElement === 'scrollParent') {
|
|
|
|
boundariesNode = getScrollParent(getParentNode(reference));
|
|
|
|
if (boundariesNode.nodeName === 'BODY') {
|
|
|
|
boundariesNode = popper.ownerDocument.documentElement;
|
|
|
|
}
|
|
|
|
} else if (boundariesElement === 'window') {
|
|
|
|
boundariesNode = popper.ownerDocument.documentElement;
|
|
|
|
} else {
|
|
|
|
boundariesNode = boundariesElement;
|
|
|
|
}
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
// In case of HTML, we need a different computation
|
|
|
|
if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
|
2019-05-18 08:27:50 +00:00
|
|
|
var _getWindowSizes = getWindowSizes(popper.ownerDocument),
|
2018-02-03 23:45:19 +00:00
|
|
|
height = _getWindowSizes.height,
|
|
|
|
width = _getWindowSizes.width;
|
|
|
|
|
|
|
|
boundaries.top += offsets.top - offsets.marginTop;
|
|
|
|
boundaries.bottom = height + offsets.top;
|
|
|
|
boundaries.left += offsets.left - offsets.marginLeft;
|
|
|
|
boundaries.right = width + offsets.left;
|
|
|
|
} else {
|
|
|
|
// for all the other DOM elements, this one is good
|
|
|
|
boundaries = offsets;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add paddings
|
2019-05-18 08:27:50 +00:00
|
|
|
padding = padding || 0;
|
|
|
|
var isPaddingNumber = typeof padding === 'number';
|
|
|
|
boundaries.left += isPaddingNumber ? padding : padding.left || 0;
|
|
|
|
boundaries.top += isPaddingNumber ? padding : padding.top || 0;
|
|
|
|
boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
|
|
|
|
boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
return boundaries;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getArea(_ref) {
|
|
|
|
var width = _ref.width,
|
|
|
|
height = _ref.height;
|
|
|
|
|
|
|
|
return width * height;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Utility used to transform the `auto` placement to the placement with more
|
|
|
|
* available space.
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Object} data - The data object generated by update method
|
|
|
|
* @argument {Object} options - Modifiers configuration and options
|
|
|
|
* @returns {Object} The data object, properly modified
|
|
|
|
*/
|
|
|
|
function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
|
|
|
|
var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
|
|
|
|
|
|
|
|
if (placement.indexOf('auto') === -1) {
|
|
|
|
return placement;
|
|
|
|
}
|
|
|
|
|
|
|
|
var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
|
|
|
|
|
|
|
|
var rects = {
|
|
|
|
top: {
|
|
|
|
width: boundaries.width,
|
|
|
|
height: refRect.top - boundaries.top
|
|
|
|
},
|
|
|
|
right: {
|
|
|
|
width: boundaries.right - refRect.right,
|
|
|
|
height: boundaries.height
|
|
|
|
},
|
|
|
|
bottom: {
|
|
|
|
width: boundaries.width,
|
|
|
|
height: boundaries.bottom - refRect.bottom
|
|
|
|
},
|
|
|
|
left: {
|
|
|
|
width: refRect.left - boundaries.left,
|
|
|
|
height: boundaries.height
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
var sortedAreas = Object.keys(rects).map(function (key) {
|
|
|
|
return _extends({
|
|
|
|
key: key
|
|
|
|
}, rects[key], {
|
|
|
|
area: getArea(rects[key])
|
|
|
|
});
|
|
|
|
}).sort(function (a, b) {
|
|
|
|
return b.area - a.area;
|
|
|
|
});
|
|
|
|
|
|
|
|
var filteredAreas = sortedAreas.filter(function (_ref2) {
|
|
|
|
var width = _ref2.width,
|
|
|
|
height = _ref2.height;
|
|
|
|
return width >= popper.clientWidth && height >= popper.clientHeight;
|
|
|
|
});
|
|
|
|
|
|
|
|
var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
|
|
|
|
|
|
|
|
var variation = placement.split('-')[1];
|
|
|
|
|
|
|
|
return computedPlacement + (variation ? '-' + variation : '');
|
|
|
|
}
|
|
|
|
|
2019-10-21 09:54:16 +00:00
|
|
|
var timeoutDuration = function () {
|
|
|
|
var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
|
|
|
|
for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
|
|
|
|
if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
|
|
|
|
return 1;
|
|
|
|
}
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
2019-10-21 09:54:16 +00:00
|
|
|
return 0;
|
|
|
|
}();
|
2018-02-03 23:45:19 +00:00
|
|
|
|
|
|
|
function microtaskDebounce(fn) {
|
|
|
|
var called = false;
|
|
|
|
return function () {
|
|
|
|
if (called) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
called = true;
|
|
|
|
window.Promise.resolve().then(function () {
|
|
|
|
called = false;
|
|
|
|
fn();
|
|
|
|
});
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
function taskDebounce(fn) {
|
|
|
|
var scheduled = false;
|
|
|
|
return function () {
|
|
|
|
if (!scheduled) {
|
|
|
|
scheduled = true;
|
|
|
|
setTimeout(function () {
|
|
|
|
scheduled = false;
|
|
|
|
fn();
|
|
|
|
}, timeoutDuration);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
var supportsMicroTasks = isBrowser && window.Promise;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a debounced version of a method, that's asynchronously deferred
|
|
|
|
* but called in the minimum time possible.
|
|
|
|
*
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Function} fn
|
|
|
|
* @returns {Function}
|
|
|
|
*/
|
|
|
|
var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Mimics the `find` method of Array
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Array} arr
|
|
|
|
* @argument prop
|
|
|
|
* @argument value
|
|
|
|
* @returns index or -1
|
|
|
|
*/
|
|
|
|
function find(arr, check) {
|
|
|
|
// use native find if supported
|
|
|
|
if (Array.prototype.find) {
|
|
|
|
return arr.find(check);
|
|
|
|
}
|
|
|
|
|
|
|
|
// use `filter` to obtain the same behavior of `find`
|
|
|
|
return arr.filter(check)[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the index of the matching object
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Array} arr
|
|
|
|
* @argument prop
|
|
|
|
* @argument value
|
|
|
|
* @returns index or -1
|
|
|
|
*/
|
|
|
|
function findIndex(arr, prop, value) {
|
|
|
|
// use native findIndex if supported
|
|
|
|
if (Array.prototype.findIndex) {
|
|
|
|
return arr.findIndex(function (cur) {
|
|
|
|
return cur[prop] === value;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// use `find` + `indexOf` if `findIndex` isn't supported
|
|
|
|
var match = find(arr, function (obj) {
|
|
|
|
return obj[prop] === value;
|
|
|
|
});
|
|
|
|
return arr.indexOf(match);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the position of the given element, relative to its offset parent
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Element} element
|
|
|
|
* @return {Object} position - Coordinates of the element and its `scrollTop`
|
|
|
|
*/
|
|
|
|
function getOffsetRect(element) {
|
|
|
|
var elementRect = void 0;
|
|
|
|
if (element.nodeName === 'HTML') {
|
2019-05-18 08:27:50 +00:00
|
|
|
var _getWindowSizes = getWindowSizes(element.ownerDocument),
|
2018-02-03 23:45:19 +00:00
|
|
|
width = _getWindowSizes.width,
|
|
|
|
height = _getWindowSizes.height;
|
|
|
|
|
|
|
|
elementRect = {
|
|
|
|
width: width,
|
|
|
|
height: height,
|
|
|
|
left: 0,
|
|
|
|
top: 0
|
|
|
|
};
|
|
|
|
} else {
|
|
|
|
elementRect = {
|
|
|
|
width: element.offsetWidth,
|
|
|
|
height: element.offsetHeight,
|
|
|
|
left: element.offsetLeft,
|
|
|
|
top: element.offsetTop
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
// position
|
|
|
|
return getClientRect(elementRect);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the outer sizes of the given element (offset size + margins)
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Object} object containing width and height properties
|
|
|
|
*/
|
|
|
|
function getOuterSizes(element) {
|
2019-05-18 08:27:50 +00:00
|
|
|
var window = element.ownerDocument.defaultView;
|
|
|
|
var styles = window.getComputedStyle(element);
|
|
|
|
var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
|
|
|
|
var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
|
2018-02-03 23:45:19 +00:00
|
|
|
var result = {
|
|
|
|
width: element.offsetWidth + y,
|
|
|
|
height: element.offsetHeight + x
|
|
|
|
};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the opposite placement of the given one
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {String} placement
|
|
|
|
* @returns {String} flipped placement
|
|
|
|
*/
|
|
|
|
function getOppositePlacement(placement) {
|
|
|
|
var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
|
|
|
|
return placement.replace(/left|right|bottom|top/g, function (matched) {
|
|
|
|
return hash[matched];
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get offsets to the popper
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Object} position - CSS position the Popper will get applied
|
|
|
|
* @param {HTMLElement} popper - the popper element
|
|
|
|
* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
|
|
|
|
* @param {String} placement - one of the valid placement options
|
|
|
|
* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
|
|
|
|
*/
|
|
|
|
function getPopperOffsets(popper, referenceOffsets, placement) {
|
|
|
|
placement = placement.split('-')[0];
|
|
|
|
|
|
|
|
// Get popper node sizes
|
|
|
|
var popperRect = getOuterSizes(popper);
|
|
|
|
|
|
|
|
// Add position, width and height to our offsets object
|
|
|
|
var popperOffsets = {
|
|
|
|
width: popperRect.width,
|
|
|
|
height: popperRect.height
|
|
|
|
};
|
|
|
|
|
|
|
|
// depending by the popper placement we have to compute its offsets slightly differently
|
|
|
|
var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
|
|
|
|
var mainSide = isHoriz ? 'top' : 'left';
|
|
|
|
var secondarySide = isHoriz ? 'left' : 'top';
|
|
|
|
var measurement = isHoriz ? 'height' : 'width';
|
|
|
|
var secondaryMeasurement = !isHoriz ? 'height' : 'width';
|
|
|
|
|
|
|
|
popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
|
|
|
|
if (placement === secondarySide) {
|
|
|
|
popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
|
|
|
|
} else {
|
|
|
|
popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
|
|
|
|
}
|
|
|
|
|
|
|
|
return popperOffsets;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get offsets to the reference element
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Object} state
|
|
|
|
* @param {Element} popper - the popper element
|
|
|
|
* @param {Element} reference - the reference element (the popper will be relative to this)
|
2018-04-23 00:08:03 +00:00
|
|
|
* @param {Element} fixedPosition - is in fixed position mode
|
2018-02-03 23:45:19 +00:00
|
|
|
* @returns {Object} An object containing the offsets which will be applied to the popper
|
|
|
|
*/
|
|
|
|
function getReferenceOffsets(state, popper, reference) {
|
2018-04-23 00:08:03 +00:00
|
|
|
var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
|
|
|
|
|
2019-10-21 09:54:16 +00:00
|
|
|
var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
|
2018-04-23 00:08:03 +00:00
|
|
|
return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
|
2018-02-03 23:45:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the prefixed supported property name
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {String} property (camelCase)
|
|
|
|
* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
|
|
|
|
*/
|
|
|
|
function getSupportedPropertyName(property) {
|
|
|
|
var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
|
|
|
|
var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
|
|
|
|
|
2018-04-23 00:08:03 +00:00
|
|
|
for (var i = 0; i < prefixes.length; i++) {
|
2018-02-03 23:45:19 +00:00
|
|
|
var prefix = prefixes[i];
|
|
|
|
var toCheck = prefix ? '' + prefix + upperProp : property;
|
|
|
|
if (typeof document.body.style[toCheck] !== 'undefined') {
|
|
|
|
return toCheck;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the given variable is a function
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Any} functionToCheck - variable to check
|
|
|
|
* @returns {Boolean} answer to: is a function?
|
|
|
|
*/
|
|
|
|
function isFunction(functionToCheck) {
|
|
|
|
var getType = {};
|
|
|
|
return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper used to know if the given modifier is enabled.
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @returns {Boolean}
|
|
|
|
*/
|
|
|
|
function isModifierEnabled(modifiers, modifierName) {
|
|
|
|
return modifiers.some(function (_ref) {
|
|
|
|
var name = _ref.name,
|
|
|
|
enabled = _ref.enabled;
|
|
|
|
return enabled && name === modifierName;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper used to know if the given modifier depends from another one.<br />
|
|
|
|
* It checks if the needed modifier is listed and enabled.
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {Array} modifiers - list of modifiers
|
|
|
|
* @param {String} requestingName - name of requesting modifier
|
|
|
|
* @param {String} requestedName - name of requested modifier
|
|
|
|
* @returns {Boolean}
|
|
|
|
*/
|
|
|
|
function isModifierRequired(modifiers, requestingName, requestedName) {
|
|
|
|
var requesting = find(modifiers, function (_ref) {
|
|
|
|
var name = _ref.name;
|
|
|
|
return name === requestingName;
|
|
|
|
});
|
|
|
|
|
|
|
|
var isRequired = !!requesting && modifiers.some(function (modifier) {
|
|
|
|
return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (!isRequired) {
|
|
|
|
var _requesting = '`' + requestingName + '`';
|
|
|
|
var requested = '`' + requestedName + '`';
|
|
|
|
console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
|
|
|
|
}
|
|
|
|
return isRequired;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Tells if a given input is a number
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {*} input to check
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function isNumeric(n) {
|
|
|
|
return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the window associated with the element
|
|
|
|
* @argument {Element} element
|
|
|
|
* @returns {Window}
|
|
|
|
*/
|
|
|
|
function getWindow(element) {
|
|
|
|
var ownerDocument = element.ownerDocument;
|
|
|
|
return ownerDocument ? ownerDocument.defaultView : window;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Remove event listeners used to update the popper position
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
function removeEventListeners(reference, state) {
|
|
|
|
// Remove resize event listener on window
|
|
|
|
getWindow(reference).removeEventListener('resize', state.updateBound);
|
|
|
|
|
|
|
|
// Remove scroll event listener on scroll parents
|
|
|
|
state.scrollParents.forEach(function (target) {
|
|
|
|
target.removeEventListener('scroll', state.updateBound);
|
|
|
|
});
|
|
|
|
|
|
|
|
// Reset state
|
|
|
|
state.updateBound = null;
|
|
|
|
state.scrollParents = [];
|
|
|
|
state.scrollElement = null;
|
|
|
|
state.eventsEnabled = false;
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loop trough the list of modifiers and run them in order,
|
|
|
|
* each of them will then edit the data object.
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @param {dataObject} data
|
|
|
|
* @param {Array} modifiers
|
|
|
|
* @param {String} ends - Optional modifier name used as stopper
|
|
|
|
* @returns {dataObject}
|
|
|
|
*/
|
|
|
|
function runModifiers(modifiers, data, ends) {
|
|
|
|
var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
|
|
|
|
|
|
|
|
modifiersToRun.forEach(function (modifier) {
|
|
|
|
if (modifier['function']) {
|
|
|
|
// eslint-disable-line dot-notation
|
|
|
|
console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
|
|
|
|
}
|
|
|
|
var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
|
|
|
|
if (modifier.enabled && isFunction(fn)) {
|
|
|
|
// Add properties to offsets to make them a complete clientRect object
|
|
|
|
// we do this before each modifier to make sure the previous one doesn't
|
|
|
|
// mess with these values
|
|
|
|
data.offsets.popper = getClientRect(data.offsets.popper);
|
|
|
|
data.offsets.reference = getClientRect(data.offsets.reference);
|
|
|
|
|
|
|
|
data = fn(data, modifier);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the attributes to the given popper
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element - Element to apply the attributes to
|
|
|
|
* @argument {Object} styles
|
|
|
|
* Object with a list of properties and values which will be applied to the element
|
|
|
|
*/
|
|
|
|
function setAttributes(element, attributes) {
|
|
|
|
Object.keys(attributes).forEach(function (prop) {
|
|
|
|
var value = attributes[prop];
|
|
|
|
if (value !== false) {
|
|
|
|
element.setAttribute(prop, attributes[prop]);
|
|
|
|
} else {
|
|
|
|
element.removeAttribute(prop);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the style to the given popper
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @argument {Element} element - Element to apply the style to
|
|
|
|
* @argument {Object} styles
|
|
|
|
* Object with a list of properties and values which will be applied to the element
|
|
|
|
*/
|
|
|
|
function setStyles(element, styles) {
|
|
|
|
Object.keys(styles).forEach(function (prop) {
|
|
|
|
var unit = '';
|
|
|
|
// add unit if the value is numeric and is one of the following
|
|
|
|
if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
|
|
|
|
unit = 'px';
|
|
|
|
}
|
|
|
|
element.style[prop] = styles[prop] + unit;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function attachToScrollParents(scrollParent, event, callback, scrollParents) {
|
|
|
|
var isBody = scrollParent.nodeName === 'BODY';
|
|
|
|
var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
|
|
|
|
target.addEventListener(event, callback, { passive: true });
|
|
|
|
|
|
|
|
if (!isBody) {
|
|
|
|
attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
|
|
|
|
}
|
|
|
|
scrollParents.push(target);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Setup needed event listeners used to update the popper position
|
|
|
|
* @method
|
|
|
|
* @memberof Popper.Utils
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
function setupEventListeners(reference, options, state, updateBound) {
|
|
|
|
// Resize event listener on window
|
|
|
|
state.updateBound = updateBound;
|
|
|
|
getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
|
|
|
|
|
|
|
|
// Scroll event listener on scroll parents
|
|
|
|
var scrollElement = getScrollParent(reference);
|
|
|
|
attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
|
|
|
|
state.scrollElement = scrollElement;
|
|
|
|
state.eventsEnabled = true;
|
|
|
|
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is here just for backward compatibility with versions lower than v1.10.3
|
|
|
|
// you should import the utilities using named exports, if you want them all use:
|
|
|
|
// ```
|
|
|
|
// import * as PopperUtils from 'popper-utils';
|
|
|
|
// ```
|
|
|
|
// The default export will be removed in the next major version.
|
|
|
|
var index = {
|
|
|
|
computeAutoPlacement: computeAutoPlacement,
|
|
|
|
debounce: debounce,
|
|
|
|
findIndex: findIndex,
|
|
|
|
getBordersSize: getBordersSize,
|
|
|
|
getBoundaries: getBoundaries,
|
|
|
|
getBoundingClientRect: getBoundingClientRect,
|
|
|
|
getClientRect: getClientRect,
|
|
|
|
getOffsetParent: getOffsetParent,
|
|
|
|
getOffsetRect: getOffsetRect,
|
|
|
|
getOffsetRectRelativeToArbitraryNode: getOffsetRectRelativeToArbitraryNode,
|
|
|
|
getOuterSizes: getOuterSizes,
|
|
|
|
getParentNode: getParentNode,
|
|
|
|
getPopperOffsets: getPopperOffsets,
|
|
|
|
getReferenceOffsets: getReferenceOffsets,
|
|
|
|
getScroll: getScroll,
|
|
|
|
getScrollParent: getScrollParent,
|
|
|
|
getStyleComputedProperty: getStyleComputedProperty,
|
|
|
|
getSupportedPropertyName: getSupportedPropertyName,
|
|
|
|
getWindowSizes: getWindowSizes,
|
|
|
|
isFixed: isFixed,
|
|
|
|
isFunction: isFunction,
|
|
|
|
isModifierEnabled: isModifierEnabled,
|
|
|
|
isModifierRequired: isModifierRequired,
|
|
|
|
isNumeric: isNumeric,
|
|
|
|
removeEventListeners: removeEventListeners,
|
|
|
|
runModifiers: runModifiers,
|
|
|
|
setAttributes: setAttributes,
|
|
|
|
setStyles: setStyles,
|
|
|
|
setupEventListeners: setupEventListeners
|
|
|
|
};
|
|
|
|
|
|
|
|
exports.computeAutoPlacement = computeAutoPlacement;
|
|
|
|
exports.debounce = debounce;
|
|
|
|
exports.findIndex = findIndex;
|
|
|
|
exports.getBordersSize = getBordersSize;
|
|
|
|
exports.getBoundaries = getBoundaries;
|
|
|
|
exports.getBoundingClientRect = getBoundingClientRect;
|
|
|
|
exports.getClientRect = getClientRect;
|
|
|
|
exports.getOffsetParent = getOffsetParent;
|
|
|
|
exports.getOffsetRect = getOffsetRect;
|
|
|
|
exports.getOffsetRectRelativeToArbitraryNode = getOffsetRectRelativeToArbitraryNode;
|
|
|
|
exports.getOuterSizes = getOuterSizes;
|
|
|
|
exports.getParentNode = getParentNode;
|
|
|
|
exports.getPopperOffsets = getPopperOffsets;
|
|
|
|
exports.getReferenceOffsets = getReferenceOffsets;
|
|
|
|
exports.getScroll = getScroll;
|
|
|
|
exports.getScrollParent = getScrollParent;
|
|
|
|
exports.getStyleComputedProperty = getStyleComputedProperty;
|
|
|
|
exports.getSupportedPropertyName = getSupportedPropertyName;
|
|
|
|
exports.getWindowSizes = getWindowSizes;
|
|
|
|
exports.isFixed = isFixed;
|
|
|
|
exports.isFunction = isFunction;
|
|
|
|
exports.isModifierEnabled = isModifierEnabled;
|
|
|
|
exports.isModifierRequired = isModifierRequired;
|
|
|
|
exports.isNumeric = isNumeric;
|
|
|
|
exports.removeEventListeners = removeEventListeners;
|
|
|
|
exports.runModifiers = runModifiers;
|
|
|
|
exports.setAttributes = setAttributes;
|
|
|
|
exports.setStyles = setStyles;
|
|
|
|
exports.setupEventListeners = setupEventListeners;
|
|
|
|
exports['default'] = index;
|
|
|
|
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
|
|
|
|
})));
|
|
|
|
//# sourceMappingURL=popper-utils.js.map
|