2020-05-29 13:41:58 +02:00
/ * !
2021-09-17 13:04:37 +02:00
* Bootstrap v5 . 1.1 ( https : //getbootstrap.com/)
* Copyright 2011 - 2021 The Bootstrap Authors ( https : //github.com/twbs/bootstrap/graphs/contributors)
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
2020-05-29 13:41:58 +02:00
* /
( function ( global , factory ) {
2021-09-17 13:04:37 +02:00
typeof exports === 'object' && typeof module !== 'undefined' ? module . exports = factory ( ) :
typeof define === 'function' && define . amd ? define ( factory ) :
( global = typeof globalThis !== 'undefined' ? globalThis : global || self , global . bootstrap = factory ( ) ) ;
} ( this , ( function ( ) { 'use strict' ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : util / index . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const MAX _UID = 1000000 ;
const MILLISECONDS _MULTIPLIER = 1000 ;
const TRANSITION _END = 'transitionend' ; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const toType = obj => {
if ( obj === null || obj === undefined ) {
return ` ${ obj } ` ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return { } . toString . call ( obj ) . match ( /\s([a-z]+)/i ) [ 1 ] . toLowerCase ( ) ;
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Public Util Api
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getUID = prefix => {
do {
prefix += Math . floor ( Math . random ( ) * MAX _UID ) ;
} while ( document . getElementById ( prefix ) ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return prefix ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getSelector = element => {
let selector = element . getAttribute ( 'data-bs-target' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! selector || selector === '#' ) {
let hrefAttr = element . getAttribute ( 'href' ) ; // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! hrefAttr || ! hrefAttr . includes ( '#' ) && ! hrefAttr . startsWith ( '.' ) ) {
return null ;
} // Just in case some CMS puts out a full URL with the anchor appended
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( hrefAttr . includes ( '#' ) && ! hrefAttr . startsWith ( '#' ) ) {
hrefAttr = ` # ${ hrefAttr . split ( '#' ) [ 1 ] } ` ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr . trim ( ) : null ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return selector ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getSelectorFromElement = element => {
const selector = getSelector ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( selector ) {
return document . querySelector ( selector ) ? selector : null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return null ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getElementFromSelector = element => {
const selector = getSelector ( element ) ;
return selector ? document . querySelector ( selector ) : null ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getTransitionDurationFromElement = element => {
if ( ! element ) {
return 0 ;
} // Get transition-duration of the element
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
let {
transitionDuration ,
transitionDelay
} = window . getComputedStyle ( element ) ;
const floatTransitionDuration = Number . parseFloat ( transitionDuration ) ;
const floatTransitionDelay = Number . parseFloat ( transitionDelay ) ; // Return 0 if element or transition duration is not found
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! floatTransitionDuration && ! floatTransitionDelay ) {
return 0 ;
} // If multiple durations are defined, take the first
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
transitionDuration = transitionDuration . split ( ',' ) [ 0 ] ;
transitionDelay = transitionDelay . split ( ',' ) [ 0 ] ;
return ( Number . parseFloat ( transitionDuration ) + Number . parseFloat ( transitionDelay ) ) * MILLISECONDS _MULTIPLIER ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const triggerTransitionEnd = element => {
element . dispatchEvent ( new Event ( TRANSITION _END ) ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isElement$1 = obj => {
if ( ! obj || typeof obj !== 'object' ) {
return false ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof obj . jquery !== 'undefined' ) {
obj = obj [ 0 ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return typeof obj . nodeType !== 'undefined' ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getElement = obj => {
if ( isElement$1 ( obj ) ) {
// it's a jQuery object or a node element
return obj . jquery ? obj [ 0 ] : obj ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof obj === 'string' && obj . length > 0 ) {
return document . querySelector ( obj ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return null ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const typeCheckConfig = ( componentName , config , configTypes ) => {
Object . keys ( configTypes ) . forEach ( property => {
const expectedTypes = configTypes [ property ] ;
const value = config [ property ] ;
const valueType = value && isElement$1 ( value ) ? 'element' : toType ( value ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! new RegExp ( expectedTypes ) . test ( valueType ) ) {
throw new TypeError ( ` ${ componentName . toUpperCase ( ) } : Option " ${ property } " provided type " ${ valueType } " but expected type " ${ expectedTypes } ". ` ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ) ;
} ;
const isVisible = element => {
if ( ! isElement$1 ( element ) || element . getClientRects ( ) . length === 0 ) {
return false ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return getComputedStyle ( element ) . getPropertyValue ( 'visibility' ) === 'visible' ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isDisabled = element => {
if ( ! element || element . nodeType !== Node . ELEMENT _NODE ) {
return true ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( element . classList . contains ( 'disabled' ) ) {
return true ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof element . disabled !== 'undefined' ) {
return element . disabled ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return element . hasAttribute ( 'disabled' ) && element . getAttribute ( 'disabled' ) !== 'false' ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const findShadowRoot = element => {
if ( ! document . documentElement . attachShadow ) {
return null ;
} // Can find the shadow root otherwise it'll return the document
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof element . getRootNode === 'function' ) {
const root = element . getRootNode ( ) ;
return root instanceof ShadowRoot ? root : null ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( element instanceof ShadowRoot ) {
return element ;
} // when we don't find a shadow root
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! element . parentNode ) {
return null ;
}
return findShadowRoot ( element . parentNode ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const noop = ( ) => { } ;
2020-05-29 13:41:58 +02:00
/ * *
2021-09-17 13:04:37 +02:00
* Trick to restart an element ' s animation
*
* @ param { HTMLElement } element
* @ return void
*
* @ see https : //www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
const reflow = element => {
// eslint-disable-next-line no-unused-expressions
element . offsetHeight ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getjQuery = ( ) => {
const {
jQuery
} = window ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( jQuery && ! document . body . hasAttribute ( 'data-bs-no-jquery' ) ) {
return jQuery ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return null ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const DOMContentLoadedCallbacks = [ ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const onDOMContentLoaded = callback => {
if ( document . readyState === 'loading' ) {
// add listener on the first call when the document is in loading state
if ( ! DOMContentLoadedCallbacks . length ) {
document . addEventListener ( 'DOMContentLoaded' , ( ) => {
DOMContentLoadedCallbacks . forEach ( callback => callback ( ) ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
DOMContentLoadedCallbacks . push ( callback ) ;
} else {
callback ( ) ;
}
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isRTL = ( ) => document . documentElement . dir === 'rtl' ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const defineJQueryPlugin = plugin => {
onDOMContentLoaded ( ( ) => {
const $ = getjQuery ( ) ;
/* istanbul ignore if */
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( $ ) {
const name = plugin . NAME ;
const JQUERY _NO _CONFLICT = $ . fn [ name ] ;
$ . fn [ name ] = plugin . jQueryInterface ;
$ . fn [ name ] . Constructor = plugin ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
$ . fn [ name ] . noConflict = ( ) => {
$ . fn [ name ] = JQUERY _NO _CONFLICT ;
return plugin . jQueryInterface ;
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const execute = callback => {
if ( typeof callback === 'function' ) {
callback ( ) ;
}
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const executeAfterTransition = ( callback , transitionElement , waitForTransition = true ) => {
if ( ! waitForTransition ) {
execute ( callback ) ;
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const durationPadding = 5 ;
const emulatedDuration = getTransitionDurationFromElement ( transitionElement ) + durationPadding ;
let called = false ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const handler = ( {
target
} ) => {
if ( target !== transitionElement ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
called = true ;
transitionElement . removeEventListener ( TRANSITION _END , handler ) ;
execute ( callback ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
transitionElement . addEventListener ( TRANSITION _END , handler ) ;
setTimeout ( ( ) => {
if ( ! called ) {
triggerTransitionEnd ( transitionElement ) ;
}
} , emulatedDuration ) ;
} ;
/ * *
* Return the previous / next element of a list .
*
* @ param { array } list The list of elements
* @ param activeElement The active element
* @ param shouldGetNext Choose to get next or previous element
* @ param isCycleAllowed
* @ return { Element | elem } The proper element
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const getNextActiveElement = ( list , activeElement , shouldGetNext , isCycleAllowed ) => {
let index = list . indexOf ( activeElement ) ; // if the element does not exist in the list return an element depending on the direction and if cycle is allowed
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( index === - 1 ) {
return list [ ! shouldGetNext && isCycleAllowed ? list . length - 1 : 0 ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const listLength = list . length ;
index += shouldGetNext ? 1 : - 1 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isCycleAllowed ) {
index = ( index + listLength ) % listLength ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return list [ Math . max ( 0 , Math . min ( index , listLength - 1 ) ) ] ;
} ;
2020-05-29 13:41:58 +02:00
/ * *
2021-09-17 13:04:37 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : dom / event - handler . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2020-05-29 13:41:58 +02:00
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* Constants
2020-05-29 13:41:58 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const namespaceRegex = /[^.]*(?=\..*)\.|.*/ ;
const stripNameRegex = /\..*/ ;
const stripUidRegex = /::\d+$/ ;
const eventRegistry = { } ; // Events storage
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
let uidEvent = 1 ;
const customEvents = {
mouseenter : 'mouseover' ,
mouseleave : 'mouseout'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const customEventsRegex = /^(mouseenter|mouseleave)/i ;
const nativeEvents = new Set ( [ 'click' , 'dblclick' , 'mouseup' , 'mousedown' , 'contextmenu' , 'mousewheel' , 'DOMMouseScroll' , 'mouseover' , 'mouseout' , 'mousemove' , 'selectstart' , 'selectend' , 'keydown' , 'keypress' , 'keyup' , 'orientationchange' , 'touchstart' , 'touchmove' , 'touchend' , 'touchcancel' , 'pointerdown' , 'pointermove' , 'pointerup' , 'pointerleave' , 'pointercancel' , 'gesturestart' , 'gesturechange' , 'gestureend' , 'focus' , 'blur' , 'change' , 'reset' , 'select' , 'submit' , 'focusin' , 'focusout' , 'load' , 'unload' , 'beforeunload' , 'resize' , 'move' , 'DOMContentLoaded' , 'readystatechange' , 'error' , 'abort' , 'scroll' ] ) ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* Private methods
2020-05-29 13:41:58 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
function getUidEvent ( element , uid ) {
return uid && ` ${ uid } :: ${ uidEvent ++ } ` || element . uidEvent || uidEvent ++ ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getEvent ( element ) {
const uid = getUidEvent ( element ) ;
element . uidEvent = uid ;
eventRegistry [ uid ] = eventRegistry [ uid ] || { } ;
return eventRegistry [ uid ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function bootstrapHandler ( element , fn ) {
return function handler ( event ) {
event . delegateTarget = element ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( handler . oneOff ) {
EventHandler . off ( element , event . type , fn ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return fn . apply ( element , [ event ] ) ;
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function bootstrapDelegationHandler ( element , selector , fn ) {
return function handler ( event ) {
const domElements = element . querySelectorAll ( selector ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( let {
target
} = event ; target && target !== this ; target = target . parentNode ) {
for ( let i = domElements . length ; i -- ; ) {
if ( domElements [ i ] === target ) {
event . delegateTarget = target ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( handler . oneOff ) {
EventHandler . off ( element , event . type , selector , fn ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return fn . apply ( target , [ event ] ) ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
} // To please ESLint
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return null ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function findHandler ( events , handler , delegationSelector = null ) {
const uidEventList = Object . keys ( events ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( let i = 0 , len = uidEventList . length ; i < len ; i ++ ) {
const event = events [ uidEventList [ i ] ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( event . originalHandler === handler && event . delegationSelector === delegationSelector ) {
return event ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function normalizeParams ( originalTypeEvent , handler , delegationFn ) {
const delegation = typeof handler === 'string' ;
const originalHandler = delegation ? delegationFn : handler ;
let typeEvent = getTypeEvent ( originalTypeEvent ) ;
const isNative = nativeEvents . has ( typeEvent ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isNative ) {
typeEvent = originalTypeEvent ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return [ delegation , originalHandler , typeEvent ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function addHandler ( element , originalTypeEvent , handler , delegationFn , oneOff ) {
if ( typeof originalTypeEvent !== 'string' || ! element ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! handler ) {
handler = delegationFn ;
delegationFn = null ;
} // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
// this prevents the handler from being dispatched the same way as mouseover or mouseout does
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( customEventsRegex . test ( originalTypeEvent ) ) {
const wrapFn = fn => {
return function ( event ) {
if ( ! event . relatedTarget || event . relatedTarget !== event . delegateTarget && ! event . delegateTarget . contains ( event . relatedTarget ) ) {
return fn . call ( this , event ) ;
}
} ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( delegationFn ) {
delegationFn = wrapFn ( delegationFn ) ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
handler = wrapFn ( handler ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const [ delegation , originalHandler , typeEvent ] = normalizeParams ( originalTypeEvent , handler , delegationFn ) ;
const events = getEvent ( element ) ;
const handlers = events [ typeEvent ] || ( events [ typeEvent ] = { } ) ;
const previousFn = findHandler ( handlers , originalHandler , delegation ? handler : null ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( previousFn ) {
previousFn . oneOff = previousFn . oneOff && oneOff ;
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const uid = getUidEvent ( originalHandler , originalTypeEvent . replace ( namespaceRegex , '' ) ) ;
const fn = delegation ? bootstrapDelegationHandler ( element , handler , delegationFn ) : bootstrapHandler ( element , handler ) ;
fn . delegationSelector = delegation ? handler : null ;
fn . originalHandler = originalHandler ;
fn . oneOff = oneOff ;
fn . uidEvent = uid ;
handlers [ uid ] = fn ;
element . addEventListener ( typeEvent , fn , delegation ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function removeHandler ( element , events , typeEvent , handler , delegationSelector ) {
const fn = findHandler ( events [ typeEvent ] , handler , delegationSelector ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! fn ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
element . removeEventListener ( typeEvent , fn , Boolean ( delegationSelector ) ) ;
delete events [ typeEvent ] [ fn . uidEvent ] ;
}
function removeNamespacedHandlers ( element , events , typeEvent , namespace ) {
const storeElementEvent = events [ typeEvent ] || { } ;
Object . keys ( storeElementEvent ) . forEach ( handlerKey => {
if ( handlerKey . includes ( namespace ) ) {
const event = storeElementEvent [ handlerKey ] ;
removeHandler ( element , events , typeEvent , event . originalHandler , event . delegationSelector ) ;
}
} ) ;
}
function getTypeEvent ( event ) {
// allow to get the native events from namespaced events ('click.bs.button' --> 'click')
event = event . replace ( stripNameRegex , '' ) ;
return customEvents [ event ] || event ;
}
const EventHandler = {
on ( element , event , handler , delegationFn ) {
addHandler ( element , event , handler , delegationFn , false ) ;
} ,
one ( element , event , handler , delegationFn ) {
addHandler ( element , event , handler , delegationFn , true ) ;
} ,
off ( element , originalTypeEvent , handler , delegationFn ) {
if ( typeof originalTypeEvent !== 'string' || ! element ) {
return ;
}
const [ delegation , originalHandler , typeEvent ] = normalizeParams ( originalTypeEvent , handler , delegationFn ) ;
const inNamespace = typeEvent !== originalTypeEvent ;
const events = getEvent ( element ) ;
const isNamespace = originalTypeEvent . startsWith ( '.' ) ;
if ( typeof originalHandler !== 'undefined' ) {
// Simplest case: handler is passed, remove that listener ONLY.
if ( ! events || ! events [ typeEvent ] ) {
return ;
}
removeHandler ( element , events , typeEvent , originalHandler , delegation ? handler : null ) ;
return ;
}
if ( isNamespace ) {
Object . keys ( events ) . forEach ( elementEvent => {
removeNamespacedHandlers ( element , events , elementEvent , originalTypeEvent . slice ( 1 ) ) ;
} ) ;
}
const storeElementEvent = events [ typeEvent ] || { } ;
Object . keys ( storeElementEvent ) . forEach ( keyHandlers => {
const handlerKey = keyHandlers . replace ( stripUidRegex , '' ) ;
if ( ! inNamespace || originalTypeEvent . includes ( handlerKey ) ) {
const event = storeElementEvent [ keyHandlers ] ;
removeHandler ( element , events , typeEvent , event . originalHandler , event . delegationSelector ) ;
}
} ) ;
} ,
trigger ( element , event , args ) {
if ( typeof event !== 'string' || ! element ) {
return null ;
}
const $ = getjQuery ( ) ;
const typeEvent = getTypeEvent ( event ) ;
const inNamespace = event !== typeEvent ;
const isNative = nativeEvents . has ( typeEvent ) ;
let jQueryEvent ;
let bubbles = true ;
let nativeDispatch = true ;
let defaultPrevented = false ;
let evt = null ;
if ( inNamespace && $ ) {
jQueryEvent = $ . Event ( event , args ) ;
$ ( element ) . trigger ( jQueryEvent ) ;
bubbles = ! jQueryEvent . isPropagationStopped ( ) ;
nativeDispatch = ! jQueryEvent . isImmediatePropagationStopped ( ) ;
defaultPrevented = jQueryEvent . isDefaultPrevented ( ) ;
}
if ( isNative ) {
evt = document . createEvent ( 'HTMLEvents' ) ;
evt . initEvent ( typeEvent , bubbles , true ) ;
} else {
evt = new CustomEvent ( event , {
bubbles ,
cancelable : true
} ) ;
} // merge custom information in our event
if ( typeof args !== 'undefined' ) {
Object . keys ( args ) . forEach ( key => {
Object . defineProperty ( evt , key , {
get ( ) {
return args [ key ] ;
}
} ) ;
} ) ;
}
if ( defaultPrevented ) {
evt . preventDefault ( ) ;
}
if ( nativeDispatch ) {
element . dispatchEvent ( evt ) ;
}
if ( evt . defaultPrevented && typeof jQueryEvent !== 'undefined' ) {
jQueryEvent . preventDefault ( ) ;
}
return evt ;
}
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : dom / data . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const elementMap = new Map ( ) ;
var Data = {
set ( element , key , instance ) {
if ( ! elementMap . has ( element ) ) {
elementMap . set ( element , new Map ( ) ) ;
}
const instanceMap = elementMap . get ( element ) ; // make it clear we only want one instance per element
// can be removed later when multiple key/instances are fine to be used
if ( ! instanceMap . has ( key ) && instanceMap . size !== 0 ) {
// eslint-disable-next-line no-console
console . error ( ` Bootstrap doesn't allow more than one instance per element. Bound instance: ${ Array . from ( instanceMap . keys ( ) ) [ 0 ] } . ` ) ;
return ;
}
instanceMap . set ( key , instance ) ;
} ,
get ( element , key ) {
if ( elementMap . has ( element ) ) {
return elementMap . get ( element ) . get ( key ) || null ;
}
return null ;
} ,
remove ( element , key ) {
if ( ! elementMap . has ( element ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const instanceMap = elementMap . get ( element ) ;
instanceMap . delete ( key ) ; // free up element references if there are no instances left for an element
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( instanceMap . size === 0 ) {
elementMap . delete ( element ) ;
}
}
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : base - component . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const VERSION = '5.1.1' ;
class BaseComponent {
constructor ( element ) {
element = getElement ( element ) ;
if ( ! element ) {
return ;
}
this . _element = element ;
Data . set ( this . _element , this . constructor . DATA _KEY , this ) ;
}
dispose ( ) {
Data . remove ( this . _element , this . constructor . DATA _KEY ) ;
EventHandler . off ( this . _element , this . constructor . EVENT _KEY ) ;
Object . getOwnPropertyNames ( this ) . forEach ( propertyName => {
this [ propertyName ] = null ;
} ) ;
}
_queueCallback ( callback , element , isAnimated = true ) {
executeAfterTransition ( callback , element , isAnimated ) ;
}
/** Static */
static getInstance ( element ) {
return Data . get ( getElement ( element ) , this . DATA _KEY ) ;
}
static getOrCreateInstance ( element , config = { } ) {
return this . getInstance ( element ) || new this ( element , typeof config === 'object' ? config : null ) ;
}
static get VERSION ( ) {
return VERSION ;
}
static get NAME ( ) {
throw new Error ( 'You have to implement the static method "NAME", for each component!' ) ;
}
static get DATA _KEY ( ) {
return ` bs. ${ this . NAME } ` ;
}
static get EVENT _KEY ( ) {
return ` . ${ this . DATA _KEY } ` ;
}
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : util / component - functions . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const enableDismissTrigger = ( component , method = 'hide' ) => {
const clickEvent = ` click.dismiss ${ component . EVENT _KEY } ` ;
const name = component . NAME ;
EventHandler . on ( document , clickEvent , ` [data-bs-dismiss=" ${ name } "] ` , function ( event ) {
if ( [ 'A' , 'AREA' ] . includes ( this . tagName ) ) {
event . preventDefault ( ) ;
}
if ( isDisabled ( this ) ) {
return ;
}
const target = getElementFromSelector ( this ) || this . closest ( ` . ${ name } ` ) ;
const instance = component . getOrCreateInstance ( target ) ; // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
instance [ method ] ( ) ;
} ) ;
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : alert . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const NAME$d = 'alert' ;
const DATA _KEY$c = 'bs.alert' ;
const EVENT _KEY$c = ` . ${ DATA _KEY$c } ` ;
const EVENT _CLOSE = ` close ${ EVENT _KEY$c } ` ;
const EVENT _CLOSED = ` closed ${ EVENT _KEY$c } ` ;
const CLASS _NAME _FADE$5 = 'fade' ;
const CLASS _NAME _SHOW$8 = 'show' ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
class Alert extends BaseComponent {
// Getters
static get NAME ( ) {
return NAME$d ;
} // Public
close ( ) {
const closeEvent = EventHandler . trigger ( this . _element , EVENT _CLOSE ) ;
if ( closeEvent . defaultPrevented ) {
return ;
}
this . _element . classList . remove ( CLASS _NAME _SHOW$8 ) ;
const isAnimated = this . _element . classList . contains ( CLASS _NAME _FADE$5 ) ;
this . _queueCallback ( ( ) => this . _destroyElement ( ) , this . _element , isAnimated ) ;
} // Private
_destroyElement ( ) {
this . _element . remove ( ) ;
EventHandler . trigger ( this . _element , EVENT _CLOSED ) ;
this . dispose ( ) ;
} // Static
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Alert . getOrCreateInstance ( this ) ;
if ( typeof config !== 'string' ) {
return ;
}
if ( data [ config ] === undefined || config . startsWith ( '_' ) || config === 'constructor' ) {
throw new TypeError ( ` No method named " ${ config } " ` ) ;
}
data [ config ] ( this ) ;
} ) ;
}
}
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
enableDismissTrigger ( Alert , 'close' ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* add . Alert to jQuery only if jQuery is present
* /
defineJQueryPlugin ( Alert ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : button . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const NAME$c = 'button' ;
const DATA _KEY$b = 'bs.button' ;
const EVENT _KEY$b = ` . ${ DATA _KEY$b } ` ;
const DATA _API _KEY$7 = '.data-api' ;
const CLASS _NAME _ACTIVE$3 = 'active' ;
const SELECTOR _DATA _TOGGLE$5 = '[data-bs-toggle="button"]' ;
const EVENT _CLICK _DATA _API$6 = ` click ${ EVENT _KEY$b } ${ DATA _API _KEY$7 } ` ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
class Button extends BaseComponent {
// Getters
static get NAME ( ) {
return NAME$c ;
} // Public
toggle ( ) {
// Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
this . _element . setAttribute ( 'aria-pressed' , this . _element . classList . toggle ( CLASS _NAME _ACTIVE$3 ) ) ;
} // Static
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Button . getOrCreateInstance ( this ) ;
if ( config === 'toggle' ) {
data [ config ] ( ) ;
}
} ) ;
}
}
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
EventHandler . on ( document , EVENT _CLICK _DATA _API$6 , SELECTOR _DATA _TOGGLE$5 , event => {
event . preventDefault ( ) ;
const button = event . target . closest ( SELECTOR _DATA _TOGGLE$5 ) ;
const data = Button . getOrCreateInstance ( button ) ;
data . toggle ( ) ;
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* add . Button to jQuery only if jQuery is present
* /
defineJQueryPlugin ( Button ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : dom / manipulator . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
function normalizeData ( val ) {
if ( val === 'true' ) {
return true ;
}
if ( val === 'false' ) {
return false ;
}
if ( val === Number ( val ) . toString ( ) ) {
return Number ( val ) ;
}
if ( val === '' || val === 'null' ) {
return null ;
}
return val ;
}
function normalizeDataKey ( key ) {
return key . replace ( /[A-Z]/g , chr => ` - ${ chr . toLowerCase ( ) } ` ) ;
}
const Manipulator = {
setDataAttribute ( element , key , value ) {
element . setAttribute ( ` data-bs- ${ normalizeDataKey ( key ) } ` , value ) ;
} ,
removeDataAttribute ( element , key ) {
element . removeAttribute ( ` data-bs- ${ normalizeDataKey ( key ) } ` ) ;
} ,
getDataAttributes ( element ) {
if ( ! element ) {
return { } ;
}
const attributes = { } ;
Object . keys ( element . dataset ) . filter ( key => key . startsWith ( 'bs' ) ) . forEach ( key => {
let pureKey = key . replace ( /^bs/ , '' ) ;
pureKey = pureKey . charAt ( 0 ) . toLowerCase ( ) + pureKey . slice ( 1 , pureKey . length ) ;
attributes [ pureKey ] = normalizeData ( element . dataset [ key ] ) ;
} ) ;
return attributes ;
} ,
getDataAttribute ( element , key ) {
return normalizeData ( element . getAttribute ( ` data-bs- ${ normalizeDataKey ( key ) } ` ) ) ;
} ,
offset ( element ) {
const rect = element . getBoundingClientRect ( ) ;
return {
top : rect . top + window . pageYOffset ,
left : rect . left + window . pageXOffset
} ;
} ,
position ( element ) {
return {
top : element . offsetTop ,
left : element . offsetLeft
} ;
}
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : dom / selector - engine . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const NODE _TEXT = 3 ;
const SelectorEngine = {
find ( selector , element = document . documentElement ) {
return [ ] . concat ( ... Element . prototype . querySelectorAll . call ( element , selector ) ) ;
} ,
findOne ( selector , element = document . documentElement ) {
return Element . prototype . querySelector . call ( element , selector ) ;
} ,
children ( element , selector ) {
return [ ] . concat ( ... element . children ) . filter ( child => child . matches ( selector ) ) ;
} ,
parents ( element , selector ) {
const parents = [ ] ;
let ancestor = element . parentNode ;
while ( ancestor && ancestor . nodeType === Node . ELEMENT _NODE && ancestor . nodeType !== NODE _TEXT ) {
if ( ancestor . matches ( selector ) ) {
parents . push ( ancestor ) ;
}
ancestor = ancestor . parentNode ;
}
return parents ;
} ,
prev ( element , selector ) {
let previous = element . previousElementSibling ;
while ( previous ) {
if ( previous . matches ( selector ) ) {
return [ previous ] ;
}
previous = previous . previousElementSibling ;
}
return [ ] ;
} ,
next ( element , selector ) {
let next = element . nextElementSibling ;
while ( next ) {
if ( next . matches ( selector ) ) {
return [ next ] ;
}
next = next . nextElementSibling ;
}
return [ ] ;
} ,
focusableChildren ( element ) {
const focusables = [ 'a' , 'button' , 'input' , 'textarea' , 'select' , 'details' , '[tabindex]' , '[contenteditable="true"]' ] . map ( selector => ` ${ selector } :not([tabindex^="-"]) ` ) . join ( ', ' ) ;
return this . find ( focusables , element ) . filter ( el => ! isDisabled ( el ) && isVisible ( el ) ) ;
}
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : carousel . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const NAME$b = 'carousel' ;
const DATA _KEY$a = 'bs.carousel' ;
const EVENT _KEY$a = ` . ${ DATA _KEY$a } ` ;
const DATA _API _KEY$6 = '.data-api' ;
const ARROW _LEFT _KEY = 'ArrowLeft' ;
const ARROW _RIGHT _KEY = 'ArrowRight' ;
const TOUCHEVENT _COMPAT _WAIT = 500 ; // Time for mouse compat events to fire after touch
const SWIPE _THRESHOLD = 40 ;
const Default$a = {
2020-05-29 13:41:58 +02:00
interval : 5000 ,
keyboard : true ,
slide : false ,
pause : 'hover' ,
wrap : true ,
touch : true
} ;
2021-09-17 13:04:37 +02:00
const DefaultType$a = {
2020-05-29 13:41:58 +02:00
interval : '(number|boolean)' ,
keyboard : 'boolean' ,
slide : '(boolean|string)' ,
pause : '(string|boolean)' ,
wrap : 'boolean' ,
touch : 'boolean'
} ;
2021-09-17 13:04:37 +02:00
const ORDER _NEXT = 'next' ;
const ORDER _PREV = 'prev' ;
const DIRECTION _LEFT = 'left' ;
const DIRECTION _RIGHT = 'right' ;
const KEY _TO _DIRECTION = {
[ ARROW _LEFT _KEY ] : DIRECTION _RIGHT ,
[ ARROW _RIGHT _KEY ] : DIRECTION _LEFT
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const EVENT _SLIDE = ` slide ${ EVENT _KEY$a } ` ;
const EVENT _SLID = ` slid ${ EVENT _KEY$a } ` ;
const EVENT _KEYDOWN = ` keydown ${ EVENT _KEY$a } ` ;
const EVENT _MOUSEENTER = ` mouseenter ${ EVENT _KEY$a } ` ;
const EVENT _MOUSELEAVE = ` mouseleave ${ EVENT _KEY$a } ` ;
const EVENT _TOUCHSTART = ` touchstart ${ EVENT _KEY$a } ` ;
const EVENT _TOUCHMOVE = ` touchmove ${ EVENT _KEY$a } ` ;
const EVENT _TOUCHEND = ` touchend ${ EVENT _KEY$a } ` ;
const EVENT _POINTERDOWN = ` pointerdown ${ EVENT _KEY$a } ` ;
const EVENT _POINTERUP = ` pointerup ${ EVENT _KEY$a } ` ;
const EVENT _DRAG _START = ` dragstart ${ EVENT _KEY$a } ` ;
const EVENT _LOAD _DATA _API$2 = ` load ${ EVENT _KEY$a } ${ DATA _API _KEY$6 } ` ;
const EVENT _CLICK _DATA _API$5 = ` click ${ EVENT _KEY$a } ${ DATA _API _KEY$6 } ` ;
const CLASS _NAME _CAROUSEL = 'carousel' ;
const CLASS _NAME _ACTIVE$2 = 'active' ;
const CLASS _NAME _SLIDE = 'slide' ;
const CLASS _NAME _END = 'carousel-item-end' ;
const CLASS _NAME _START = 'carousel-item-start' ;
const CLASS _NAME _NEXT = 'carousel-item-next' ;
const CLASS _NAME _PREV = 'carousel-item-prev' ;
const CLASS _NAME _POINTER _EVENT = 'pointer-event' ;
const SELECTOR _ACTIVE$1 = '.active' ;
const SELECTOR _ACTIVE _ITEM = '.active.carousel-item' ;
const SELECTOR _ITEM = '.carousel-item' ;
const SELECTOR _ITEM _IMG = '.carousel-item img' ;
const SELECTOR _NEXT _PREV = '.carousel-item-next, .carousel-item-prev' ;
const SELECTOR _INDICATORS = '.carousel-indicators' ;
const SELECTOR _INDICATOR = '[data-bs-target]' ;
const SELECTOR _DATA _SLIDE = '[data-bs-slide], [data-bs-slide-to]' ;
const SELECTOR _DATA _RIDE = '[data-bs-ride="carousel"]' ;
const POINTER _TYPE _TOUCH = 'touch' ;
const POINTER _TYPE _PEN = 'pen' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Carousel extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
2020-05-29 13:41:58 +02:00
this . _items = null ;
this . _interval = null ;
this . _activeElement = null ;
this . _isPaused = false ;
this . _isSliding = false ;
this . touchTimeout = null ;
this . touchStartX = 0 ;
this . touchDeltaX = 0 ;
this . _config = this . _getConfig ( config ) ;
2021-09-17 13:04:37 +02:00
this . _indicatorsElement = SelectorEngine . findOne ( SELECTOR _INDICATORS , this . _element ) ;
2020-05-29 13:41:58 +02:00
this . _touchSupported = 'ontouchstart' in document . documentElement || navigator . maxTouchPoints > 0 ;
2021-09-17 13:04:37 +02:00
this . _pointerEvent = Boolean ( window . PointerEvent ) ;
2020-05-29 13:41:58 +02:00
this . _addEventListeners ( ) ;
} // Getters
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$a ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get NAME ( ) {
return NAME$b ;
} // Public
next ( ) {
this . _slide ( ORDER _NEXT ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
nextWhenVisible ( ) {
2020-05-29 13:41:58 +02:00
// Don't call next when the page isn't visible
// or the carousel or its parent isn't visible
2021-09-17 13:04:37 +02:00
if ( ! document . hidden && isVisible ( this . _element ) ) {
2020-05-29 13:41:58 +02:00
this . next ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
prev ( ) {
this . _slide ( ORDER _PREV ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
pause ( event ) {
2020-05-29 13:41:58 +02:00
if ( ! event ) {
this . _isPaused = true ;
}
2021-09-17 13:04:37 +02:00
if ( SelectorEngine . findOne ( SELECTOR _NEXT _PREV , this . _element ) ) {
triggerTransitionEnd ( this . _element ) ;
2020-05-29 13:41:58 +02:00
this . cycle ( true ) ;
}
clearInterval ( this . _interval ) ;
this . _interval = null ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
cycle ( event ) {
2020-05-29 13:41:58 +02:00
if ( ! event ) {
this . _isPaused = false ;
}
if ( this . _interval ) {
clearInterval ( this . _interval ) ;
this . _interval = null ;
}
2021-09-17 13:04:37 +02:00
if ( this . _config && this . _config . interval && ! this . _isPaused ) {
this . _updateInterval ( ) ;
2020-05-29 13:41:58 +02:00
this . _interval = setInterval ( ( document . visibilityState ? this . nextWhenVisible : this . next ) . bind ( this ) , this . _config . interval ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
to ( index ) {
this . _activeElement = SelectorEngine . findOne ( SELECTOR _ACTIVE _ITEM , this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const activeIndex = this . _getItemIndex ( this . _activeElement ) ;
2020-05-29 13:41:58 +02:00
if ( index > this . _items . length - 1 || index < 0 ) {
return ;
}
if ( this . _isSliding ) {
2021-09-17 13:04:37 +02:00
EventHandler . one ( this . _element , EVENT _SLID , ( ) => this . to ( index ) ) ;
2020-05-29 13:41:58 +02:00
return ;
}
if ( activeIndex === index ) {
this . pause ( ) ;
this . cycle ( ) ;
return ;
}
2021-09-17 13:04:37 +02:00
const order = index > activeIndex ? ORDER _NEXT : ORDER _PREV ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _slide ( order , this . _items [ index ] ) ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default$a ,
... Manipulator . getDataAttributes ( this . _element ) ,
... ( typeof config === 'object' ? config : { } )
} ;
typeCheckConfig ( NAME$b , config , DefaultType$a ) ;
2020-05-29 13:41:58 +02:00
return config ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_handleSwipe ( ) {
const absDeltax = Math . abs ( this . touchDeltaX ) ;
2020-05-29 13:41:58 +02:00
if ( absDeltax <= SWIPE _THRESHOLD ) {
return ;
}
2021-09-17 13:04:37 +02:00
const direction = absDeltax / this . touchDeltaX ;
this . touchDeltaX = 0 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! direction ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _slide ( direction > 0 ? DIRECTION _RIGHT : DIRECTION _LEFT ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_addEventListeners ( ) {
2020-05-29 13:41:58 +02:00
if ( this . _config . keyboard ) {
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element , EVENT _KEYDOWN , event => this . _keydown ( event ) ) ;
2020-05-29 13:41:58 +02:00
}
if ( this . _config . pause === 'hover' ) {
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element , EVENT _MOUSEENTER , event => this . pause ( event ) ) ;
EventHandler . on ( this . _element , EVENT _MOUSELEAVE , event => this . cycle ( event ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( this . _config . touch && this . _touchSupported ) {
2020-05-29 13:41:58 +02:00
this . _addTouchEventListeners ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_addTouchEventListeners ( ) {
const hasPointerPenTouch = event => {
return this . _pointerEvent && ( event . pointerType === POINTER _TYPE _PEN || event . pointerType === POINTER _TYPE _TOUCH ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const start = event => {
if ( hasPointerPenTouch ( event ) ) {
this . touchStartX = event . clientX ;
} else if ( ! this . _pointerEvent ) {
this . touchStartX = event . touches [ 0 ] . clientX ;
2020-05-29 13:41:58 +02:00
}
} ;
2021-09-17 13:04:37 +02:00
const move = event => {
2020-05-29 13:41:58 +02:00
// ensure swiping with one touch and not pinching
2021-09-17 13:04:37 +02:00
this . touchDeltaX = event . touches && event . touches . length > 1 ? 0 : event . touches [ 0 ] . clientX - this . touchStartX ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const end = event => {
if ( hasPointerPenTouch ( event ) ) {
this . touchDeltaX = event . clientX - this . touchStartX ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _handleSwipe ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _config . pause === 'hover' ) {
2020-05-29 13:41:58 +02:00
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// would stop cycling until user tapped out of it;
// here, we listen for touchend, explicitly pause the carousel
// (as if it's the second time we tap on it, mouseenter compat event
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
2021-09-17 13:04:37 +02:00
this . pause ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . touchTimeout ) {
clearTimeout ( this . touchTimeout ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . touchTimeout = setTimeout ( event => this . cycle ( event ) , TOUCHEVENT _COMPAT _WAIT + this . _config . interval ) ;
2020-05-29 13:41:58 +02:00
}
} ;
2021-09-17 13:04:37 +02:00
SelectorEngine . find ( SELECTOR _ITEM _IMG , this . _element ) . forEach ( itemImg => {
EventHandler . on ( itemImg , EVENT _DRAG _START , e => e . preventDefault ( ) ) ;
2020-05-29 13:41:58 +02:00
} ) ;
if ( this . _pointerEvent ) {
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element , EVENT _POINTERDOWN , event => start ( event ) ) ;
EventHandler . on ( this . _element , EVENT _POINTERUP , event => end ( event ) ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _POINTER _EVENT ) ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element , EVENT _TOUCHSTART , event => start ( event ) ) ;
EventHandler . on ( this . _element , EVENT _TOUCHMOVE , event => move ( event ) ) ;
EventHandler . on ( this . _element , EVENT _TOUCHEND , event => end ( event ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_keydown ( event ) {
2020-05-29 13:41:58 +02:00
if ( /input|textarea/i . test ( event . target . tagName ) ) {
return ;
}
2021-09-17 13:04:37 +02:00
const direction = KEY _TO _DIRECTION [ event . key ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( direction ) {
event . preventDefault ( ) ;
this . _slide ( direction ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getItemIndex ( element ) {
this . _items = element && element . parentNode ? SelectorEngine . find ( SELECTOR _ITEM , element . parentNode ) : [ ] ;
2020-05-29 13:41:58 +02:00
return this . _items . indexOf ( element ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getItemByOrder ( order , activeElement ) {
const isNext = order === ORDER _NEXT ;
return getNextActiveElement ( this . _items , activeElement , isNext , this . _config . wrap ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_triggerSlideEvent ( relatedTarget , eventDirectionName ) {
const targetIndex = this . _getItemIndex ( relatedTarget ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const fromIndex = this . _getItemIndex ( SelectorEngine . findOne ( SELECTOR _ACTIVE _ITEM , this . _element ) ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return EventHandler . trigger ( this . _element , EVENT _SLIDE , {
relatedTarget ,
2020-05-29 13:41:58 +02:00
direction : eventDirectionName ,
from : fromIndex ,
to : targetIndex
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_setActiveIndicatorElement ( element ) {
2020-05-29 13:41:58 +02:00
if ( this . _indicatorsElement ) {
2021-09-17 13:04:37 +02:00
const activeIndicator = SelectorEngine . findOne ( SELECTOR _ACTIVE$1 , this . _indicatorsElement ) ;
activeIndicator . classList . remove ( CLASS _NAME _ACTIVE$2 ) ;
activeIndicator . removeAttribute ( 'aria-current' ) ;
const indicators = SelectorEngine . find ( SELECTOR _INDICATOR , this . _indicatorsElement ) ;
for ( let i = 0 ; i < indicators . length ; i ++ ) {
if ( Number . parseInt ( indicators [ i ] . getAttribute ( 'data-bs-slide-to' ) , 10 ) === this . _getItemIndex ( element ) ) {
indicators [ i ] . classList . add ( CLASS _NAME _ACTIVE$2 ) ;
indicators [ i ] . setAttribute ( 'aria-current' , 'true' ) ;
break ;
}
}
}
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_updateInterval ( ) {
const element = this . _activeElement || SelectorEngine . findOne ( SELECTOR _ACTIVE _ITEM , this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! element ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const elementInterval = Number . parseInt ( element . getAttribute ( 'data-bs-interval' ) , 10 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( elementInterval ) {
this . _config . defaultInterval = this . _config . defaultInterval || this . _config . interval ;
this . _config . interval = elementInterval ;
} else {
this . _config . interval = this . _config . defaultInterval || this . _config . interval ;
}
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_slide ( directionOrOrder , element ) {
const order = this . _directionToOrder ( directionOrOrder ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const activeElement = SelectorEngine . findOne ( SELECTOR _ACTIVE _ITEM , this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const activeElementIndex = this . _getItemIndex ( activeElement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const nextElement = element || this . _getItemByOrder ( order , activeElement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const nextElementIndex = this . _getItemIndex ( nextElement ) ;
const isCycling = Boolean ( this . _interval ) ;
const isNext = order === ORDER _NEXT ;
const directionalClassName = isNext ? CLASS _NAME _START : CLASS _NAME _END ;
const orderClassName = isNext ? CLASS _NAME _NEXT : CLASS _NAME _PREV ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const eventDirectionName = this . _orderToDirection ( order ) ;
if ( nextElement && nextElement . classList . contains ( CLASS _NAME _ACTIVE$2 ) ) {
2020-05-29 13:41:58 +02:00
this . _isSliding = false ;
return ;
}
2021-09-17 13:04:37 +02:00
if ( this . _isSliding ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const slideEvent = this . _triggerSlideEvent ( nextElement , eventDirectionName ) ;
if ( slideEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
if ( ! activeElement || ! nextElement ) {
// Some weirdness is happening, so we bail
return ;
}
this . _isSliding = true ;
if ( isCycling ) {
this . pause ( ) ;
}
this . _setActiveIndicatorElement ( nextElement ) ;
2021-09-17 13:04:37 +02:00
this . _activeElement = nextElement ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const triggerSlidEvent = ( ) => {
EventHandler . trigger ( this . _element , EVENT _SLID , {
relatedTarget : nextElement ,
direction : eventDirectionName ,
from : activeElementIndex ,
to : nextElementIndex
} ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _element . classList . contains ( CLASS _NAME _SLIDE ) ) {
nextElement . classList . add ( orderClassName ) ;
reflow ( nextElement ) ;
activeElement . classList . add ( directionalClassName ) ;
nextElement . classList . add ( directionalClassName ) ;
const completeCallBack = ( ) => {
nextElement . classList . remove ( directionalClassName , orderClassName ) ;
nextElement . classList . add ( CLASS _NAME _ACTIVE$2 ) ;
activeElement . classList . remove ( CLASS _NAME _ACTIVE$2 , orderClassName , directionalClassName ) ;
this . _isSliding = false ;
setTimeout ( triggerSlidEvent , 0 ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( completeCallBack , activeElement , true ) ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
activeElement . classList . remove ( CLASS _NAME _ACTIVE$2 ) ;
nextElement . classList . add ( CLASS _NAME _ACTIVE$2 ) ;
2020-05-29 13:41:58 +02:00
this . _isSliding = false ;
2021-09-17 13:04:37 +02:00
triggerSlidEvent ( ) ;
2020-05-29 13:41:58 +02:00
}
if ( isCycling ) {
this . cycle ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_directionToOrder ( direction ) {
if ( ! [ DIRECTION _RIGHT , DIRECTION _LEFT ] . includes ( direction ) ) {
return direction ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isRTL ( ) ) {
return direction === DIRECTION _LEFT ? ORDER _PREV : ORDER _NEXT ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return direction === DIRECTION _LEFT ? ORDER _NEXT : ORDER _PREV ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_orderToDirection ( order ) {
if ( ! [ ORDER _NEXT , ORDER _PREV ] . includes ( order ) ) {
return order ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isRTL ( ) ) {
return order === ORDER _PREV ? DIRECTION _LEFT : DIRECTION _RIGHT ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return order === ORDER _PREV ? DIRECTION _RIGHT : DIRECTION _LEFT ;
} // Static
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static carouselInterface ( element , config ) {
const data = Carousel . getOrCreateInstance ( element , config ) ;
let {
_config
} = data ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config === 'object' ) {
_config = { ... _config ,
... config
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const action = typeof config === 'string' ? config : _config . slide ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config === 'number' ) {
data . to ( config ) ;
} else if ( typeof action === 'string' ) {
if ( typeof data [ action ] === 'undefined' ) {
throw new TypeError ( ` No method named " ${ action } " ` ) ;
}
data [ action ] ( ) ;
} else if ( _config . interval && _config . ride ) {
data . pause ( ) ;
data . cycle ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
static jQueryInterface ( config ) {
return this . each ( function ( ) {
Carousel . carouselInterface ( this , config ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static dataApiClickHandler ( event ) {
const target = getElementFromSelector ( this ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! target || ! target . classList . contains ( CLASS _NAME _CAROUSEL ) ) {
return ;
}
const config = { ... Manipulator . getDataAttributes ( target ) ,
... Manipulator . getDataAttributes ( this )
} ;
const slideIndex = this . getAttribute ( 'data-bs-slide-to' ) ;
2020-05-29 13:41:58 +02:00
if ( slideIndex ) {
config . interval = false ;
}
2021-09-17 13:04:37 +02:00
Carousel . carouselInterface ( target , config ) ;
2020-05-29 13:41:58 +02:00
if ( slideIndex ) {
2021-09-17 13:04:37 +02:00
Carousel . getInstance ( target ) . to ( slideIndex ) ;
2020-05-29 13:41:58 +02:00
}
event . preventDefault ( ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _CLICK _DATA _API$5 , SELECTOR _DATA _SLIDE , Carousel . dataApiClickHandler ) ;
EventHandler . on ( window , EVENT _LOAD _DATA _API$2 , ( ) => {
const carousels = SelectorEngine . find ( SELECTOR _DATA _RIDE ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( let i = 0 , len = carousels . length ; i < len ; i ++ ) {
Carousel . carouselInterface ( carousels [ i ] , Carousel . getInstance ( carousels [ i ] ) ) ;
2020-05-29 13:41:58 +02:00
}
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Carousel to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Carousel ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : collapse . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$a = 'collapse' ;
const DATA _KEY$9 = 'bs.collapse' ;
const EVENT _KEY$9 = ` . ${ DATA _KEY$9 } ` ;
const DATA _API _KEY$5 = '.data-api' ;
const Default$9 = {
2020-05-29 13:41:58 +02:00
toggle : true ,
2021-09-17 13:04:37 +02:00
parent : null
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const DefaultType$9 = {
2020-05-29 13:41:58 +02:00
toggle : 'boolean' ,
2021-09-17 13:04:37 +02:00
parent : '(null|element)'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const EVENT _SHOW$5 = ` show ${ EVENT _KEY$9 } ` ;
const EVENT _SHOWN$5 = ` shown ${ EVENT _KEY$9 } ` ;
const EVENT _HIDE$5 = ` hide ${ EVENT _KEY$9 } ` ;
const EVENT _HIDDEN$5 = ` hidden ${ EVENT _KEY$9 } ` ;
const EVENT _CLICK _DATA _API$4 = ` click ${ EVENT _KEY$9 } ${ DATA _API _KEY$5 } ` ;
const CLASS _NAME _SHOW$7 = 'show' ;
const CLASS _NAME _COLLAPSE = 'collapse' ;
const CLASS _NAME _COLLAPSING = 'collapsing' ;
const CLASS _NAME _COLLAPSED = 'collapsed' ;
const CLASS _NAME _HORIZONTAL = 'collapse-horizontal' ;
const WIDTH = 'width' ;
const HEIGHT = 'height' ;
const SELECTOR _ACTIVES = '.collapse.show, .collapse.collapsing' ;
const SELECTOR _DATA _TOGGLE$4 = '[data-bs-toggle="collapse"]' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Collapse extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
2020-05-29 13:41:58 +02:00
this . _isTransitioning = false ;
this . _config = this . _getConfig ( config ) ;
2021-09-17 13:04:37 +02:00
this . _triggerArray = [ ] ;
const toggleList = SelectorEngine . find ( SELECTOR _DATA _TOGGLE$4 ) ;
for ( let i = 0 , len = toggleList . length ; i < len ; i ++ ) {
const elem = toggleList [ i ] ;
const selector = getSelectorFromElement ( elem ) ;
const filterElement = SelectorEngine . find ( selector ) . filter ( foundElem => foundElem === this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( selector !== null && filterElement . length ) {
2020-05-29 13:41:58 +02:00
this . _selector = selector ;
this . _triggerArray . push ( elem ) ;
}
}
2021-09-17 13:04:37 +02:00
this . _initializeChildren ( ) ;
2020-05-29 13:41:58 +02:00
if ( ! this . _config . parent ) {
2021-09-17 13:04:37 +02:00
this . _addAriaAndCollapsedClass ( this . _triggerArray , this . _isShown ( ) ) ;
2020-05-29 13:41:58 +02:00
}
if ( this . _config . toggle ) {
this . toggle ( ) ;
}
} // Getters
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$9 ;
}
static get NAME ( ) {
return NAME$a ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
toggle ( ) {
if ( this . _isShown ( ) ) {
2020-05-29 13:41:58 +02:00
this . hide ( ) ;
} else {
this . show ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
show ( ) {
if ( this . _isTransitioning || this . _isShown ( ) ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
let actives = [ ] ;
let activesData ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _config . parent ) {
const children = SelectorEngine . find ( ` . ${ CLASS _NAME _COLLAPSE } . ${ CLASS _NAME _COLLAPSE } ` , this . _config . parent ) ;
actives = SelectorEngine . find ( SELECTOR _ACTIVES , this . _config . parent ) . filter ( elem => ! children . includes ( elem ) ) ; // remove children if greater depth
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const container = SelectorEngine . findOne ( this . _selector ) ;
if ( actives . length ) {
const tempActiveData = actives . find ( elem => container !== elem ) ;
activesData = tempActiveData ? Collapse . getInstance ( tempActiveData ) : null ;
2020-05-29 13:41:58 +02:00
if ( activesData && activesData . _isTransitioning ) {
return ;
}
}
2021-09-17 13:04:37 +02:00
const startEvent = EventHandler . trigger ( this . _element , EVENT _SHOW$5 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( startEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
actives . forEach ( elemActive => {
if ( container !== elemActive ) {
Collapse . getOrCreateInstance ( elemActive , {
toggle : false
} ) . hide ( ) ;
}
2020-05-29 13:41:58 +02:00
if ( ! activesData ) {
2021-09-17 13:04:37 +02:00
Data . set ( elemActive , DATA _KEY$9 , null ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ) ;
const dimension = this . _getDimension ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _COLLAPSE ) ;
this . _element . classList . add ( CLASS _NAME _COLLAPSING ) ;
2020-05-29 13:41:58 +02:00
this . _element . style [ dimension ] = 0 ;
2021-09-17 13:04:37 +02:00
this . _addAriaAndCollapsedClass ( this . _triggerArray , true ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _isTransitioning = true ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
this . _isTransitioning = false ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _COLLAPSING ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _COLLAPSE , CLASS _NAME _SHOW$7 ) ;
this . _element . style [ dimension ] = '' ;
EventHandler . trigger ( this . _element , EVENT _SHOWN$5 ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const capitalizedDimension = dimension [ 0 ] . toUpperCase ( ) + dimension . slice ( 1 ) ;
const scrollSize = ` scroll ${ capitalizedDimension } ` ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( complete , this . _element , true ) ;
this . _element . style [ dimension ] = ` ${ this . _element [ scrollSize ] } px ` ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
if ( this . _isTransitioning || ! this . _isShown ( ) ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
const startEvent = EventHandler . trigger ( this . _element , EVENT _HIDE$5 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( startEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
const dimension = this . _getDimension ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . style [ dimension ] = ` ${ this . _element . getBoundingClientRect ( ) [ dimension ] } px ` ;
reflow ( this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _COLLAPSING ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _COLLAPSE , CLASS _NAME _SHOW$7 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const triggerArrayLength = this . _triggerArray . length ;
for ( let i = 0 ; i < triggerArrayLength ; i ++ ) {
const trigger = this . _triggerArray [ i ] ;
const elem = getElementFromSelector ( trigger ) ;
if ( elem && ! this . _isShown ( elem ) ) {
this . _addAriaAndCollapsedClass ( [ trigger ] , false ) ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
this . _isTransitioning = true ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
this . _isTransitioning = false ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _COLLAPSING ) ;
this . _element . classList . add ( CLASS _NAME _COLLAPSE ) ;
EventHandler . trigger ( this . _element , EVENT _HIDDEN$5 ) ;
2020-05-29 13:41:58 +02:00
} ;
this . _element . style [ dimension ] = '' ;
2021-09-17 13:04:37 +02:00
this . _queueCallback ( complete , this . _element , true ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_isShown ( element = this . _element ) {
return element . classList . contains ( CLASS _NAME _SHOW$7 ) ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default$9 ,
... Manipulator . getDataAttributes ( this . _element ) ,
... config
} ;
2020-05-29 13:41:58 +02:00
config . toggle = Boolean ( config . toggle ) ; // Coerce string values
2021-09-17 13:04:37 +02:00
config . parent = getElement ( config . parent ) ;
typeCheckConfig ( NAME$a , config , DefaultType$9 ) ;
2020-05-29 13:41:58 +02:00
return config ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getDimension ( ) {
return this . _element . classList . contains ( CLASS _NAME _HORIZONTAL ) ? WIDTH : HEIGHT ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_initializeChildren ( ) {
if ( ! this . _config . parent ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const children = SelectorEngine . find ( ` . ${ CLASS _NAME _COLLAPSE } . ${ CLASS _NAME _COLLAPSE } ` , this . _config . parent ) ;
SelectorEngine . find ( SELECTOR _DATA _TOGGLE$4 , this . _config . parent ) . filter ( elem => ! children . includes ( elem ) ) . forEach ( element => {
const selected = getElementFromSelector ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( selected ) {
this . _addAriaAndCollapsedClass ( [ element ] , this . _isShown ( selected ) ) ;
2020-05-29 13:41:58 +02:00
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_addAriaAndCollapsedClass ( triggerArray , isOpen ) {
if ( ! triggerArray . length ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
triggerArray . forEach ( elem => {
if ( isOpen ) {
elem . classList . remove ( CLASS _NAME _COLLAPSED ) ;
} else {
elem . classList . add ( CLASS _NAME _COLLAPSED ) ;
}
elem . setAttribute ( 'aria-expanded' , isOpen ) ;
} ) ;
2020-05-29 13:41:58 +02:00
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
2020-05-29 13:41:58 +02:00
return this . each ( function ( ) {
2021-09-17 13:04:37 +02:00
const _config = { } ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config === 'string' && /show|hide/ . test ( config ) ) {
2020-05-29 13:41:58 +02:00
_config . toggle = false ;
}
2021-09-17 13:04:37 +02:00
const data = Collapse . getOrCreateInstance ( this , _config ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config === 'string' ) {
if ( typeof data [ config ] === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
data [ config ] ( ) ;
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _CLICK _DATA _API$4 , SELECTOR _DATA _TOGGLE$4 , function ( event ) {
2020-05-29 13:41:58 +02:00
// preventDefault only for <a> elements (which change the URL) not inside the collapsible element
2021-09-17 13:04:37 +02:00
if ( event . target . tagName === 'A' || event . delegateTarget && event . delegateTarget . tagName === 'A' ) {
2020-05-29 13:41:58 +02:00
event . preventDefault ( ) ;
}
2021-09-17 13:04:37 +02:00
const selector = getSelectorFromElement ( this ) ;
const selectorElements = SelectorEngine . find ( selector ) ;
selectorElements . forEach ( element => {
Collapse . getOrCreateInstance ( element , {
toggle : false
} ) . toggle ( ) ;
2020-05-29 13:41:58 +02:00
} ) ;
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Collapse to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Collapse ) ;
var top = 'top' ;
var bottom = 'bottom' ;
var right = 'right' ;
var left = 'left' ;
var auto = 'auto' ;
var basePlacements = [ top , bottom , right , left ] ;
var start = 'start' ;
var end = 'end' ;
var clippingParents = 'clippingParents' ;
var viewport = 'viewport' ;
var popper = 'popper' ;
var reference = 'reference' ;
var variationPlacements = /*#__PURE__*/ basePlacements . reduce ( function ( acc , placement ) {
return acc . concat ( [ placement + "-" + start , placement + "-" + end ] ) ;
} , [ ] ) ;
var placements = /*#__PURE__*/ [ ] . concat ( basePlacements , [ auto ] ) . reduce ( function ( acc , placement ) {
return acc . concat ( [ placement , placement + "-" + start , placement + "-" + end ] ) ;
} , [ ] ) ; // modifiers that need to read the DOM
var beforeRead = 'beforeRead' ;
var read = 'read' ;
var afterRead = 'afterRead' ; // pure-logic modifiers
var beforeMain = 'beforeMain' ;
var main = 'main' ;
var afterMain = 'afterMain' ; // modifier with the purpose to write to the DOM (or write into a framework state)
var beforeWrite = 'beforeWrite' ;
var write = 'write' ;
var afterWrite = 'afterWrite' ;
var modifierPhases = [ beforeRead , read , afterRead , beforeMain , main , afterMain , beforeWrite , write , afterWrite ] ;
function getNodeName ( element ) {
return element ? ( element . nodeName || '' ) . toLowerCase ( ) : null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getWindow ( node ) {
if ( node == null ) {
return window ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( node . toString ( ) !== '[object Window]' ) {
var ownerDocument = node . ownerDocument ;
return ownerDocument ? ownerDocument . defaultView || window : window ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return node ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isElement ( node ) {
var OwnElement = getWindow ( node ) . Element ;
return node instanceof OwnElement || node instanceof Element ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isHTMLElement ( node ) {
var OwnElement = getWindow ( node ) . HTMLElement ;
return node instanceof OwnElement || node instanceof HTMLElement ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isShadowRoot ( node ) {
// IE 11 has no ShadowRoot
if ( typeof ShadowRoot === 'undefined' ) {
return false ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var OwnElement = getWindow ( node ) . ShadowRoot ;
return node instanceof OwnElement || node instanceof ShadowRoot ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
// and applies them to the HTMLElements such as popper and arrow
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function applyStyles ( _ref ) {
var state = _ref . state ;
Object . keys ( state . elements ) . forEach ( function ( name ) {
var style = state . styles [ name ] || { } ;
var attributes = state . attributes [ name ] || { } ;
var element = state . elements [ name ] ; // arrow is optional + virtual elements
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isHTMLElement ( element ) || ! getNodeName ( element ) ) {
return ;
} // Flow doesn't support to extend this property, but it's the most
// effective way to apply styles to an HTMLElement
// $FlowFixMe[cannot-write]
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
Object . assign ( element . style , style ) ;
Object . keys ( attributes ) . forEach ( function ( name ) {
var value = attributes [ name ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( value === false ) {
element . removeAttribute ( name ) ;
} else {
element . setAttribute ( name , value === true ? '' : value ) ;
}
} ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function effect$2 ( _ref2 ) {
var state = _ref2 . state ;
var initialStyles = {
popper : {
position : state . options . strategy ,
left : '0' ,
top : '0' ,
margin : '0'
} ,
arrow : {
position : 'absolute'
} ,
reference : { }
} ;
Object . assign ( state . elements . popper . style , initialStyles . popper ) ;
state . styles = initialStyles ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( state . elements . arrow ) {
Object . assign ( state . elements . arrow . style , initialStyles . arrow ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return function ( ) {
Object . keys ( state . elements ) . forEach ( function ( name ) {
var element = state . elements [ name ] ;
var attributes = state . attributes [ name ] || { } ;
var styleProperties = Object . keys ( state . styles . hasOwnProperty ( name ) ? state . styles [ name ] : initialStyles [ name ] ) ; // Set all values to an empty string to unset them
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var style = styleProperties . reduce ( function ( style , property ) {
style [ property ] = '' ;
return style ;
} , { } ) ; // arrow is optional + virtual elements
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isHTMLElement ( element ) || ! getNodeName ( element ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
Object . assign ( element . style , style ) ;
Object . keys ( attributes ) . forEach ( function ( attribute ) {
element . removeAttribute ( attribute ) ;
} ) ;
} ) ;
} ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var applyStyles$1 = {
name : 'applyStyles' ,
enabled : true ,
phase : 'write' ,
fn : applyStyles ,
effect : effect$2 ,
requires : [ 'computeStyles' ]
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getBasePlacement ( placement ) {
return placement . split ( '-' ) [ 0 ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var round$1 = Math . round ;
function getBoundingClientRect ( element , includeScale ) {
if ( includeScale === void 0 ) {
includeScale = false ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var rect = element . getBoundingClientRect ( ) ;
var scaleX = 1 ;
var scaleY = 1 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isHTMLElement ( element ) && includeScale ) {
var offsetHeight = element . offsetHeight ;
var offsetWidth = element . offsetWidth ; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
// Fallback to 1 in case both values are `0`
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( offsetWidth > 0 ) {
scaleX = rect . width / offsetWidth || 1 ;
}
if ( offsetHeight > 0 ) {
scaleY = rect . height / offsetHeight || 1 ;
}
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return {
width : round$1 ( rect . width / scaleX ) ,
height : round$1 ( rect . height / scaleY ) ,
top : round$1 ( rect . top / scaleY ) ,
right : round$1 ( rect . right / scaleX ) ,
bottom : round$1 ( rect . bottom / scaleY ) ,
left : round$1 ( rect . left / scaleX ) ,
x : round$1 ( rect . left / scaleX ) ,
y : round$1 ( rect . top / scaleY )
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
// means it doesn't take into account transforms.
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getLayoutRect ( element ) {
var clientRect = getBoundingClientRect ( element ) ; // Use the clientRect sizes if it's not been transformed.
// Fixes https://github.com/popperjs/popper-core/issues/1223
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var width = element . offsetWidth ;
var height = element . offsetHeight ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( Math . abs ( clientRect . width - width ) <= 1 ) {
width = clientRect . width ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( Math . abs ( clientRect . height - height ) <= 1 ) {
height = clientRect . height ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return {
x : element . offsetLeft ,
y : element . offsetTop ,
width : width ,
height : height
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function contains ( parent , child ) {
var rootNode = child . getRootNode && child . getRootNode ( ) ; // First, attempt with faster native method
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( parent . contains ( child ) ) {
return true ;
} // then fallback to custom implementation with Shadow DOM support
else if ( rootNode && isShadowRoot ( rootNode ) ) {
var next = child ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
do {
if ( next && parent . isSameNode ( next ) ) {
return true ;
} // $FlowFixMe[prop-missing]: need a better way to handle this...
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
next = next . parentNode || next . host ;
} while ( next ) ;
} // Give up, the result is false
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return false ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function getComputedStyle$1 ( element ) {
return getWindow ( element ) . getComputedStyle ( element ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isTableElement ( element ) {
return [ 'table' , 'td' , 'th' ] . indexOf ( getNodeName ( element ) ) >= 0 ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function getDocumentElement ( element ) {
// $FlowFixMe[incompatible-return]: assume body is always available
return ( ( isElement ( element ) ? element . ownerDocument : // $FlowFixMe[prop-missing]
element . document ) || window . document ) . documentElement ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getParentNode ( element ) {
if ( getNodeName ( element ) === 'html' ) {
return element ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return ( // this is a quicker (but less type safe) way to save quite some bytes from the bundle
// $FlowFixMe[incompatible-return]
// $FlowFixMe[prop-missing]
element . assignedSlot || // step into the shadow DOM of the parent of a slotted node
element . parentNode || ( // DOM Element detected
isShadowRoot ( element ) ? element . host : null ) || // ShadowRoot detected
// $FlowFixMe[incompatible-call]: HTMLElement is a Node
getDocumentElement ( element ) // fallback
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getTrueOffsetParent ( element ) {
if ( ! isHTMLElement ( element ) || // https://github.com/popperjs/popper-core/issues/837
getComputedStyle$1 ( element ) . position === 'fixed' ) {
return null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return element . offsetParent ;
} // `.offsetParent` reports `null` for fixed elements, while absolute elements
// return the containing block
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getContainingBlock ( element ) {
var isFirefox = navigator . userAgent . toLowerCase ( ) . indexOf ( 'firefox' ) !== - 1 ;
var isIE = navigator . userAgent . indexOf ( 'Trident' ) !== - 1 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isIE && isHTMLElement ( element ) ) {
// In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
var elementCss = getComputedStyle$1 ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( elementCss . position === 'fixed' ) {
return null ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
var currentNode = getParentNode ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
while ( isHTMLElement ( currentNode ) && [ 'html' , 'body' ] . indexOf ( getNodeName ( currentNode ) ) < 0 ) {
var css = getComputedStyle$1 ( currentNode ) ; // This is non-exhaustive but covers the most common CSS properties that
// create a containing block.
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( css . transform !== 'none' || css . perspective !== 'none' || css . contain === 'paint' || [ 'transform' , 'perspective' ] . indexOf ( css . willChange ) !== - 1 || isFirefox && css . willChange === 'filter' || isFirefox && css . filter && css . filter !== 'none' ) {
return currentNode ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
currentNode = currentNode . parentNode ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
return null ;
} // Gets the closest ancestor positioned element. Handles some edge cases,
// such as table ancestors and cross browser bugs.
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getOffsetParent ( element ) {
var window = getWindow ( element ) ;
var offsetParent = getTrueOffsetParent ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
while ( offsetParent && isTableElement ( offsetParent ) && getComputedStyle$1 ( offsetParent ) . position === 'static' ) {
offsetParent = getTrueOffsetParent ( offsetParent ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( offsetParent && ( getNodeName ( offsetParent ) === 'html' || getNodeName ( offsetParent ) === 'body' && getComputedStyle$1 ( offsetParent ) . position === 'static' ) ) {
return window ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return offsetParent || getContainingBlock ( element ) || window ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function getMainAxisFromPlacement ( placement ) {
return [ 'top' , 'bottom' ] . indexOf ( placement ) >= 0 ? 'x' : 'y' ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var max = Math . max ;
var min = Math . min ;
var round = Math . round ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function within ( min$1 , value , max$1 ) {
return max ( min$1 , min ( value , max$1 ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getFreshSideObject ( ) {
return {
top : 0 ,
right : 0 ,
bottom : 0 ,
left : 0
2020-05-29 13:41:58 +02:00
} ;
}
2021-09-17 13:04:37 +02:00
function mergePaddingObject ( paddingObject ) {
return Object . assign ( { } , getFreshSideObject ( ) , paddingObject ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function expandToHashMap ( value , keys ) {
return keys . reduce ( function ( hashMap , key ) {
hashMap [ key ] = value ;
return hashMap ;
} , { } ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var toPaddingObject = function toPaddingObject ( padding , state ) {
padding = typeof padding === 'function' ? padding ( Object . assign ( { } , state . rects , {
placement : state . placement
} ) ) : padding ;
return mergePaddingObject ( typeof padding !== 'number' ? padding : expandToHashMap ( padding , basePlacements ) ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function arrow ( _ref ) {
var _state$modifiersData$ ;
var state = _ref . state ,
name = _ref . name ,
options = _ref . options ;
var arrowElement = state . elements . arrow ;
var popperOffsets = state . modifiersData . popperOffsets ;
var basePlacement = getBasePlacement ( state . placement ) ;
var axis = getMainAxisFromPlacement ( basePlacement ) ;
var isVertical = [ left , right ] . indexOf ( basePlacement ) >= 0 ;
var len = isVertical ? 'height' : 'width' ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! arrowElement || ! popperOffsets ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var paddingObject = toPaddingObject ( options . padding , state ) ;
var arrowRect = getLayoutRect ( arrowElement ) ;
var minProp = axis === 'y' ? top : left ;
var maxProp = axis === 'y' ? bottom : right ;
var endDiff = state . rects . reference [ len ] + state . rects . reference [ axis ] - popperOffsets [ axis ] - state . rects . popper [ len ] ;
var startDiff = popperOffsets [ axis ] - state . rects . reference [ axis ] ;
var arrowOffsetParent = getOffsetParent ( arrowElement ) ;
var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent . clientHeight || 0 : arrowOffsetParent . clientWidth || 0 : 0 ;
var centerToReference = endDiff / 2 - startDiff / 2 ; // Make sure the arrow doesn't overflow the popper if the center point is
// outside of the popper bounds
var min = paddingObject [ minProp ] ;
var max = clientSize - arrowRect [ len ] - paddingObject [ maxProp ] ;
var center = clientSize / 2 - arrowRect [ len ] / 2 + centerToReference ;
var offset = within ( min , center , max ) ; // Prevents breaking syntax highlighting...
var axisProp = axis ;
state . modifiersData [ name ] = ( _state$modifiersData$ = { } , _state$modifiersData$ [ axisProp ] = offset , _state$modifiersData$ . centerOffset = offset - center , _state$modifiersData$ ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function effect$1 ( _ref2 ) {
var state = _ref2 . state ,
options = _ref2 . options ;
var _options$element = options . element ,
arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( arrowElement == null ) {
return ;
} // CSS selector
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof arrowElement === 'string' ) {
arrowElement = state . elements . popper . querySelector ( arrowElement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! arrowElement ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! contains ( state . elements . popper , arrowElement ) ) {
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
state . elements . arrow = arrowElement ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var arrow$1 = {
name : 'arrow' ,
enabled : true ,
phase : 'main' ,
fn : arrow ,
effect : effect$1 ,
requires : [ 'popperOffsets' ] ,
requiresIfExists : [ 'preventOverflow' ]
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getVariation ( placement ) {
return placement . split ( '-' ) [ 1 ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var unsetSides = {
top : 'auto' ,
right : 'auto' ,
bottom : 'auto' ,
left : 'auto'
} ; // Round the offsets to the nearest suitable subpixel based on the DPR.
// Zooming can change the DPR, but it seems to report a value that will
// cleanly divide the values into the appropriate subpixels.
function roundOffsetsByDPR ( _ref ) {
var x = _ref . x ,
y = _ref . y ;
var win = window ;
var dpr = win . devicePixelRatio || 1 ;
return {
x : round ( round ( x * dpr ) / dpr ) || 0 ,
y : round ( round ( y * dpr ) / dpr ) || 0
2020-05-29 13:41:58 +02:00
} ;
}
2021-09-17 13:04:37 +02:00
function mapToStyles ( _ref2 ) {
var _Object$assign2 ;
var popper = _ref2 . popper ,
popperRect = _ref2 . popperRect ,
placement = _ref2 . placement ,
variation = _ref2 . variation ,
offsets = _ref2 . offsets ,
position = _ref2 . position ,
gpuAcceleration = _ref2 . gpuAcceleration ,
adaptive = _ref2 . adaptive ,
roundOffsets = _ref2 . roundOffsets ;
var _ref3 = roundOffsets === true ? roundOffsetsByDPR ( offsets ) : typeof roundOffsets === 'function' ? roundOffsets ( offsets ) : offsets ,
_ref3$x = _ref3 . x ,
x = _ref3$x === void 0 ? 0 : _ref3$x ,
_ref3$y = _ref3 . y ,
y = _ref3$y === void 0 ? 0 : _ref3$y ;
var hasX = offsets . hasOwnProperty ( 'x' ) ;
var hasY = offsets . hasOwnProperty ( 'y' ) ;
var sideX = left ;
var sideY = top ;
var win = window ;
if ( adaptive ) {
var offsetParent = getOffsetParent ( popper ) ;
var heightProp = 'clientHeight' ;
var widthProp = 'clientWidth' ;
if ( offsetParent === getWindow ( popper ) ) {
offsetParent = getDocumentElement ( popper ) ;
if ( getComputedStyle$1 ( offsetParent ) . position !== 'static' && position === 'absolute' ) {
heightProp = 'scrollHeight' ;
widthProp = 'scrollWidth' ;
}
} // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
offsetParent = offsetParent ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( placement === top || ( placement === left || placement === right ) && variation === end ) {
sideY = bottom ; // $FlowFixMe[prop-missing]
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
y -= offsetParent [ heightProp ] - popperRect . height ;
y *= gpuAcceleration ? 1 : - 1 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( placement === left || ( placement === top || placement === bottom ) && variation === end ) {
sideX = right ; // $FlowFixMe[prop-missing]
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
x -= offsetParent [ widthProp ] - popperRect . width ;
x *= gpuAcceleration ? 1 : - 1 ;
}
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var commonStyles = Object . assign ( {
position : position
} , adaptive && unsetSides ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( gpuAcceleration ) {
var _Object$assign ;
return Object . assign ( { } , commonStyles , ( _Object$assign = { } , _Object$assign [ sideY ] = hasY ? '0' : '' , _Object$assign [ sideX ] = hasX ? '0' : '' , _Object$assign . transform = ( win . devicePixelRatio || 1 ) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)" , _Object$assign ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return Object . assign ( { } , commonStyles , ( _Object$assign2 = { } , _Object$assign2 [ sideY ] = hasY ? y + "px" : '' , _Object$assign2 [ sideX ] = hasX ? x + "px" : '' , _Object$assign2 . transform = '' , _Object$assign2 ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function computeStyles ( _ref4 ) {
var state = _ref4 . state ,
options = _ref4 . options ;
var _options$gpuAccelerat = options . gpuAcceleration ,
gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat ,
_options$adaptive = options . adaptive ,
adaptive = _options$adaptive === void 0 ? true : _options$adaptive ,
_options$roundOffsets = options . roundOffsets ,
roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets ;
var commonStyles = {
placement : getBasePlacement ( state . placement ) ,
variation : getVariation ( state . placement ) ,
popper : state . elements . popper ,
popperRect : state . rects . popper ,
gpuAcceleration : gpuAcceleration
} ;
if ( state . modifiersData . popperOffsets != null ) {
state . styles . popper = Object . assign ( { } , state . styles . popper , mapToStyles ( Object . assign ( { } , commonStyles , {
offsets : state . modifiersData . popperOffsets ,
position : state . options . strategy ,
adaptive : adaptive ,
roundOffsets : roundOffsets
} ) ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( state . modifiersData . arrow != null ) {
state . styles . arrow = Object . assign ( { } , state . styles . arrow , mapToStyles ( Object . assign ( { } , commonStyles , {
offsets : state . modifiersData . arrow ,
position : 'absolute' ,
adaptive : false ,
roundOffsets : roundOffsets
} ) ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
state . attributes . popper = Object . assign ( { } , state . attributes . popper , {
'data-popper-placement' : state . placement
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var computeStyles$1 = {
name : 'computeStyles' ,
enabled : true ,
phase : 'beforeWrite' ,
fn : computeStyles ,
data : { }
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var passive = {
passive : true
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function effect ( _ref ) {
var state = _ref . state ,
instance = _ref . instance ,
options = _ref . options ;
var _options$scroll = options . scroll ,
scroll = _options$scroll === void 0 ? true : _options$scroll ,
_options$resize = options . resize ,
resize = _options$resize === void 0 ? true : _options$resize ;
var window = getWindow ( state . elements . popper ) ;
var scrollParents = [ ] . concat ( state . scrollParents . reference , state . scrollParents . popper ) ;
if ( scroll ) {
scrollParents . forEach ( function ( scrollParent ) {
scrollParent . addEventListener ( 'scroll' , instance . update , passive ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( resize ) {
window . addEventListener ( 'resize' , instance . update , passive ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return function ( ) {
if ( scroll ) {
scrollParents . forEach ( function ( scrollParent ) {
scrollParent . removeEventListener ( 'scroll' , instance . update , passive ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( resize ) {
window . removeEventListener ( 'resize' , instance . update , passive ) ;
}
} ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var eventListeners = {
name : 'eventListeners' ,
enabled : true ,
phase : 'write' ,
fn : function fn ( ) { } ,
effect : effect ,
data : { }
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var hash$1 = {
left : 'right' ,
right : 'left' ,
bottom : 'top' ,
top : 'bottom'
} ;
function getOppositePlacement ( placement ) {
return placement . replace ( /left|right|bottom|top/g , function ( matched ) {
return hash$1 [ matched ] ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var hash = {
start : 'end' ,
end : 'start'
} ;
function getOppositeVariationPlacement ( placement ) {
return placement . replace ( /start|end/g , function ( matched ) {
return hash [ matched ] ;
2020-05-29 13:41:58 +02:00
} ) ;
}
2021-09-17 13:04:37 +02:00
function getWindowScroll ( node ) {
var win = getWindow ( node ) ;
var scrollLeft = win . pageXOffset ;
var scrollTop = win . pageYOffset ;
return {
scrollLeft : scrollLeft ,
scrollTop : scrollTop
} ;
}
function getWindowScrollBarX ( element ) {
// If <html> has a CSS width greater than the viewport, then this will be
// incorrect for RTL.
// Popper 1 is broken in this case and never had a bug report so let's assume
// it's not an issue. I don't think anyone ever specifies width on <html>
// anyway.
// Browsers where the left scrollbar doesn't cause an issue report `0` for
// this (e.g. Edge 2019, IE11, Safari)
return getBoundingClientRect ( getDocumentElement ( element ) ) . left + getWindowScroll ( element ) . scrollLeft ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getViewportRect ( element ) {
var win = getWindow ( element ) ;
var html = getDocumentElement ( element ) ;
var visualViewport = win . visualViewport ;
var width = html . clientWidth ;
var height = html . clientHeight ;
var x = 0 ;
var y = 0 ; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
// can be obscured underneath it.
// Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
// if it isn't open, so if this isn't available, the popper will be detected
// to overflow the bottom of the screen too early.
if ( visualViewport ) {
width = visualViewport . width ;
height = visualViewport . height ; // Uses Layout Viewport (like Chrome; Safari does not currently)
// In Chrome, it returns a value very close to 0 (+/-) but contains rounding
// errors due to floating point numbers, so we need to check precision.
// Safari returns a number <= 0, usually < -1 when pinch-zoomed
// Feature detection fails in mobile emulation mode in Chrome.
// Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
// 0.001
// Fallback here: "Not Safari" userAgent
if ( ! /^((?!chrome|android).)*safari/i . test ( navigator . userAgent ) ) {
x = visualViewport . offsetLeft ;
y = visualViewport . offsetTop ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
return {
width : width ,
height : height ,
x : x + getWindowScrollBarX ( element ) ,
y : y
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
// of the `<html>` and `<body>` rect bounds if horizontally scrollable
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getDocumentRect ( element ) {
var _element$ownerDocumen ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var html = getDocumentElement ( element ) ;
var winScroll = getWindowScroll ( element ) ;
var body = ( _element$ownerDocumen = element . ownerDocument ) == null ? void 0 : _element$ownerDocumen . body ;
var width = max ( html . scrollWidth , html . clientWidth , body ? body . scrollWidth : 0 , body ? body . clientWidth : 0 ) ;
var height = max ( html . scrollHeight , html . clientHeight , body ? body . scrollHeight : 0 , body ? body . clientHeight : 0 ) ;
var x = - winScroll . scrollLeft + getWindowScrollBarX ( element ) ;
var y = - winScroll . scrollTop ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( getComputedStyle$1 ( body || html ) . direction === 'rtl' ) {
x += max ( html . clientWidth , body ? body . clientWidth : 0 ) - width ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return {
width : width ,
height : height ,
x : x ,
y : y
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isScrollParent ( element ) {
// Firefox wants us to check `-x` and `-y` variations as well
var _getComputedStyle = getComputedStyle$1 ( element ) ,
overflow = _getComputedStyle . overflow ,
overflowX = _getComputedStyle . overflowX ,
overflowY = _getComputedStyle . overflowY ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return /auto|scroll|overlay|hidden/ . test ( overflow + overflowY + overflowX ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function getScrollParent ( node ) {
if ( [ 'html' , 'body' , '#document' ] . indexOf ( getNodeName ( node ) ) >= 0 ) {
// $FlowFixMe[incompatible-return]: assume body is always available
return node . ownerDocument . body ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isHTMLElement ( node ) && isScrollParent ( node ) ) {
return node ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return getScrollParent ( getParentNode ( node ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ *
given a DOM element , return the list of all scroll parents , up the list of ancesors
until we get to the top window object . This list is what we attach scroll listeners
to , because if any of these parent elements scroll , we ' ll need to re - calculate the
reference element ' s position .
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function listScrollParents ( element , list ) {
var _element$ownerDocumen ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( list === void 0 ) {
list = [ ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var scrollParent = getScrollParent ( element ) ;
var isBody = scrollParent === ( ( _element$ownerDocumen = element . ownerDocument ) == null ? void 0 : _element$ownerDocumen . body ) ;
var win = getWindow ( scrollParent ) ;
var target = isBody ? [ win ] . concat ( win . visualViewport || [ ] , isScrollParent ( scrollParent ) ? scrollParent : [ ] ) : scrollParent ;
var updatedList = list . concat ( target ) ;
return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
updatedList . concat ( listScrollParents ( getParentNode ( target ) ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function rectToClientRect ( rect ) {
return Object . assign ( { } , rect , {
left : rect . x ,
top : rect . y ,
right : rect . x + rect . width ,
bottom : rect . y + rect . height
2020-05-29 13:41:58 +02:00
} ) ;
}
2021-09-17 13:04:37 +02:00
function getInnerBoundingClientRect ( element ) {
var rect = getBoundingClientRect ( element ) ;
rect . top = rect . top + element . clientTop ;
rect . left = rect . left + element . clientLeft ;
rect . bottom = rect . top + element . clientHeight ;
rect . right = rect . left + element . clientWidth ;
rect . width = element . clientWidth ;
rect . height = element . clientHeight ;
rect . x = rect . left ;
rect . y = rect . top ;
return rect ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function getClientRectFromMixedType ( element , clippingParent ) {
return clippingParent === viewport ? rectToClientRect ( getViewportRect ( element ) ) : isHTMLElement ( clippingParent ) ? getInnerBoundingClientRect ( clippingParent ) : rectToClientRect ( getDocumentRect ( getDocumentElement ( element ) ) ) ;
} // A "clipping parent" is an overflowable container with the characteristic of
// clipping (or hiding) overflowing elements with a position different from
// `initial`
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getClippingParents ( element ) {
var clippingParents = listScrollParents ( getParentNode ( element ) ) ;
var canEscapeClipping = [ 'absolute' , 'fixed' ] . indexOf ( getComputedStyle$1 ( element ) . position ) >= 0 ;
var clipperElement = canEscapeClipping && isHTMLElement ( element ) ? getOffsetParent ( element ) : element ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isElement ( clipperElement ) ) {
return [ ] ;
} // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return clippingParents . filter ( function ( clippingParent ) {
return isElement ( clippingParent ) && contains ( clippingParent , clipperElement ) && getNodeName ( clippingParent ) !== 'body' ;
} ) ;
} // Gets the maximum area that the element is visible in due to any number of
// clipping parents
function getClippingRect ( element , boundary , rootBoundary ) {
var mainClippingParents = boundary === 'clippingParents' ? getClippingParents ( element ) : [ ] . concat ( boundary ) ;
var clippingParents = [ ] . concat ( mainClippingParents , [ rootBoundary ] ) ;
var firstClippingParent = clippingParents [ 0 ] ;
var clippingRect = clippingParents . reduce ( function ( accRect , clippingParent ) {
var rect = getClientRectFromMixedType ( element , clippingParent ) ;
accRect . top = max ( rect . top , accRect . top ) ;
accRect . right = min ( rect . right , accRect . right ) ;
accRect . bottom = min ( rect . bottom , accRect . bottom ) ;
accRect . left = max ( rect . left , accRect . left ) ;
return accRect ;
} , getClientRectFromMixedType ( element , firstClippingParent ) ) ;
clippingRect . width = clippingRect . right - clippingRect . left ;
clippingRect . height = clippingRect . bottom - clippingRect . top ;
clippingRect . x = clippingRect . left ;
clippingRect . y = clippingRect . top ;
return clippingRect ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function computeOffsets ( _ref ) {
var reference = _ref . reference ,
element = _ref . element ,
placement = _ref . placement ;
var basePlacement = placement ? getBasePlacement ( placement ) : null ;
var variation = placement ? getVariation ( placement ) : null ;
var commonX = reference . x + reference . width / 2 - element . width / 2 ;
var commonY = reference . y + reference . height / 2 - element . height / 2 ;
var offsets ;
switch ( basePlacement ) {
case top :
offsets = {
x : commonX ,
y : reference . y - element . height
} ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
case bottom :
offsets = {
x : commonX ,
y : reference . y + reference . height
} ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
case right :
offsets = {
x : reference . x + reference . width ,
y : commonY
} ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
case left :
offsets = {
x : reference . x - element . width ,
y : commonY
} ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
default :
offsets = {
x : reference . x ,
y : reference . y
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var mainAxis = basePlacement ? getMainAxisFromPlacement ( basePlacement ) : null ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( mainAxis != null ) {
var len = mainAxis === 'y' ? 'height' : 'width' ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
switch ( variation ) {
case start :
offsets [ mainAxis ] = offsets [ mainAxis ] - ( reference [ len ] / 2 - element [ len ] / 2 ) ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
case end :
offsets [ mainAxis ] = offsets [ mainAxis ] + ( reference [ len ] / 2 - element [ len ] / 2 ) ;
break ;
}
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return offsets ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function detectOverflow ( state , options ) {
if ( options === void 0 ) {
options = { } ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var _options = options ,
_options$placement = _options . placement ,
placement = _options$placement === void 0 ? state . placement : _options$placement ,
_options$boundary = _options . boundary ,
boundary = _options$boundary === void 0 ? clippingParents : _options$boundary ,
_options$rootBoundary = _options . rootBoundary ,
rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary ,
_options$elementConte = _options . elementContext ,
elementContext = _options$elementConte === void 0 ? popper : _options$elementConte ,
_options$altBoundary = _options . altBoundary ,
altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary ,
_options$padding = _options . padding ,
padding = _options$padding === void 0 ? 0 : _options$padding ;
var paddingObject = mergePaddingObject ( typeof padding !== 'number' ? padding : expandToHashMap ( padding , basePlacements ) ) ;
var altContext = elementContext === popper ? reference : popper ;
var popperRect = state . rects . popper ;
var element = state . elements [ altBoundary ? altContext : elementContext ] ;
var clippingClientRect = getClippingRect ( isElement ( element ) ? element : element . contextElement || getDocumentElement ( state . elements . popper ) , boundary , rootBoundary ) ;
var referenceClientRect = getBoundingClientRect ( state . elements . reference ) ;
var popperOffsets = computeOffsets ( {
reference : referenceClientRect ,
element : popperRect ,
strategy : 'absolute' ,
placement : placement
} ) ;
var popperClientRect = rectToClientRect ( Object . assign ( { } , popperRect , popperOffsets ) ) ;
var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect ; // positive = overflowing the clipping rect
// 0 or negative = within the clipping rect
var overflowOffsets = {
top : clippingClientRect . top - elementClientRect . top + paddingObject . top ,
bottom : elementClientRect . bottom - clippingClientRect . bottom + paddingObject . bottom ,
left : clippingClientRect . left - elementClientRect . left + paddingObject . left ,
right : elementClientRect . right - clippingClientRect . right + paddingObject . right
} ;
var offsetData = state . modifiersData . offset ; // Offsets can be applied only to the popper element
if ( elementContext === popper && offsetData ) {
var offset = offsetData [ placement ] ;
Object . keys ( overflowOffsets ) . forEach ( function ( key ) {
var multiply = [ right , bottom ] . indexOf ( key ) >= 0 ? 1 : - 1 ;
var axis = [ top , bottom ] . indexOf ( key ) >= 0 ? 'y' : 'x' ;
overflowOffsets [ key ] += offset [ axis ] * multiply ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return overflowOffsets ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function computeAutoPlacement ( state , options ) {
if ( options === void 0 ) {
options = { } ;
}
var _options = options ,
placement = _options . placement ,
boundary = _options . boundary ,
rootBoundary = _options . rootBoundary ,
padding = _options . padding ,
flipVariations = _options . flipVariations ,
_options$allowedAutoP = _options . allowedAutoPlacements ,
allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP ;
var variation = getVariation ( placement ) ;
var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements . filter ( function ( placement ) {
return getVariation ( placement ) === variation ;
} ) : basePlacements ;
var allowedPlacements = placements$1 . filter ( function ( placement ) {
return allowedAutoPlacements . indexOf ( placement ) >= 0 ;
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
if ( allowedPlacements . length === 0 ) {
allowedPlacements = placements$1 ;
} // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
var overflows = allowedPlacements . reduce ( function ( acc , placement ) {
acc [ placement ] = detectOverflow ( state , {
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
padding : padding
} ) [ getBasePlacement ( placement ) ] ;
return acc ;
} , { } ) ;
return Object . keys ( overflows ) . sort ( function ( a , b ) {
return overflows [ a ] - overflows [ b ] ;
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getExpandedFallbackPlacements ( placement ) {
if ( getBasePlacement ( placement ) === auto ) {
return [ ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var oppositePlacement = getOppositePlacement ( placement ) ;
return [ getOppositeVariationPlacement ( placement ) , oppositePlacement , getOppositeVariationPlacement ( oppositePlacement ) ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function flip ( _ref ) {
var state = _ref . state ,
options = _ref . options ,
name = _ref . name ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( state . modifiersData [ name ] . _skip ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var _options$mainAxis = options . mainAxis ,
checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis ,
_options$altAxis = options . altAxis ,
checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis ,
specifiedFallbackPlacements = options . fallbackPlacements ,
padding = options . padding ,
boundary = options . boundary ,
rootBoundary = options . rootBoundary ,
altBoundary = options . altBoundary ,
_options$flipVariatio = options . flipVariations ,
flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio ,
allowedAutoPlacements = options . allowedAutoPlacements ;
var preferredPlacement = state . options . placement ;
var basePlacement = getBasePlacement ( preferredPlacement ) ;
var isBasePlacement = basePlacement === preferredPlacement ;
var fallbackPlacements = specifiedFallbackPlacements || ( isBasePlacement || ! flipVariations ? [ getOppositePlacement ( preferredPlacement ) ] : getExpandedFallbackPlacements ( preferredPlacement ) ) ;
var placements = [ preferredPlacement ] . concat ( fallbackPlacements ) . reduce ( function ( acc , placement ) {
return acc . concat ( getBasePlacement ( placement ) === auto ? computeAutoPlacement ( state , {
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
padding : padding ,
flipVariations : flipVariations ,
allowedAutoPlacements : allowedAutoPlacements
} ) : placement ) ;
} , [ ] ) ;
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var checksMap = new Map ( ) ;
var makeFallbackChecks = true ;
var firstFittingPlacement = placements [ 0 ] ;
for ( var i = 0 ; i < placements . length ; i ++ ) {
var placement = placements [ i ] ;
var _basePlacement = getBasePlacement ( placement ) ;
var isStartVariation = getVariation ( placement ) === start ;
var isVertical = [ top , bottom ] . indexOf ( _basePlacement ) >= 0 ;
var len = isVertical ? 'width' : 'height' ;
var overflow = detectOverflow ( state , {
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
altBoundary : altBoundary ,
padding : padding
} ) ;
var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top ;
if ( referenceRect [ len ] > popperRect [ len ] ) {
mainVariationSide = getOppositePlacement ( mainVariationSide ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var altVariationSide = getOppositePlacement ( mainVariationSide ) ;
var checks = [ ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( checkMainAxis ) {
checks . push ( overflow [ _basePlacement ] <= 0 ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( checkAltAxis ) {
checks . push ( overflow [ mainVariationSide ] <= 0 , overflow [ altVariationSide ] <= 0 ) ;
}
if ( checks . every ( function ( check ) {
return check ;
} ) ) {
firstFittingPlacement = placement ;
makeFallbackChecks = false ;
break ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
checksMap . set ( placement , checks ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( makeFallbackChecks ) {
// `2` may be desired in some cases – research later
var numberOfChecks = flipVariations ? 3 : 1 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _loop = function _loop ( _i ) {
var fittingPlacement = placements . find ( function ( placement ) {
var checks = checksMap . get ( placement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( checks ) {
return checks . slice ( 0 , _i ) . every ( function ( check ) {
return check ;
} ) ;
}
} ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( fittingPlacement ) {
firstFittingPlacement = fittingPlacement ;
return "break" ;
}
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( var _i = numberOfChecks ; _i > 0 ; _i -- ) {
var _ret = _loop ( _i ) ;
if ( _ret === "break" ) break ;
}
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( state . placement !== firstFittingPlacement ) {
state . modifiersData [ name ] . _skip = true ;
state . placement = firstFittingPlacement ;
state . reset = true ;
}
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var flip$1 = {
name : 'flip' ,
enabled : true ,
phase : 'main' ,
fn : flip ,
requiresIfExists : [ 'offset' ] ,
data : {
_skip : false
}
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getSideOffsets ( overflow , rect , preventedOffsets ) {
if ( preventedOffsets === void 0 ) {
preventedOffsets = {
x : 0 ,
y : 0
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return {
top : overflow . top - rect . height - preventedOffsets . y ,
right : overflow . right - rect . width + preventedOffsets . x ,
bottom : overflow . bottom - rect . height + preventedOffsets . y ,
left : overflow . left - rect . width - preventedOffsets . x
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isAnySideFullyClipped ( overflow ) {
return [ top , right , bottom , left ] . some ( function ( side ) {
return overflow [ side ] >= 0 ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function hide ( _ref ) {
var state = _ref . state ,
name = _ref . name ;
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var preventedOffsets = state . modifiersData . preventOverflow ;
var referenceOverflow = detectOverflow ( state , {
elementContext : 'reference'
} ) ;
var popperAltOverflow = detectOverflow ( state , {
altBoundary : true
} ) ;
var referenceClippingOffsets = getSideOffsets ( referenceOverflow , referenceRect ) ;
var popperEscapeOffsets = getSideOffsets ( popperAltOverflow , popperRect , preventedOffsets ) ;
var isReferenceHidden = isAnySideFullyClipped ( referenceClippingOffsets ) ;
var hasPopperEscaped = isAnySideFullyClipped ( popperEscapeOffsets ) ;
state . modifiersData [ name ] = {
referenceClippingOffsets : referenceClippingOffsets ,
popperEscapeOffsets : popperEscapeOffsets ,
isReferenceHidden : isReferenceHidden ,
hasPopperEscaped : hasPopperEscaped
} ;
state . attributes . popper = Object . assign ( { } , state . attributes . popper , {
'data-popper-reference-hidden' : isReferenceHidden ,
'data-popper-escaped' : hasPopperEscaped
} ) ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var hide$1 = {
name : 'hide' ,
enabled : true ,
phase : 'main' ,
requiresIfExists : [ 'preventOverflow' ] ,
fn : hide
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function distanceAndSkiddingToXY ( placement , rects , offset ) {
var basePlacement = getBasePlacement ( placement ) ;
var invertDistance = [ left , top ] . indexOf ( basePlacement ) >= 0 ? - 1 : 1 ;
var _ref = typeof offset === 'function' ? offset ( Object . assign ( { } , rects , {
placement : placement
} ) ) : offset ,
skidding = _ref [ 0 ] ,
distance = _ref [ 1 ] ;
skidding = skidding || 0 ;
distance = ( distance || 0 ) * invertDistance ;
return [ left , right ] . indexOf ( basePlacement ) >= 0 ? {
x : distance ,
y : skidding
} : {
x : skidding ,
y : distance
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function offset ( _ref2 ) {
var state = _ref2 . state ,
options = _ref2 . options ,
name = _ref2 . name ;
var _options$offset = options . offset ,
offset = _options$offset === void 0 ? [ 0 , 0 ] : _options$offset ;
var data = placements . reduce ( function ( acc , placement ) {
acc [ placement ] = distanceAndSkiddingToXY ( placement , state . rects , offset ) ;
return acc ;
} , { } ) ;
var _data$state$placement = data [ state . placement ] ,
x = _data$state$placement . x ,
y = _data$state$placement . y ;
if ( state . modifiersData . popperOffsets != null ) {
state . modifiersData . popperOffsets . x += x ;
state . modifiersData . popperOffsets . y += y ;
}
state . modifiersData [ name ] = data ;
} // eslint-disable-next-line import/no-unused-modules
var offset$1 = {
name : 'offset' ,
enabled : true ,
phase : 'main' ,
requires : [ 'popperOffsets' ] ,
fn : offset
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
function popperOffsets ( _ref ) {
var state = _ref . state ,
name = _ref . name ;
// Offsets are the actual position the popper needs to have to be
// properly positioned near its reference element
// This is the most basic placement, and will be adjusted by
// the modifiers in the next step
state . modifiersData [ name ] = computeOffsets ( {
reference : state . rects . reference ,
element : state . rects . popper ,
strategy : 'absolute' ,
placement : state . placement
} ) ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var popperOffsets$1 = {
name : 'popperOffsets' ,
enabled : true ,
phase : 'read' ,
fn : popperOffsets ,
data : { }
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getAltAxis ( axis ) {
return axis === 'x' ? 'y' : 'x' ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function preventOverflow ( _ref ) {
var state = _ref . state ,
options = _ref . options ,
name = _ref . name ;
var _options$mainAxis = options . mainAxis ,
checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis ,
_options$altAxis = options . altAxis ,
checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis ,
boundary = options . boundary ,
rootBoundary = options . rootBoundary ,
altBoundary = options . altBoundary ,
padding = options . padding ,
_options$tether = options . tether ,
tether = _options$tether === void 0 ? true : _options$tether ,
_options$tetherOffset = options . tetherOffset ,
tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset ;
var overflow = detectOverflow ( state , {
boundary : boundary ,
rootBoundary : rootBoundary ,
padding : padding ,
altBoundary : altBoundary
} ) ;
var basePlacement = getBasePlacement ( state . placement ) ;
var variation = getVariation ( state . placement ) ;
var isBasePlacement = ! variation ;
var mainAxis = getMainAxisFromPlacement ( basePlacement ) ;
var altAxis = getAltAxis ( mainAxis ) ;
var popperOffsets = state . modifiersData . popperOffsets ;
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset ( Object . assign ( { } , state . rects , {
placement : state . placement
} ) ) : tetherOffset ;
var data = {
x : 0 ,
y : 0
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! popperOffsets ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( checkMainAxis || checkAltAxis ) {
var mainSide = mainAxis === 'y' ? top : left ;
var altSide = mainAxis === 'y' ? bottom : right ;
var len = mainAxis === 'y' ? 'height' : 'width' ;
var offset = popperOffsets [ mainAxis ] ;
var min$1 = popperOffsets [ mainAxis ] + overflow [ mainSide ] ;
var max$1 = popperOffsets [ mainAxis ] - overflow [ altSide ] ;
var additive = tether ? - popperRect [ len ] / 2 : 0 ;
var minLen = variation === start ? referenceRect [ len ] : popperRect [ len ] ;
var maxLen = variation === start ? - popperRect [ len ] : - referenceRect [ len ] ; // We need to include the arrow in the calculation so the arrow doesn't go
// outside the reference bounds
var arrowElement = state . elements . arrow ;
var arrowRect = tether && arrowElement ? getLayoutRect ( arrowElement ) : {
width : 0 ,
height : 0
} ;
var arrowPaddingObject = state . modifiersData [ 'arrow#persistent' ] ? state . modifiersData [ 'arrow#persistent' ] . padding : getFreshSideObject ( ) ;
var arrowPaddingMin = arrowPaddingObject [ mainSide ] ;
var arrowPaddingMax = arrowPaddingObject [ altSide ] ; // If the reference length is smaller than the arrow length, we don't want
// to include its full size in the calculation. If the reference is small
// and near the edge of a boundary, the popper can overflow even if the
// reference is not overflowing as well (e.g. virtual elements with no
// width or height)
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var arrowLen = within ( 0 , referenceRect [ len ] , arrowRect [ len ] ) ;
var minOffset = isBasePlacement ? referenceRect [ len ] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue ;
var maxOffset = isBasePlacement ? - referenceRect [ len ] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue ;
var arrowOffsetParent = state . elements . arrow && getOffsetParent ( state . elements . arrow ) ;
var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent . clientTop || 0 : arrowOffsetParent . clientLeft || 0 : 0 ;
var offsetModifierValue = state . modifiersData . offset ? state . modifiersData . offset [ state . placement ] [ mainAxis ] : 0 ;
var tetherMin = popperOffsets [ mainAxis ] + minOffset - offsetModifierValue - clientOffset ;
var tetherMax = popperOffsets [ mainAxis ] + maxOffset - offsetModifierValue ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( checkMainAxis ) {
var preventedOffset = within ( tether ? min ( min$1 , tetherMin ) : min$1 , offset , tether ? max ( max$1 , tetherMax ) : max$1 ) ;
popperOffsets [ mainAxis ] = preventedOffset ;
data [ mainAxis ] = preventedOffset - offset ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( checkAltAxis ) {
var _mainSide = mainAxis === 'x' ? top : left ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _altSide = mainAxis === 'x' ? bottom : right ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _offset = popperOffsets [ altAxis ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _min = _offset + overflow [ _mainSide ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _max = _offset - overflow [ _altSide ] ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _preventedOffset = within ( tether ? min ( _min , tetherMin ) : _min , _offset , tether ? max ( _max , tetherMax ) : _max ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
popperOffsets [ altAxis ] = _preventedOffset ;
data [ altAxis ] = _preventedOffset - _offset ;
}
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
state . modifiersData [ name ] = data ;
} // eslint-disable-next-line import/no-unused-modules
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var preventOverflow$1 = {
name : 'preventOverflow' ,
enabled : true ,
phase : 'main' ,
fn : preventOverflow ,
requiresIfExists : [ 'offset' ]
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getHTMLElementScroll ( element ) {
return {
scrollLeft : element . scrollLeft ,
scrollTop : element . scrollTop
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getNodeScroll ( node ) {
if ( node === getWindow ( node ) || ! isHTMLElement ( node ) ) {
return getWindowScroll ( node ) ;
} else {
return getHTMLElementScroll ( node ) ;
}
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function isElementScaled ( element ) {
var rect = element . getBoundingClientRect ( ) ;
var scaleX = rect . width / element . offsetWidth || 1 ;
var scaleY = rect . height / element . offsetHeight || 1 ;
return scaleX !== 1 || scaleY !== 1 ;
} // Returns the composite rect of an element relative to its offsetParent.
// Composite means it takes into account transforms as well as layout.
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function getCompositeRect ( elementOrVirtualElement , offsetParent , isFixed ) {
if ( isFixed === void 0 ) {
isFixed = false ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var isOffsetParentAnElement = isHTMLElement ( offsetParent ) ;
var offsetParentIsScaled = isHTMLElement ( offsetParent ) && isElementScaled ( offsetParent ) ;
var documentElement = getDocumentElement ( offsetParent ) ;
var rect = getBoundingClientRect ( elementOrVirtualElement , offsetParentIsScaled ) ;
var scroll = {
scrollLeft : 0 ,
scrollTop : 0
} ;
var offsets = {
x : 0 ,
y : 0
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isOffsetParentAnElement || ! isOffsetParentAnElement && ! isFixed ) {
if ( getNodeName ( offsetParent ) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
isScrollParent ( documentElement ) ) {
scroll = getNodeScroll ( offsetParent ) ;
}
if ( isHTMLElement ( offsetParent ) ) {
offsets = getBoundingClientRect ( offsetParent , true ) ;
offsets . x += offsetParent . clientLeft ;
offsets . y += offsetParent . clientTop ;
} else if ( documentElement ) {
offsets . x = getWindowScrollBarX ( documentElement ) ;
2020-05-29 13:41:58 +02:00
}
}
2021-09-17 13:04:37 +02:00
return {
x : rect . left + scroll . scrollLeft - offsets . x ,
y : rect . top + scroll . scrollTop - offsets . y ,
width : rect . width ,
height : rect . height
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function order ( modifiers ) {
var map = new Map ( ) ;
var visited = new Set ( ) ;
var result = [ ] ;
modifiers . forEach ( function ( modifier ) {
map . set ( modifier . name , modifier ) ;
} ) ; // On visiting object, check for its dependencies and visit them recursively
function sort ( modifier ) {
visited . add ( modifier . name ) ;
var requires = [ ] . concat ( modifier . requires || [ ] , modifier . requiresIfExists || [ ] ) ;
requires . forEach ( function ( dep ) {
if ( ! visited . has ( dep ) ) {
var depModifier = map . get ( dep ) ;
if ( depModifier ) {
sort ( depModifier ) ;
}
2020-05-29 13:41:58 +02:00
}
} ) ;
2021-09-17 13:04:37 +02:00
result . push ( modifier ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
modifiers . forEach ( function ( modifier ) {
if ( ! visited . has ( modifier . name ) ) {
// check for visited object
sort ( modifier ) ;
}
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
return result ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function orderModifiers ( modifiers ) {
// order based on dependencies
var orderedModifiers = order ( modifiers ) ; // order based on phase
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return modifierPhases . reduce ( function ( acc , phase ) {
return acc . concat ( orderedModifiers . filter ( function ( modifier ) {
return modifier . phase === phase ;
} ) ) ;
} , [ ] ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function debounce ( fn ) {
var pending ;
return function ( ) {
if ( ! pending ) {
pending = new Promise ( function ( resolve ) {
Promise . resolve ( ) . then ( function ( ) {
pending = undefined ;
resolve ( fn ( ) ) ;
} ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return pending ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function mergeByName ( modifiers ) {
var merged = modifiers . reduce ( function ( merged , current ) {
var existing = merged [ current . name ] ;
merged [ current . name ] = existing ? Object . assign ( { } , existing , current , {
options : Object . assign ( { } , existing . options , current . options ) ,
data : Object . assign ( { } , existing . data , current . data )
} ) : current ;
return merged ;
} , { } ) ; // IE11 does not support Object.values
return Object . keys ( merged ) . map ( function ( key ) {
return merged [ key ] ;
2020-05-29 13:41:58 +02:00
} ) ;
}
2021-09-17 13:04:37 +02:00
var DEFAULT _OPTIONS = {
placement : 'bottom' ,
modifiers : [ ] ,
strategy : 'absolute'
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function areValidElements ( ) {
for ( var _len = arguments . length , args = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
args [ _key ] = arguments [ _key ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return ! args . some ( function ( element ) {
return ! ( element && typeof element . getBoundingClientRect === 'function' ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
function popperGenerator ( generatorOptions ) {
if ( generatorOptions === void 0 ) {
generatorOptions = { } ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var _generatorOptions = generatorOptions ,
_generatorOptions$def = _generatorOptions . defaultModifiers ,
defaultModifiers = _generatorOptions$def === void 0 ? [ ] : _generatorOptions$def ,
_generatorOptions$def2 = _generatorOptions . defaultOptions ,
defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT _OPTIONS : _generatorOptions$def2 ;
return function createPopper ( reference , popper , options ) {
if ( options === void 0 ) {
options = defaultOptions ;
}
var state = {
placement : 'bottom' ,
orderedModifiers : [ ] ,
options : Object . assign ( { } , DEFAULT _OPTIONS , defaultOptions ) ,
modifiersData : { } ,
elements : {
reference : reference ,
popper : popper
} ,
attributes : { } ,
styles : { }
} ;
var effectCleanupFns = [ ] ;
var isDestroyed = false ;
var instance = {
state : state ,
setOptions : function setOptions ( setOptionsAction ) {
var options = typeof setOptionsAction === 'function' ? setOptionsAction ( state . options ) : setOptionsAction ;
cleanupModifierEffects ( ) ;
state . options = Object . assign ( { } , defaultOptions , state . options , options ) ;
state . scrollParents = {
reference : isElement ( reference ) ? listScrollParents ( reference ) : reference . contextElement ? listScrollParents ( reference . contextElement ) : [ ] ,
popper : listScrollParents ( popper )
} ; // Orders the modifiers based on their dependencies and `phase`
// properties
var orderedModifiers = orderModifiers ( mergeByName ( [ ] . concat ( defaultModifiers , state . options . modifiers ) ) ) ; // Strip out disabled modifiers
state . orderedModifiers = orderedModifiers . filter ( function ( m ) {
return m . enabled ;
} ) ; // Validate the provided modifiers so that the consumer will get warned
runModifierEffects ( ) ;
return instance . update ( ) ;
} ,
// Sync update – it will always be executed, even if not necessary. This
// is useful for low frequency updates where sync behavior simplifies the
// logic.
// For high frequency updates (e.g. `resize` and `scroll` events), always
// prefer the async Popper#update method
forceUpdate : function forceUpdate ( ) {
if ( isDestroyed ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _state$elements = state . elements ,
reference = _state$elements . reference ,
popper = _state$elements . popper ; // Don't proceed if `reference` or `popper` are not valid elements
// anymore
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! areValidElements ( reference , popper ) ) {
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return ;
} // Store the reference and popper rects to be read by modifiers
state . rects = {
reference : getCompositeRect ( reference , getOffsetParent ( popper ) , state . options . strategy === 'fixed' ) ,
popper : getLayoutRect ( popper )
} ; // Modifiers have the ability to reset the current update cycle. The
// most common use case for this is the `flip` modifier changing the
// placement, which then needs to re-run all the modifiers, because the
// logic was previously ran for the previous placement and is therefore
// stale/incorrect
state . reset = false ;
state . placement = state . options . placement ; // On each update cycle, the `modifiersData` property for each modifier
// is filled with the initial data specified by the modifier. This means
// it doesn't persist and is fresh on each update.
// To ensure persistent data, use `${name}#persistent`
state . orderedModifiers . forEach ( function ( modifier ) {
return state . modifiersData [ modifier . name ] = Object . assign ( { } , modifier . data ) ;
} ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( var index = 0 ; index < state . orderedModifiers . length ; index ++ ) {
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( state . reset === true ) {
state . reset = false ;
index = - 1 ;
continue ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
var _state$orderedModifie = state . orderedModifiers [ index ] ,
fn = _state$orderedModifie . fn ,
_state$orderedModifie2 = _state$orderedModifie . options ,
_options = _state$orderedModifie2 === void 0 ? { } : _state$orderedModifie2 ,
name = _state$orderedModifie . name ;
if ( typeof fn === 'function' ) {
state = fn ( {
state : state ,
options : _options ,
name : name ,
instance : instance
} ) || state ;
}
}
} ,
// Async and optimistically optimized update – it will not be executed if
// not necessary (debounced to run at most once-per-tick)
update : debounce ( function ( ) {
return new Promise ( function ( resolve ) {
instance . forceUpdate ( ) ;
resolve ( state ) ;
} ) ;
} ) ,
destroy : function destroy ( ) {
cleanupModifierEffects ( ) ;
isDestroyed = true ;
}
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! areValidElements ( reference , popper ) ) {
return instance ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
instance . setOptions ( options ) . then ( function ( state ) {
if ( ! isDestroyed && options . onFirstUpdate ) {
options . onFirstUpdate ( state ) ;
}
} ) ; // Modifiers have the ability to execute arbitrary code before the first
// update cycle runs. They will be executed in the same order as the update
// cycle. This is useful when a modifier adds some persistent data that
// other modifiers need to use, but the modifier is run after the dependent
// one.
function runModifierEffects ( ) {
state . orderedModifiers . forEach ( function ( _ref3 ) {
var name = _ref3 . name ,
_ref3$options = _ref3 . options ,
options = _ref3$options === void 0 ? { } : _ref3$options ,
effect = _ref3 . effect ;
if ( typeof effect === 'function' ) {
var cleanupFn = effect ( {
state : state ,
name : name ,
instance : instance ,
options : options
} ) ;
var noopFn = function noopFn ( ) { } ;
effectCleanupFns . push ( cleanupFn || noopFn ) ;
}
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
function cleanupModifierEffects ( ) {
effectCleanupFns . forEach ( function ( fn ) {
return fn ( ) ;
} ) ;
effectCleanupFns = [ ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return instance ;
} ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
var createPopper$2 = /*#__PURE__*/ popperGenerator ( ) ; // eslint-disable-next-line import/no-unused-modules
var defaultModifiers$1 = [ eventListeners , popperOffsets$1 , computeStyles$1 , applyStyles$1 ] ;
var createPopper$1 = /*#__PURE__*/ popperGenerator ( {
defaultModifiers : defaultModifiers$1
} ) ; // eslint-disable-next-line import/no-unused-modules
var defaultModifiers = [ eventListeners , popperOffsets$1 , computeStyles$1 , applyStyles$1 , offset$1 , flip$1 , preventOverflow$1 , arrow$1 , hide$1 ] ;
var createPopper = /*#__PURE__*/ popperGenerator ( {
defaultModifiers : defaultModifiers
} ) ; // eslint-disable-next-line import/no-unused-modules
var Popper = /*#__PURE__*/ Object . freeze ( {
_ _proto _ _ : null ,
popperGenerator : popperGenerator ,
detectOverflow : detectOverflow ,
createPopperBase : createPopper$2 ,
createPopper : createPopper ,
createPopperLite : createPopper$1 ,
top : top ,
bottom : bottom ,
right : right ,
left : left ,
auto : auto ,
basePlacements : basePlacements ,
start : start ,
end : end ,
clippingParents : clippingParents ,
viewport : viewport ,
popper : popper ,
reference : reference ,
variationPlacements : variationPlacements ,
placements : placements ,
beforeRead : beforeRead ,
read : read ,
afterRead : afterRead ,
beforeMain : beforeMain ,
main : main ,
afterMain : afterMain ,
beforeWrite : beforeWrite ,
write : write ,
afterWrite : afterWrite ,
modifierPhases : modifierPhases ,
applyStyles : applyStyles$1 ,
arrow : arrow$1 ,
computeStyles : computeStyles$1 ,
eventListeners : eventListeners ,
flip : flip$1 ,
hide : hide$1 ,
offset : offset$1 ,
popperOffsets : popperOffsets$1 ,
preventOverflow : preventOverflow$1
} ) ;
2020-05-29 13:41:58 +02:00
/ * *
2021-09-17 13:04:37 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : dropdown . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2020-05-29 13:41:58 +02:00
* /
/ * *
2021-09-17 13:04:37 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
const NAME$9 = 'dropdown' ;
const DATA _KEY$8 = 'bs.dropdown' ;
const EVENT _KEY$8 = ` . ${ DATA _KEY$8 } ` ;
const DATA _API _KEY$4 = '.data-api' ;
const ESCAPE _KEY$2 = 'Escape' ;
const SPACE _KEY = 'Space' ;
const TAB _KEY$1 = 'Tab' ;
const ARROW _UP _KEY = 'ArrowUp' ;
const ARROW _DOWN _KEY = 'ArrowDown' ;
const RIGHT _MOUSE _BUTTON = 2 ; // MouseEvent.button value for the secondary button, usually the right button
const REGEXP _KEYDOWN = new RegExp ( ` ${ ARROW _UP _KEY } | ${ ARROW _DOWN _KEY } | ${ ESCAPE _KEY$2 } ` ) ;
const EVENT _HIDE$4 = ` hide ${ EVENT _KEY$8 } ` ;
const EVENT _HIDDEN$4 = ` hidden ${ EVENT _KEY$8 } ` ;
const EVENT _SHOW$4 = ` show ${ EVENT _KEY$8 } ` ;
const EVENT _SHOWN$4 = ` shown ${ EVENT _KEY$8 } ` ;
const EVENT _CLICK _DATA _API$3 = ` click ${ EVENT _KEY$8 } ${ DATA _API _KEY$4 } ` ;
const EVENT _KEYDOWN _DATA _API = ` keydown ${ EVENT _KEY$8 } ${ DATA _API _KEY$4 } ` ;
const EVENT _KEYUP _DATA _API = ` keyup ${ EVENT _KEY$8 } ${ DATA _API _KEY$4 } ` ;
const CLASS _NAME _SHOW$6 = 'show' ;
const CLASS _NAME _DROPUP = 'dropup' ;
const CLASS _NAME _DROPEND = 'dropend' ;
const CLASS _NAME _DROPSTART = 'dropstart' ;
const CLASS _NAME _NAVBAR = 'navbar' ;
const SELECTOR _DATA _TOGGLE$3 = '[data-bs-toggle="dropdown"]' ;
const SELECTOR _MENU = '.dropdown-menu' ;
const SELECTOR _NAVBAR _NAV = '.navbar-nav' ;
const SELECTOR _VISIBLE _ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)' ;
const PLACEMENT _TOP = isRTL ( ) ? 'top-end' : 'top-start' ;
const PLACEMENT _TOPEND = isRTL ( ) ? 'top-start' : 'top-end' ;
const PLACEMENT _BOTTOM = isRTL ( ) ? 'bottom-end' : 'bottom-start' ;
const PLACEMENT _BOTTOMEND = isRTL ( ) ? 'bottom-start' : 'bottom-end' ;
const PLACEMENT _RIGHT = isRTL ( ) ? 'left-start' : 'right-start' ;
const PLACEMENT _LEFT = isRTL ( ) ? 'right-start' : 'left-start' ;
const Default$8 = {
offset : [ 0 , 2 ] ,
boundary : 'clippingParents' ,
reference : 'toggle' ,
display : 'dynamic' ,
popperConfig : null ,
autoClose : true
} ;
const DefaultType$8 = {
offset : '(array|string|function)' ,
boundary : '(string|element)' ,
reference : '(string|element|object)' ,
display : 'string' ,
popperConfig : '(null|object|function)' ,
autoClose : '(boolean|string)'
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
class Dropdown extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
this . _popper = null ;
this . _config = this . _getConfig ( config ) ;
this . _menu = this . _getMenuElement ( ) ;
this . _inNavbar = this . _detectNavbar ( ) ;
} // Getters
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$8 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get DefaultType ( ) {
return DefaultType$8 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get NAME ( ) {
return NAME$9 ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
toggle ( ) {
return this . _isShown ( ) ? this . hide ( ) : this . show ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
show ( ) {
if ( isDisabled ( this . _element ) || this . _isShown ( this . _menu ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const relatedTarget = {
relatedTarget : this . _element
} ;
const showEvent = EventHandler . trigger ( this . _element , EVENT _SHOW$4 , relatedTarget ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const parent = Dropdown . getParentFromElement ( this . _element ) ; // Totally disable Popper for Dropdowns in Navbar
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _inNavbar ) {
Manipulator . setDataAttribute ( this . _menu , 'popper' , 'none' ) ;
} else {
this . _createPopper ( parent ) ;
} // If this is a touch-enabled device we add extra
// empty mouseover listeners to the body's immediate children;
// only needed because of broken event delegation on iOS
// https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( 'ontouchstart' in document . documentElement && ! parent . closest ( SELECTOR _NAVBAR _NAV ) ) {
[ ] . concat ( ... document . body . children ) . forEach ( elem => EventHandler . on ( elem , 'mouseover' , noop ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . focus ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'aria-expanded' , true ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _menu . classList . add ( CLASS _NAME _SHOW$6 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _SHOW$6 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _element , EVENT _SHOWN$4 , relatedTarget ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
if ( isDisabled ( this . _element ) || ! this . _isShown ( this . _menu ) ) {
return ;
}
const relatedTarget = {
relatedTarget : this . _element
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _completeHide ( relatedTarget ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
if ( this . _popper ) {
this . _popper . destroy ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
super . dispose ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
update ( ) {
this . _inNavbar = this . _detectNavbar ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _popper ) {
this . _popper . update ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} // Private
_completeHide ( relatedTarget ) {
const hideEvent = EventHandler . trigger ( this . _element , EVENT _HIDE$4 , relatedTarget ) ;
if ( hideEvent . defaultPrevented ) {
return ;
} // If this is a touch-enabled device we remove the extra
// empty mouseover listeners we added for iOS support
if ( 'ontouchstart' in document . documentElement ) {
[ ] . concat ( ... document . body . children ) . forEach ( elem => EventHandler . off ( elem , 'mouseover' , noop ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( this . _popper ) {
this . _popper . destroy ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _menu . classList . remove ( CLASS _NAME _SHOW$6 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _SHOW$6 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'aria-expanded' , 'false' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
Manipulator . removeDataAttribute ( this . _menu , 'popper' ) ;
EventHandler . trigger ( this . _element , EVENT _HIDDEN$4 , relatedTarget ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... this . constructor . Default ,
... Manipulator . getDataAttributes ( this . _element ) ,
... config
} ;
typeCheckConfig ( NAME$9 , config , this . constructor . DefaultType ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config . reference === 'object' && ! isElement$1 ( config . reference ) && typeof config . reference . getBoundingClientRect !== 'function' ) {
// Popper virtual elements require a getBoundingClientRect method
throw new TypeError ( ` ${ NAME$9 . toUpperCase ( ) } : Option "reference" provided type "object" without a required "getBoundingClientRect" method. ` ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return config ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_createPopper ( parent ) {
if ( typeof Popper === 'undefined' ) {
throw new TypeError ( 'Bootstrap\'s dropdowns require Popper (https://popper.js.org)' ) ;
}
let referenceElement = this . _element ;
if ( this . _config . reference === 'parent' ) {
referenceElement = parent ;
} else if ( isElement$1 ( this . _config . reference ) ) {
referenceElement = getElement ( this . _config . reference ) ;
} else if ( typeof this . _config . reference === 'object' ) {
referenceElement = this . _config . reference ;
}
const popperConfig = this . _getPopperConfig ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isDisplayStatic = popperConfig . modifiers . find ( modifier => modifier . name === 'applyStyles' && modifier . enabled === false ) ;
this . _popper = createPopper ( referenceElement , this . _menu , popperConfig ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isDisplayStatic ) {
Manipulator . setDataAttribute ( this . _menu , 'popper' , 'static' ) ;
}
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_isShown ( element = this . _element ) {
return element . classList . contains ( CLASS _NAME _SHOW$6 ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getMenuElement ( ) {
return SelectorEngine . next ( this . _element , SELECTOR _MENU ) [ 0 ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getPlacement ( ) {
const parentDropdown = this . _element . parentNode ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( parentDropdown . classList . contains ( CLASS _NAME _DROPEND ) ) {
return PLACEMENT _RIGHT ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( parentDropdown . classList . contains ( CLASS _NAME _DROPSTART ) ) {
return PLACEMENT _LEFT ;
} // We need to trim the value because custom properties can also include spaces
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isEnd = getComputedStyle ( this . _menu ) . getPropertyValue ( '--bs-position' ) . trim ( ) === 'end' ;
if ( parentDropdown . classList . contains ( CLASS _NAME _DROPUP ) ) {
return isEnd ? PLACEMENT _TOPEND : PLACEMENT _TOP ;
}
return isEnd ? PLACEMENT _BOTTOMEND : PLACEMENT _BOTTOM ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_detectNavbar ( ) {
return this . _element . closest ( ` . ${ CLASS _NAME _NAVBAR } ` ) !== null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getOffset ( ) {
const {
offset
} = this . _config ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof offset === 'string' ) {
return offset . split ( ',' ) . map ( val => Number . parseInt ( val , 10 ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( typeof offset === 'function' ) {
return popperData => offset ( popperData , this . _element ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return offset ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getPopperConfig ( ) {
const defaultBsPopperConfig = {
placement : this . _getPlacement ( ) ,
modifiers : [ {
name : 'preventOverflow' ,
options : {
boundary : this . _config . boundary
}
} , {
name : 'offset' ,
options : {
offset : this . _getOffset ( )
}
} ]
} ; // Disable Popper if we have a static display
if ( this . _config . display === 'static' ) {
defaultBsPopperConfig . modifiers = [ {
name : 'applyStyles' ,
enabled : false
} ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return { ... defaultBsPopperConfig ,
... ( typeof this . _config . popperConfig === 'function' ? this . _config . popperConfig ( defaultBsPopperConfig ) : this . _config . popperConfig )
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_selectMenuItem ( {
key ,
target
} ) {
const items = SelectorEngine . find ( SELECTOR _VISIBLE _ITEMS , this . _menu ) . filter ( isVisible ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! items . length ) {
2020-05-29 13:41:58 +02:00
return ;
2021-09-17 13:04:37 +02:00
} // if target isn't included in items (e.g. when expanding the dropdown)
// allow cycling to get the last item in case key equals ARROW_UP_KEY
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
getNextActiveElement ( items , target , key === ARROW _DOWN _KEY , ! items . includes ( target ) ) . focus ( ) ;
} // Static
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Dropdown . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config !== 'string' ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof data [ config ] === 'undefined' ) {
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
data [ config ] ( ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static clearMenus ( event ) {
if ( event && ( event . button === RIGHT _MOUSE _BUTTON || event . type === 'keyup' && event . key !== TAB _KEY$1 ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const toggles = SelectorEngine . find ( SELECTOR _DATA _TOGGLE$3 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( let i = 0 , len = toggles . length ; i < len ; i ++ ) {
const context = Dropdown . getInstance ( toggles [ i ] ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! context || context . _config . autoClose === false ) {
continue ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( ! context . _isShown ( ) ) {
continue ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const relatedTarget = {
relatedTarget : context . _element
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( event ) {
const composedPath = event . composedPath ( ) ;
const isMenuTarget = composedPath . includes ( context . _menu ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( composedPath . includes ( context . _element ) || context . _config . autoClose === 'inside' && ! isMenuTarget || context . _config . autoClose === 'outside' && isMenuTarget ) {
continue ;
} // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( context . _menu . contains ( event . target ) && ( event . type === 'keyup' && event . key === TAB _KEY$1 || /input|select|option|textarea|form/i . test ( event . target . tagName ) ) ) {
continue ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( event . type === 'click' ) {
relatedTarget . clickEvent = event ;
}
}
context . _completeHide ( relatedTarget ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static getParentFromElement ( element ) {
return getElementFromSelector ( element ) || element . parentNode ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static dataApiKeydownHandler ( event ) {
// If not input/textarea:
// - And not a key in REGEXP_KEYDOWN => not a dropdown command
// If input/textarea:
// - If space key => not a dropdown command
// - If key is other than escape
// - If key is not up or down => not a dropdown command
// - If trigger inside the menu => not a dropdown command
if ( /input|textarea/i . test ( event . target . tagName ) ? event . key === SPACE _KEY || event . key !== ESCAPE _KEY$2 && ( event . key !== ARROW _DOWN _KEY && event . key !== ARROW _UP _KEY || event . target . closest ( SELECTOR _MENU ) ) : ! REGEXP _KEYDOWN . test ( event . key ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const isActive = this . classList . contains ( CLASS _NAME _SHOW$6 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isActive && event . key === ESCAPE _KEY$2 ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
event . preventDefault ( ) ;
event . stopPropagation ( ) ;
if ( isDisabled ( this ) ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const getToggleButton = this . matches ( SELECTOR _DATA _TOGGLE$3 ) ? this : SelectorEngine . prev ( this , SELECTOR _DATA _TOGGLE$3 ) [ 0 ] ;
const instance = Dropdown . getOrCreateInstance ( getToggleButton ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( event . key === ESCAPE _KEY$2 ) {
instance . hide ( ) ;
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( event . key === ARROW _UP _KEY || event . key === ARROW _DOWN _KEY ) {
if ( ! isActive ) {
instance . show ( ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
instance . _selectMenuItem ( event ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isActive || event . key === SPACE _KEY ) {
Dropdown . clearMenus ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _KEYDOWN _DATA _API , SELECTOR _DATA _TOGGLE$3 , Dropdown . dataApiKeydownHandler ) ;
EventHandler . on ( document , EVENT _KEYDOWN _DATA _API , SELECTOR _MENU , Dropdown . dataApiKeydownHandler ) ;
EventHandler . on ( document , EVENT _CLICK _DATA _API$3 , Dropdown . clearMenus ) ;
EventHandler . on ( document , EVENT _KEYUP _DATA _API , Dropdown . clearMenus ) ;
EventHandler . on ( document , EVENT _CLICK _DATA _API$3 , SELECTOR _DATA _TOGGLE$3 , function ( event ) {
event . preventDefault ( ) ;
Dropdown . getOrCreateInstance ( this ) . toggle ( ) ;
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* add . Dropdown to jQuery only if jQuery is present
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Dropdown ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : util / scrollBar . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const SELECTOR _FIXED _CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top' ;
const SELECTOR _STICKY _CONTENT = '.sticky-top' ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
class ScrollBarHelper {
constructor ( ) {
this . _element = document . body ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
getWidth ( ) {
// https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
const documentWidth = document . documentElement . clientWidth ;
return Math . abs ( window . innerWidth - documentWidth ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
const width = this . getWidth ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _disableOverFlow ( ) ; // give padding to element to balance the hidden scrollbar width
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _setElementAttributes ( this . _element , 'paddingRight' , calculatedValue => calculatedValue + width ) ; // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _setElementAttributes ( SELECTOR _FIXED _CONTENT , 'paddingRight' , calculatedValue => calculatedValue + width ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _setElementAttributes ( SELECTOR _STICKY _CONTENT , 'marginRight' , calculatedValue => calculatedValue - width ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_disableOverFlow ( ) {
this . _saveInitialAttribute ( this . _element , 'overflow' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . style . overflow = 'hidden' ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_setElementAttributes ( selector , styleProp , callback ) {
const scrollbarWidth = this . getWidth ( ) ;
const manipulationCallBack = element => {
if ( element !== this . _element && window . innerWidth > element . clientWidth + scrollbarWidth ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _saveInitialAttribute ( element , styleProp ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const calculatedValue = window . getComputedStyle ( element ) [ styleProp ] ;
element . style [ styleProp ] = ` ${ callback ( Number . parseFloat ( calculatedValue ) ) } px ` ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _applyManipulationCallback ( selector , manipulationCallBack ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
reset ( ) {
this . _resetElementAttributes ( this . _element , 'overflow' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _resetElementAttributes ( this . _element , 'paddingRight' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _resetElementAttributes ( SELECTOR _FIXED _CONTENT , 'paddingRight' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _resetElementAttributes ( SELECTOR _STICKY _CONTENT , 'marginRight' ) ;
}
_saveInitialAttribute ( element , styleProp ) {
const actualValue = element . style [ styleProp ] ;
if ( actualValue ) {
Manipulator . setDataAttribute ( element , styleProp , actualValue ) ;
}
}
_resetElementAttributes ( selector , styleProp ) {
const manipulationCallBack = element => {
const value = Manipulator . getDataAttribute ( element , styleProp ) ;
if ( typeof value === 'undefined' ) {
element . style . removeProperty ( styleProp ) ;
} else {
Manipulator . removeDataAttribute ( element , styleProp ) ;
element . style [ styleProp ] = value ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _applyManipulationCallback ( selector , manipulationCallBack ) ;
}
_applyManipulationCallback ( selector , callBack ) {
if ( isElement$1 ( selector ) ) {
callBack ( selector ) ;
} else {
SelectorEngine . find ( selector , this . _element ) . forEach ( callBack ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
isOverflowing ( ) {
return this . getWidth ( ) > 0 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : util / backdrop . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/master/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const Default$7 = {
className : 'modal-backdrop' ,
isVisible : true ,
// if false, we use the backdrop helper without adding any element to the dom
isAnimated : false ,
rootElement : 'body' ,
// give the choice to place backdrop under different elements
clickCallback : null
} ;
const DefaultType$7 = {
className : 'string' ,
isVisible : 'boolean' ,
isAnimated : 'boolean' ,
rootElement : '(element|string)' ,
clickCallback : '(function|null)'
} ;
const NAME$8 = 'backdrop' ;
const CLASS _NAME _FADE$4 = 'fade' ;
const CLASS _NAME _SHOW$5 = 'show' ;
const EVENT _MOUSEDOWN = ` mousedown.bs. ${ NAME$8 } ` ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
class Backdrop {
constructor ( config ) {
this . _config = this . _getConfig ( config ) ;
this . _isAppended = false ;
this . _element = null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
show ( callback ) {
if ( ! this . _config . isVisible ) {
execute ( callback ) ;
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _append ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _config . isAnimated ) {
reflow ( this . _getElement ( ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _getElement ( ) . classList . add ( CLASS _NAME _SHOW$5 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _emulateAnimation ( ( ) => {
execute ( callback ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( callback ) {
if ( ! this . _config . isVisible ) {
execute ( callback ) ;
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _getElement ( ) . classList . remove ( CLASS _NAME _SHOW$5 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _emulateAnimation ( ( ) => {
this . dispose ( ) ;
execute ( callback ) ;
} ) ;
} // Private
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getElement ( ) {
if ( ! this . _element ) {
const backdrop = document . createElement ( 'div' ) ;
backdrop . className = this . _config . className ;
if ( this . _config . isAnimated ) {
backdrop . classList . add ( CLASS _NAME _FADE$4 ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _element = backdrop ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return this . _element ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default$7 ,
... ( typeof config === 'object' ? config : { } )
} ; // use getElement() with the default "body" to get a fresh Element on each instantiation
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
config . rootElement = getElement ( config . rootElement ) ;
typeCheckConfig ( NAME$8 , config , DefaultType$7 ) ;
return config ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_append ( ) {
if ( this . _isAppended ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
this . _config . rootElement . append ( this . _getElement ( ) ) ;
EventHandler . on ( this . _getElement ( ) , EVENT _MOUSEDOWN , ( ) => {
execute ( this . _config . clickCallback ) ;
} ) ;
this . _isAppended = true ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
if ( ! this . _isAppended ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
EventHandler . off ( this . _element , EVENT _MOUSEDOWN ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . remove ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _isAppended = false ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_emulateAnimation ( callback ) {
executeAfterTransition ( callback , this . _getElement ( ) , this . _config . isAnimated ) ;
}
}
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : util / focustrap . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/master/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const Default$6 = {
trapElement : null ,
// The element to trap focus inside of
autofocus : true
} ;
const DefaultType$6 = {
trapElement : 'element' ,
autofocus : 'boolean'
} ;
const NAME$7 = 'focustrap' ;
const DATA _KEY$7 = 'bs.focustrap' ;
const EVENT _KEY$7 = ` . ${ DATA _KEY$7 } ` ;
const EVENT _FOCUSIN$1 = ` focusin ${ EVENT _KEY$7 } ` ;
const EVENT _KEYDOWN _TAB = ` keydown.tab ${ EVENT _KEY$7 } ` ;
const TAB _KEY = 'Tab' ;
const TAB _NAV _FORWARD = 'forward' ;
const TAB _NAV _BACKWARD = 'backward' ;
class FocusTrap {
constructor ( config ) {
this . _config = this . _getConfig ( config ) ;
this . _isActive = false ;
this . _lastTabNavDirection = null ;
}
activate ( ) {
const {
trapElement ,
autofocus
} = this . _config ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _isActive ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
if ( autofocus ) {
trapElement . focus ( ) ;
}
EventHandler . off ( document , EVENT _KEY$7 ) ; // guard against infinite focus loop
EventHandler . on ( document , EVENT _FOCUSIN$1 , event => this . _handleFocusin ( event ) ) ;
EventHandler . on ( document , EVENT _KEYDOWN _TAB , event => this . _handleKeydown ( event ) ) ;
this . _isActive = true ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
deactivate ( ) {
if ( ! this . _isActive ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
this . _isActive = false ;
EventHandler . off ( document , EVENT _KEY$7 ) ;
} // Private
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_handleFocusin ( event ) {
const {
target
} = event ;
const {
trapElement
} = this . _config ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( target === document || target === trapElement || trapElement . contains ( target ) ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const elements = SelectorEngine . focusableChildren ( trapElement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( elements . length === 0 ) {
trapElement . focus ( ) ;
} else if ( this . _lastTabNavDirection === TAB _NAV _BACKWARD ) {
elements [ elements . length - 1 ] . focus ( ) ;
} else {
elements [ 0 ] . focus ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
_handleKeydown ( event ) {
if ( event . key !== TAB _KEY ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _lastTabNavDirection = event . shiftKey ? TAB _NAV _BACKWARD : TAB _NAV _FORWARD ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default$6 ,
... ( typeof config === 'object' ? config : { } )
} ;
typeCheckConfig ( NAME$7 , config , DefaultType$6 ) ;
return config ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
2021-09-17 13:04:37 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : modal . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$6 = 'modal' ;
const DATA _KEY$6 = 'bs.modal' ;
const EVENT _KEY$6 = ` . ${ DATA _KEY$6 } ` ;
const DATA _API _KEY$3 = '.data-api' ;
const ESCAPE _KEY$1 = 'Escape' ;
const Default$5 = {
2020-05-29 13:41:58 +02:00
backdrop : true ,
keyboard : true ,
2021-09-17 13:04:37 +02:00
focus : true
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const DefaultType$5 = {
2020-05-29 13:41:58 +02:00
backdrop : '(boolean|string)' ,
keyboard : 'boolean' ,
2021-09-17 13:04:37 +02:00
focus : 'boolean'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const EVENT _HIDE$3 = ` hide ${ EVENT _KEY$6 } ` ;
const EVENT _HIDE _PREVENTED = ` hidePrevented ${ EVENT _KEY$6 } ` ;
const EVENT _HIDDEN$3 = ` hidden ${ EVENT _KEY$6 } ` ;
const EVENT _SHOW$3 = ` show ${ EVENT _KEY$6 } ` ;
const EVENT _SHOWN$3 = ` shown ${ EVENT _KEY$6 } ` ;
const EVENT _RESIZE = ` resize ${ EVENT _KEY$6 } ` ;
const EVENT _CLICK _DISMISS = ` click.dismiss ${ EVENT _KEY$6 } ` ;
const EVENT _KEYDOWN _DISMISS$1 = ` keydown.dismiss ${ EVENT _KEY$6 } ` ;
const EVENT _MOUSEUP _DISMISS = ` mouseup.dismiss ${ EVENT _KEY$6 } ` ;
const EVENT _MOUSEDOWN _DISMISS = ` mousedown.dismiss ${ EVENT _KEY$6 } ` ;
const EVENT _CLICK _DATA _API$2 = ` click ${ EVENT _KEY$6 } ${ DATA _API _KEY$3 } ` ;
const CLASS _NAME _OPEN = 'modal-open' ;
const CLASS _NAME _FADE$3 = 'fade' ;
const CLASS _NAME _SHOW$4 = 'show' ;
const CLASS _NAME _STATIC = 'modal-static' ;
const OPEN _SELECTOR$1 = '.modal.show' ;
const SELECTOR _DIALOG = '.modal-dialog' ;
const SELECTOR _MODAL _BODY = '.modal-body' ;
const SELECTOR _DATA _TOGGLE$2 = '[data-bs-toggle="modal"]' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Modal extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
2020-05-29 13:41:58 +02:00
this . _config = this . _getConfig ( config ) ;
2021-09-17 13:04:37 +02:00
this . _dialog = SelectorEngine . findOne ( SELECTOR _DIALOG , this . _element ) ;
this . _backdrop = this . _initializeBackDrop ( ) ;
this . _focustrap = this . _initializeFocusTrap ( ) ;
2020-05-29 13:41:58 +02:00
this . _isShown = false ;
this . _ignoreBackdropClick = false ;
this . _isTransitioning = false ;
2021-09-17 13:04:37 +02:00
this . _scrollBar = new ScrollBarHelper ( ) ;
2020-05-29 13:41:58 +02:00
} // Getters
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$5 ;
}
static get NAME ( ) {
return NAME$6 ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
toggle ( relatedTarget ) {
return this . _isShown ? this . hide ( ) : this . show ( relatedTarget ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
show ( relatedTarget ) {
2020-05-29 13:41:58 +02:00
if ( this . _isShown || this . _isTransitioning ) {
return ;
}
2021-09-17 13:04:37 +02:00
const showEvent = EventHandler . trigger ( this . _element , EVENT _SHOW$3 , {
relatedTarget
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
this . _isShown = true ;
2021-09-17 13:04:37 +02:00
if ( this . _isAnimated ( ) ) {
this . _isTransitioning = true ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _scrollBar . hide ( ) ;
document . body . classList . add ( CLASS _NAME _OPEN ) ;
2020-05-29 13:41:58 +02:00
this . _adjustDialog ( ) ;
this . _setEscapeEvent ( ) ;
this . _setResizeEvent ( ) ;
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _dialog , EVENT _MOUSEDOWN _DISMISS , ( ) => {
EventHandler . one ( this . _element , EVENT _MOUSEUP _DISMISS , event => {
if ( event . target === this . _element ) {
this . _ignoreBackdropClick = true ;
2020-05-29 13:41:58 +02:00
}
} ) ;
} ) ;
2021-09-17 13:04:37 +02:00
this . _showBackdrop ( ( ) => this . _showElement ( relatedTarget ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
2020-05-29 13:41:58 +02:00
if ( ! this . _isShown || this . _isTransitioning ) {
return ;
}
2021-09-17 13:04:37 +02:00
const hideEvent = EventHandler . trigger ( this . _element , EVENT _HIDE$3 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( hideEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
this . _isShown = false ;
2021-09-17 13:04:37 +02:00
const isAnimated = this . _isAnimated ( ) ;
if ( isAnimated ) {
2020-05-29 13:41:58 +02:00
this . _isTransitioning = true ;
}
this . _setEscapeEvent ( ) ;
this . _setResizeEvent ( ) ;
2021-09-17 13:04:37 +02:00
this . _focustrap . deactivate ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _SHOW$4 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . off ( this . _element , EVENT _CLICK _DISMISS ) ;
EventHandler . off ( this . _dialog , EVENT _MOUSEDOWN _DISMISS ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( ( ) => this . _hideModal ( ) , this . _element , isAnimated ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
[ window , this . _dialog ] . forEach ( htmlElement => EventHandler . off ( htmlElement , EVENT _KEY$6 ) ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _backdrop . dispose ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _focustrap . deactivate ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
super . dispose ( ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
handleUpdate ( ) {
this . _adjustDialog ( ) ;
} // Private
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_initializeBackDrop ( ) {
return new Backdrop ( {
isVisible : Boolean ( this . _config . backdrop ) ,
// 'static' option will be translated to true, and booleans will keep their value
isAnimated : this . _isAnimated ( )
} ) ;
}
_initializeFocusTrap ( ) {
return new FocusTrap ( {
trapElement : this . _element
} ) ;
}
_getConfig ( config ) {
config = { ... Default$5 ,
... Manipulator . getDataAttributes ( this . _element ) ,
... ( typeof config === 'object' ? config : { } )
} ;
typeCheckConfig ( NAME$6 , config , DefaultType$5 ) ;
return config ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_showElement ( relatedTarget ) {
const isAnimated = this . _isAnimated ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const modalBody = SelectorEngine . findOne ( SELECTOR _MODAL _BODY , this . _dialog ) ;
2020-05-29 13:41:58 +02:00
if ( ! this . _element . parentNode || this . _element . parentNode . nodeType !== Node . ELEMENT _NODE ) {
// Don't move modal's DOM position
2021-09-17 13:04:37 +02:00
document . body . append ( this . _element ) ;
2020-05-29 13:41:58 +02:00
}
this . _element . style . display = 'block' ;
this . _element . removeAttribute ( 'aria-hidden' ) ;
this . _element . setAttribute ( 'aria-modal' , true ) ;
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'role' , 'dialog' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . scrollTop = 0 ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( modalBody ) {
modalBody . scrollTop = 0 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isAnimated ) {
reflow ( this . _element ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _SHOW$4 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const transitionComplete = ( ) => {
if ( this . _config . focus ) {
this . _focustrap . activate ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _isTransitioning = false ;
EventHandler . trigger ( this . _element , EVENT _SHOWN$3 , {
relatedTarget
} ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
this . _queueCallback ( transitionComplete , this . _dialog , isAnimated ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_setEscapeEvent ( ) {
if ( this . _isShown ) {
EventHandler . on ( this . _element , EVENT _KEYDOWN _DISMISS$1 , event => {
if ( this . _config . keyboard && event . key === ESCAPE _KEY$1 ) {
event . preventDefault ( ) ;
this . hide ( ) ;
} else if ( ! this . _config . keyboard && event . key === ESCAPE _KEY$1 ) {
this . _triggerBackdropTransition ( ) ;
2020-05-29 13:41:58 +02:00
}
} ) ;
2021-09-17 13:04:37 +02:00
} else {
EventHandler . off ( this . _element , EVENT _KEYDOWN _DISMISS$1 ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_setResizeEvent ( ) {
2020-05-29 13:41:58 +02:00
if ( this . _isShown ) {
2021-09-17 13:04:37 +02:00
EventHandler . on ( window , EVENT _RESIZE , ( ) => this . _adjustDialog ( ) ) ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
EventHandler . off ( window , EVENT _RESIZE ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_hideModal ( ) {
2020-05-29 13:41:58 +02:00
this . _element . style . display = 'none' ;
this . _element . setAttribute ( 'aria-hidden' , true ) ;
this . _element . removeAttribute ( 'aria-modal' ) ;
2021-09-17 13:04:37 +02:00
this . _element . removeAttribute ( 'role' ) ;
2020-05-29 13:41:58 +02:00
this . _isTransitioning = false ;
2021-09-17 13:04:37 +02:00
this . _backdrop . hide ( ( ) => {
document . body . classList . remove ( CLASS _NAME _OPEN ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _resetAdjustments ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _scrollBar . reset ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _element , EVENT _HIDDEN$3 ) ;
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
}
_showBackdrop ( callback ) {
EventHandler . on ( this . _element , EVENT _CLICK _DISMISS , event => {
if ( this . _ignoreBackdropClick ) {
this . _ignoreBackdropClick = false ;
return ;
}
if ( event . target !== event . currentTarget ) {
return ;
}
if ( this . _config . backdrop === true ) {
this . hide ( ) ;
} else if ( this . _config . backdrop === 'static' ) {
this . _triggerBackdropTransition ( ) ;
}
} ) ;
this . _backdrop . show ( callback ) ;
}
_isAnimated ( ) {
return this . _element . classList . contains ( CLASS _NAME _FADE$3 ) ;
}
_triggerBackdropTransition ( ) {
const hideEvent = EventHandler . trigger ( this . _element , EVENT _HIDE _PREVENTED ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( hideEvent . defaultPrevented ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const {
classList ,
scrollHeight ,
style
} = this . _element ;
const isModalOverflowing = scrollHeight > document . documentElement . clientHeight ; // return if the following background transition hasn't yet completed
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! isModalOverflowing && style . overflowY === 'hidden' || classList . contains ( CLASS _NAME _STATIC ) ) {
return ;
}
if ( ! isModalOverflowing ) {
style . overflowY = 'hidden' ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
classList . add ( CLASS _NAME _STATIC ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( ( ) => {
classList . remove ( CLASS _NAME _STATIC ) ;
if ( ! isModalOverflowing ) {
this . _queueCallback ( ( ) => {
style . overflowY = '' ;
} , this . _dialog ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} , this . _dialog ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . focus ( ) ;
} // ----------------------------------------------------------------------
// the following methods are used to handle overflowing modals
// ----------------------------------------------------------------------
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_adjustDialog ( ) {
const isModalOverflowing = this . _element . scrollHeight > document . documentElement . clientHeight ;
const scrollbarWidth = this . _scrollBar . getWidth ( ) ;
const isBodyOverflowing = scrollbarWidth > 0 ;
if ( ! isBodyOverflowing && isModalOverflowing && ! isRTL ( ) || isBodyOverflowing && ! isModalOverflowing && isRTL ( ) ) {
this . _element . style . paddingLeft = ` ${ scrollbarWidth } px ` ;
}
if ( isBodyOverflowing && ! isModalOverflowing && ! isRTL ( ) || ! isBodyOverflowing && isModalOverflowing && isRTL ( ) ) {
this . _element . style . paddingRight = ` ${ scrollbarWidth } px ` ;
}
}
_resetAdjustments ( ) {
this . _element . style . paddingLeft = '' ;
this . _element . style . paddingRight = '' ;
} // Static
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config , relatedTarget ) {
return this . each ( function ( ) {
const data = Modal . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config !== 'string' ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
if ( typeof data [ config ] === 'undefined' ) {
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
data [ config ] ( relatedTarget ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _CLICK _DATA _API$2 , SELECTOR _DATA _TOGGLE$2 , function ( event ) {
const target = getElementFromSelector ( this ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( [ 'A' , 'AREA' ] . includes ( this . tagName ) ) {
event . preventDefault ( ) ;
}
EventHandler . one ( target , EVENT _SHOW$3 , showEvent => {
if ( showEvent . defaultPrevented ) {
// only register focus restorer if modal will actually get shown
return ;
}
EventHandler . one ( target , EVENT _HIDDEN$3 , ( ) => {
if ( isVisible ( this ) ) {
this . focus ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ) ;
} ) ; // avoid conflict when clicking moddal toggler while another one is open
const allReadyOpen = SelectorEngine . findOne ( OPEN _SELECTOR$1 ) ;
if ( allReadyOpen ) {
Modal . getInstance ( allReadyOpen ) . hide ( ) ;
}
const data = Modal . getOrCreateInstance ( target ) ;
data . toggle ( this ) ;
} ) ;
enableDismissTrigger ( Modal ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* add . Modal to jQuery only if jQuery is present
* /
defineJQueryPlugin ( Modal ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : offcanvas . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/master/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
const NAME$5 = 'offcanvas' ;
const DATA _KEY$5 = 'bs.offcanvas' ;
const EVENT _KEY$5 = ` . ${ DATA _KEY$5 } ` ;
const DATA _API _KEY$2 = '.data-api' ;
const EVENT _LOAD _DATA _API$1 = ` load ${ EVENT _KEY$5 } ${ DATA _API _KEY$2 } ` ;
const ESCAPE _KEY = 'Escape' ;
const Default$4 = {
backdrop : true ,
keyboard : true ,
scroll : false
} ;
const DefaultType$4 = {
backdrop : 'boolean' ,
keyboard : 'boolean' ,
scroll : 'boolean'
} ;
const CLASS _NAME _SHOW$3 = 'show' ;
const CLASS _NAME _BACKDROP = 'offcanvas-backdrop' ;
const OPEN _SELECTOR = '.offcanvas.show' ;
const EVENT _SHOW$2 = ` show ${ EVENT _KEY$5 } ` ;
const EVENT _SHOWN$2 = ` shown ${ EVENT _KEY$5 } ` ;
const EVENT _HIDE$2 = ` hide ${ EVENT _KEY$5 } ` ;
const EVENT _HIDDEN$2 = ` hidden ${ EVENT _KEY$5 } ` ;
const EVENT _CLICK _DATA _API$1 = ` click ${ EVENT _KEY$5 } ${ DATA _API _KEY$2 } ` ;
const EVENT _KEYDOWN _DISMISS = ` keydown.dismiss ${ EVENT _KEY$5 } ` ;
const SELECTOR _DATA _TOGGLE$1 = '[data-bs-toggle="offcanvas"]' ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
class Offcanvas extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
this . _config = this . _getConfig ( config ) ;
this . _isShown = false ;
this . _backdrop = this . _initializeBackDrop ( ) ;
this . _focustrap = this . _initializeFocusTrap ( ) ;
this . _addEventListeners ( ) ;
} // Getters
static get NAME ( ) {
return NAME$5 ;
}
static get Default ( ) {
return Default$4 ;
} // Public
toggle ( relatedTarget ) {
return this . _isShown ? this . hide ( ) : this . show ( relatedTarget ) ;
}
show ( relatedTarget ) {
if ( this . _isShown ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const showEvent = EventHandler . trigger ( this . _element , EVENT _SHOW$2 , {
relatedTarget
} ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _isShown = true ;
this . _element . style . visibility = 'visible' ;
this . _backdrop . show ( ) ;
if ( ! this . _config . scroll ) {
new ScrollBarHelper ( ) . hide ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _element . removeAttribute ( 'aria-hidden' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'aria-modal' , true ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'role' , 'dialog' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _SHOW$3 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const completeCallBack = ( ) => {
if ( ! this . _config . scroll ) {
this . _focustrap . activate ( ) ;
}
EventHandler . trigger ( this . _element , EVENT _SHOWN$2 , {
relatedTarget
} ) ;
} ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( completeCallBack , this . _element , true ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
if ( ! this . _isShown ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const hideEvent = EventHandler . trigger ( this . _element , EVENT _HIDE$2 ) ;
if ( hideEvent . defaultPrevented ) {
return ;
}
this . _focustrap . deactivate ( ) ;
this . _element . blur ( ) ;
this . _isShown = false ;
this . _element . classList . remove ( CLASS _NAME _SHOW$3 ) ;
this . _backdrop . hide ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const completeCallback = ( ) => {
this . _element . setAttribute ( 'aria-hidden' , true ) ;
this . _element . removeAttribute ( 'aria-modal' ) ;
this . _element . removeAttribute ( 'role' ) ;
this . _element . style . visibility = 'hidden' ;
if ( ! this . _config . scroll ) {
new ScrollBarHelper ( ) . reset ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _element , EVENT _HIDDEN$2 ) ;
} ;
this . _queueCallback ( completeCallback , this . _element , true ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
this . _backdrop . dispose ( ) ;
this . _focustrap . deactivate ( ) ;
super . dispose ( ) ;
} // Private
_getConfig ( config ) {
config = { ... Default$4 ,
... Manipulator . getDataAttributes ( this . _element ) ,
... ( typeof config === 'object' ? config : { } )
} ;
typeCheckConfig ( NAME$5 , config , DefaultType$4 ) ;
return config ;
}
_initializeBackDrop ( ) {
return new Backdrop ( {
className : CLASS _NAME _BACKDROP ,
isVisible : this . _config . backdrop ,
isAnimated : true ,
rootElement : this . _element . parentNode ,
clickCallback : ( ) => this . hide ( )
} ) ;
}
_initializeFocusTrap ( ) {
return new FocusTrap ( {
trapElement : this . _element
} ) ;
}
_addEventListeners ( ) {
EventHandler . on ( this . _element , EVENT _KEYDOWN _DISMISS , event => {
if ( this . _config . keyboard && event . key === ESCAPE _KEY ) {
this . hide ( ) ;
}
} ) ;
2020-05-29 13:41:58 +02:00
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Offcanvas . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config !== 'string' ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( data [ config ] === undefined || config . startsWith ( '_' ) || config === 'constructor' ) {
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
data [ config ] ( this ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _CLICK _DATA _API$1 , SELECTOR _DATA _TOGGLE$1 , function ( event ) {
const target = getElementFromSelector ( this ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( [ 'A' , 'AREA' ] . includes ( this . tagName ) ) {
event . preventDefault ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( isDisabled ( this ) ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
EventHandler . one ( target , EVENT _HIDDEN$2 , ( ) => {
// focus on trigger when it is closed
if ( isVisible ( this ) ) {
this . focus ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ) ; // avoid conflict when clicking a toggler of an offcanvas, while another is open
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const allReadyOpen = SelectorEngine . findOne ( OPEN _SELECTOR ) ;
if ( allReadyOpen && allReadyOpen !== target ) {
Offcanvas . getInstance ( allReadyOpen ) . hide ( ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const data = Offcanvas . getOrCreateInstance ( target ) ;
data . toggle ( this ) ;
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
EventHandler . on ( window , EVENT _LOAD _DATA _API$1 , ( ) => SelectorEngine . find ( OPEN _SELECTOR ) . forEach ( el => Offcanvas . getOrCreateInstance ( el ) . show ( ) ) ) ;
enableDismissTrigger ( Offcanvas ) ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Offcanvas ) ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* Bootstrap ( v5 . 1.1 ) : util / sanitizer . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
2020-05-29 13:41:58 +02:00
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const uriAttrs = new Set ( [ 'background' , 'cite' , 'href' , 'itemtype' , 'longdesc' , 'poster' , 'src' , 'xlink:href' ] ) ;
const ARIA _ATTRIBUTE _PATTERN = /^aria-[\w-]*$/i ;
/ * *
* A pattern that recognizes a commonly useful subset of URLs that are safe .
*
* Shoutout to Angular 7 https : //github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
* /
const SAFE _URL _PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/i ;
/ * *
* A pattern that matches safe data URLs . Only matches image , video and audio types .
*
* Shoutout to Angular 7 https : //github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
* /
const DATA _URL _PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i ;
const allowedAttribute = ( attr , allowedAttributeList ) => {
const attrName = attr . nodeName . toLowerCase ( ) ;
if ( allowedAttributeList . includes ( attrName ) ) {
if ( uriAttrs . has ( attrName ) ) {
return Boolean ( SAFE _URL _PATTERN . test ( attr . nodeValue ) || DATA _URL _PATTERN . test ( attr . nodeValue ) ) ;
}
return true ;
}
const regExp = allowedAttributeList . filter ( attrRegex => attrRegex instanceof RegExp ) ; // Check if a regular expression validates the attribute.
for ( let i = 0 , len = regExp . length ; i < len ; i ++ ) {
if ( regExp [ i ] . test ( attrName ) ) {
return true ;
}
}
return false ;
} ;
const DefaultAllowlist = {
2020-05-29 13:41:58 +02:00
// Global attributes allowed on any supplied element below.
'*' : [ 'class' , 'dir' , 'id' , 'lang' , 'role' , ARIA _ATTRIBUTE _PATTERN ] ,
a : [ 'target' , 'href' , 'title' , 'rel' ] ,
area : [ ] ,
b : [ ] ,
br : [ ] ,
col : [ ] ,
code : [ ] ,
div : [ ] ,
em : [ ] ,
hr : [ ] ,
h1 : [ ] ,
h2 : [ ] ,
h3 : [ ] ,
h4 : [ ] ,
h5 : [ ] ,
h6 : [ ] ,
i : [ ] ,
2021-09-17 13:04:37 +02:00
img : [ 'src' , 'srcset' , 'alt' , 'title' , 'width' , 'height' ] ,
2020-05-29 13:41:58 +02:00
li : [ ] ,
ol : [ ] ,
p : [ ] ,
pre : [ ] ,
s : [ ] ,
small : [ ] ,
span : [ ] ,
sub : [ ] ,
sup : [ ] ,
strong : [ ] ,
u : [ ] ,
ul : [ ]
} ;
2021-09-17 13:04:37 +02:00
function sanitizeHtml ( unsafeHtml , allowList , sanitizeFn ) {
if ( ! unsafeHtml . length ) {
2020-05-29 13:41:58 +02:00
return unsafeHtml ;
}
if ( sanitizeFn && typeof sanitizeFn === 'function' ) {
return sanitizeFn ( unsafeHtml ) ;
}
2021-09-17 13:04:37 +02:00
const domParser = new window . DOMParser ( ) ;
const createdDocument = domParser . parseFromString ( unsafeHtml , 'text/html' ) ;
const allowlistKeys = Object . keys ( allowList ) ;
const elements = [ ] . concat ( ... createdDocument . body . querySelectorAll ( '*' ) ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( let i = 0 , len = elements . length ; i < len ; i ++ ) {
const el = elements [ i ] ;
const elName = el . nodeName . toLowerCase ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! allowlistKeys . includes ( elName ) ) {
el . remove ( ) ;
continue ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const attributeList = [ ] . concat ( ... el . attributes ) ;
const allowedAttributes = [ ] . concat ( allowList [ '*' ] || [ ] , allowList [ elName ] || [ ] ) ;
attributeList . forEach ( attr => {
if ( ! allowedAttribute ( attr , allowedAttributes ) ) {
2020-05-29 13:41:58 +02:00
el . removeAttribute ( attr . nodeName ) ;
}
} ) ;
}
return createdDocument . body . innerHTML ;
}
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : tooltip . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$4 = 'tooltip' ;
const DATA _KEY$4 = 'bs.tooltip' ;
const EVENT _KEY$4 = ` . ${ DATA _KEY$4 } ` ;
const CLASS _PREFIX$1 = 'bs-tooltip' ;
const DISALLOWED _ATTRIBUTES = new Set ( [ 'sanitize' , 'allowList' , 'sanitizeFn' ] ) ;
const DefaultType$3 = {
2020-05-29 13:41:58 +02:00
animation : 'boolean' ,
template : 'string' ,
title : '(string|element|function)' ,
trigger : 'string' ,
delay : '(number|object)' ,
html : 'boolean' ,
selector : '(string|boolean)' ,
placement : '(string|function)' ,
2021-09-17 13:04:37 +02:00
offset : '(array|string|function)' ,
2020-05-29 13:41:58 +02:00
container : '(string|element|boolean)' ,
2021-09-17 13:04:37 +02:00
fallbackPlacements : 'array' ,
2020-05-29 13:41:58 +02:00
boundary : '(string|element)' ,
2021-09-17 13:04:37 +02:00
customClass : '(string|function)' ,
2020-05-29 13:41:58 +02:00
sanitize : 'boolean' ,
sanitizeFn : '(null|function)' ,
2021-09-17 13:04:37 +02:00
allowList : 'object' ,
popperConfig : '(null|object|function)'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const AttachmentMap = {
2020-05-29 13:41:58 +02:00
AUTO : 'auto' ,
TOP : 'top' ,
2021-09-17 13:04:37 +02:00
RIGHT : isRTL ( ) ? 'left' : 'right' ,
2020-05-29 13:41:58 +02:00
BOTTOM : 'bottom' ,
2021-09-17 13:04:37 +02:00
LEFT : isRTL ( ) ? 'right' : 'left'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const Default$3 = {
2020-05-29 13:41:58 +02:00
animation : true ,
2021-09-17 13:04:37 +02:00
template : '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>' ,
2020-05-29 13:41:58 +02:00
trigger : 'hover focus' ,
title : '' ,
delay : 0 ,
html : false ,
selector : false ,
placement : 'top' ,
2021-09-17 13:04:37 +02:00
offset : [ 0 , 0 ] ,
2020-05-29 13:41:58 +02:00
container : false ,
2021-09-17 13:04:37 +02:00
fallbackPlacements : [ 'top' , 'right' , 'bottom' , 'left' ] ,
boundary : 'clippingParents' ,
customClass : '' ,
2020-05-29 13:41:58 +02:00
sanitize : true ,
sanitizeFn : null ,
2021-09-17 13:04:37 +02:00
allowList : DefaultAllowlist ,
2020-05-29 13:41:58 +02:00
popperConfig : null
} ;
2021-09-17 13:04:37 +02:00
const Event$2 = {
HIDE : ` hide ${ EVENT _KEY$4 } ` ,
HIDDEN : ` hidden ${ EVENT _KEY$4 } ` ,
SHOW : ` show ${ EVENT _KEY$4 } ` ,
SHOWN : ` shown ${ EVENT _KEY$4 } ` ,
INSERTED : ` inserted ${ EVENT _KEY$4 } ` ,
CLICK : ` click ${ EVENT _KEY$4 } ` ,
FOCUSIN : ` focusin ${ EVENT _KEY$4 } ` ,
FOCUSOUT : ` focusout ${ EVENT _KEY$4 } ` ,
MOUSEENTER : ` mouseenter ${ EVENT _KEY$4 } ` ,
MOUSELEAVE : ` mouseleave ${ EVENT _KEY$4 } `
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const CLASS _NAME _FADE$2 = 'fade' ;
const CLASS _NAME _MODAL = 'modal' ;
const CLASS _NAME _SHOW$2 = 'show' ;
const HOVER _STATE _SHOW = 'show' ;
const HOVER _STATE _OUT = 'out' ;
const SELECTOR _TOOLTIP _INNER = '.tooltip-inner' ;
const SELECTOR _MODAL = ` . ${ CLASS _NAME _MODAL } ` ;
const EVENT _MODAL _HIDE = 'hide.bs.modal' ;
const TRIGGER _HOVER = 'hover' ;
const TRIGGER _FOCUS = 'focus' ;
const TRIGGER _CLICK = 'click' ;
const TRIGGER _MANUAL = 'manual' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Tooltip extends BaseComponent {
constructor ( element , config ) {
2020-05-29 13:41:58 +02:00
if ( typeof Popper === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( 'Bootstrap\'s tooltips require Popper (https://popper.js.org)' ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
super ( element ) ; // private
2020-05-29 13:41:58 +02:00
this . _isEnabled = true ;
this . _timeout = 0 ;
this . _hoverState = '' ;
this . _activeTrigger = { } ;
this . _popper = null ; // Protected
2021-09-17 13:04:37 +02:00
this . _config = this . _getConfig ( config ) ;
2020-05-29 13:41:58 +02:00
this . tip = null ;
this . _setListeners ( ) ;
} // Getters
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$3 ;
}
static get NAME ( ) {
return NAME$4 ;
}
static get Event ( ) {
return Event$2 ;
}
static get DefaultType ( ) {
return DefaultType$3 ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
enable ( ) {
2020-05-29 13:41:58 +02:00
this . _isEnabled = true ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
disable ( ) {
2020-05-29 13:41:58 +02:00
this . _isEnabled = false ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
toggleEnabled ( ) {
2020-05-29 13:41:58 +02:00
this . _isEnabled = ! this . _isEnabled ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
toggle ( event ) {
2020-05-29 13:41:58 +02:00
if ( ! this . _isEnabled ) {
return ;
}
if ( event ) {
2021-09-17 13:04:37 +02:00
const context = this . _initializeOnDelegatedTarget ( event ) ;
2020-05-29 13:41:58 +02:00
context . _activeTrigger . click = ! context . _activeTrigger . click ;
if ( context . _isWithActiveTrigger ( ) ) {
context . _enter ( null , context ) ;
} else {
context . _leave ( null , context ) ;
}
} else {
2021-09-17 13:04:37 +02:00
if ( this . getTipElement ( ) . classList . contains ( CLASS _NAME _SHOW$2 ) ) {
2020-05-29 13:41:58 +02:00
this . _leave ( null , this ) ;
return ;
}
this . _enter ( null , this ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
2020-05-29 13:41:58 +02:00
clearTimeout ( this . _timeout ) ;
2021-09-17 13:04:37 +02:00
EventHandler . off ( this . _element . closest ( SELECTOR _MODAL ) , EVENT _MODAL _HIDE , this . _hideModalHandler ) ;
2020-05-29 13:41:58 +02:00
if ( this . tip ) {
2021-09-17 13:04:37 +02:00
this . tip . remove ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _disposePopper ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
super . dispose ( ) ;
}
show ( ) {
if ( this . _element . style . display === 'none' ) {
throw new Error ( 'Please use show on visible elements' ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( ! ( this . isWithContent ( ) && this . _isEnabled ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const showEvent = EventHandler . trigger ( this . _element , this . constructor . Event . SHOW ) ;
const shadowRoot = findShadowRoot ( this . _element ) ;
const isInTheDom = shadowRoot === null ? this . _element . ownerDocument . documentElement . contains ( this . _element ) : shadowRoot . contains ( this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented || ! isInTheDom ) {
return ;
} // A trick to recreate a tooltip in case a new title is given by using the NOT documented `data-bs-original-title`
// This will be removed later in favor of a `setContent` method
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . constructor . NAME === 'tooltip' && this . tip && this . getTitle ( ) !== this . tip . querySelector ( SELECTOR _TOOLTIP _INNER ) . innerHTML ) {
this . _disposePopper ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . tip . remove ( ) ;
this . tip = null ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const tip = this . getTipElement ( ) ;
const tipId = getUID ( this . constructor . NAME ) ;
tip . setAttribute ( 'id' , tipId ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'aria-describedby' , tipId ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _config . animation ) {
tip . classList . add ( CLASS _NAME _FADE$2 ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const placement = typeof this . _config . placement === 'function' ? this . _config . placement . call ( this , tip , this . _element ) : this . _config . placement ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const attachment = this . _getAttachment ( placement ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _addAttachmentClass ( attachment ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const {
container
} = this . _config ;
Data . set ( tip , this . constructor . DATA _KEY , this ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! this . _element . ownerDocument . documentElement . contains ( this . tip ) ) {
container . append ( tip ) ;
EventHandler . trigger ( this . _element , this . constructor . Event . INSERTED ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _popper ) {
this . _popper . update ( ) ;
} else {
this . _popper = createPopper ( this . _element , tip , this . _getPopperConfig ( attachment ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
tip . classList . add ( CLASS _NAME _SHOW$2 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const customClass = this . _resolvePossibleFunction ( this . _config . customClass ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( customClass ) {
tip . classList . add ( ... customClass . split ( ' ' ) ) ;
} // If this is a touch-enabled device we add extra
// empty mouseover listeners to the body's immediate children;
// only needed because of broken event delegation on iOS
// https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( 'ontouchstart' in document . documentElement ) {
[ ] . concat ( ... document . body . children ) . forEach ( element => {
EventHandler . on ( element , 'mouseover' , noop ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
const prevHoverState = this . _hoverState ;
this . _hoverState = null ;
EventHandler . trigger ( this . _element , this . constructor . Event . SHOWN ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( prevHoverState === HOVER _STATE _OUT ) {
this . _leave ( null , this ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} ;
const isAnimated = this . tip . classList . contains ( CLASS _NAME _FADE$2 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( complete , this . tip , isAnimated ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
hide ( ) {
if ( ! this . _popper ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const tip = this . getTipElement ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
if ( this . _isWithActiveTrigger ( ) ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( this . _hoverState !== HOVER _STATE _SHOW ) {
tip . remove ( ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _cleanTipClass ( ) ;
this . _element . removeAttribute ( 'aria-describedby' ) ;
EventHandler . trigger ( this . _element , this . constructor . Event . HIDDEN ) ;
this . _disposePopper ( ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const hideEvent = EventHandler . trigger ( this . _element , this . constructor . Event . HIDE ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( hideEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
tip . classList . remove ( CLASS _NAME _SHOW$2 ) ; // If this is a touch-enabled device we remove the extra
2020-05-29 13:41:58 +02:00
// empty mouseover listeners we added for iOS support
if ( 'ontouchstart' in document . documentElement ) {
2021-09-17 13:04:37 +02:00
[ ] . concat ( ... document . body . children ) . forEach ( element => EventHandler . off ( element , 'mouseover' , noop ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . _activeTrigger [ TRIGGER _CLICK ] = false ;
this . _activeTrigger [ TRIGGER _FOCUS ] = false ;
this . _activeTrigger [ TRIGGER _HOVER ] = false ;
const isAnimated = this . tip . classList . contains ( CLASS _NAME _FADE$2 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( complete , this . tip , isAnimated ) ;
2020-05-29 13:41:58 +02:00
this . _hoverState = '' ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
update ( ) {
2020-05-29 13:41:58 +02:00
if ( this . _popper !== null ) {
2021-09-17 13:04:37 +02:00
this . _popper . update ( ) ;
2020-05-29 13:41:58 +02:00
}
} // Protected
2021-09-17 13:04:37 +02:00
isWithContent ( ) {
2020-05-29 13:41:58 +02:00
return Boolean ( this . getTitle ( ) ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
getTipElement ( ) {
if ( this . tip ) {
return this . tip ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const element = document . createElement ( 'div' ) ;
element . innerHTML = this . _config . template ;
const tip = element . children [ 0 ] ;
this . setContent ( tip ) ;
tip . classList . remove ( CLASS _NAME _FADE$2 , CLASS _NAME _SHOW$2 ) ;
this . tip = tip ;
2020-05-29 13:41:58 +02:00
return this . tip ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
setContent ( tip ) {
this . _sanitizeAndSetContent ( tip , this . getTitle ( ) , SELECTOR _TOOLTIP _INNER ) ;
}
_sanitizeAndSetContent ( template , content , selector ) {
const templateElement = SelectorEngine . findOne ( selector , template ) ;
if ( ! content && templateElement ) {
templateElement . remove ( ) ;
return ;
} // we use append for html objects to maintain js events
this . setElementContent ( templateElement , content ) ;
}
setElementContent ( element , content ) {
if ( element === null ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isElement$1 ( content ) ) {
content = getElement ( content ) ; // content is a DOM node or a jQuery
if ( this . _config . html ) {
if ( content . parentNode !== element ) {
element . innerHTML = '' ;
element . append ( content ) ;
2020-05-29 13:41:58 +02:00
}
} else {
2021-09-17 13:04:37 +02:00
element . textContent = content . textContent ;
2020-05-29 13:41:58 +02:00
}
return ;
}
2021-09-17 13:04:37 +02:00
if ( this . _config . html ) {
if ( this . _config . sanitize ) {
content = sanitizeHtml ( content , this . _config . allowList , this . _config . sanitizeFn ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
element . innerHTML = content ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
element . textContent = content ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
getTitle ( ) {
const title = this . _element . getAttribute ( 'data-bs-original-title' ) || this . _config . title ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return this . _resolvePossibleFunction ( title ) ;
}
updateAttachment ( attachment ) {
if ( attachment === 'right' ) {
return 'end' ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( attachment === 'left' ) {
return 'start' ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
return attachment ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_initializeOnDelegatedTarget ( event , context ) {
return context || this . constructor . getOrCreateInstance ( event . delegateTarget , this . _getDelegateConfig ( ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getOffset ( ) {
const {
offset
} = this . _config ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof offset === 'string' ) {
return offset . split ( ',' ) . map ( val => Number . parseInt ( val , 10 ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof offset === 'function' ) {
return popperData => offset ( popperData , this . _element ) ;
2020-05-29 13:41:58 +02:00
}
return offset ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_resolvePossibleFunction ( content ) {
return typeof content === 'function' ? content . call ( this . _element ) : content ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getPopperConfig ( attachment ) {
const defaultBsPopperConfig = {
placement : attachment ,
modifiers : [ {
name : 'flip' ,
options : {
fallbackPlacements : this . _config . fallbackPlacements
}
} , {
name : 'offset' ,
options : {
offset : this . _getOffset ( )
}
} , {
name : 'preventOverflow' ,
options : {
boundary : this . _config . boundary
}
} , {
name : 'arrow' ,
options : {
element : ` . ${ this . constructor . NAME } -arrow `
}
} , {
name : 'onChange' ,
enabled : true ,
phase : 'afterWrite' ,
fn : data => this . _handlePopperPlacementChange ( data )
} ] ,
onFirstUpdate : data => {
if ( data . options . placement !== data . placement ) {
this . _handlePopperPlacementChange ( data ) ;
}
}
} ;
return { ... defaultBsPopperConfig ,
... ( typeof this . _config . popperConfig === 'function' ? this . _config . popperConfig ( defaultBsPopperConfig ) : this . _config . popperConfig )
} ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_addAttachmentClass ( attachment ) {
this . getTipElement ( ) . classList . add ( ` ${ this . _getBasicClassPrefix ( ) } - ${ this . updateAttachment ( attachment ) } ` ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getAttachment ( placement ) {
return AttachmentMap [ placement . toUpperCase ( ) ] ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_setListeners ( ) {
const triggers = this . _config . trigger . split ( ' ' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
triggers . forEach ( trigger => {
2020-05-29 13:41:58 +02:00
if ( trigger === 'click' ) {
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element , this . constructor . Event . CLICK , this . _config . selector , event => this . toggle ( event ) ) ;
} else if ( trigger !== TRIGGER _MANUAL ) {
const eventIn = trigger === TRIGGER _HOVER ? this . constructor . Event . MOUSEENTER : this . constructor . Event . FOCUSIN ;
const eventOut = trigger === TRIGGER _HOVER ? this . constructor . Event . MOUSELEAVE : this . constructor . Event . FOCUSOUT ;
EventHandler . on ( this . _element , eventIn , this . _config . selector , event => this . _enter ( event ) ) ;
EventHandler . on ( this . _element , eventOut , this . _config . selector , event => this . _leave ( event ) ) ;
2020-05-29 13:41:58 +02:00
}
} ) ;
2021-09-17 13:04:37 +02:00
this . _hideModalHandler = ( ) => {
if ( this . _element ) {
this . hide ( ) ;
2020-05-29 13:41:58 +02:00
}
} ;
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _element . closest ( SELECTOR _MODAL ) , EVENT _MODAL _HIDE , this . _hideModalHandler ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _config . selector ) {
this . _config = { ... this . _config ,
2020-05-29 13:41:58 +02:00
trigger : 'manual' ,
selector : ''
2021-09-17 13:04:37 +02:00
} ;
2020-05-29 13:41:58 +02:00
} else {
this . _fixTitle ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_fixTitle ( ) {
const title = this . _element . getAttribute ( 'title' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const originalTitleType = typeof this . _element . getAttribute ( 'data-bs-original-title' ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( title || originalTitleType !== 'string' ) {
this . _element . setAttribute ( 'data-bs-original-title' , title || '' ) ;
if ( title && ! this . _element . getAttribute ( 'aria-label' ) && ! this . _element . textContent ) {
this . _element . setAttribute ( 'aria-label' , title ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . setAttribute ( 'title' , '' ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
_enter ( event , context ) {
context = this . _initializeOnDelegatedTarget ( event , context ) ;
2020-05-29 13:41:58 +02:00
if ( event ) {
2021-09-17 13:04:37 +02:00
context . _activeTrigger [ event . type === 'focusin' ? TRIGGER _FOCUS : TRIGGER _HOVER ] = true ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( context . getTipElement ( ) . classList . contains ( CLASS _NAME _SHOW$2 ) || context . _hoverState === HOVER _STATE _SHOW ) {
context . _hoverState = HOVER _STATE _SHOW ;
2020-05-29 13:41:58 +02:00
return ;
}
clearTimeout ( context . _timeout ) ;
2021-09-17 13:04:37 +02:00
context . _hoverState = HOVER _STATE _SHOW ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! context . _config . delay || ! context . _config . delay . show ) {
2020-05-29 13:41:58 +02:00
context . show ( ) ;
return ;
}
2021-09-17 13:04:37 +02:00
context . _timeout = setTimeout ( ( ) => {
if ( context . _hoverState === HOVER _STATE _SHOW ) {
2020-05-29 13:41:58 +02:00
context . show ( ) ;
}
2021-09-17 13:04:37 +02:00
} , context . _config . delay . show ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_leave ( event , context ) {
context = this . _initializeOnDelegatedTarget ( event , context ) ;
2020-05-29 13:41:58 +02:00
if ( event ) {
2021-09-17 13:04:37 +02:00
context . _activeTrigger [ event . type === 'focusout' ? TRIGGER _FOCUS : TRIGGER _HOVER ] = context . _element . contains ( event . relatedTarget ) ;
2020-05-29 13:41:58 +02:00
}
if ( context . _isWithActiveTrigger ( ) ) {
return ;
}
clearTimeout ( context . _timeout ) ;
2021-09-17 13:04:37 +02:00
context . _hoverState = HOVER _STATE _OUT ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! context . _config . delay || ! context . _config . delay . hide ) {
2020-05-29 13:41:58 +02:00
context . hide ( ) ;
return ;
}
2021-09-17 13:04:37 +02:00
context . _timeout = setTimeout ( ( ) => {
if ( context . _hoverState === HOVER _STATE _OUT ) {
2020-05-29 13:41:58 +02:00
context . hide ( ) ;
}
2021-09-17 13:04:37 +02:00
} , context . _config . delay . hide ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_isWithActiveTrigger ( ) {
for ( const trigger in this . _activeTrigger ) {
2020-05-29 13:41:58 +02:00
if ( this . _activeTrigger [ trigger ] ) {
return true ;
}
}
return false ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
const dataAttributes = Manipulator . getDataAttributes ( this . _element ) ;
Object . keys ( dataAttributes ) . forEach ( dataAttr => {
if ( DISALLOWED _ATTRIBUTES . has ( dataAttr ) ) {
2020-05-29 13:41:58 +02:00
delete dataAttributes [ dataAttr ] ;
}
} ) ;
2021-09-17 13:04:37 +02:00
config = { ... this . constructor . Default ,
... dataAttributes ,
... ( typeof config === 'object' && config ? config : { } )
} ;
config . container = config . container === false ? document . body : getElement ( config . container ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config . delay === 'number' ) {
config . delay = {
show : config . delay ,
hide : config . delay
} ;
}
if ( typeof config . title === 'number' ) {
config . title = config . title . toString ( ) ;
}
if ( typeof config . content === 'number' ) {
config . content = config . content . toString ( ) ;
}
2021-09-17 13:04:37 +02:00
typeCheckConfig ( NAME$4 , config , this . constructor . DefaultType ) ;
2020-05-29 13:41:58 +02:00
if ( config . sanitize ) {
2021-09-17 13:04:37 +02:00
config . template = sanitizeHtml ( config . template , config . allowList , config . sanitizeFn ) ;
2020-05-29 13:41:58 +02:00
}
return config ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getDelegateConfig ( ) {
const config = { } ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
for ( const key in this . _config ) {
if ( this . constructor . Default [ key ] !== this . _config [ key ] ) {
config [ key ] = this . _config [ key ] ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
} // In the future can be replaced with:
// const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
// `Object.fromEntries(keysWithDifferentValues)`
return config ;
}
_cleanTipClass ( ) {
const tip = this . getTipElement ( ) ;
const basicClassPrefixRegex = new RegExp ( ` (^| \\ s) ${ this . _getBasicClassPrefix ( ) } \\ S+ ` , 'g' ) ;
const tabClass = tip . getAttribute ( 'class' ) . match ( basicClassPrefixRegex ) ;
if ( tabClass !== null && tabClass . length > 0 ) {
tabClass . map ( token => token . trim ( ) ) . forEach ( tClass => tip . classList . remove ( tClass ) ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getBasicClassPrefix ( ) {
return CLASS _PREFIX$1 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_handlePopperPlacementChange ( popperData ) {
const {
state
} = popperData ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( ! state ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
this . tip = state . elements . popper ;
2020-05-29 13:41:58 +02:00
this . _cleanTipClass ( ) ;
2021-09-17 13:04:37 +02:00
this . _addAttachmentClass ( this . _getAttachment ( state . placement ) ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_disposePopper ( ) {
if ( this . _popper ) {
this . _popper . destroy ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _popper = null ;
2020-05-29 13:41:58 +02:00
}
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Tooltip . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config === 'string' ) {
if ( typeof data [ config ] === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
data [ config ] ( ) ;
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Tooltip to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Tooltip ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : popover . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$3 = 'popover' ;
const DATA _KEY$3 = 'bs.popover' ;
const EVENT _KEY$3 = ` . ${ DATA _KEY$3 } ` ;
const CLASS _PREFIX = 'bs-popover' ;
const Default$2 = { ... Tooltip . Default ,
2020-05-29 13:41:58 +02:00
placement : 'right' ,
2021-09-17 13:04:37 +02:00
offset : [ 0 , 8 ] ,
2020-05-29 13:41:58 +02:00
trigger : 'click' ,
content : '' ,
2021-09-17 13:04:37 +02:00
template : '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const DefaultType$2 = { ... Tooltip . DefaultType ,
content : '(string|element|function)'
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const Event$1 = {
HIDE : ` hide ${ EVENT _KEY$3 } ` ,
HIDDEN : ` hidden ${ EVENT _KEY$3 } ` ,
SHOW : ` show ${ EVENT _KEY$3 } ` ,
SHOWN : ` shown ${ EVENT _KEY$3 } ` ,
INSERTED : ` inserted ${ EVENT _KEY$3 } ` ,
CLICK : ` click ${ EVENT _KEY$3 } ` ,
FOCUSIN : ` focusin ${ EVENT _KEY$3 } ` ,
FOCUSOUT : ` focusout ${ EVENT _KEY$3 } ` ,
MOUSEENTER : ` mouseenter ${ EVENT _KEY$3 } ` ,
MOUSELEAVE : ` mouseleave ${ EVENT _KEY$3 } `
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
const SELECTOR _TITLE = '.popover-header' ;
const SELECTOR _CONTENT = '.popover-body' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Popover extends Tooltip {
// Getters
static get Default ( ) {
return Default$2 ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
static get NAME ( ) {
return NAME$3 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get Event ( ) {
return Event$1 ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
static get DefaultType ( ) {
return DefaultType$2 ;
} // Overrides
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
isWithContent ( ) {
return this . getTitle ( ) || this . _getContent ( ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
setContent ( tip ) {
this . _sanitizeAndSetContent ( tip , this . getTitle ( ) , SELECTOR _TITLE ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _sanitizeAndSetContent ( tip , this . _getContent ( ) , SELECTOR _CONTENT ) ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_getContent ( ) {
return this . _resolvePossibleFunction ( this . _config . content ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getBasicClassPrefix ( ) {
return CLASS _PREFIX ;
2020-05-29 13:41:58 +02:00
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Popover . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config === 'string' ) {
if ( typeof data [ config ] === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
data [ config ] ( ) ;
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Popover to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Popover ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : scrollspy . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$2 = 'scrollspy' ;
const DATA _KEY$2 = 'bs.scrollspy' ;
const EVENT _KEY$2 = ` . ${ DATA _KEY$2 } ` ;
const DATA _API _KEY$1 = '.data-api' ;
const Default$1 = {
2020-05-29 13:41:58 +02:00
offset : 10 ,
method : 'auto' ,
target : ''
} ;
2021-09-17 13:04:37 +02:00
const DefaultType$1 = {
2020-05-29 13:41:58 +02:00
offset : 'number' ,
method : 'string' ,
target : '(string|element)'
} ;
2021-09-17 13:04:37 +02:00
const EVENT _ACTIVATE = ` activate ${ EVENT _KEY$2 } ` ;
const EVENT _SCROLL = ` scroll ${ EVENT _KEY$2 } ` ;
const EVENT _LOAD _DATA _API = ` load ${ EVENT _KEY$2 } ${ DATA _API _KEY$1 } ` ;
const CLASS _NAME _DROPDOWN _ITEM = 'dropdown-item' ;
const CLASS _NAME _ACTIVE$1 = 'active' ;
const SELECTOR _DATA _SPY = '[data-bs-spy="scroll"]' ;
const SELECTOR _NAV _LIST _GROUP$1 = '.nav, .list-group' ;
const SELECTOR _NAV _LINKS = '.nav-link' ;
const SELECTOR _NAV _ITEMS = '.nav-item' ;
const SELECTOR _LIST _ITEMS = '.list-group-item' ;
const SELECTOR _LINK _ITEMS = ` ${ SELECTOR _NAV _LINKS } , ${ SELECTOR _LIST _ITEMS } , . ${ CLASS _NAME _DROPDOWN _ITEM } ` ;
const SELECTOR _DROPDOWN$1 = '.dropdown' ;
const SELECTOR _DROPDOWN _TOGGLE$1 = '.dropdown-toggle' ;
const METHOD _OFFSET = 'offset' ;
const METHOD _POSITION = 'position' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class ScrollSpy extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
this . _scrollElement = this . _element . tagName === 'BODY' ? window : this . _element ;
2020-05-29 13:41:58 +02:00
this . _config = this . _getConfig ( config ) ;
this . _offsets = [ ] ;
this . _targets = [ ] ;
this . _activeTarget = null ;
this . _scrollHeight = 0 ;
2021-09-17 13:04:37 +02:00
EventHandler . on ( this . _scrollElement , EVENT _SCROLL , ( ) => this . _process ( ) ) ;
2020-05-29 13:41:58 +02:00
this . refresh ( ) ;
this . _process ( ) ;
} // Getters
2021-09-17 13:04:37 +02:00
static get Default ( ) {
return Default$1 ;
}
static get NAME ( ) {
return NAME$2 ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
refresh ( ) {
const autoMethod = this . _scrollElement === this . _scrollElement . window ? METHOD _OFFSET : METHOD _POSITION ;
const offsetMethod = this . _config . method === 'auto' ? autoMethod : this . _config . method ;
const offsetBase = offsetMethod === METHOD _POSITION ? this . _getScrollTop ( ) : 0 ;
2020-05-29 13:41:58 +02:00
this . _offsets = [ ] ;
this . _targets = [ ] ;
this . _scrollHeight = this . _getScrollHeight ( ) ;
2021-09-17 13:04:37 +02:00
const targets = SelectorEngine . find ( SELECTOR _LINK _ITEMS , this . _config . target ) ;
targets . map ( element => {
const targetSelector = getSelectorFromElement ( element ) ;
const target = targetSelector ? SelectorEngine . findOne ( targetSelector ) : null ;
2020-05-29 13:41:58 +02:00
if ( target ) {
2021-09-17 13:04:37 +02:00
const targetBCR = target . getBoundingClientRect ( ) ;
2020-05-29 13:41:58 +02:00
if ( targetBCR . width || targetBCR . height ) {
2021-09-17 13:04:37 +02:00
return [ Manipulator [ offsetMethod ] ( target ) . top + offsetBase , targetSelector ] ;
2020-05-29 13:41:58 +02:00
}
}
return null ;
2021-09-17 13:04:37 +02:00
} ) . filter ( item => item ) . sort ( ( a , b ) => a [ 0 ] - b [ 0 ] ) . forEach ( item => {
this . _offsets . push ( item [ 0 ] ) ;
this . _targets . push ( item [ 1 ] ) ;
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
dispose ( ) {
EventHandler . off ( this . _scrollElement , EVENT _KEY$2 ) ;
super . dispose ( ) ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default$1 ,
... Manipulator . getDataAttributes ( this . _element ) ,
... ( typeof config === 'object' && config ? config : { } )
} ;
config . target = getElement ( config . target ) || document . documentElement ;
typeCheckConfig ( NAME$2 , config , DefaultType$1 ) ;
2020-05-29 13:41:58 +02:00
return config ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getScrollTop ( ) {
2020-05-29 13:41:58 +02:00
return this . _scrollElement === window ? this . _scrollElement . pageYOffset : this . _scrollElement . scrollTop ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getScrollHeight ( ) {
2020-05-29 13:41:58 +02:00
return this . _scrollElement . scrollHeight || Math . max ( document . body . scrollHeight , document . documentElement . scrollHeight ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_getOffsetHeight ( ) {
2020-05-29 13:41:58 +02:00
return this . _scrollElement === window ? window . innerHeight : this . _scrollElement . getBoundingClientRect ( ) . height ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_process ( ) {
const scrollTop = this . _getScrollTop ( ) + this . _config . offset ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const scrollHeight = this . _getScrollHeight ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const maxScroll = this . _config . offset + scrollHeight - this . _getOffsetHeight ( ) ;
2020-05-29 13:41:58 +02:00
if ( this . _scrollHeight !== scrollHeight ) {
this . refresh ( ) ;
}
if ( scrollTop >= maxScroll ) {
2021-09-17 13:04:37 +02:00
const target = this . _targets [ this . _targets . length - 1 ] ;
2020-05-29 13:41:58 +02:00
if ( this . _activeTarget !== target ) {
this . _activate ( target ) ;
}
return ;
}
if ( this . _activeTarget && scrollTop < this . _offsets [ 0 ] && this . _offsets [ 0 ] > 0 ) {
this . _activeTarget = null ;
this . _clear ( ) ;
return ;
}
2021-09-17 13:04:37 +02:00
for ( let i = this . _offsets . length ; i -- ; ) {
const isActiveTarget = this . _activeTarget !== this . _targets [ i ] && scrollTop >= this . _offsets [ i ] && ( typeof this . _offsets [ i + 1 ] === 'undefined' || scrollTop < this . _offsets [ i + 1 ] ) ;
2020-05-29 13:41:58 +02:00
if ( isActiveTarget ) {
this . _activate ( this . _targets [ i ] ) ;
}
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_activate ( target ) {
2020-05-29 13:41:58 +02:00
this . _activeTarget = target ;
this . _clear ( ) ;
2021-09-17 13:04:37 +02:00
const queries = SELECTOR _LINK _ITEMS . split ( ',' ) . map ( selector => ` ${ selector } [data-bs-target=" ${ target } "], ${ selector } [href=" ${ target } "] ` ) ;
const link = SelectorEngine . findOne ( queries . join ( ',' ) , this . _config . target ) ;
link . classList . add ( CLASS _NAME _ACTIVE$1 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( link . classList . contains ( CLASS _NAME _DROPDOWN _ITEM ) ) {
SelectorEngine . findOne ( SELECTOR _DROPDOWN _TOGGLE$1 , link . closest ( SELECTOR _DROPDOWN$1 ) ) . classList . add ( CLASS _NAME _ACTIVE$1 ) ;
2020-05-29 13:41:58 +02:00
} else {
2021-09-17 13:04:37 +02:00
SelectorEngine . parents ( link , SELECTOR _NAV _LIST _GROUP$1 ) . forEach ( listGroup => {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
SelectorEngine . prev ( listGroup , ` ${ SELECTOR _NAV _LINKS } , ${ SELECTOR _LIST _ITEMS } ` ) . forEach ( item => item . classList . add ( CLASS _NAME _ACTIVE$1 ) ) ; // Handle special case when .nav-link is inside .nav-item
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
SelectorEngine . prev ( listGroup , SELECTOR _NAV _ITEMS ) . forEach ( navItem => {
SelectorEngine . children ( navItem , SELECTOR _NAV _LINKS ) . forEach ( item => item . classList . add ( CLASS _NAME _ACTIVE$1 ) ) ;
} ) ;
} ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _scrollElement , EVENT _ACTIVATE , {
2020-05-29 13:41:58 +02:00
relatedTarget : target
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_clear ( ) {
SelectorEngine . find ( SELECTOR _LINK _ITEMS , this . _config . target ) . filter ( node => node . classList . contains ( CLASS _NAME _ACTIVE$1 ) ) . forEach ( node => node . classList . remove ( CLASS _NAME _ACTIVE$1 ) ) ;
2020-05-29 13:41:58 +02:00
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = ScrollSpy . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( typeof config !== 'string' ) {
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
if ( typeof data [ config ] === 'undefined' ) {
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
data [ config ] ( ) ;
} ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
EventHandler . on ( window , EVENT _LOAD _DATA _API , ( ) => {
SelectorEngine . find ( SELECTOR _DATA _SPY ) . forEach ( spy => new ScrollSpy ( spy ) ) ;
2020-05-29 13:41:58 +02:00
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . ScrollSpy to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( ScrollSpy ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : tab . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME$1 = 'tab' ;
const DATA _KEY$1 = 'bs.tab' ;
const EVENT _KEY$1 = ` . ${ DATA _KEY$1 } ` ;
const DATA _API _KEY = '.data-api' ;
const EVENT _HIDE$1 = ` hide ${ EVENT _KEY$1 } ` ;
const EVENT _HIDDEN$1 = ` hidden ${ EVENT _KEY$1 } ` ;
const EVENT _SHOW$1 = ` show ${ EVENT _KEY$1 } ` ;
const EVENT _SHOWN$1 = ` shown ${ EVENT _KEY$1 } ` ;
const EVENT _CLICK _DATA _API = ` click ${ EVENT _KEY$1 } ${ DATA _API _KEY } ` ;
const CLASS _NAME _DROPDOWN _MENU = 'dropdown-menu' ;
const CLASS _NAME _ACTIVE = 'active' ;
const CLASS _NAME _FADE$1 = 'fade' ;
const CLASS _NAME _SHOW$1 = 'show' ;
const SELECTOR _DROPDOWN = '.dropdown' ;
const SELECTOR _NAV _LIST _GROUP = '.nav, .list-group' ;
const SELECTOR _ACTIVE = '.active' ;
const SELECTOR _ACTIVE _UL = ':scope > li > .active' ;
const SELECTOR _DATA _TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]' ;
const SELECTOR _DROPDOWN _TOGGLE = '.dropdown-toggle' ;
const SELECTOR _DROPDOWN _ACTIVE _CHILD = ':scope > .dropdown-menu .active' ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Tab extends BaseComponent {
// Getters
static get NAME ( ) {
return NAME$1 ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
show ( ) {
if ( this . _element . parentNode && this . _element . parentNode . nodeType === Node . ELEMENT _NODE && this . _element . classList . contains ( CLASS _NAME _ACTIVE ) ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
let previous ;
const target = getElementFromSelector ( this . _element ) ;
const listElement = this . _element . closest ( SELECTOR _NAV _LIST _GROUP ) ;
2020-05-29 13:41:58 +02:00
if ( listElement ) {
2021-09-17 13:04:37 +02:00
const itemSelector = listElement . nodeName === 'UL' || listElement . nodeName === 'OL' ? SELECTOR _ACTIVE _UL : SELECTOR _ACTIVE ;
previous = SelectorEngine . find ( itemSelector , listElement ) ;
2020-05-29 13:41:58 +02:00
previous = previous [ previous . length - 1 ] ;
}
2021-09-17 13:04:37 +02:00
const hideEvent = previous ? EventHandler . trigger ( previous , EVENT _HIDE$1 , {
2020-05-29 13:41:58 +02:00
relatedTarget : this . _element
2021-09-17 13:04:37 +02:00
} ) : null ;
const showEvent = EventHandler . trigger ( this . _element , EVENT _SHOW$1 , {
2020-05-29 13:41:58 +02:00
relatedTarget : previous
} ) ;
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented || hideEvent !== null && hideEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
this . _activate ( this . _element , listElement ) ;
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
EventHandler . trigger ( previous , EVENT _HIDDEN$1 , {
relatedTarget : this . _element
2020-05-29 13:41:58 +02:00
} ) ;
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _element , EVENT _SHOWN$1 , {
2020-05-29 13:41:58 +02:00
relatedTarget : previous
} ) ;
} ;
if ( target ) {
this . _activate ( target , target . parentNode , complete ) ;
} else {
complete ( ) ;
}
} // Private
2021-09-17 13:04:37 +02:00
_activate ( element , container , callback ) {
const activeElements = container && ( container . nodeName === 'UL' || container . nodeName === 'OL' ) ? SelectorEngine . find ( SELECTOR _ACTIVE _UL , container ) : SelectorEngine . children ( container , SELECTOR _ACTIVE ) ;
const active = activeElements [ 0 ] ;
const isTransitioning = callback && active && active . classList . contains ( CLASS _NAME _FADE$1 ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const complete = ( ) => this . _transitionComplete ( element , active , callback ) ;
2020-05-29 13:41:58 +02:00
if ( active && isTransitioning ) {
2021-09-17 13:04:37 +02:00
active . classList . remove ( CLASS _NAME _SHOW$1 ) ;
this . _queueCallback ( complete , element , true ) ;
2020-05-29 13:41:58 +02:00
} else {
complete ( ) ;
}
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_transitionComplete ( element , active , callback ) {
2020-05-29 13:41:58 +02:00
if ( active ) {
2021-09-17 13:04:37 +02:00
active . classList . remove ( CLASS _NAME _ACTIVE ) ;
const dropdownChild = SelectorEngine . findOne ( SELECTOR _DROPDOWN _ACTIVE _CHILD , active . parentNode ) ;
2020-05-29 13:41:58 +02:00
if ( dropdownChild ) {
2021-09-17 13:04:37 +02:00
dropdownChild . classList . remove ( CLASS _NAME _ACTIVE ) ;
2020-05-29 13:41:58 +02:00
}
if ( active . getAttribute ( 'role' ) === 'tab' ) {
active . setAttribute ( 'aria-selected' , false ) ;
}
}
2021-09-17 13:04:37 +02:00
element . classList . add ( CLASS _NAME _ACTIVE ) ;
2020-05-29 13:41:58 +02:00
if ( element . getAttribute ( 'role' ) === 'tab' ) {
element . setAttribute ( 'aria-selected' , true ) ;
}
2021-09-17 13:04:37 +02:00
reflow ( element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( element . classList . contains ( CLASS _NAME _FADE$1 ) ) {
element . classList . add ( CLASS _NAME _SHOW$1 ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
let parent = element . parentNode ;
if ( parent && parent . nodeName === 'LI' ) {
parent = parent . parentNode ;
}
if ( parent && parent . classList . contains ( CLASS _NAME _DROPDOWN _MENU ) ) {
const dropdownElement = element . closest ( SELECTOR _DROPDOWN ) ;
2020-05-29 13:41:58 +02:00
if ( dropdownElement ) {
2021-09-17 13:04:37 +02:00
SelectorEngine . find ( SELECTOR _DROPDOWN _TOGGLE , dropdownElement ) . forEach ( dropdown => dropdown . classList . add ( CLASS _NAME _ACTIVE ) ) ;
2020-05-29 13:41:58 +02:00
}
element . setAttribute ( 'aria-expanded' , true ) ;
}
if ( callback ) {
callback ( ) ;
}
} // Static
2021-09-17 13:04:37 +02:00
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Tab . getOrCreateInstance ( this ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config === 'string' ) {
if ( typeof data [ config ] === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
data [ config ] ( ) ;
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Data Api implementation
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
EventHandler . on ( document , EVENT _CLICK _DATA _API , SELECTOR _DATA _TOGGLE , function ( event ) {
if ( [ 'A' , 'AREA' ] . includes ( this . tagName ) ) {
event . preventDefault ( ) ;
}
if ( isDisabled ( this ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
const data = Tab . getOrCreateInstance ( this ) ;
data . show ( ) ;
2020-05-29 13:41:58 +02:00
} ) ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Tab to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Tab ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : toast . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Constants
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
const NAME = 'toast' ;
const DATA _KEY = 'bs.toast' ;
const EVENT _KEY = ` . ${ DATA _KEY } ` ;
const EVENT _MOUSEOVER = ` mouseover ${ EVENT _KEY } ` ;
const EVENT _MOUSEOUT = ` mouseout ${ EVENT _KEY } ` ;
const EVENT _FOCUSIN = ` focusin ${ EVENT _KEY } ` ;
const EVENT _FOCUSOUT = ` focusout ${ EVENT _KEY } ` ;
const EVENT _HIDE = ` hide ${ EVENT _KEY } ` ;
const EVENT _HIDDEN = ` hidden ${ EVENT _KEY } ` ;
const EVENT _SHOW = ` show ${ EVENT _KEY } ` ;
const EVENT _SHOWN = ` shown ${ EVENT _KEY } ` ;
const CLASS _NAME _FADE = 'fade' ;
const CLASS _NAME _HIDE = 'hide' ; // @deprecated - kept here only for backwards compatibility
const CLASS _NAME _SHOW = 'show' ;
const CLASS _NAME _SHOWING = 'showing' ;
const DefaultType = {
2020-05-29 13:41:58 +02:00
animation : 'boolean' ,
autohide : 'boolean' ,
delay : 'number'
} ;
2021-09-17 13:04:37 +02:00
const Default = {
2020-05-29 13:41:58 +02:00
animation : true ,
autohide : true ,
2021-09-17 13:04:37 +02:00
delay : 5000
2020-05-29 13:41:58 +02:00
} ;
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Class Definition
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
2021-09-17 13:04:37 +02:00
class Toast extends BaseComponent {
constructor ( element , config ) {
super ( element ) ;
2020-05-29 13:41:58 +02:00
this . _config = this . _getConfig ( config ) ;
this . _timeout = null ;
2021-09-17 13:04:37 +02:00
this . _hasMouseInteraction = false ;
this . _hasKeyboardInteraction = false ;
2020-05-29 13:41:58 +02:00
this . _setListeners ( ) ;
} // Getters
2021-09-17 13:04:37 +02:00
static get DefaultType ( ) {
return DefaultType ;
}
static get Default ( ) {
return Default ;
}
static get NAME ( ) {
return NAME ;
} // Public
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
show ( ) {
const showEvent = EventHandler . trigger ( this . _element , EVENT _SHOW ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( showEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
this . _clearTimeout ( ) ;
2020-05-29 13:41:58 +02:00
if ( this . _config . animation ) {
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _FADE ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
this . _element . classList . remove ( CLASS _NAME _SHOWING ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
EventHandler . trigger ( this . _element , EVENT _SHOWN ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _maybeScheduleHide ( ) ;
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _HIDE ) ; // @deprecated
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
reflow ( this . _element ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . add ( CLASS _NAME _SHOW ) ;
this . _element . classList . add ( CLASS _NAME _SHOWING ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _queueCallback ( complete , this . _element , this . _config . animation ) ;
}
hide ( ) {
if ( ! this . _element . classList . contains ( CLASS _NAME _SHOW ) ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
const hideEvent = EventHandler . trigger ( this . _element , EVENT _HIDE ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( hideEvent . defaultPrevented ) {
2020-05-29 13:41:58 +02:00
return ;
}
2021-09-17 13:04:37 +02:00
const complete = ( ) => {
this . _element . classList . add ( CLASS _NAME _HIDE ) ; // @deprecated
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _element . classList . remove ( CLASS _NAME _SHOWING ) ;
this . _element . classList . remove ( CLASS _NAME _SHOW ) ;
EventHandler . trigger ( this . _element , EVENT _HIDDEN ) ;
} ;
this . _element . classList . add ( CLASS _NAME _SHOWING ) ;
this . _queueCallback ( complete , this . _element , this . _config . animation ) ;
}
dispose ( ) {
this . _clearTimeout ( ) ;
if ( this . _element . classList . contains ( CLASS _NAME _SHOW ) ) {
this . _element . classList . remove ( CLASS _NAME _SHOW ) ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
super . dispose ( ) ;
2020-05-29 13:41:58 +02:00
} // Private
2021-09-17 13:04:37 +02:00
_getConfig ( config ) {
config = { ... Default ,
... Manipulator . getDataAttributes ( this . _element ) ,
... ( typeof config === 'object' && config ? config : { } )
} ;
typeCheckConfig ( NAME , config , this . constructor . DefaultType ) ;
2020-05-29 13:41:58 +02:00
return config ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_maybeScheduleHide ( ) {
if ( ! this . _config . autohide ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _hasMouseInteraction || this . _hasKeyboardInteraction ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _timeout = setTimeout ( ( ) => {
this . hide ( ) ;
} , this . _config . delay ) ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
_onInteraction ( event , isInteracting ) {
switch ( event . type ) {
case 'mouseover' :
case 'mouseout' :
this . _hasMouseInteraction = isInteracting ;
break ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
case 'focusin' :
case 'focusout' :
this . _hasKeyboardInteraction = isInteracting ;
break ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( isInteracting ) {
this . _clearTimeout ( ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
return ;
2020-05-29 13:41:58 +02:00
}
2021-09-17 13:04:37 +02:00
const nextElement = event . relatedTarget ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
if ( this . _element === nextElement || this . _element . contains ( nextElement ) ) {
return ;
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
this . _maybeScheduleHide ( ) ;
}
_setListeners ( ) {
EventHandler . on ( this . _element , EVENT _MOUSEOVER , event => this . _onInteraction ( event , true ) ) ;
EventHandler . on ( this . _element , EVENT _MOUSEOUT , event => this . _onInteraction ( event , false ) ) ;
EventHandler . on ( this . _element , EVENT _FOCUSIN , event => this . _onInteraction ( event , true ) ) ;
EventHandler . on ( this . _element , EVENT _FOCUSOUT , event => this . _onInteraction ( event , false ) ) ;
}
_clearTimeout ( ) {
clearTimeout ( this . _timeout ) ;
this . _timeout = null ;
} // Static
static jQueryInterface ( config ) {
return this . each ( function ( ) {
const data = Toast . getOrCreateInstance ( this , config ) ;
2020-05-29 13:41:58 +02:00
if ( typeof config === 'string' ) {
if ( typeof data [ config ] === 'undefined' ) {
2021-09-17 13:04:37 +02:00
throw new TypeError ( ` No method named " ${ config } " ` ) ;
2020-05-29 13:41:58 +02:00
}
data [ config ] ( this ) ;
}
} ) ;
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
}
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
enableDismissTrigger ( Toast ) ;
2020-05-29 13:41:58 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* jQuery
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2021-09-17 13:04:37 +02:00
* add . Toast to jQuery only if jQuery is present
2020-05-29 13:41:58 +02:00
* /
2021-09-17 13:04:37 +02:00
defineJQueryPlugin ( Toast ) ;
2020-05-29 13:41:58 +02:00
2021-09-17 13:04:37 +02:00
/ * *
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* Bootstrap ( v5 . 1.1 ) : index . umd . js
* Licensed under MIT ( https : //github.com/twbs/bootstrap/blob/main/LICENSE)
* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
* /
var index _umd = {
Alert ,
Button ,
Carousel ,
Collapse ,
Dropdown ,
Modal ,
Offcanvas ,
Popover ,
ScrollSpy ,
Tab ,
Toast ,
Tooltip
2020-05-29 13:41:58 +02:00
} ;
2021-09-17 13:04:37 +02:00
return index _umd ;
2020-05-29 13:41:58 +02:00
} ) ) ) ;
//# sourceMappingURL=bootstrap.bundle.js.map