diff options
Diffstat (limited to 'npm_assets/node_modules/popper.js/src')
63 files changed, 2943 insertions, 0 deletions
diff --git a/npm_assets/node_modules/popper.js/src/index.js b/npm_assets/node_modules/popper.js/src/index.js new file mode 100644 index 0000000..3f37a06 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/index.js @@ -0,0 +1,154 @@ +// Utils +import debounce from './utils/debounce'; +import isFunction from './utils/isFunction'; + +// Methods +import update from './methods/update'; +import destroy from './methods/destroy'; +import enableEventListeners from './methods/enableEventListeners'; +import disableEventListeners from './methods/disableEventListeners'; +import Defaults from './methods/defaults'; +import placements from './methods/placements'; + +export default class Popper { + /** + * Creates a new Popper.js instance. + * @class Popper + * @param {Element|referenceObject} reference - The reference element used to position the popper + * @param {Element} popper - The HTML / XML element used as the popper + * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults) + * @return {Object} instance - The generated Popper.js instance + */ + constructor(reference, popper, options = {}) { + // make update() debounced, so that it only runs at most once-per-tick + this.update = debounce(this.update.bind(this)); + + // with {} we create a new object with the options inside it + this.options = { ...Popper.Defaults, ...options }; + + // init state + this.state = { + isDestroyed: false, + isCreated: false, + scrollParents: [], + }; + + // get reference and popper elements (allow jQuery wrappers) + this.reference = reference && reference.jquery ? reference[0] : reference; + this.popper = popper && popper.jquery ? popper[0] : popper; + + // Deep merge modifiers options + this.options.modifiers = {}; + Object.keys({ + ...Popper.Defaults.modifiers, + ...options.modifiers, + }).forEach(name => { + this.options.modifiers[name] = { + // If it's a built-in modifier, use it as base + ...(Popper.Defaults.modifiers[name] || {}), + // If there are custom options, override and merge with default ones + ...(options.modifiers ? options.modifiers[name] : {}), + }; + }); + + // Refactoring modifiers' list (Object => Array) + this.modifiers = Object.keys(this.options.modifiers) + .map(name => ({ + name, + ...this.options.modifiers[name], + })) + // sort the modifiers by order + .sort((a, b) => a.order - b.order); + + // modifiers have the ability to execute arbitrary code when Popper.js get inited + // such code is executed in the same order of its modifier + // they could add new properties to their options configuration + // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`! + this.modifiers.forEach(modifierOptions => { + if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) { + modifierOptions.onLoad( + this.reference, + this.popper, + this.options, + modifierOptions, + this.state + ); + } + }); + + // fire the first update to position the popper in the right place + this.update(); + + const eventsEnabled = this.options.eventsEnabled; + if (eventsEnabled) { + // setup event listeners, they will take care of update the position in specific situations + this.enableEventListeners(); + } + + this.state.eventsEnabled = eventsEnabled; + } + + // We can't use class properties because they don't get listed in the + // class prototype and break stuff like Sinon stubs + update() { + return update.call(this); + } + destroy() { + return destroy.call(this); + } + enableEventListeners() { + return enableEventListeners.call(this); + } + disableEventListeners() { + return disableEventListeners.call(this); + } + + /** + * Schedules an update. It will run on the next UI update available. + * @method scheduleUpdate + * @memberof Popper + */ + scheduleUpdate = () => requestAnimationFrame(this.update); + + /** + * Collection of utilities useful when writing custom modifiers. + * Starting from version 1.7, this method is available only if you + * include `popper-utils.js` before `popper.js`. + * + * **DEPRECATION**: This way to access PopperUtils is deprecated + * and will be removed in v2! Use the PopperUtils module directly instead. + * Due to the high instability of the methods contained in Utils, we can't + * guarantee them to follow semver. Use them at your own risk! + * @static + * @private + * @type {Object} + * @deprecated since version 1.8 + * @member Utils + * @memberof Popper + */ + static Utils = (typeof window !== 'undefined' ? window : global).PopperUtils; + + static placements = placements; + + static Defaults = Defaults; +} + +/** + * The `referenceObject` is an object that provides an interface compatible with Popper.js + * and lets you use it as replacement of a real DOM node.<br /> + * You can use this method to position a popper relatively to a set of coordinates + * in case you don't have a DOM node to use as reference. + * + * ``` + * new Popper(referenceObject, popperNode); + * ``` + * + * NB: This feature isn't supported in Internet Explorer 10. + * @name referenceObject + * @property {Function} data.getBoundingClientRect + * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. + * @property {number} data.clientWidth + * An ES6 getter that will return the width of the virtual reference element. + * @property {number} data.clientHeight + * An ES6 getter that will return the height of the virtual reference element. + */ diff --git a/npm_assets/node_modules/popper.js/src/methods/defaults.js b/npm_assets/node_modules/popper.js/src/methods/defaults.js new file mode 100644 index 0000000..461f981 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/defaults.js @@ -0,0 +1,79 @@ +import modifiers from '../modifiers/index'; + +/** + * Default options provided to Popper.js constructor.<br /> + * These can be overridden using the `options` argument of Popper.js.<br /> + * To override an option, simply pass an object with the same + * structure of the `options` object, as the 3rd argument. For example: + * ``` + * new Popper(ref, pop, { + * modifiers: { + * preventOverflow: { enabled: false } + * } + * }) + * ``` + * @type {Object} + * @static + * @memberof Popper + */ +export default { + /** + * Popper's placement. + * @prop {Popper.placements} placement='bottom' + */ + placement: 'bottom', + + /** + * Set this to true if you want popper to position it self in 'fixed' mode + * @prop {Boolean} positionFixed=false + */ + positionFixed: false, + + /** + * Whether events (resize, scroll) are initially enabled. + * @prop {Boolean} eventsEnabled=true + */ + eventsEnabled: true, + + /** + * Set to true if you want to automatically remove the popper when + * you call the `destroy` method. + * @prop {Boolean} removeOnDestroy=false + */ + removeOnDestroy: false, + + /** + * Callback called when the popper is created.<br /> + * By default, it is set to no-op.<br /> + * Access Popper.js instance with `data.instance`. + * @prop {onCreate} + */ + onCreate: () => {}, + + /** + * Callback called when the popper is updated. This callback is not called + * on the initialization/creation of the popper, but only on subsequent + * updates.<br /> + * By default, it is set to no-op.<br /> + * Access Popper.js instance with `data.instance`. + * @prop {onUpdate} + */ + onUpdate: () => {}, + + /** + * List of modifiers used to modify the offsets before they are applied to the popper. + * They provide most of the functionalities of Popper.js. + * @prop {modifiers} + */ + modifiers, +}; + +/** + * @callback onCreate + * @param {dataObject} data + */ + +/** + * @callback onUpdate + * @param {dataObject} data + */ diff --git a/npm_assets/node_modules/popper.js/src/methods/destroy.js b/npm_assets/node_modules/popper.js/src/methods/destroy.js new file mode 100644 index 0000000..2888a67 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/destroy.js @@ -0,0 +1,32 @@ +import isModifierEnabled from '../utils/isModifierEnabled'; +import getSupportedPropertyName from '../utils/getSupportedPropertyName'; + +/** + * Destroys the popper. + * @method + * @memberof Popper + */ +export default function destroy() { + this.state.isDestroyed = true; + + // touch DOM only if `applyStyle` modifier is enabled + if (isModifierEnabled(this.modifiers, 'applyStyle')) { + this.popper.removeAttribute('x-placement'); + this.popper.style.position = ''; + this.popper.style.top = ''; + this.popper.style.left = ''; + this.popper.style.right = ''; + this.popper.style.bottom = ''; + this.popper.style.willChange = ''; + this.popper.style[getSupportedPropertyName('transform')] = ''; + } + + this.disableEventListeners(); + + // remove the popper if user explicitly asked for the deletion on destroy + // do not use `remove` because IE11 doesn't support it + if (this.options.removeOnDestroy) { + this.popper.parentNode.removeChild(this.popper); + } + return this; +} diff --git a/npm_assets/node_modules/popper.js/src/methods/disableEventListeners.js b/npm_assets/node_modules/popper.js/src/methods/disableEventListeners.js new file mode 100644 index 0000000..4d2e032 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/disableEventListeners.js @@ -0,0 +1,15 @@ +import removeEventListeners from '../utils/removeEventListeners'; + +/** + * It will remove resize/scroll events and won't recalculate popper position + * when they are triggered. It also won't trigger `onUpdate` callback anymore, + * unless you call `update` method manually. + * @method + * @memberof Popper + */ +export default function disableEventListeners() { + if (this.state.eventsEnabled) { + cancelAnimationFrame(this.scheduleUpdate); + this.state = removeEventListeners(this.reference, this.state); + } +} diff --git a/npm_assets/node_modules/popper.js/src/methods/enableEventListeners.js b/npm_assets/node_modules/popper.js/src/methods/enableEventListeners.js new file mode 100644 index 0000000..ff1a63d --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/enableEventListeners.js @@ -0,0 +1,18 @@ +import setupEventListeners from '../utils/setupEventListeners'; + +/** + * It will add resize/scroll events and start recalculating + * position of the popper element when they are triggered. + * @method + * @memberof Popper + */ +export default function enableEventListeners() { + if (!this.state.eventsEnabled) { + this.state = setupEventListeners( + this.reference, + this.options, + this.state, + this.scheduleUpdate + ); + } +} diff --git a/npm_assets/node_modules/popper.js/src/methods/placements.js b/npm_assets/node_modules/popper.js/src/methods/placements.js new file mode 100644 index 0000000..35b4d23 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/placements.js @@ -0,0 +1,48 @@ +/** + * List of accepted placements to use as values of the `placement` option.<br /> + * Valid placements are: + * - `auto` + * - `top` + * - `right` + * - `bottom` + * - `left` + * + * Each placement can have a variation from this list: + * - `-start` + * - `-end` + * + * Variations are interpreted easily if you think of them as the left to right + * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` + * is right.<br /> + * Vertically (`left` and `right`), `start` is top and `end` is bottom. + * + * Some valid examples are: + * - `top-end` (on top of reference, right aligned) + * - `right-start` (on right of reference, top aligned) + * - `bottom` (on bottom, centered) + * - `auto-end` (on the side with more space available, alignment depends by placement) + * + * @static + * @type {Array} + * @enum {String} + * @readonly + * @method placements + * @memberof Popper + */ +export default [ + 'auto-start', + 'auto', + 'auto-end', + 'top-start', + 'top', + 'top-end', + 'right-start', + 'right', + 'right-end', + 'bottom-end', + 'bottom', + 'bottom-start', + 'left-end', + 'left', + 'left-start', +]; diff --git a/npm_assets/node_modules/popper.js/src/methods/update.js b/npm_assets/node_modules/popper.js/src/methods/update.js new file mode 100644 index 0000000..0660d1e --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/methods/update.js @@ -0,0 +1,75 @@ +import computeAutoPlacement from '../utils/computeAutoPlacement'; +import getReferenceOffsets from '../utils/getReferenceOffsets'; +import getPopperOffsets from '../utils/getPopperOffsets'; +import runModifiers from '../utils/runModifiers'; + +/** + * Updates the position of the popper, computing the new offsets and applying + * the new style.<br /> + * Prefer `scheduleUpdate` over `update` because of performance reasons. + * @method + * @memberof Popper + */ +export default function update() { + // if popper is destroyed, don't perform any further update + if (this.state.isDestroyed) { + return; + } + + let data = { + instance: this, + styles: {}, + arrowStyles: {}, + attributes: {}, + flipped: false, + offsets: {}, + }; + + // compute reference element offsets + data.offsets.reference = getReferenceOffsets( + this.state, + this.popper, + this.reference, + this.options.positionFixed + ); + + // compute auto placement, store placement inside the data object, + // modifiers will be able to edit `placement` if needed + // and refer to originalPlacement to know the original value + data.placement = computeAutoPlacement( + this.options.placement, + data.offsets.reference, + this.popper, + this.reference, + this.options.modifiers.flip.boundariesElement, + this.options.modifiers.flip.padding + ); + + // store the computed placement inside `originalPlacement` + data.originalPlacement = data.placement; + + data.positionFixed = this.options.positionFixed; + + // compute the popper offsets + data.offsets.popper = getPopperOffsets( + this.popper, + data.offsets.reference, + data.placement + ); + + data.offsets.popper.position = this.options.positionFixed + ? 'fixed' + : 'absolute'; + + // run the modifiers + data = runModifiers(this.modifiers, data); + + // the first `update` will call `onCreate` callback + // the other ones will call `onUpdate` callback + if (!this.state.isCreated) { + this.state.isCreated = true; + this.options.onCreate(data); + } else { + this.options.onUpdate(data); + } +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/applyStyle.js b/npm_assets/node_modules/popper.js/src/modifiers/applyStyle.js new file mode 100644 index 0000000..8f38d3b --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/applyStyle.js @@ -0,0 +1,73 @@ +import setStyles from '../utils/setStyles'; +import setAttributes from '../utils/setAttributes'; +import getReferenceOffsets from '../utils/getReferenceOffsets'; +import computeAutoPlacement from '../utils/computeAutoPlacement'; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by `update` method + * @argument {Object} data.styles - List of style properties - values to apply to popper element + * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The same data object + */ +export default function applyStyle(data) { + // any property present in `data.styles` will be applied to the popper, + // in this way we can make the 3rd party modifiers add custom styles to it + // Be aware, modifiers could override the properties defined in the previous + // lines of this modifier! + setStyles(data.instance.popper, data.styles); + + // any property present in `data.attributes` will be applied to the popper, + // they will be set as HTML attributes of the element + setAttributes(data.instance.popper, data.attributes); + + // if arrowElement is defined and arrowStyles has some properties + if (data.arrowElement && Object.keys(data.arrowStyles).length) { + setStyles(data.arrowElement, data.arrowStyles); + } + + return data; +} + +/** + * Set the x-placement attribute before everything else because it could be used + * to add margins to the popper margins needs to be calculated to get the + * correct popper offsets. + * @method + * @memberof Popper.modifiers + * @param {HTMLElement} reference - The reference element used to position the popper + * @param {HTMLElement} popper - The HTML element used as popper + * @param {Object} options - Popper.js options + */ +export function applyStyleOnLoad( + reference, + popper, + options, + modifierOptions, + state +) { + // compute reference element offsets + const referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed); + + // compute auto placement, store placement inside the data object, + // modifiers will be able to edit `placement` if needed + // and refer to originalPlacement to know the original value + const placement = computeAutoPlacement( + options.placement, + referenceOffsets, + popper, + reference, + options.modifiers.flip.boundariesElement, + options.modifiers.flip.padding + ); + + popper.setAttribute('x-placement', placement); + + // Apply `position` to popper before anything else because + // without the position applied we can't guarantee correct computations + setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' }); + + return options; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/arrow.js b/npm_assets/node_modules/popper.js/src/modifiers/arrow.js new file mode 100644 index 0000000..5b68920 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/arrow.js @@ -0,0 +1,89 @@ +import getClientRect from '../utils/getClientRect'; +import getOuterSizes from '../utils/getOuterSizes'; +import isModifierRequired from '../utils/isModifierRequired'; +import getStyleComputedProperty from '../utils/getStyleComputedProperty'; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by update method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function arrow(data, options) { + // arrow depends on keepTogether in order to work + if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) { + return data; + } + + let arrowElement = options.element; + + // if arrowElement is a string, suppose it's a CSS selector + if (typeof arrowElement === 'string') { + arrowElement = data.instance.popper.querySelector(arrowElement); + + // if arrowElement is not found, don't run the modifier + if (!arrowElement) { + return data; + } + } else { + // if the arrowElement isn't a query selector we must check that the + // provided DOM node is child of its popper node + if (!data.instance.popper.contains(arrowElement)) { + console.warn( + 'WARNING: `arrow.element` must be child of its popper element!' + ); + return data; + } + } + + const placement = data.placement.split('-')[0]; + const { popper, reference } = data.offsets; + const isVertical = ['left', 'right'].indexOf(placement) !== -1; + + const len = isVertical ? 'height' : 'width'; + const sideCapitalized = isVertical ? 'Top' : 'Left'; + const side = sideCapitalized.toLowerCase(); + const altSide = isVertical ? 'left' : 'top'; + const opSide = isVertical ? 'bottom' : 'right'; + const arrowElementSize = getOuterSizes(arrowElement)[len]; + + // + // extends keepTogether behavior making sure the popper and its + // reference have enough pixels in conjunction + // + + // top/left side + if (reference[opSide] - arrowElementSize < popper[side]) { + data.offsets.popper[side] -= + popper[side] - (reference[opSide] - arrowElementSize); + } + // bottom/right side + if (reference[side] + arrowElementSize > popper[opSide]) { + data.offsets.popper[side] += + reference[side] + arrowElementSize - popper[opSide]; + } + data.offsets.popper = getClientRect(data.offsets.popper); + + // compute center of the popper + const center = reference[side] + reference[len] / 2 - arrowElementSize / 2; + + // Compute the sideValue using the updated popper offsets + // take popper margin in account because we don't have this info available + const css = getStyleComputedProperty(data.instance.popper); + const popperMarginSide = parseFloat(css[`margin${sideCapitalized}`]); + const popperBorderSide = parseFloat(css[`border${sideCapitalized}Width`]); + let sideValue = + center - data.offsets.popper[side] - popperMarginSide - popperBorderSide; + + // prevent arrowElement from being placed not contiguously to its popper + sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0); + + data.arrowElement = arrowElement; + data.offsets.arrow = { + [side]: Math.round(sideValue), + [altSide]: '', // make sure to unset any eventual altSide value from the DOM node + }; + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/computeStyle.js b/npm_assets/node_modules/popper.js/src/modifiers/computeStyle.js new file mode 100644 index 0000000..55e0200 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/computeStyle.js @@ -0,0 +1,112 @@ +import getSupportedPropertyName from '../utils/getSupportedPropertyName'; +import find from '../utils/find'; +import getOffsetParent from '../utils/getOffsetParent'; +import getBoundingClientRect from '../utils/getBoundingClientRect'; +import getRoundedOffsets from '../utils/getRoundedOffsets'; +import isBrowser from '../utils/isBrowser'; + +const isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent); + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by `update` method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function computeStyle(data, options) { + const { x, y } = options; + const { popper } = data.offsets; + + // Remove this legacy support in Popper.js v2 + const legacyGpuAccelerationOption = find( + data.instance.modifiers, + modifier => modifier.name === 'applyStyle' + ).gpuAcceleration; + if (legacyGpuAccelerationOption !== undefined) { + console.warn( + 'WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!' + ); + } + const gpuAcceleration = + legacyGpuAccelerationOption !== undefined + ? legacyGpuAccelerationOption + : options.gpuAcceleration; + + const offsetParent = getOffsetParent(data.instance.popper); + const offsetParentRect = getBoundingClientRect(offsetParent); + + // Styles + const styles = { + position: popper.position, + }; + + const offsets = getRoundedOffsets( + data, + window.devicePixelRatio < 2 || !isFirefox + ); + + const sideA = x === 'bottom' ? 'top' : 'bottom'; + const sideB = y === 'right' ? 'left' : 'right'; + + // if gpuAcceleration is set to `true` and transform is supported, + // we use `translate3d` to apply the position to the popper we + // automatically use the supported prefixed version if needed + const prefixedProperty = getSupportedPropertyName('transform'); + + // now, let's make a step back and look at this code closely (wtf?) + // If the content of the popper grows once it's been positioned, it + // may happen that the popper gets misplaced because of the new content + // overflowing its reference element + // To avoid this problem, we provide two options (x and y), which allow + // the consumer to define the offset origin. + // If we position a popper on top of a reference element, we can set + // `x` to `top` to make the popper grow towards its top instead of + // its bottom. + let left, top; + if (sideA === 'bottom') { + // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar) + // and not the bottom of the html element + if (offsetParent.nodeName === 'HTML') { + top = -offsetParent.clientHeight + offsets.bottom; + } else { + top = -offsetParentRect.height + offsets.bottom; + } + } else { + top = offsets.top; + } + if (sideB === 'right') { + if (offsetParent.nodeName === 'HTML') { + left = -offsetParent.clientWidth + offsets.right; + } else { + left = -offsetParentRect.width + offsets.right; + } + } else { + left = offsets.left; + } + if (gpuAcceleration && prefixedProperty) { + styles[prefixedProperty] = `translate3d(${left}px, ${top}px, 0)`; + styles[sideA] = 0; + styles[sideB] = 0; + styles.willChange = 'transform'; + } else { + // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties + const invertTop = sideA === 'bottom' ? -1 : 1; + const invertLeft = sideB === 'right' ? -1 : 1; + styles[sideA] = top * invertTop; + styles[sideB] = left * invertLeft; + styles.willChange = `${sideA}, ${sideB}`; + } + + // Attributes + const attributes = { + 'x-placement': data.placement, + }; + + // Update `data` attributes, styles and arrowStyles + data.attributes = { ...attributes, ...data.attributes }; + data.styles = { ...styles, ...data.styles }; + data.arrowStyles = { ...data.offsets.arrow, ...data.arrowStyles }; + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/flip.js b/npm_assets/node_modules/popper.js/src/modifiers/flip.js new file mode 100644 index 0000000..109b4e9 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/flip.js @@ -0,0 +1,146 @@ +import getOppositePlacement from '../utils/getOppositePlacement'; +import getOppositeVariation from '../utils/getOppositeVariation'; +import getPopperOffsets from '../utils/getPopperOffsets'; +import runModifiers from '../utils/runModifiers'; +import getBoundaries from '../utils/getBoundaries'; +import isModifierEnabled from '../utils/isModifierEnabled'; +import clockwise from '../utils/clockwise'; + +const BEHAVIORS = { + FLIP: 'flip', + CLOCKWISE: 'clockwise', + COUNTERCLOCKWISE: 'counterclockwise', +}; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by update method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function flip(data, options) { + // if `inner` modifier is enabled, we can't use the `flip` modifier + if (isModifierEnabled(data.instance.modifiers, 'inner')) { + return data; + } + + if (data.flipped && data.placement === data.originalPlacement) { + // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides + return data; + } + + const boundaries = getBoundaries( + data.instance.popper, + data.instance.reference, + options.padding, + options.boundariesElement, + data.positionFixed + ); + + let placement = data.placement.split('-')[0]; + let placementOpposite = getOppositePlacement(placement); + let variation = data.placement.split('-')[1] || ''; + + let flipOrder = []; + + switch (options.behavior) { + case BEHAVIORS.FLIP: + flipOrder = [placement, placementOpposite]; + break; + case BEHAVIORS.CLOCKWISE: + flipOrder = clockwise(placement); + break; + case BEHAVIORS.COUNTERCLOCKWISE: + flipOrder = clockwise(placement, true); + break; + default: + flipOrder = options.behavior; + } + + flipOrder.forEach((step, index) => { + if (placement !== step || flipOrder.length === index + 1) { + return data; + } + + placement = data.placement.split('-')[0]; + placementOpposite = getOppositePlacement(placement); + + const popperOffsets = data.offsets.popper; + const refOffsets = data.offsets.reference; + + // using floor because the reference offsets may contain decimals we are not going to consider here + const floor = Math.floor; + const overlapsRef = + (placement === 'left' && + floor(popperOffsets.right) > floor(refOffsets.left)) || + (placement === 'right' && + floor(popperOffsets.left) < floor(refOffsets.right)) || + (placement === 'top' && + floor(popperOffsets.bottom) > floor(refOffsets.top)) || + (placement === 'bottom' && + floor(popperOffsets.top) < floor(refOffsets.bottom)); + + const overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left); + const overflowsRight = floor(popperOffsets.right) > floor(boundaries.right); + const overflowsTop = floor(popperOffsets.top) < floor(boundaries.top); + const overflowsBottom = + floor(popperOffsets.bottom) > floor(boundaries.bottom); + + const overflowsBoundaries = + (placement === 'left' && overflowsLeft) || + (placement === 'right' && overflowsRight) || + (placement === 'top' && overflowsTop) || + (placement === 'bottom' && overflowsBottom); + + // flip the variation if required + const isVertical = ['top', 'bottom'].indexOf(placement) !== -1; + + // flips variation if reference element overflows boundaries + const flippedVariationByRef = + !!options.flipVariations && + ((isVertical && variation === 'start' && overflowsLeft) || + (isVertical && variation === 'end' && overflowsRight) || + (!isVertical && variation === 'start' && overflowsTop) || + (!isVertical && variation === 'end' && overflowsBottom)); + + // flips variation if popper content overflows boundaries + const flippedVariationByContent = + !!options.flipVariationsByContent && + ((isVertical && variation === 'start' && overflowsRight) || + (isVertical && variation === 'end' && overflowsLeft) || + (!isVertical && variation === 'start' && overflowsBottom) || + (!isVertical && variation === 'end' && overflowsTop)); + + const flippedVariation = flippedVariationByRef || flippedVariationByContent; + + if (overlapsRef || overflowsBoundaries || flippedVariation) { + // this boolean to detect any flip loop + data.flipped = true; + + if (overlapsRef || overflowsBoundaries) { + placement = flipOrder[index + 1]; + } + + if (flippedVariation) { + variation = getOppositeVariation(variation); + } + + data.placement = placement + (variation ? '-' + variation : ''); + + // this object contains `position`, we want to preserve it along with + // any additional property we may add in the future + data.offsets.popper = { + ...data.offsets.popper, + ...getPopperOffsets( + data.instance.popper, + data.offsets.reference, + data.placement + ), + }; + + data = runModifiers(data.instance.modifiers, data, 'flip'); + } + }); + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/hide.js b/npm_assets/node_modules/popper.js/src/modifiers/hide.js new file mode 100644 index 0000000..4527438 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/hide.js @@ -0,0 +1,46 @@ +import isModifierRequired from '../utils/isModifierRequired'; +import find from '../utils/find'; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by update method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function hide(data) { + if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) { + return data; + } + + const refRect = data.offsets.reference; + const bound = find( + data.instance.modifiers, + modifier => modifier.name === 'preventOverflow' + ).boundaries; + + if ( + refRect.bottom < bound.top || + refRect.left > bound.right || + refRect.top > bound.bottom || + refRect.right < bound.left + ) { + // Avoid unnecessary DOM access if visibility hasn't changed + if (data.hide === true) { + return data; + } + + data.hide = true; + data.attributes['x-out-of-boundaries'] = ''; + } else { + // Avoid unnecessary DOM access if visibility hasn't changed + if (data.hide === false) { + return data; + } + + data.hide = false; + data.attributes['x-out-of-boundaries'] = false; + } + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/index.js b/npm_assets/node_modules/popper.js/src/modifiers/index.js new file mode 100644 index 0000000..3fd648a --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/index.js @@ -0,0 +1,369 @@ +import applyStyle, { applyStyleOnLoad } from './applyStyle'; +import computeStyle from './computeStyle'; +import arrow from './arrow'; +import flip from './flip'; +import keepTogether from './keepTogether'; +import offset from './offset'; +import preventOverflow from './preventOverflow'; +import shift from './shift'; +import hide from './hide'; +import inner from './inner'; + +/** + * Modifier function, each modifier can have a function of this type assigned + * to its `fn` property.<br /> + * These functions will be called on each update, this means that you must + * make sure they are performant enough to avoid performance bottlenecks. + * + * @function ModifierFn + * @argument {dataObject} data - The data object generated by `update` method + * @argument {Object} options - Modifiers configuration and options + * @returns {dataObject} The data object, properly modified + */ + +/** + * Modifiers are plugins used to alter the behavior of your poppers.<br /> + * Popper.js uses a set of 9 modifiers to provide all the basic functionalities + * needed by the library. + * + * Usually you don't want to override the `order`, `fn` and `onLoad` props. + * All the other properties are configurations that could be tweaked. + * @namespace modifiers + */ +export default { + /** + * Modifier used to shift the popper on the start or end of its reference + * element.<br /> + * It will read the variation of the `placement` property.<br /> + * It can be one either `-end` or `-start`. + * @memberof modifiers + * @inner + */ + shift: { + /** @prop {number} order=100 - Index used to define the order of execution */ + order: 100, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: shift, + }, + + /** + * The `offset` modifier can shift your popper on both its axis. + * + * It accepts the following units: + * - `px` or unit-less, interpreted as pixels + * - `%` or `%r`, percentage relative to the length of the reference element + * - `%p`, percentage relative to the length of the popper element + * - `vw`, CSS viewport width unit + * - `vh`, CSS viewport height unit + * + * For length is intended the main axis relative to the placement of the popper.<br /> + * This means that if the placement is `top` or `bottom`, the length will be the + * `width`. In case of `left` or `right`, it will be the `height`. + * + * You can provide a single value (as `Number` or `String`), or a pair of values + * as `String` divided by a comma or one (or more) white spaces.<br /> + * The latter is a deprecated method because it leads to confusion and will be + * removed in v2.<br /> + * Additionally, it accepts additions and subtractions between different units. + * Note that multiplications and divisions aren't supported. + * + * Valid examples are: + * ``` + * 10 + * '10%' + * '10, 10' + * '10%, 10' + * '10 + 10%' + * '10 - 5vh + 3%' + * '-10px + 5vh, 5px - 6%' + * ``` + * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap + * > with their reference element, unfortunately, you will have to disable the `flip` modifier. + * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373). + * + * @memberof modifiers + * @inner + */ + offset: { + /** @prop {number} order=200 - Index used to define the order of execution */ + order: 200, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: offset, + /** @prop {Number|String} offset=0 + * The offset value as described in the modifier description + */ + offset: 0, + }, + + /** + * Modifier used to prevent the popper from being positioned outside the boundary. + * + * A scenario exists where the reference itself is not within the boundaries.<br /> + * We can say it has "escaped the boundaries" — or just "escaped".<br /> + * In this case we need to decide whether the popper should either: + * + * - detach from the reference and remain "trapped" in the boundaries, or + * - if it should ignore the boundary and "escape with its reference" + * + * When `escapeWithReference` is set to`true` and reference is completely + * outside its boundaries, the popper will overflow (or completely leave) + * the boundaries in order to remain attached to the edge of the reference. + * + * @memberof modifiers + * @inner + */ + preventOverflow: { + /** @prop {number} order=300 - Index used to define the order of execution */ + order: 300, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: preventOverflow, + /** + * @prop {Array} [priority=['left','right','top','bottom']] + * Popper will try to prevent overflow following these priorities by default, + * then, it could overflow on the left and on top of the `boundariesElement` + */ + priority: ['left', 'right', 'top', 'bottom'], + /** + * @prop {number} padding=5 + * Amount of pixel used to define a minimum distance between the boundaries + * and the popper. This makes sure the popper always has a little padding + * between the edges of its container + */ + padding: 5, + /** + * @prop {String|HTMLElement} boundariesElement='scrollParent' + * Boundaries used by the modifier. Can be `scrollParent`, `window`, + * `viewport` or any DOM element. + */ + boundariesElement: 'scrollParent', + }, + + /** + * Modifier used to make sure the reference and its popper stay near each other + * without leaving any gap between the two. Especially useful when the arrow is + * enabled and you want to ensure that it points to its reference element. + * It cares only about the first axis. You can still have poppers with margin + * between the popper and its reference element. + * @memberof modifiers + * @inner + */ + keepTogether: { + /** @prop {number} order=400 - Index used to define the order of execution */ + order: 400, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: keepTogether, + }, + + /** + * This modifier is used to move the `arrowElement` of the popper to make + * sure it is positioned between the reference element and its popper element. + * It will read the outer size of the `arrowElement` node to detect how many + * pixels of conjunction are needed. + * + * It has no effect if no `arrowElement` is provided. + * @memberof modifiers + * @inner + */ + arrow: { + /** @prop {number} order=500 - Index used to define the order of execution */ + order: 500, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: arrow, + /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */ + element: '[x-arrow]', + }, + + /** + * Modifier used to flip the popper's placement when it starts to overlap its + * reference element. + * + * Requires the `preventOverflow` modifier before it in order to work. + * + * **NOTE:** this modifier will interrupt the current update cycle and will + * restart it if it detects the need to flip the placement. + * @memberof modifiers + * @inner + */ + flip: { + /** @prop {number} order=600 - Index used to define the order of execution */ + order: 600, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: flip, + /** + * @prop {String|Array} behavior='flip' + * The behavior used to change the popper's placement. It can be one of + * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid + * placements (with optional variations) + */ + behavior: 'flip', + /** + * @prop {number} padding=5 + * The popper will flip if it hits the edges of the `boundariesElement` + */ + padding: 5, + /** + * @prop {String|HTMLElement} boundariesElement='viewport' + * The element which will define the boundaries of the popper position. + * The popper will never be placed outside of the defined boundaries + * (except if `keepTogether` is enabled) + */ + boundariesElement: 'viewport', + /** + * @prop {Boolean} flipVariations=false + * The popper will switch placement variation between `-start` and `-end` when + * the reference element overlaps its boundaries. + * + * The original placement should have a set variation. + */ + flipVariations: false, + /** + * @prop {Boolean} flipVariationsByContent=false + * The popper will switch placement variation between `-start` and `-end` when + * the popper element overlaps its reference boundaries. + * + * The original placement should have a set variation. + */ + flipVariationsByContent: false, + }, + + /** + * Modifier used to make the popper flow toward the inner of the reference element. + * By default, when this modifier is disabled, the popper will be placed outside + * the reference element. + * @memberof modifiers + * @inner + */ + inner: { + /** @prop {number} order=700 - Index used to define the order of execution */ + order: 700, + /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */ + enabled: false, + /** @prop {ModifierFn} */ + fn: inner, + }, + + /** + * Modifier used to hide the popper when its reference element is outside of the + * popper boundaries. It will set a `x-out-of-boundaries` attribute which can + * be used to hide with a CSS selector the popper when its reference is + * out of boundaries. + * + * Requires the `preventOverflow` modifier before it in order to work. + * @memberof modifiers + * @inner + */ + hide: { + /** @prop {number} order=800 - Index used to define the order of execution */ + order: 800, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: hide, + }, + + /** + * Computes the style that will be applied to the popper element to gets + * properly positioned. + * + * Note that this modifier will not touch the DOM, it just prepares the styles + * so that `applyStyle` modifier can apply it. This separation is useful + * in case you need to replace `applyStyle` with a custom implementation. + * + * This modifier has `850` as `order` value to maintain backward compatibility + * with previous versions of Popper.js. Expect the modifiers ordering method + * to change in future major versions of the library. + * + * @memberof modifiers + * @inner + */ + computeStyle: { + /** @prop {number} order=850 - Index used to define the order of execution */ + order: 850, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: computeStyle, + /** + * @prop {Boolean} gpuAcceleration=true + * If true, it uses the CSS 3D transformation to position the popper. + * Otherwise, it will use the `top` and `left` properties + */ + gpuAcceleration: true, + /** + * @prop {string} [x='bottom'] + * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin. + * Change this if your popper should grow in a direction different from `bottom` + */ + x: 'bottom', + /** + * @prop {string} [x='left'] + * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin. + * Change this if your popper should grow in a direction different from `right` + */ + y: 'right', + }, + + /** + * Applies the computed styles to the popper element. + * + * All the DOM manipulations are limited to this modifier. This is useful in case + * you want to integrate Popper.js inside a framework or view library and you + * want to delegate all the DOM manipulations to it. + * + * Note that if you disable this modifier, you must make sure the popper element + * has its position set to `absolute` before Popper.js can do its work! + * + * Just disable this modifier and define your own to achieve the desired effect. + * + * @memberof modifiers + * @inner + */ + applyStyle: { + /** @prop {number} order=900 - Index used to define the order of execution */ + order: 900, + /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ + enabled: true, + /** @prop {ModifierFn} */ + fn: applyStyle, + /** @prop {Function} */ + onLoad: applyStyleOnLoad, + /** + * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier + * @prop {Boolean} gpuAcceleration=true + * If true, it uses the CSS 3D transformation to position the popper. + * Otherwise, it will use the `top` and `left` properties + */ + gpuAcceleration: undefined, + }, +}; + +/** + * The `dataObject` is an object containing all the information used by Popper.js. + * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks. + * @name dataObject + * @property {Object} data.instance The Popper.js instance + * @property {String} data.placement Placement applied to popper + * @property {String} data.originalPlacement Placement originally defined on init + * @property {Boolean} data.flipped True if popper has been flipped by flip modifier + * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper + * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier + * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`) + * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`) + * @property {Object} data.boundaries Offsets of the popper boundaries + * @property {Object} data.offsets The measurements of popper, reference and arrow elements + * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values + * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values + * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0 + */ diff --git a/npm_assets/node_modules/popper.js/src/modifiers/inner.js b/npm_assets/node_modules/popper.js/src/modifiers/inner.js new file mode 100644 index 0000000..da2b927 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/inner.js @@ -0,0 +1,27 @@ +import getClientRect from '../utils/getClientRect'; +import getOppositePlacement from '../utils/getOppositePlacement'; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by `update` method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function inner(data) { + const placement = data.placement; + const basePlacement = placement.split('-')[0]; + const { popper, reference } = data.offsets; + const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1; + + const subtractLength = ['top', 'left'].indexOf(basePlacement) === -1; + + popper[isHoriz ? 'left' : 'top'] = + reference[basePlacement] - + (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0); + + data.placement = getOppositePlacement(placement); + data.offsets.popper = getClientRect(popper); + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/keepTogether.js b/npm_assets/node_modules/popper.js/src/modifiers/keepTogether.js new file mode 100644 index 0000000..3d5b0b3 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/keepTogether.js @@ -0,0 +1,26 @@ +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by update method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function keepTogether(data) { + const { popper, reference } = data.offsets; + const placement = data.placement.split('-')[0]; + const floor = Math.floor; + const isVertical = ['top', 'bottom'].indexOf(placement) !== -1; + const side = isVertical ? 'right' : 'bottom'; + const opSide = isVertical ? 'left' : 'top'; + const measurement = isVertical ? 'width' : 'height'; + + if (popper[side] < floor(reference[opSide])) { + data.offsets.popper[opSide] = + floor(reference[opSide]) - popper[measurement]; + } + if (popper[opSide] > floor(reference[side])) { + data.offsets.popper[opSide] = floor(reference[side]); + } + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/offset.js b/npm_assets/node_modules/popper.js/src/modifiers/offset.js new file mode 100644 index 0000000..70c9222 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/offset.js @@ -0,0 +1,194 @@ +import isNumeric from '../utils/isNumeric'; +import getClientRect from '../utils/getClientRect'; +import find from '../utils/find'; + +/** + * Converts a string containing value + unit into a px value number + * @function + * @memberof {modifiers~offset} + * @private + * @argument {String} str - Value + unit string + * @argument {String} measurement - `height` or `width` + * @argument {Object} popperOffsets + * @argument {Object} referenceOffsets + * @returns {Number|String} + * Value in pixels, or original string if no values were extracted + */ +export function toValue(str, measurement, popperOffsets, referenceOffsets) { + // separate value from unit + const split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/); + const value = +split[1]; + const unit = split[2]; + + // If it's not a number it's an operator, I guess + if (!value) { + return str; + } + + if (unit.indexOf('%') === 0) { + let element; + switch (unit) { + case '%p': + element = popperOffsets; + break; + case '%': + case '%r': + default: + element = referenceOffsets; + } + + const rect = getClientRect(element); + return rect[measurement] / 100 * value; + } else if (unit === 'vh' || unit === 'vw') { + // if is a vh or vw, we calculate the size based on the viewport + let size; + if (unit === 'vh') { + size = Math.max( + document.documentElement.clientHeight, + window.innerHeight || 0 + ); + } else { + size = Math.max( + document.documentElement.clientWidth, + window.innerWidth || 0 + ); + } + return size / 100 * value; + } else { + // if is an explicit pixel unit, we get rid of the unit and keep the value + // if is an implicit unit, it's px, and we return just the value + return value; + } +} + +/** + * Parse an `offset` string to extrapolate `x` and `y` numeric offsets. + * @function + * @memberof {modifiers~offset} + * @private + * @argument {String} offset + * @argument {Object} popperOffsets + * @argument {Object} referenceOffsets + * @argument {String} basePlacement + * @returns {Array} a two cells array with x and y offsets in numbers + */ +export function parseOffset( + offset, + popperOffsets, + referenceOffsets, + basePlacement +) { + const offsets = [0, 0]; + + // Use height if placement is left or right and index is 0 otherwise use width + // in this way the first offset will use an axis and the second one + // will use the other one + const useHeight = ['right', 'left'].indexOf(basePlacement) !== -1; + + // Split the offset string to obtain a list of values and operands + // The regex addresses values with the plus or minus sign in front (+10, -20, etc) + const fragments = offset.split(/(\+|\-)/).map(frag => frag.trim()); + + // Detect if the offset string contains a pair of values or a single one + // they could be separated by comma or space + const divider = fragments.indexOf( + find(fragments, frag => frag.search(/,|\s/) !== -1) + ); + + if (fragments[divider] && fragments[divider].indexOf(',') === -1) { + console.warn( + 'Offsets separated by white space(s) are deprecated, use a comma (,) instead.' + ); + } + + // If divider is found, we divide the list of values and operands to divide + // them by ofset X and Y. + const splitRegex = /\s*,\s*|\s+/; + let ops = divider !== -1 + ? [ + fragments + .slice(0, divider) + .concat([fragments[divider].split(splitRegex)[0]]), + [fragments[divider].split(splitRegex)[1]].concat( + fragments.slice(divider + 1) + ), + ] + : [fragments]; + + // Convert the values with units to absolute pixels to allow our computations + ops = ops.map((op, index) => { + // Most of the units rely on the orientation of the popper + const measurement = (index === 1 ? !useHeight : useHeight) + ? 'height' + : 'width'; + let mergeWithPrevious = false; + return ( + op + // This aggregates any `+` or `-` sign that aren't considered operators + // e.g.: 10 + +5 => [10, +, +5] + .reduce((a, b) => { + if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) { + a[a.length - 1] = b; + mergeWithPrevious = true; + return a; + } else if (mergeWithPrevious) { + a[a.length - 1] += b; + mergeWithPrevious = false; + return a; + } else { + return a.concat(b); + } + }, []) + // Here we convert the string values into number values (in px) + .map(str => toValue(str, measurement, popperOffsets, referenceOffsets)) + ); + }); + + // Loop trough the offsets arrays and execute the operations + ops.forEach((op, index) => { + op.forEach((frag, index2) => { + if (isNumeric(frag)) { + offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1); + } + }); + }); + return offsets; +} + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by update method + * @argument {Object} options - Modifiers configuration and options + * @argument {Number|String} options.offset=0 + * The offset value as described in the modifier description + * @returns {Object} The data object, properly modified + */ +export default function offset(data, { offset }) { + const { placement, offsets: { popper, reference } } = data; + const basePlacement = placement.split('-')[0]; + + let offsets; + if (isNumeric(+offset)) { + offsets = [+offset, 0]; + } else { + offsets = parseOffset(offset, popper, reference, basePlacement); + } + + if (basePlacement === 'left') { + popper.top += offsets[0]; + popper.left -= offsets[1]; + } else if (basePlacement === 'right') { + popper.top += offsets[0]; + popper.left += offsets[1]; + } else if (basePlacement === 'top') { + popper.left += offsets[0]; + popper.top -= offsets[1]; + } else if (basePlacement === 'bottom') { + popper.left += offsets[0]; + popper.top += offsets[1]; + } + + data.popper = popper; + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/preventOverflow.js b/npm_assets/node_modules/popper.js/src/modifiers/preventOverflow.js new file mode 100644 index 0000000..d2d6779 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/preventOverflow.js @@ -0,0 +1,89 @@ +import getOffsetParent from '../utils/getOffsetParent'; +import getBoundaries from '../utils/getBoundaries'; +import getSupportedPropertyName from '../utils/getSupportedPropertyName'; + +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by `update` method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function preventOverflow(data, options) { + let boundariesElement = + options.boundariesElement || getOffsetParent(data.instance.popper); + + // If offsetParent is the reference element, we really want to + // go one step up and use the next offsetParent as reference to + // avoid to make this modifier completely useless and look like broken + if (data.instance.reference === boundariesElement) { + boundariesElement = getOffsetParent(boundariesElement); + } + + // NOTE: DOM access here + // resets the popper's position so that the document size can be calculated excluding + // the size of the popper element itself + const transformProp = getSupportedPropertyName('transform'); + const popperStyles = data.instance.popper.style; // assignment to help minification + const { top, left, [transformProp]: transform } = popperStyles; + popperStyles.top = ''; + popperStyles.left = ''; + popperStyles[transformProp] = ''; + + const boundaries = getBoundaries( + data.instance.popper, + data.instance.reference, + options.padding, + boundariesElement, + data.positionFixed + ); + + // NOTE: DOM access here + // restores the original style properties after the offsets have been computed + popperStyles.top = top; + popperStyles.left = left; + popperStyles[transformProp] = transform; + + options.boundaries = boundaries; + + const order = options.priority; + let popper = data.offsets.popper; + + const check = { + primary(placement) { + let value = popper[placement]; + if ( + popper[placement] < boundaries[placement] && + !options.escapeWithReference + ) { + value = Math.max(popper[placement], boundaries[placement]); + } + return { [placement]: value }; + }, + secondary(placement) { + const mainSide = placement === 'right' ? 'left' : 'top'; + let value = popper[mainSide]; + if ( + popper[placement] > boundaries[placement] && + !options.escapeWithReference + ) { + value = Math.min( + popper[mainSide], + boundaries[placement] - + (placement === 'right' ? popper.width : popper.height) + ); + } + return { [mainSide]: value }; + }, + }; + + order.forEach(placement => { + const side = + ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary'; + popper = { ...popper, ...check[side](placement) }; + }); + + data.offsets.popper = popper; + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/modifiers/shift.js b/npm_assets/node_modules/popper.js/src/modifiers/shift.js new file mode 100644 index 0000000..e9bef79 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/modifiers/shift.js @@ -0,0 +1,31 @@ +/** + * @function + * @memberof Modifiers + * @argument {Object} data - The data object generated by `update` method + * @argument {Object} options - Modifiers configuration and options + * @returns {Object} The data object, properly modified + */ +export default function shift(data) { + const placement = data.placement; + const basePlacement = placement.split('-')[0]; + const shiftvariation = placement.split('-')[1]; + + // if shift shiftvariation is specified, run the modifier + if (shiftvariation) { + const { reference, popper } = data.offsets; + const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1; + const side = isVertical ? 'left' : 'top'; + const measurement = isVertical ? 'width' : 'height'; + + const shiftOffsets = { + start: { [side]: reference[side] }, + end: { + [side]: reference[side] + reference[measurement] - popper[measurement], + }, + }; + + data.offsets.popper = { ...popper, ...shiftOffsets[shiftvariation] }; + } + + return data; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/clockwise.js b/npm_assets/node_modules/popper.js/src/utils/clockwise.js new file mode 100644 index 0000000..0ff93aa --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/clockwise.js @@ -0,0 +1,22 @@ +import placements from '../methods/placements'; + +// Get rid of `auto` `auto-start` and `auto-end` +const validPlacements = placements.slice(3); + +/** + * Given an initial placement, returns all the subsequent placements + * clockwise (or counter-clockwise). + * + * @method + * @memberof Popper.Utils + * @argument {String} placement - A valid placement (it accepts variations) + * @argument {Boolean} counter - Set to true to walk the placements counterclockwise + * @returns {Array} placements including their variations + */ +export default function clockwise(placement, counter = false) { + const index = validPlacements.indexOf(placement); + const arr = validPlacements + .slice(index + 1) + .concat(validPlacements.slice(0, index)); + return counter ? arr.reverse() : arr; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/computeAutoPlacement.js b/npm_assets/node_modules/popper.js/src/utils/computeAutoPlacement.js new file mode 100644 index 0000000..7fcad2a --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/computeAutoPlacement.js @@ -0,0 +1,74 @@ +import getBoundaries from '../utils/getBoundaries'; + +function getArea({ width, 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 + */ +export default function computeAutoPlacement( + placement, + refRect, + popper, + reference, + boundariesElement, + padding = 0 +) { + if (placement.indexOf('auto') === -1) { + return placement; + } + + const boundaries = getBoundaries( + popper, + reference, + padding, + boundariesElement + ); + + const 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, + }, + }; + + const sortedAreas = Object.keys(rects) + .map(key => ({ + key, + ...rects[key], + area: getArea(rects[key]), + })) + .sort((a, b) => b.area - a.area); + + const filteredAreas = sortedAreas.filter( + ({ width, height }) => + width >= popper.clientWidth && height >= popper.clientHeight + ); + + const computedPlacement = filteredAreas.length > 0 + ? filteredAreas[0].key + : sortedAreas[0].key; + + const variation = placement.split('-')[1]; + + return computedPlacement + (variation ? `-${variation}` : ''); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/debounce.js b/npm_assets/node_modules/popper.js/src/utils/debounce.js new file mode 100644 index 0000000..0b9d8d3 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/debounce.js @@ -0,0 +1,54 @@ +import isBrowser from './isBrowser'; + +const timeoutDuration = (function(){ + const longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox']; + for (let i = 0; i < longerTimeoutBrowsers.length; i += 1) { + if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) { + return 1; + } + } + return 0; +}()); + +export function microtaskDebounce(fn) { + let called = false + return () => { + if (called) { + return + } + called = true + window.Promise.resolve().then(() => { + called = false + fn() + }) + } +} + +export function taskDebounce(fn) { + let scheduled = false; + return () => { + if (!scheduled) { + scheduled = true; + setTimeout(() => { + scheduled = false; + fn(); + }, timeoutDuration); + } + }; +} + +const 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} +*/ +export default (supportsMicroTasks + ? microtaskDebounce + : taskDebounce); diff --git a/npm_assets/node_modules/popper.js/src/utils/find.js b/npm_assets/node_modules/popper.js/src/utils/find.js new file mode 100644 index 0000000..1ce9949 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/find.js @@ -0,0 +1,18 @@ +/** + * Mimics the `find` method of Array + * @method + * @memberof Popper.Utils + * @argument {Array} arr + * @argument prop + * @argument value + * @returns index or -1 + */ +export default 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]; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/findCommonOffsetParent.js b/npm_assets/node_modules/popper.js/src/utils/findCommonOffsetParent.js new file mode 100644 index 0000000..ca905fa --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/findCommonOffsetParent.js @@ -0,0 +1,52 @@ +import isOffsetContainer from './isOffsetContainer'; +import getRoot from './getRoot'; +import getOffsetParent from './getOffsetParent'; + +/** + * 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 + */ +export default 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 + const order = + element1.compareDocumentPosition(element2) & + Node.DOCUMENT_POSITION_FOLLOWING; + const start = order ? element1 : element2; + const end = order ? element2 : element1; + + // Get common ancestor container + const range = document.createRange(); + range.setStart(start, 0); + range.setEnd(end, 0); + const { commonAncestorContainer } = range; + + // 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 + const element1root = getRoot(element1); + if (element1root.host) { + return findCommonOffsetParent(element1root.host, element2); + } else { + return findCommonOffsetParent(element1, getRoot(element2).host); + } +} diff --git a/npm_assets/node_modules/popper.js/src/utils/findIndex.js b/npm_assets/node_modules/popper.js/src/utils/findIndex.js new file mode 100644 index 0000000..ebadfcc --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/findIndex.js @@ -0,0 +1,21 @@ +import find from './find'; + +/** + * Return the index of the matching object + * @method + * @memberof Popper.Utils + * @argument {Array} arr + * @argument prop + * @argument value + * @returns index or -1 + */ +export default function findIndex(arr, prop, value) { + // use native findIndex if supported + if (Array.prototype.findIndex) { + return arr.findIndex(cur => cur[prop] === value); + } + + // use `find` + `indexOf` if `findIndex` isn't supported + const match = find(arr, obj => obj[prop] === value); + return arr.indexOf(match); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getBordersSize.js b/npm_assets/node_modules/popper.js/src/utils/getBordersSize.js new file mode 100644 index 0000000..1fe551d --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getBordersSize.js @@ -0,0 +1,19 @@ +/* + * 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 + */ + +export default function getBordersSize(styles, axis) { + const sideA = axis === 'x' ? 'Left' : 'Top'; + const sideB = sideA === 'Left' ? 'Right' : 'Bottom'; + + return ( + parseFloat(styles[`border${sideA}Width`]) + + parseFloat(styles[`border${sideB}Width`]) + ); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getBoundaries.js b/npm_assets/node_modules/popper.js/src/utils/getBoundaries.js new file mode 100644 index 0000000..45cb54a --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getBoundaries.js @@ -0,0 +1,81 @@ +import getScrollParent from './getScrollParent'; +import getParentNode from './getParentNode'; +import getReferenceNode from './getReferenceNode'; +import findCommonOffsetParent from './findCommonOffsetParent'; +import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; +import getViewportOffsetRectRelativeToArtbitraryNode from './getViewportOffsetRectRelativeToArtbitraryNode'; +import getWindowSizes from './getWindowSizes'; +import isFixed from './isFixed'; +import getFixedPositionOffsetParent from './getFixedPositionOffsetParent'; + +/** + * 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 + * @param {Boolean} fixedPosition - Is in fixed position mode + * @returns {Object} Coordinates of the boundaries + */ +export default function getBoundaries( + popper, + reference, + padding, + boundariesElement, + fixedPosition = false +) { + // NOTE: 1 DOM access here + + let boundaries = { top: 0, left: 0 }; + const offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); + + // Handle viewport case + if (boundariesElement === 'viewport' ) { + boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition); + } + + else { + // Handle other cases based on DOM element used as boundaries + let boundariesNode; + 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; + } + + const offsets = getOffsetRectRelativeToArbitraryNode( + boundariesNode, + offsetParent, + fixedPosition + ); + + // In case of HTML, we need a different computation + if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) { + const { height, width } = getWindowSizes(popper.ownerDocument); + 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 + padding = padding || 0; + const 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; + + return boundaries; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getBoundingClientRect.js b/npm_assets/node_modules/popper.js/src/utils/getBoundingClientRect.js new file mode 100644 index 0000000..f9e0543 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getBoundingClientRect.js @@ -0,0 +1,66 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import getBordersSize from './getBordersSize'; +import getWindowSizes from './getWindowSizes'; +import getScroll from './getScroll'; +import getClientRect from './getClientRect'; +import isIE from './isIE'; + +/** + * Get bounding client rect of given element + * @method + * @memberof Popper.Utils + * @param {HTMLElement} element + * @return {Object} client rect + */ +export default function getBoundingClientRect(element) { + let 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 + try { + if (isIE(10)) { + rect = element.getBoundingClientRect(); + const scrollTop = getScroll(element, 'top'); + const scrollLeft = getScroll(element, 'left'); + rect.top += scrollTop; + rect.left += scrollLeft; + rect.bottom += scrollTop; + rect.right += scrollLeft; + } + else { + rect = element.getBoundingClientRect(); + } + } + catch(e){} + + const result = { + left: rect.left, + top: rect.top, + width: rect.right - rect.left, + height: rect.bottom - rect.top, + }; + + // subtract scrollbar size from sizes + const sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {}; + const width = + sizes.width || element.clientWidth || result.width; + const height = + sizes.height || element.clientHeight || result.height; + + let horizScrollbar = element.offsetWidth - width; + let 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) { + const styles = getStyleComputedProperty(element); + horizScrollbar -= getBordersSize(styles, 'x'); + vertScrollbar -= getBordersSize(styles, 'y'); + + result.width -= horizScrollbar; + result.height -= vertScrollbar; + } + + return getClientRect(result); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getClientRect.js b/npm_assets/node_modules/popper.js/src/utils/getClientRect.js new file mode 100644 index 0000000..4f659d3 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getClientRect.js @@ -0,0 +1,14 @@ +/** + * Given element offsets, generate an output similar to getBoundingClientRect + * @method + * @memberof Popper.Utils + * @argument {Object} offsets + * @returns {Object} ClientRect like output + */ +export default function getClientRect(offsets) { + return { + ...offsets, + right: offsets.left + offsets.width, + bottom: offsets.top + offsets.height, + }; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getFixedPositionOffsetParent.js b/npm_assets/node_modules/popper.js/src/utils/getFixedPositionOffsetParent.js new file mode 100644 index 0000000..ae6de16 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getFixedPositionOffsetParent.js @@ -0,0 +1,22 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import isIE from './isIE'; +/** + * 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 + */ + +export default 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; + } + let el = element.parentElement; + while (el && getStyleComputedProperty(el, 'transform') === 'none') { + el = el.parentElement; + } + return el || document.documentElement; + +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOffsetParent.js b/npm_assets/node_modules/popper.js/src/utils/getOffsetParent.js new file mode 100644 index 0000000..875aacd --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOffsetParent.js @@ -0,0 +1,40 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import isIE from './isIE'; +/** + * Returns the offset parent of the given element + * @method + * @memberof Popper.Utils + * @argument {Element} element + * @returns {Element} offset parent + */ +export default function getOffsetParent(element) { + if (!element) { + return document.documentElement; + } + + const noOffsetParent = isIE(10) ? document.body : null; + + // NOTE: 1 DOM access here + let offsetParent = element.offsetParent || null; + // Skip hidden elements which don't have an offsetParent + while (offsetParent === noOffsetParent && element.nextElementSibling) { + offsetParent = (element = element.nextElementSibling).offsetParent; + } + + const nodeName = offsetParent && offsetParent.nodeName; + + if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') { + return element ? element.ownerDocument.documentElement : document.documentElement; + } + + // .offsetParent will return the closest TH, TD or TABLE in case + // no offsetParent is present, I hate this job... + if ( + ['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && + getStyleComputedProperty(offsetParent, 'position') === 'static' + ) { + return getOffsetParent(offsetParent); + } + + return offsetParent; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOffsetRect.js b/npm_assets/node_modules/popper.js/src/utils/getOffsetRect.js new file mode 100644 index 0000000..c14051b --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOffsetRect.js @@ -0,0 +1,32 @@ +import getWindowSizes from './getWindowSizes'; +import getClientRect from './getClientRect'; + +/** + * 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` + */ +export default function getOffsetRect(element) { + let elementRect; + if (element.nodeName === 'HTML') { + const { width, height } = getWindowSizes(element.ownerDocument); + elementRect = { + width, + height, + left: 0, + top: 0, + }; + } else { + elementRect = { + width: element.offsetWidth, + height: element.offsetHeight, + left: element.offsetLeft, + top: element.offsetTop, + }; + } + + // position + return getClientRect(elementRect); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOffsetRectRelativeToArbitraryNode.js b/npm_assets/node_modules/popper.js/src/utils/getOffsetRectRelativeToArbitraryNode.js new file mode 100644 index 0000000..362b5b3 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOffsetRectRelativeToArbitraryNode.js @@ -0,0 +1,60 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import includeScroll from './includeScroll'; +import getScrollParent from './getScrollParent'; +import getBoundingClientRect from './getBoundingClientRect'; +import runIsIE from './isIE'; +import getClientRect from './getClientRect'; + +export default function getOffsetRectRelativeToArbitraryNode(children, parent, fixedPosition = false) { + const isIE10 = runIsIE(10); + const isHTML = parent.nodeName === 'HTML'; + const childrenRect = getBoundingClientRect(children); + const parentRect = getBoundingClientRect(parent); + const scrollParent = getScrollParent(children); + + const styles = getStyleComputedProperty(parent); + const borderTopWidth = parseFloat(styles.borderTopWidth); + const borderLeftWidth = parseFloat(styles.borderLeftWidth); + + // In cases where the parent is fixed, we must ignore negative scroll in offset calc + if(fixedPosition && isHTML) { + parentRect.top = Math.max(parentRect.top, 0); + parentRect.left = Math.max(parentRect.left, 0); + } + let 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) { + const marginTop = parseFloat(styles.marginTop); + const marginLeft = parseFloat(styles.marginLeft); + + 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; + } + + if ( + isIE10 && !fixedPosition + ? parent.contains(scrollParent) + : parent === scrollParent && scrollParent.nodeName !== 'BODY' + ) { + offsets = includeScroll(offsets, parent); + } + + return offsets; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOppositePlacement.js b/npm_assets/node_modules/popper.js/src/utils/getOppositePlacement.js new file mode 100644 index 0000000..26a144d --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOppositePlacement.js @@ -0,0 +1,11 @@ +/** + * Get the opposite placement of the given one + * @method + * @memberof Popper.Utils + * @argument {String} placement + * @returns {String} flipped placement + */ +export default function getOppositePlacement(placement) { + const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; + return placement.replace(/left|right|bottom|top/g, matched => hash[matched]); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOppositeVariation.js b/npm_assets/node_modules/popper.js/src/utils/getOppositeVariation.js new file mode 100644 index 0000000..405cbd6 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOppositeVariation.js @@ -0,0 +1,15 @@ +/** + * Get the opposite placement variation of the given one + * @method + * @memberof Popper.Utils + * @argument {String} placement variation + * @returns {String} flipped placement variation + */ +export default function getOppositeVariation(variation) { + if (variation === 'end') { + return 'start'; + } else if (variation === 'start') { + return 'end'; + } + return variation; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getOuterSizes.js b/npm_assets/node_modules/popper.js/src/utils/getOuterSizes.js new file mode 100644 index 0000000..cf55c3e --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getOuterSizes.js @@ -0,0 +1,18 @@ +/** + * 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 + */ +export default function getOuterSizes(element) { + const window = element.ownerDocument.defaultView; + const styles = window.getComputedStyle(element); + const x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0); + const y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0); + const result = { + width: element.offsetWidth + y, + height: element.offsetHeight + x, + }; + return result; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getParentNode.js b/npm_assets/node_modules/popper.js/src/utils/getParentNode.js new file mode 100644 index 0000000..d90f706 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getParentNode.js @@ -0,0 +1,13 @@ +/** + * Returns the parentNode or the host of the element + * @method + * @memberof Popper.Utils + * @argument {Element} element + * @returns {Element} parent + */ +export default function getParentNode(element) { + if (element.nodeName === 'HTML') { + return element; + } + return element.parentNode || element.host; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getPopperOffsets.js b/npm_assets/node_modules/popper.js/src/utils/getPopperOffsets.js new file mode 100644 index 0000000..46d9bfb --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getPopperOffsets.js @@ -0,0 +1,46 @@ +import getOuterSizes from './getOuterSizes'; +import getOppositePlacement from './getOppositePlacement'; + +/** + * 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 + */ +export default function getPopperOffsets(popper, referenceOffsets, placement) { + placement = placement.split('-')[0]; + + // Get popper node sizes + const popperRect = getOuterSizes(popper); + + // Add position, width and height to our offsets object + const popperOffsets = { + width: popperRect.width, + height: popperRect.height, + }; + + // depending by the popper placement we have to compute its offsets slightly differently + const isHoriz = ['right', 'left'].indexOf(placement) !== -1; + const mainSide = isHoriz ? 'top' : 'left'; + const secondarySide = isHoriz ? 'left' : 'top'; + const measurement = isHoriz ? 'height' : 'width'; + const 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; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getReferenceNode.js b/npm_assets/node_modules/popper.js/src/utils/getReferenceNode.js new file mode 100644 index 0000000..25f5604 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getReferenceNode.js @@ -0,0 +1,10 @@ +/** + * 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 + */ +export default function getReferenceNode(reference) { + return reference && reference.referenceNode ? reference.referenceNode : reference; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getReferenceOffsets.js b/npm_assets/node_modules/popper.js/src/utils/getReferenceOffsets.js new file mode 100644 index 0000000..f1ac32f --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getReferenceOffsets.js @@ -0,0 +1,19 @@ +import findCommonOffsetParent from './findCommonOffsetParent'; +import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; +import getFixedPositionOffsetParent from './getFixedPositionOffsetParent'; +import getReferenceNode from './getReferenceNode'; + +/** + * 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) + * @param {Element} fixedPosition - is in fixed position mode + * @returns {Object} An object containing the offsets which will be applied to the popper + */ +export default function getReferenceOffsets(state, popper, reference, fixedPosition = null) { + const commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); + return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getRoot.js b/npm_assets/node_modules/popper.js/src/utils/getRoot.js new file mode 100644 index 0000000..5b60287 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getRoot.js @@ -0,0 +1,14 @@ +/** + * Finds the root node (document, shadowDOM root) of the given element + * @method + * @memberof Popper.Utils + * @argument {Element} node + * @returns {Element} root node + */ +export default function getRoot(node) { + if (node.parentNode !== null) { + return getRoot(node.parentNode); + } + + return node; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getRoundedOffsets.js b/npm_assets/node_modules/popper.js/src/utils/getRoundedOffsets.js new file mode 100644 index 0000000..3240dbc --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getRoundedOffsets.js @@ -0,0 +1,50 @@ +/** + * @function + * @memberof Popper.Utils + * @argument {Object} data - The data object generated by `update` method + * @argument {Boolean} shouldRound - If the offsets should be rounded at all + * @returns {Object} The popper's position offsets rounded + * + * The tale of pixel-perfect positioning. It's still not 100% perfect, but as + * good as it can be within reason. + * Discussion here: https://github.com/FezVrasta/popper.js/pull/715 + * + * Low DPI screens cause a popper to be blurry if not using full pixels (Safari + * as well on High DPI screens). + * + * Firefox prefers no rounding for positioning and does not have blurriness on + * high DPI screens. + * + * Only horizontal placement and left/right values need to be considered. + */ +export default function getRoundedOffsets(data, shouldRound) { + const { popper, reference } = data.offsets; + const { round, floor } = Math; + const noRound = v => v; + + const referenceWidth = round(reference.width); + const popperWidth = round(popper.width); + + const isVertical = ['left', 'right'].indexOf(data.placement) !== -1; + const isVariation = data.placement.indexOf('-') !== -1; + const sameWidthParity = referenceWidth % 2 === popperWidth % 2; + const bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1; + + const horizontalToInteger = !shouldRound + ? noRound + : isVertical || isVariation || sameWidthParity + ? round + : floor; + const verticalToInteger = !shouldRound ? noRound : round; + + return { + left: horizontalToInteger( + bothOddWidth && !isVariation && shouldRound + ? popper.left - 1 + : popper.left + ), + top: verticalToInteger(popper.top), + bottom: verticalToInteger(popper.bottom), + right: horizontalToInteger(popper.right), + }; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getScroll.js b/npm_assets/node_modules/popper.js/src/utils/getScroll.js new file mode 100644 index 0000000..b94f06a --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getScroll.js @@ -0,0 +1,20 @@ +/** + * 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 + */ +export default function getScroll(element, side = 'top') { + const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft'; + const nodeName = element.nodeName; + + if (nodeName === 'BODY' || nodeName === 'HTML') { + const html = element.ownerDocument.documentElement; + const scrollingElement = element.ownerDocument.scrollingElement || html; + return scrollingElement[upperSide]; + } + + return element[upperSide]; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getScrollParent.js b/npm_assets/node_modules/popper.js/src/utils/getScrollParent.js new file mode 100644 index 0000000..9dca3cf --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getScrollParent.js @@ -0,0 +1,32 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import getParentNode from './getParentNode'; + +/** + * Returns the scrolling parent of the given element + * @method + * @memberof Popper.Utils + * @argument {Element} element + * @returns {Element} scroll parent + */ +export default 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 + const { overflow, overflowX, overflowY } = getStyleComputedProperty(element); + if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { + return element; + } + + return getScrollParent(getParentNode(element)); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getStyleComputedProperty.js b/npm_assets/node_modules/popper.js/src/utils/getStyleComputedProperty.js new file mode 100644 index 0000000..014f32b --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getStyleComputedProperty.js @@ -0,0 +1,16 @@ +/** + * Get CSS computed property of the given element + * @method + * @memberof Popper.Utils + * @argument {Eement} element + * @argument {String} property + */ +export default function getStyleComputedProperty(element, property) { + if (element.nodeType !== 1) { + return []; + } + // NOTE: 1 DOM access here + const window = element.ownerDocument.defaultView; + const css = window.getComputedStyle(element, null); + return property ? css[property] : css; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getSupportedPropertyName.js b/npm_assets/node_modules/popper.js/src/utils/getSupportedPropertyName.js new file mode 100644 index 0000000..c097e56 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getSupportedPropertyName.js @@ -0,0 +1,20 @@ +/** + * 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) + */ +export default function getSupportedPropertyName(property) { + const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O']; + const upperProp = property.charAt(0).toUpperCase() + property.slice(1); + + for (let i = 0; i < prefixes.length; i++) { + const prefix = prefixes[i]; + const toCheck = prefix ? `${prefix}${upperProp}` : property; + if (typeof document.body.style[toCheck] !== 'undefined') { + return toCheck; + } + } + return null; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getViewportOffsetRectRelativeToArtbitraryNode.js b/npm_assets/node_modules/popper.js/src/utils/getViewportOffsetRectRelativeToArtbitraryNode.js new file mode 100644 index 0000000..f401157 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getViewportOffsetRectRelativeToArtbitraryNode.js @@ -0,0 +1,22 @@ +import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; +import getScroll from './getScroll'; +import getClientRect from './getClientRect'; + +export default function getViewportOffsetRectRelativeToArtbitraryNode(element, excludeScroll = false) { + const html = element.ownerDocument.documentElement; + const relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html); + const width = Math.max(html.clientWidth, window.innerWidth || 0); + const height = Math.max(html.clientHeight, window.innerHeight || 0); + + const scrollTop = !excludeScroll ? getScroll(html) : 0; + const scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0; + + const offset = { + top: scrollTop - relativeOffset.top + relativeOffset.marginTop, + left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft, + width, + height, + }; + + return getClientRect(offset); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getWindow.js b/npm_assets/node_modules/popper.js/src/utils/getWindow.js new file mode 100644 index 0000000..f455522 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getWindow.js @@ -0,0 +1,9 @@ +/** + * Get the window associated with the element + * @argument {Element} element + * @returns {Window} + */ +export default function getWindow(element) { + const ownerDocument = element.ownerDocument; + return ownerDocument ? ownerDocument.defaultView : window; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/getWindowSizes.js b/npm_assets/node_modules/popper.js/src/utils/getWindowSizes.js new file mode 100644 index 0000000..1437ad4 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/getWindowSizes.js @@ -0,0 +1,27 @@ +import isIE from './isIE'; + +function getSize(axis, body, html, computedStyle) { + 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 + ); +} + +export default function getWindowSizes(document) { + const body = document.body; + const html = document.documentElement; + const computedStyle = isIE(10) && getComputedStyle(html); + + return { + height: getSize('Height', body, html, computedStyle), + width: getSize('Width', body, html, computedStyle), + }; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/includeScroll.js b/npm_assets/node_modules/popper.js/src/utils/includeScroll.js new file mode 100644 index 0000000..156561c --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/includeScroll.js @@ -0,0 +1,21 @@ +import getScroll from './getScroll'; + +/* + * 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 + */ +export default function includeScroll(rect, element, subtract = false) { + const scrollTop = getScroll(element, 'top'); + const scrollLeft = getScroll(element, 'left'); + const modifier = subtract ? -1 : 1; + rect.top += scrollTop * modifier; + rect.bottom += scrollTop * modifier; + rect.left += scrollLeft * modifier; + rect.right += scrollLeft * modifier; + return rect; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/index.js b/npm_assets/node_modules/popper.js/src/utils/index.js new file mode 100644 index 0000000..7f38680 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/index.js @@ -0,0 +1,100 @@ +import computeAutoPlacement from './computeAutoPlacement'; +import debounce from './debounce'; +import findIndex from './findIndex'; +import getBordersSize from './getBordersSize'; +import getBoundaries from './getBoundaries'; +import getBoundingClientRect from './getBoundingClientRect'; +import getClientRect from './getClientRect'; +import getOffsetParent from './getOffsetParent'; +import getOffsetRect from './getOffsetRect'; +import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; +import getOuterSizes from './getOuterSizes'; +import getParentNode from './getParentNode'; +import getPopperOffsets from './getPopperOffsets'; +import getReferenceOffsets from './getReferenceOffsets'; +import getScroll from './getScroll'; +import getScrollParent from './getScrollParent'; +import getStyleComputedProperty from './getStyleComputedProperty'; +import getSupportedPropertyName from './getSupportedPropertyName'; +import getWindowSizes from './getWindowSizes'; +import isFixed from './isFixed'; +import isFunction from './isFunction'; +import isModifierEnabled from './isModifierEnabled'; +import isModifierRequired from './isModifierRequired'; +import isNumeric from './isNumeric'; +import removeEventListeners from './removeEventListeners'; +import runModifiers from './runModifiers'; +import setAttributes from './setAttributes'; +import setStyles from './setStyles'; +import setupEventListeners from './setupEventListeners'; + +/** @namespace Popper.Utils */ +export { + computeAutoPlacement, + debounce, + findIndex, + getBordersSize, + getBoundaries, + getBoundingClientRect, + getClientRect, + getOffsetParent, + getOffsetRect, + getOffsetRectRelativeToArbitraryNode, + getOuterSizes, + getParentNode, + getPopperOffsets, + getReferenceOffsets, + getScroll, + getScrollParent, + getStyleComputedProperty, + getSupportedPropertyName, + getWindowSizes, + isFixed, + isFunction, + isModifierEnabled, + isModifierRequired, + isNumeric, + removeEventListeners, + runModifiers, + setAttributes, + setStyles, + setupEventListeners, +}; + +// 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. +export default { + computeAutoPlacement, + debounce, + findIndex, + getBordersSize, + getBoundaries, + getBoundingClientRect, + getClientRect, + getOffsetParent, + getOffsetRect, + getOffsetRectRelativeToArbitraryNode, + getOuterSizes, + getParentNode, + getPopperOffsets, + getReferenceOffsets, + getScroll, + getScrollParent, + getStyleComputedProperty, + getSupportedPropertyName, + getWindowSizes, + isFixed, + isFunction, + isModifierEnabled, + isModifierRequired, + isNumeric, + removeEventListeners, + runModifiers, + setAttributes, + setStyles, + setupEventListeners, +}; diff --git a/npm_assets/node_modules/popper.js/src/utils/isBrowser.js b/npm_assets/node_modules/popper.js/src/utils/isBrowser.js new file mode 100644 index 0000000..173d09f --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isBrowser.js @@ -0,0 +1 @@ +export default typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined'; diff --git a/npm_assets/node_modules/popper.js/src/utils/isFixed.js b/npm_assets/node_modules/popper.js/src/utils/isFixed.js new file mode 100644 index 0000000..b4ad5af --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isFixed.js @@ -0,0 +1,25 @@ +import getStyleComputedProperty from './getStyleComputedProperty'; +import getParentNode from './getParentNode'; + +/** + * 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?" + */ +export default function isFixed(element) { + const nodeName = element.nodeName; + if (nodeName === 'BODY' || nodeName === 'HTML') { + return false; + } + if (getStyleComputedProperty(element, 'position') === 'fixed') { + return true; + } + const parentNode = getParentNode(element); + if (!parentNode) { + return false; + } + return isFixed(parentNode); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isFunction.js b/npm_assets/node_modules/popper.js/src/utils/isFunction.js new file mode 100644 index 0000000..007a127 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isFunction.js @@ -0,0 +1,14 @@ +/** + * 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? + */ +export default function isFunction(functionToCheck) { + const getType = {}; + return ( + functionToCheck && + getType.toString.call(functionToCheck) === '[object Function]' + ); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isIE.js b/npm_assets/node_modules/popper.js/src/utils/isIE.js new file mode 100644 index 0000000..6e69d90 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isIE.js @@ -0,0 +1,21 @@ +import isBrowser from './isBrowser'; + +const isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode); +const 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 + */ +export default function isIE(version) { + if (version === 11) { + return isIE11; + } + if (version === 10) { + return isIE10; + } + return isIE11 || isIE10; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isModifierEnabled.js b/npm_assets/node_modules/popper.js/src/utils/isModifierEnabled.js new file mode 100644 index 0000000..f48bb2d --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isModifierEnabled.js @@ -0,0 +1,11 @@ +/** + * Helper used to know if the given modifier is enabled. + * @method + * @memberof Popper.Utils + * @returns {Boolean} + */ +export default function isModifierEnabled(modifiers, modifierName) { + return modifiers.some( + ({ name, enabled }) => enabled && name === modifierName + ); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isModifierRequired.js b/npm_assets/node_modules/popper.js/src/utils/isModifierRequired.js new file mode 100644 index 0000000..31f47e6 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isModifierRequired.js @@ -0,0 +1,38 @@ +import find from './find'; + +/** + * 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} + */ +export default function isModifierRequired( + modifiers, + requestingName, + requestedName +) { + const requesting = find(modifiers, ({ name }) => name === requestingName); + + const isRequired = + !!requesting && + modifiers.some(modifier => { + return ( + modifier.name === requestedName && + modifier.enabled && + modifier.order < requesting.order + ); + }); + + if (!isRequired) { + const requesting = `\`${requestingName}\``; + const requested = `\`${requestedName}\``; + console.warn( + `${requested} modifier is required by ${requesting} modifier in order to work, be sure to include it before ${requesting}!` + ); + } + return isRequired; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isNumeric.js b/npm_assets/node_modules/popper.js/src/utils/isNumeric.js new file mode 100644 index 0000000..8c7c751 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isNumeric.js @@ -0,0 +1,10 @@ +/** + * Tells if a given input is a number + * @method + * @memberof Popper.Utils + * @param {*} input to check + * @return {Boolean} + */ +export default function isNumeric(n) { + return n !== '' && !isNaN(parseFloat(n)) && isFinite(n); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/isOffsetContainer.js b/npm_assets/node_modules/popper.js/src/utils/isOffsetContainer.js new file mode 100644 index 0000000..ff0532c --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/isOffsetContainer.js @@ -0,0 +1,11 @@ +import getOffsetParent from './getOffsetParent'; + +export default function isOffsetContainer(element) { + const { nodeName } = element; + if (nodeName === 'BODY') { + return false; + } + return ( + nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element + ); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/removeEventListeners.js b/npm_assets/node_modules/popper.js/src/utils/removeEventListeners.js new file mode 100644 index 0000000..f8fb42d --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/removeEventListeners.js @@ -0,0 +1,24 @@ +import getWindow from './getWindow'; + +/** + * Remove event listeners used to update the popper position + * @method + * @memberof Popper.Utils + * @private + */ +export default 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(target => { + target.removeEventListener('scroll', state.updateBound); + }); + + // Reset state + state.updateBound = null; + state.scrollParents = []; + state.scrollElement = null; + state.eventsEnabled = false; + return state; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/runModifiers.js b/npm_assets/node_modules/popper.js/src/utils/runModifiers.js new file mode 100644 index 0000000..f7bdccc --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/runModifiers.js @@ -0,0 +1,37 @@ +import isFunction from './isFunction'; +import findIndex from './findIndex'; +import getClientRect from '../utils/getClientRect'; + +/** + * 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} + */ +export default function runModifiers(modifiers, data, ends) { + const modifiersToRun = ends === undefined + ? modifiers + : modifiers.slice(0, findIndex(modifiers, 'name', ends)); + + modifiersToRun.forEach(modifier => { + if (modifier['function']) { // eslint-disable-line dot-notation + console.warn('`modifier.function` is deprecated, use `modifier.fn`!'); + } + const 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; +} diff --git a/npm_assets/node_modules/popper.js/src/utils/setAttributes.js b/npm_assets/node_modules/popper.js/src/utils/setAttributes.js new file mode 100644 index 0000000..912f84e --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/setAttributes.js @@ -0,0 +1,18 @@ +/** + * 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 + */ +export default function setAttributes(element, attributes) { + Object.keys(attributes).forEach(function(prop) { + const value = attributes[prop]; + if (value !== false) { + element.setAttribute(prop, attributes[prop]); + } else { + element.removeAttribute(prop); + } + }); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/setStyles.js b/npm_assets/node_modules/popper.js/src/utils/setStyles.js new file mode 100644 index 0000000..4ae7f79 --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/setStyles.js @@ -0,0 +1,24 @@ +import isNumeric from './isNumeric'; + +/** + * 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 + */ +export default function setStyles(element, styles) { + Object.keys(styles).forEach(prop => { + let 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; + }); +} diff --git a/npm_assets/node_modules/popper.js/src/utils/setupEventListeners.js b/npm_assets/node_modules/popper.js/src/utils/setupEventListeners.js new file mode 100644 index 0000000..0b1255f --- /dev/null +++ b/npm_assets/node_modules/popper.js/src/utils/setupEventListeners.js @@ -0,0 +1,48 @@ +import getScrollParent from './getScrollParent'; +import getWindow from './getWindow'; + +function attachToScrollParents(scrollParent, event, callback, scrollParents) { + const isBody = scrollParent.nodeName === 'BODY'; + const 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 + */ +export default 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 + const scrollElement = getScrollParent(reference); + attachToScrollParents( + scrollElement, + 'scroll', + state.updateBound, + state.scrollParents + ); + state.scrollElement = scrollElement; + state.eventsEnabled = true; + + return state; +} |