* --------------------------------------------------------------------------
*/
-const Alert = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'alert'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.alert'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
-
- const Selector = {
- DISMISS : '[data-dismiss="alert"]'
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const NAME = 'alert'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.alert'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+
+const Selector = {
+ DISMISS : '[data-dismiss="alert"]'
+}
+
+const Event = {
+ CLOSE : `close${EVENT_KEY}`,
+ CLOSED : `closed${EVENT_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ ALERT : 'alert',
+ FADE : 'fade',
+ SHOW : 'show'
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- const Event = {
- CLOSE : `close${EVENT_KEY}`,
- CLOSED : `closed${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+class Alert {
+ constructor(element) {
+ this._element = element
}
- const ClassName = {
- ALERT : 'alert',
- FADE : 'fade',
- SHOW : 'show'
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
+ // Public
- class Alert {
- constructor(element) {
- this._element = element
+ close(element) {
+ let rootElement = this._element
+ if (element) {
+ rootElement = this._getRootElement(element)
}
- // Getters
+ const customEvent = this._triggerCloseEvent(rootElement)
- static get VERSION() {
- return VERSION
+ if (customEvent.isDefaultPrevented()) {
+ return
}
- // Public
+ this._removeElement(rootElement)
+ }
- close(element) {
- let rootElement = this._element
- if (element) {
- rootElement = this._getRootElement(element)
- }
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
+ this._element = null
+ }
- const customEvent = this._triggerCloseEvent(rootElement)
+ // Private
- if (customEvent.isDefaultPrevented()) {
- return
- }
+ _getRootElement(element) {
+ const selector = Util.getSelectorFromElement(element)
+ let parent = false
- this._removeElement(rootElement)
+ if (selector) {
+ parent = document.querySelector(selector)
}
- dispose() {
- $.removeData(this._element, DATA_KEY)
- this._element = null
+ if (!parent) {
+ parent = $(element).closest(`.${ClassName.ALERT}`)[0]
}
- // Private
-
- _getRootElement(element) {
- const selector = Util.getSelectorFromElement(element)
- let parent = false
-
- if (selector) {
- parent = document.querySelector(selector)
- }
+ return parent
+ }
- if (!parent) {
- parent = $(element).closest(`.${ClassName.ALERT}`)[0]
- }
+ _triggerCloseEvent(element) {
+ const closeEvent = $.Event(Event.CLOSE)
- return parent
- }
+ $(element).trigger(closeEvent)
+ return closeEvent
+ }
- _triggerCloseEvent(element) {
- const closeEvent = $.Event(Event.CLOSE)
+ _removeElement(element) {
+ $(element).removeClass(ClassName.SHOW)
- $(element).trigger(closeEvent)
- return closeEvent
+ if (!$(element).hasClass(ClassName.FADE)) {
+ this._destroyElement(element)
+ return
}
- _removeElement(element) {
- $(element).removeClass(ClassName.SHOW)
+ const transitionDuration = Util.getTransitionDurationFromElement(element)
- if (!$(element).hasClass(ClassName.FADE)) {
- this._destroyElement(element)
- return
- }
+ $(element)
+ .one(Util.TRANSITION_END, (event) => this._destroyElement(element, event))
+ .emulateTransitionEnd(transitionDuration)
+ }
- const transitionDuration = Util.getTransitionDurationFromElement(element)
+ _destroyElement(element) {
+ $(element)
+ .detach()
+ .trigger(Event.CLOSED)
+ .remove()
+ }
- $(element)
- .one(Util.TRANSITION_END, (event) => this._destroyElement(element, event))
- .emulateTransitionEnd(transitionDuration)
- }
+ // Static
- _destroyElement(element) {
- $(element)
- .detach()
- .trigger(Event.CLOSED)
- .remove()
- }
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ const $element = $(this)
+ let data = $element.data(DATA_KEY)
- // Static
+ if (!data) {
+ data = new Alert(this)
+ $element.data(DATA_KEY, data)
+ }
- static _jQueryInterface(config) {
- return this.each(function () {
- const $element = $(this)
- let data = $element.data(DATA_KEY)
+ if (config === 'close') {
+ data[config](this)
+ }
+ })
+ }
- if (!data) {
- data = new Alert(this)
- $element.data(DATA_KEY, data)
- }
+ static _handleDismiss(alertInstance) {
+ return function (event) {
+ if (event) {
+ event.preventDefault()
+ }
- if (config === 'close') {
- data[config](this)
- }
- })
+ alertInstance.close(this)
}
+ }
+}
- static _handleDismiss(alertInstance) {
- return function (event) {
- if (event) {
- event.preventDefault()
- }
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- alertInstance.close(this)
- }
- }
- }
+$(document).on(
+ Event.CLICK_DATA_API,
+ Selector.DISMISS,
+ Alert._handleDismiss(new Alert())
+)
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
-
- $(document).on(
- Event.CLICK_DATA_API,
- Selector.DISMISS,
- Alert._handleDismiss(new Alert())
- )
-
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Alert._jQueryInterface
- $.fn[NAME].Constructor = Alert
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Alert._jQueryInterface
- }
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Alert
-})($)
+$.fn[NAME] = Alert._jQueryInterface
+$.fn[NAME].Constructor = Alert
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Alert._jQueryInterface
+}
export default Alert
* --------------------------------------------------------------------------
*/
-const Button = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'button'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.button'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
-
- const ClassName = {
- ACTIVE : 'active',
- BUTTON : 'btn',
- FOCUS : 'focus'
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const Selector = {
- DATA_TOGGLE_CARROT : '[data-toggle^="button"]',
- DATA_TOGGLE : '[data-toggle="buttons"]',
- INPUT : 'input',
- ACTIVE : '.active',
- BUTTON : '.btn'
+const NAME = 'button'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.button'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+
+const ClassName = {
+ ACTIVE : 'active',
+ BUTTON : 'btn',
+ FOCUS : 'focus'
+}
+
+const Selector = {
+ DATA_TOGGLE_CARROT : '[data-toggle^="button"]',
+ DATA_TOGGLE : '[data-toggle="buttons"]',
+ INPUT : 'input',
+ ACTIVE : '.active',
+ BUTTON : '.btn'
+}
+
+const Event = {
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`,
+ FOCUS_BLUR_DATA_API : `focus${EVENT_KEY}${DATA_API_KEY} ` +
+ `blur${EVENT_KEY}${DATA_API_KEY}`
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
+
+class Button {
+ constructor(element) {
+ this._element = element
}
- const Event = {
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`,
- FOCUS_BLUR_DATA_API : `focus${EVENT_KEY}${DATA_API_KEY} ` +
- `blur${EVENT_KEY}${DATA_API_KEY}`
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
+ // Public
- class Button {
- constructor(element) {
- this._element = element
- }
+ toggle() {
+ let triggerChangeEvent = true
+ let addAriaPressed = true
+ const rootElement = $(this._element).closest(
+ Selector.DATA_TOGGLE
+ )[0]
- // Getters
+ if (rootElement) {
+ const input = this._element.querySelector(Selector.INPUT)
- static get VERSION() {
- return VERSION
- }
+ if (input) {
+ if (input.type === 'radio') {
+ if (input.checked &&
+ this._element.classList.contains(ClassName.ACTIVE)) {
+ triggerChangeEvent = false
+ } else {
+ const activeElement = rootElement.querySelector(Selector.ACTIVE)
- // Public
-
- toggle() {
- let triggerChangeEvent = true
- let addAriaPressed = true
- const rootElement = $(this._element).closest(
- Selector.DATA_TOGGLE
- )[0]
-
- if (rootElement) {
- const input = this._element.querySelector(Selector.INPUT)
-
- if (input) {
- if (input.type === 'radio') {
- if (input.checked &&
- this._element.classList.contains(ClassName.ACTIVE)) {
- triggerChangeEvent = false
- } else {
- const activeElement = rootElement.querySelector(Selector.ACTIVE)
-
- if (activeElement) {
- $(activeElement).removeClass(ClassName.ACTIVE)
- }
+ if (activeElement) {
+ $(activeElement).removeClass(ClassName.ACTIVE)
}
}
+ }
- if (triggerChangeEvent) {
- if (input.hasAttribute('disabled') ||
- rootElement.hasAttribute('disabled') ||
- input.classList.contains('disabled') ||
- rootElement.classList.contains('disabled')) {
- return
- }
- input.checked = !this._element.classList.contains(ClassName.ACTIVE)
- $(input).trigger('change')
+ if (triggerChangeEvent) {
+ if (input.hasAttribute('disabled') ||
+ rootElement.hasAttribute('disabled') ||
+ input.classList.contains('disabled') ||
+ rootElement.classList.contains('disabled')) {
+ return
}
-
- input.focus()
- addAriaPressed = false
+ input.checked = !this._element.classList.contains(ClassName.ACTIVE)
+ $(input).trigger('change')
}
- }
- if (addAriaPressed) {
- this._element.setAttribute('aria-pressed',
- !this._element.classList.contains(ClassName.ACTIVE))
+ input.focus()
+ addAriaPressed = false
}
+ }
- if (triggerChangeEvent) {
- $(this._element).toggleClass(ClassName.ACTIVE)
- }
+ if (addAriaPressed) {
+ this._element.setAttribute('aria-pressed',
+ !this._element.classList.contains(ClassName.ACTIVE))
}
- dispose() {
- $.removeData(this._element, DATA_KEY)
- this._element = null
+ if (triggerChangeEvent) {
+ $(this._element).toggleClass(ClassName.ACTIVE)
}
+ }
- // Static
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
+ this._element = null
+ }
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
+ // Static
- if (!data) {
- data = new Button(this)
- $(this).data(DATA_KEY, data)
- }
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
- if (config === 'toggle') {
- data[config]()
- }
- })
- }
+ if (!data) {
+ data = new Button(this)
+ $(this).data(DATA_KEY, data)
+ }
+
+ if (config === 'toggle') {
+ data[config]()
+ }
+ })
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- $(document)
- .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
- event.preventDefault()
+$(document)
+ .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
+ event.preventDefault()
- let button = event.target
+ let button = event.target
- if (!$(button).hasClass(ClassName.BUTTON)) {
- button = $(button).closest(Selector.BUTTON)
- }
+ if (!$(button).hasClass(ClassName.BUTTON)) {
+ button = $(button).closest(Selector.BUTTON)
+ }
- Button._jQueryInterface.call($(button), 'toggle')
- })
- .on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
- const button = $(event.target).closest(Selector.BUTTON)[0]
- $(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type))
- })
+ Button._jQueryInterface.call($(button), 'toggle')
+ })
+ .on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
+ const button = $(event.target).closest(Selector.BUTTON)[0]
+ $(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type))
+ })
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Button._jQueryInterface
- $.fn[NAME].Constructor = Button
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Button._jQueryInterface
- }
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Button
-})($)
+$.fn[NAME] = Button._jQueryInterface
+$.fn[NAME].Constructor = Button
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Button._jQueryInterface
+}
export default Button
* --------------------------------------------------------------------------
*/
-const Carousel = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'carousel'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.carousel'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- const ARROW_LEFT_KEYCODE = 37 // KeyboardEvent.which value for left arrow key
- const ARROW_RIGHT_KEYCODE = 39 // KeyboardEvent.which value for right arrow key
- const TOUCHEVENT_COMPAT_WAIT = 500 // Time for mouse compat events to fire after touch
-
- const Default = {
- interval : 5000,
- keyboard : true,
- slide : false,
- pause : 'hover',
- wrap : true
- }
-
- const DefaultType = {
- interval : '(number|boolean)',
- keyboard : 'boolean',
- slide : '(boolean|string)',
- pause : '(string|boolean)',
- wrap : 'boolean'
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const Direction = {
- NEXT : 'next',
- PREV : 'prev',
- LEFT : 'left',
- RIGHT : 'right'
- }
+const NAME = 'carousel'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.carousel'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+const ARROW_LEFT_KEYCODE = 37 // KeyboardEvent.which value for left arrow key
+const ARROW_RIGHT_KEYCODE = 39 // KeyboardEvent.which value for right arrow key
+const TOUCHEVENT_COMPAT_WAIT = 500 // Time for mouse compat events to fire after touch
+
+const Default = {
+ interval : 5000,
+ keyboard : true,
+ slide : false,
+ pause : 'hover',
+ wrap : true
+}
+
+const DefaultType = {
+ interval : '(number|boolean)',
+ keyboard : 'boolean',
+ slide : '(boolean|string)',
+ pause : '(string|boolean)',
+ wrap : 'boolean'
+}
+
+const Direction = {
+ NEXT : 'next',
+ PREV : 'prev',
+ LEFT : 'left',
+ RIGHT : 'right'
+}
+
+const Event = {
+ SLIDE : `slide${EVENT_KEY}`,
+ SLID : `slid${EVENT_KEY}`,
+ KEYDOWN : `keydown${EVENT_KEY}`,
+ MOUSEENTER : `mouseenter${EVENT_KEY}`,
+ MOUSELEAVE : `mouseleave${EVENT_KEY}`,
+ TOUCHEND : `touchend${EVENT_KEY}`,
+ LOAD_DATA_API : `load${EVENT_KEY}${DATA_API_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ CAROUSEL : 'carousel',
+ ACTIVE : 'active',
+ SLIDE : 'slide',
+ RIGHT : 'carousel-item-right',
+ LEFT : 'carousel-item-left',
+ NEXT : 'carousel-item-next',
+ PREV : 'carousel-item-prev',
+ ITEM : 'carousel-item'
+}
+
+const Selector = {
+ ACTIVE : '.active',
+ ACTIVE_ITEM : '.active.carousel-item',
+ ITEM : '.carousel-item',
+ NEXT_PREV : '.carousel-item-next, .carousel-item-prev',
+ INDICATORS : '.carousel-indicators',
+ DATA_SLIDE : '[data-slide], [data-slide-to]',
+ DATA_RIDE : '[data-ride="carousel"]'
+}
- const Event = {
- SLIDE : `slide${EVENT_KEY}`,
- SLID : `slid${EVENT_KEY}`,
- KEYDOWN : `keydown${EVENT_KEY}`,
- MOUSEENTER : `mouseenter${EVENT_KEY}`,
- MOUSELEAVE : `mouseleave${EVENT_KEY}`,
- TOUCHEND : `touchend${EVENT_KEY}`,
- LOAD_DATA_API : `load${EVENT_KEY}${DATA_API_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
- }
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- const ClassName = {
- CAROUSEL : 'carousel',
- ACTIVE : 'active',
- SLIDE : 'slide',
- RIGHT : 'carousel-item-right',
- LEFT : 'carousel-item-left',
- NEXT : 'carousel-item-next',
- PREV : 'carousel-item-prev',
- ITEM : 'carousel-item'
- }
+class Carousel {
+ constructor(element, config) {
+ this._items = null
+ this._interval = null
+ this._activeElement = null
- const Selector = {
- ACTIVE : '.active',
- ACTIVE_ITEM : '.active.carousel-item',
- ITEM : '.carousel-item',
- NEXT_PREV : '.carousel-item-next, .carousel-item-prev',
- INDICATORS : '.carousel-indicators',
- DATA_SLIDE : '[data-slide], [data-slide-to]',
- DATA_RIDE : '[data-ride="carousel"]'
- }
+ this._isPaused = false
+ this._isSliding = false
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
+ this.touchTimeout = null
- class Carousel {
- constructor(element, config) {
- this._items = null
- this._interval = null
- this._activeElement = null
+ this._config = this._getConfig(config)
+ this._element = $(element)[0]
+ this._indicatorsElement = this._element.querySelector(Selector.INDICATORS)
- this._isPaused = false
- this._isSliding = false
+ this._addEventListeners()
+ }
- this.touchTimeout = null
+ // Getters
- this._config = this._getConfig(config)
- this._element = $(element)[0]
- this._indicatorsElement = this._element.querySelector(Selector.INDICATORS)
+ static get VERSION() {
+ return VERSION
+ }
- this._addEventListeners()
- }
+ static get Default() {
+ return Default
+ }
- // Getters
+ // Public
- static get VERSION() {
- return VERSION
+ next() {
+ if (!this._isSliding) {
+ this._slide(Direction.NEXT)
}
+ }
- static get Default() {
- return Default
+ nextWhenVisible() {
+ // Don't call next when the page isn't visible
+ // or the carousel or its parent isn't visible
+ if (!document.hidden &&
+ ($(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden')) {
+ this.next()
}
+ }
- // Public
-
- next() {
- if (!this._isSliding) {
- this._slide(Direction.NEXT)
- }
+ prev() {
+ if (!this._isSliding) {
+ this._slide(Direction.PREV)
}
+ }
- nextWhenVisible() {
- // Don't call next when the page isn't visible
- // or the carousel or its parent isn't visible
- if (!document.hidden &&
- ($(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden')) {
- this.next()
- }
+ pause(event) {
+ if (!event) {
+ this._isPaused = true
}
- prev() {
- if (!this._isSliding) {
- this._slide(Direction.PREV)
- }
+ if (this._element.querySelector(Selector.NEXT_PREV)) {
+ Util.triggerTransitionEnd(this._element)
+ this.cycle(true)
}
- pause(event) {
- if (!event) {
- this._isPaused = true
- }
+ clearInterval(this._interval)
+ this._interval = null
+ }
- if (this._element.querySelector(Selector.NEXT_PREV)) {
- Util.triggerTransitionEnd(this._element)
- this.cycle(true)
- }
+ cycle(event) {
+ if (!event) {
+ this._isPaused = false
+ }
+ if (this._interval) {
clearInterval(this._interval)
this._interval = null
}
- cycle(event) {
- if (!event) {
- this._isPaused = false
- }
+ if (this._config.interval && !this._isPaused) {
+ this._interval = setInterval(
+ (document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
+ this._config.interval
+ )
+ }
+ }
- if (this._interval) {
- clearInterval(this._interval)
- this._interval = null
- }
+ to(index) {
+ this._activeElement = this._element.querySelector(Selector.ACTIVE_ITEM)
- if (this._config.interval && !this._isPaused) {
- this._interval = setInterval(
- (document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
- this._config.interval
- )
- }
+ const activeIndex = this._getItemIndex(this._activeElement)
+
+ if (index > this._items.length - 1 || index < 0) {
+ return
}
- to(index) {
- this._activeElement = this._element.querySelector(Selector.ACTIVE_ITEM)
+ if (this._isSliding) {
+ $(this._element).one(Event.SLID, () => this.to(index))
+ return
+ }
- const activeIndex = this._getItemIndex(this._activeElement)
+ if (activeIndex === index) {
+ this.pause()
+ this.cycle()
+ return
+ }
- if (index > this._items.length - 1 || index < 0) {
- return
- }
+ const direction = index > activeIndex
+ ? Direction.NEXT
+ : Direction.PREV
- if (this._isSliding) {
- $(this._element).one(Event.SLID, () => this.to(index))
- return
- }
+ this._slide(direction, this._items[index])
+ }
- if (activeIndex === index) {
- this.pause()
- this.cycle()
- return
- }
+ dispose() {
+ $(this._element).off(EVENT_KEY)
+ $.removeData(this._element, DATA_KEY)
+
+ this._items = null
+ this._config = null
+ this._element = null
+ this._interval = null
+ this._isPaused = null
+ this._isSliding = null
+ this._activeElement = null
+ this._indicatorsElement = null
+ }
- const direction = index > activeIndex
- ? Direction.NEXT
- : Direction.PREV
+ // Private
- this._slide(direction, this._items[index])
+ _getConfig(config) {
+ config = {
+ ...Default,
+ ...config
}
+ Util.typeCheckConfig(NAME, config, DefaultType)
+ return config
+ }
- dispose() {
- $(this._element).off(EVENT_KEY)
- $.removeData(this._element, DATA_KEY)
-
- this._items = null
- this._config = null
- this._element = null
- this._interval = null
- this._isPaused = null
- this._isSliding = null
- this._activeElement = null
- this._indicatorsElement = null
+ _addEventListeners() {
+ if (this._config.keyboard) {
+ $(this._element)
+ .on(Event.KEYDOWN, (event) => this._keydown(event))
}
- // Private
-
- _getConfig(config) {
- config = {
- ...Default,
- ...config
+ if (this._config.pause === 'hover') {
+ $(this._element)
+ .on(Event.MOUSEENTER, (event) => this.pause(event))
+ .on(Event.MOUSELEAVE, (event) => this.cycle(event))
+ if ('ontouchstart' in document.documentElement) {
+ // 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
+ $(this._element).on(Event.TOUCHEND, () => {
+ this.pause()
+ if (this.touchTimeout) {
+ clearTimeout(this.touchTimeout)
+ }
+ this.touchTimeout = setTimeout((event) => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval)
+ })
}
- Util.typeCheckConfig(NAME, config, DefaultType)
- return config
}
+ }
- _addEventListeners() {
- if (this._config.keyboard) {
- $(this._element)
- .on(Event.KEYDOWN, (event) => this._keydown(event))
- }
-
- if (this._config.pause === 'hover') {
- $(this._element)
- .on(Event.MOUSEENTER, (event) => this.pause(event))
- .on(Event.MOUSELEAVE, (event) => this.cycle(event))
- if ('ontouchstart' in document.documentElement) {
- // 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
- $(this._element).on(Event.TOUCHEND, () => {
- this.pause()
- if (this.touchTimeout) {
- clearTimeout(this.touchTimeout)
- }
- this.touchTimeout = setTimeout((event) => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval)
- })
- }
- }
+ _keydown(event) {
+ if (/input|textarea/i.test(event.target.tagName)) {
+ return
}
- _keydown(event) {
- if (/input|textarea/i.test(event.target.tagName)) {
- return
- }
-
- switch (event.which) {
- case ARROW_LEFT_KEYCODE:
- event.preventDefault()
- this.prev()
- break
- case ARROW_RIGHT_KEYCODE:
- event.preventDefault()
- this.next()
- break
- default:
- }
+ switch (event.which) {
+ case ARROW_LEFT_KEYCODE:
+ event.preventDefault()
+ this.prev()
+ break
+ case ARROW_RIGHT_KEYCODE:
+ event.preventDefault()
+ this.next()
+ break
+ default:
}
+ }
- _getItemIndex(element) {
- this._items = element && element.parentNode
- ? [].slice.call(element.parentNode.querySelectorAll(Selector.ITEM))
- : []
- return this._items.indexOf(element)
- }
+ _getItemIndex(element) {
+ this._items = element && element.parentNode
+ ? [].slice.call(element.parentNode.querySelectorAll(Selector.ITEM))
+ : []
+ return this._items.indexOf(element)
+ }
- _getItemByDirection(direction, activeElement) {
- const isNextDirection = direction === Direction.NEXT
- const isPrevDirection = direction === Direction.PREV
- const activeIndex = this._getItemIndex(activeElement)
- const lastItemIndex = this._items.length - 1
- const isGoingToWrap = isPrevDirection && activeIndex === 0 ||
- isNextDirection && activeIndex === lastItemIndex
+ _getItemByDirection(direction, activeElement) {
+ const isNextDirection = direction === Direction.NEXT
+ const isPrevDirection = direction === Direction.PREV
+ const activeIndex = this._getItemIndex(activeElement)
+ const lastItemIndex = this._items.length - 1
+ const isGoingToWrap = isPrevDirection && activeIndex === 0 ||
+ isNextDirection && activeIndex === lastItemIndex
- if (isGoingToWrap && !this._config.wrap) {
- return activeElement
- }
+ if (isGoingToWrap && !this._config.wrap) {
+ return activeElement
+ }
- const delta = direction === Direction.PREV ? -1 : 1
- const itemIndex = (activeIndex + delta) % this._items.length
+ const delta = direction === Direction.PREV ? -1 : 1
+ const itemIndex = (activeIndex + delta) % this._items.length
- return itemIndex === -1
- ? this._items[this._items.length - 1] : this._items[itemIndex]
- }
+ return itemIndex === -1
+ ? this._items[this._items.length - 1] : this._items[itemIndex]
+ }
- _triggerSlideEvent(relatedTarget, eventDirectionName) {
- const targetIndex = this._getItemIndex(relatedTarget)
- const fromIndex = this._getItemIndex(this._element.querySelector(Selector.ACTIVE_ITEM))
- const slideEvent = $.Event(Event.SLIDE, {
- relatedTarget,
- direction: eventDirectionName,
- from: fromIndex,
- to: targetIndex
- })
+ _triggerSlideEvent(relatedTarget, eventDirectionName) {
+ const targetIndex = this._getItemIndex(relatedTarget)
+ const fromIndex = this._getItemIndex(this._element.querySelector(Selector.ACTIVE_ITEM))
+ const slideEvent = $.Event(Event.SLIDE, {
+ relatedTarget,
+ direction: eventDirectionName,
+ from: fromIndex,
+ to: targetIndex
+ })
- $(this._element).trigger(slideEvent)
+ $(this._element).trigger(slideEvent)
- return slideEvent
- }
+ return slideEvent
+ }
- _setActiveIndicatorElement(element) {
- if (this._indicatorsElement) {
- const indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector.ACTIVE))
- $(indicators)
- .removeClass(ClassName.ACTIVE)
+ _setActiveIndicatorElement(element) {
+ if (this._indicatorsElement) {
+ const indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector.ACTIVE))
+ $(indicators)
+ .removeClass(ClassName.ACTIVE)
- const nextIndicator = this._indicatorsElement.children[
- this._getItemIndex(element)
- ]
+ const nextIndicator = this._indicatorsElement.children[
+ this._getItemIndex(element)
+ ]
- if (nextIndicator) {
- $(nextIndicator).addClass(ClassName.ACTIVE)
- }
+ if (nextIndicator) {
+ $(nextIndicator).addClass(ClassName.ACTIVE)
}
}
+ }
- _slide(direction, element) {
- const activeElement = this._element.querySelector(Selector.ACTIVE_ITEM)
- const activeElementIndex = this._getItemIndex(activeElement)
- const nextElement = element || activeElement &&
- this._getItemByDirection(direction, activeElement)
- const nextElementIndex = this._getItemIndex(nextElement)
- const isCycling = Boolean(this._interval)
-
- let directionalClassName
- let orderClassName
- let eventDirectionName
-
- if (direction === Direction.NEXT) {
- directionalClassName = ClassName.LEFT
- orderClassName = ClassName.NEXT
- eventDirectionName = Direction.LEFT
- } else {
- directionalClassName = ClassName.RIGHT
- orderClassName = ClassName.PREV
- eventDirectionName = Direction.RIGHT
- }
+ _slide(direction, element) {
+ const activeElement = this._element.querySelector(Selector.ACTIVE_ITEM)
+ const activeElementIndex = this._getItemIndex(activeElement)
+ const nextElement = element || activeElement &&
+ this._getItemByDirection(direction, activeElement)
+ const nextElementIndex = this._getItemIndex(nextElement)
+ const isCycling = Boolean(this._interval)
+
+ let directionalClassName
+ let orderClassName
+ let eventDirectionName
+
+ if (direction === Direction.NEXT) {
+ directionalClassName = ClassName.LEFT
+ orderClassName = ClassName.NEXT
+ eventDirectionName = Direction.LEFT
+ } else {
+ directionalClassName = ClassName.RIGHT
+ orderClassName = ClassName.PREV
+ eventDirectionName = Direction.RIGHT
+ }
- if (nextElement && $(nextElement).hasClass(ClassName.ACTIVE)) {
- this._isSliding = false
- return
- }
+ if (nextElement && $(nextElement).hasClass(ClassName.ACTIVE)) {
+ this._isSliding = false
+ return
+ }
- const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName)
- if (slideEvent.isDefaultPrevented()) {
- return
- }
+ const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName)
+ if (slideEvent.isDefaultPrevented()) {
+ return
+ }
- if (!activeElement || !nextElement) {
- // Some weirdness is happening, so we bail
- return
- }
+ if (!activeElement || !nextElement) {
+ // Some weirdness is happening, so we bail
+ return
+ }
- this._isSliding = true
+ this._isSliding = true
- if (isCycling) {
- this.pause()
- }
+ if (isCycling) {
+ this.pause()
+ }
- this._setActiveIndicatorElement(nextElement)
+ this._setActiveIndicatorElement(nextElement)
- const slidEvent = $.Event(Event.SLID, {
- relatedTarget: nextElement,
- direction: eventDirectionName,
- from: activeElementIndex,
- to: nextElementIndex
- })
+ const slidEvent = $.Event(Event.SLID, {
+ relatedTarget: nextElement,
+ direction: eventDirectionName,
+ from: activeElementIndex,
+ to: nextElementIndex
+ })
- if ($(this._element).hasClass(ClassName.SLIDE)) {
- $(nextElement).addClass(orderClassName)
+ if ($(this._element).hasClass(ClassName.SLIDE)) {
+ $(nextElement).addClass(orderClassName)
- Util.reflow(nextElement)
+ Util.reflow(nextElement)
- $(activeElement).addClass(directionalClassName)
- $(nextElement).addClass(directionalClassName)
+ $(activeElement).addClass(directionalClassName)
+ $(nextElement).addClass(directionalClassName)
- const nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10)
- if (nextElementInterval) {
- this._config.defaultInterval = this._config.defaultInterval || this._config.interval
- this._config.interval = nextElementInterval
- } else {
- this._config.interval = this._config.defaultInterval || this._config.interval
- }
+ const nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10)
+ if (nextElementInterval) {
+ this._config.defaultInterval = this._config.defaultInterval || this._config.interval
+ this._config.interval = nextElementInterval
+ } else {
+ this._config.interval = this._config.defaultInterval || this._config.interval
+ }
- const transitionDuration = Util.getTransitionDurationFromElement(activeElement)
+ const transitionDuration = Util.getTransitionDurationFromElement(activeElement)
- $(activeElement)
- .one(Util.TRANSITION_END, () => {
- $(nextElement)
- .removeClass(`${directionalClassName} ${orderClassName}`)
- .addClass(ClassName.ACTIVE)
+ $(activeElement)
+ .one(Util.TRANSITION_END, () => {
+ $(nextElement)
+ .removeClass(`${directionalClassName} ${orderClassName}`)
+ .addClass(ClassName.ACTIVE)
- $(activeElement).removeClass(`${ClassName.ACTIVE} ${orderClassName} ${directionalClassName}`)
+ $(activeElement).removeClass(`${ClassName.ACTIVE} ${orderClassName} ${directionalClassName}`)
- this._isSliding = false
+ this._isSliding = false
- setTimeout(() => $(this._element).trigger(slidEvent), 0)
- })
- .emulateTransitionEnd(transitionDuration)
- } else {
- $(activeElement).removeClass(ClassName.ACTIVE)
- $(nextElement).addClass(ClassName.ACTIVE)
+ setTimeout(() => $(this._element).trigger(slidEvent), 0)
+ })
+ .emulateTransitionEnd(transitionDuration)
+ } else {
+ $(activeElement).removeClass(ClassName.ACTIVE)
+ $(nextElement).addClass(ClassName.ACTIVE)
- this._isSliding = false
- $(this._element).trigger(slidEvent)
- }
+ this._isSliding = false
+ $(this._element).trigger(slidEvent)
+ }
- if (isCycling) {
- this.cycle()
- }
+ if (isCycling) {
+ this.cycle()
}
+ }
- // Static
+ // Static
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- let _config = {
- ...Default,
- ...$(this).data()
- }
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ let _config = {
+ ...Default,
+ ...$(this).data()
+ }
- if (typeof config === 'object') {
- _config = {
- ..._config,
- ...config
- }
+ if (typeof config === 'object') {
+ _config = {
+ ..._config,
+ ...config
}
+ }
- const action = typeof config === 'string' ? config : _config.slide
+ const action = typeof config === 'string' ? config : _config.slide
- if (!data) {
- data = new Carousel(this, _config)
- $(this).data(DATA_KEY, data)
- }
+ if (!data) {
+ data = new Carousel(this, _config)
+ $(this).data(DATA_KEY, data)
+ }
- 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) {
- data.pause()
- data.cycle()
+ if (typeof config === 'number') {
+ data.to(config)
+ } else if (typeof action === 'string') {
+ if (typeof data[action] === 'undefined') {
+ throw new TypeError(`No method named "${action}"`)
}
- })
- }
-
- static _dataApiClickHandler(event) {
- const selector = Util.getSelectorFromElement(this)
-
- if (!selector) {
- return
+ data[action]()
+ } else if (_config.interval) {
+ data.pause()
+ data.cycle()
}
+ })
+ }
- const target = $(selector)[0]
+ static _dataApiClickHandler(event) {
+ const selector = Util.getSelectorFromElement(this)
- if (!target || !$(target).hasClass(ClassName.CAROUSEL)) {
- return
- }
+ if (!selector) {
+ return
+ }
- const config = {
- ...$(target).data(),
- ...$(this).data()
- }
- const slideIndex = this.getAttribute('data-slide-to')
+ const target = $(selector)[0]
- if (slideIndex) {
- config.interval = false
- }
+ if (!target || !$(target).hasClass(ClassName.CAROUSEL)) {
+ return
+ }
- Carousel._jQueryInterface.call($(target), config)
+ const config = {
+ ...$(target).data(),
+ ...$(this).data()
+ }
+ const slideIndex = this.getAttribute('data-slide-to')
- if (slideIndex) {
- $(target).data(DATA_KEY).to(slideIndex)
- }
+ if (slideIndex) {
+ config.interval = false
+ }
+
+ Carousel._jQueryInterface.call($(target), config)
- event.preventDefault()
+ if (slideIndex) {
+ $(target).data(DATA_KEY).to(slideIndex)
}
+
+ event.preventDefault()
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- $(document)
- .on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler)
+$(document)
+ .on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler)
- $(window).on(Event.LOAD_DATA_API, () => {
- const carousels = [].slice.call(document.querySelectorAll(Selector.DATA_RIDE))
- for (let i = 0, len = carousels.length; i < len; i++) {
- const $carousel = $(carousels[i])
- Carousel._jQueryInterface.call($carousel, $carousel.data())
- }
- })
-
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Carousel._jQueryInterface
- $.fn[NAME].Constructor = Carousel
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Carousel._jQueryInterface
+$(window).on(Event.LOAD_DATA_API, () => {
+ const carousels = [].slice.call(document.querySelectorAll(Selector.DATA_RIDE))
+ for (let i = 0, len = carousels.length; i < len; i++) {
+ const $carousel = $(carousels[i])
+ Carousel._jQueryInterface.call($carousel, $carousel.data())
}
+})
+
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Carousel
-})($)
+$.fn[NAME] = Carousel._jQueryInterface
+$.fn[NAME].Constructor = Carousel
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Carousel._jQueryInterface
+}
export default Carousel
* --------------------------------------------------------------------------
*/
-const Collapse = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'collapse'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.collapse'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
-
- const Default = {
- toggle : true,
- parent : ''
- }
-
- const DefaultType = {
- toggle : 'boolean',
- parent : '(string|element)'
- }
-
- const Event = {
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
- }
-
- const ClassName = {
- SHOW : 'show',
- COLLAPSE : 'collapse',
- COLLAPSING : 'collapsing',
- COLLAPSED : 'collapsed'
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const Dimension = {
- WIDTH : 'width',
- HEIGHT : 'height'
- }
+const NAME = 'collapse'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.collapse'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+
+const Default = {
+ toggle : true,
+ parent : ''
+}
+
+const DefaultType = {
+ toggle : 'boolean',
+ parent : '(string|element)'
+}
+
+const Event = {
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ SHOW : 'show',
+ COLLAPSE : 'collapse',
+ COLLAPSING : 'collapsing',
+ COLLAPSED : 'collapsed'
+}
+
+const Dimension = {
+ WIDTH : 'width',
+ HEIGHT : 'height'
+}
+
+const Selector = {
+ ACTIVES : '.show, .collapsing',
+ DATA_TOGGLE : '[data-toggle="collapse"]'
+}
- const Selector = {
- ACTIVES : '.show, .collapsing',
- DATA_TOGGLE : '[data-toggle="collapse"]'
- }
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
-
- class Collapse {
- constructor(element, config) {
- this._isTransitioning = false
- this._element = element
- this._config = this._getConfig(config)
- this._triggerArray = $.makeArray(document.querySelectorAll(
- `[data-toggle="collapse"][href="#${element.id}"],` +
- `[data-toggle="collapse"][data-target="#${element.id}"]`
- ))
- const toggleList = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE))
- for (let i = 0, len = toggleList.length; i < len; i++) {
- const elem = toggleList[i]
- const selector = Util.getSelectorFromElement(elem)
- const filterElement = [].slice.call(document.querySelectorAll(selector))
- .filter((foundElem) => foundElem === element)
-
- if (selector !== null && filterElement.length > 0) {
- this._selector = selector
- this._triggerArray.push(elem)
- }
+class Collapse {
+ constructor(element, config) {
+ this._isTransitioning = false
+ this._element = element
+ this._config = this._getConfig(config)
+ this._triggerArray = $.makeArray(document.querySelectorAll(
+ `[data-toggle="collapse"][href="#${element.id}"],` +
+ `[data-toggle="collapse"][data-target="#${element.id}"]`
+ ))
+ const toggleList = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE))
+ for (let i = 0, len = toggleList.length; i < len; i++) {
+ const elem = toggleList[i]
+ const selector = Util.getSelectorFromElement(elem)
+ const filterElement = [].slice.call(document.querySelectorAll(selector))
+ .filter((foundElem) => foundElem === element)
+
+ if (selector !== null && filterElement.length > 0) {
+ this._selector = selector
+ this._triggerArray.push(elem)
}
+ }
- this._parent = this._config.parent ? this._getParent() : null
+ this._parent = this._config.parent ? this._getParent() : null
- if (!this._config.parent) {
- this._addAriaAndCollapsedClass(this._element, this._triggerArray)
- }
+ if (!this._config.parent) {
+ this._addAriaAndCollapsedClass(this._element, this._triggerArray)
+ }
- if (this._config.toggle) {
- this.toggle()
- }
+ if (this._config.toggle) {
+ this.toggle()
}
+ }
- // Getters
+ // Getters
- static get VERSION() {
- return VERSION
- }
+ static get VERSION() {
+ return VERSION
+ }
- static get Default() {
- return Default
- }
+ static get Default() {
+ return Default
+ }
- // Public
+ // Public
- toggle() {
- if ($(this._element).hasClass(ClassName.SHOW)) {
- this.hide()
- } else {
- this.show()
- }
+ toggle() {
+ if ($(this._element).hasClass(ClassName.SHOW)) {
+ this.hide()
+ } else {
+ this.show()
}
+ }
- show() {
- if (this._isTransitioning ||
- $(this._element).hasClass(ClassName.SHOW)) {
- return
- }
-
- let actives
- let activesData
+ show() {
+ if (this._isTransitioning ||
+ $(this._element).hasClass(ClassName.SHOW)) {
+ return
+ }
- if (this._parent) {
- actives = [].slice.call(this._parent.querySelectorAll(Selector.ACTIVES))
- .filter((elem) => {
- if (typeof this._config.parent === 'string') {
- return elem.getAttribute('data-parent') === this._config.parent
- }
+ let actives
+ let activesData
- return elem.classList.contains(ClassName.COLLAPSE)
- })
+ if (this._parent) {
+ actives = [].slice.call(this._parent.querySelectorAll(Selector.ACTIVES))
+ .filter((elem) => {
+ if (typeof this._config.parent === 'string') {
+ return elem.getAttribute('data-parent') === this._config.parent
+ }
- if (actives.length === 0) {
- actives = null
- }
- }
+ return elem.classList.contains(ClassName.COLLAPSE)
+ })
- if (actives) {
- activesData = $(actives).not(this._selector).data(DATA_KEY)
- if (activesData && activesData._isTransitioning) {
- return
- }
+ if (actives.length === 0) {
+ actives = null
}
+ }
- const startEvent = $.Event(Event.SHOW)
- $(this._element).trigger(startEvent)
- if (startEvent.isDefaultPrevented()) {
+ if (actives) {
+ activesData = $(actives).not(this._selector).data(DATA_KEY)
+ if (activesData && activesData._isTransitioning) {
return
}
+ }
- if (actives) {
- Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide')
- if (!activesData) {
- $(actives).data(DATA_KEY, null)
- }
+ const startEvent = $.Event(Event.SHOW)
+ $(this._element).trigger(startEvent)
+ if (startEvent.isDefaultPrevented()) {
+ return
+ }
+
+ if (actives) {
+ Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide')
+ if (!activesData) {
+ $(actives).data(DATA_KEY, null)
}
+ }
- const dimension = this._getDimension()
+ const dimension = this._getDimension()
- $(this._element)
- .removeClass(ClassName.COLLAPSE)
- .addClass(ClassName.COLLAPSING)
+ $(this._element)
+ .removeClass(ClassName.COLLAPSE)
+ .addClass(ClassName.COLLAPSING)
- this._element.style[dimension] = 0
+ this._element.style[dimension] = 0
- if (this._triggerArray.length) {
- $(this._triggerArray)
- .removeClass(ClassName.COLLAPSED)
- .attr('aria-expanded', true)
- }
+ if (this._triggerArray.length) {
+ $(this._triggerArray)
+ .removeClass(ClassName.COLLAPSED)
+ .attr('aria-expanded', true)
+ }
+
+ this.setTransitioning(true)
- this.setTransitioning(true)
+ const complete = () => {
+ $(this._element)
+ .removeClass(ClassName.COLLAPSING)
+ .addClass(ClassName.COLLAPSE)
+ .addClass(ClassName.SHOW)
- const complete = () => {
- $(this._element)
- .removeClass(ClassName.COLLAPSING)
- .addClass(ClassName.COLLAPSE)
- .addClass(ClassName.SHOW)
+ this._element.style[dimension] = ''
- this._element.style[dimension] = ''
+ this.setTransitioning(false)
- this.setTransitioning(false)
+ $(this._element).trigger(Event.SHOWN)
+ }
- $(this._element).trigger(Event.SHOWN)
- }
+ const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1)
+ const scrollSize = `scroll${capitalizedDimension}`
+ const transitionDuration = Util.getTransitionDurationFromElement(this._element)
- const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1)
- const scrollSize = `scroll${capitalizedDimension}`
- const transitionDuration = Util.getTransitionDurationFromElement(this._element)
+ $(this._element)
+ .one(Util.TRANSITION_END, complete)
+ .emulateTransitionEnd(transitionDuration)
- $(this._element)
- .one(Util.TRANSITION_END, complete)
- .emulateTransitionEnd(transitionDuration)
+ this._element.style[dimension] = `${this._element[scrollSize]}px`
+ }
- this._element.style[dimension] = `${this._element[scrollSize]}px`
+ hide() {
+ if (this._isTransitioning ||
+ !$(this._element).hasClass(ClassName.SHOW)) {
+ return
}
- hide() {
- if (this._isTransitioning ||
- !$(this._element).hasClass(ClassName.SHOW)) {
- return
- }
+ const startEvent = $.Event(Event.HIDE)
+ $(this._element).trigger(startEvent)
+ if (startEvent.isDefaultPrevented()) {
+ return
+ }
- const startEvent = $.Event(Event.HIDE)
- $(this._element).trigger(startEvent)
- if (startEvent.isDefaultPrevented()) {
- return
- }
+ const dimension = this._getDimension()
- const dimension = this._getDimension()
+ this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`
- this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`
+ Util.reflow(this._element)
- Util.reflow(this._element)
+ $(this._element)
+ .addClass(ClassName.COLLAPSING)
+ .removeClass(ClassName.COLLAPSE)
+ .removeClass(ClassName.SHOW)
- $(this._element)
- .addClass(ClassName.COLLAPSING)
- .removeClass(ClassName.COLLAPSE)
- .removeClass(ClassName.SHOW)
-
- const triggerArrayLength = this._triggerArray.length
- if (triggerArrayLength > 0) {
- for (let i = 0; i < triggerArrayLength; i++) {
- const trigger = this._triggerArray[i]
- const selector = Util.getSelectorFromElement(trigger)
- if (selector !== null) {
- const $elem = $([].slice.call(document.querySelectorAll(selector)))
- if (!$elem.hasClass(ClassName.SHOW)) {
- $(trigger).addClass(ClassName.COLLAPSED)
- .attr('aria-expanded', false)
- }
+ const triggerArrayLength = this._triggerArray.length
+ if (triggerArrayLength > 0) {
+ for (let i = 0; i < triggerArrayLength; i++) {
+ const trigger = this._triggerArray[i]
+ const selector = Util.getSelectorFromElement(trigger)
+ if (selector !== null) {
+ const $elem = $([].slice.call(document.querySelectorAll(selector)))
+ if (!$elem.hasClass(ClassName.SHOW)) {
+ $(trigger).addClass(ClassName.COLLAPSED)
+ .attr('aria-expanded', false)
}
}
}
+ }
- this.setTransitioning(true)
-
- const complete = () => {
- this.setTransitioning(false)
- $(this._element)
- .removeClass(ClassName.COLLAPSING)
- .addClass(ClassName.COLLAPSE)
- .trigger(Event.HIDDEN)
- }
-
- this._element.style[dimension] = ''
- const transitionDuration = Util.getTransitionDurationFromElement(this._element)
+ this.setTransitioning(true)
+ const complete = () => {
+ this.setTransitioning(false)
$(this._element)
- .one(Util.TRANSITION_END, complete)
- .emulateTransitionEnd(transitionDuration)
+ .removeClass(ClassName.COLLAPSING)
+ .addClass(ClassName.COLLAPSE)
+ .trigger(Event.HIDDEN)
}
- setTransitioning(isTransitioning) {
- this._isTransitioning = isTransitioning
- }
+ this._element.style[dimension] = ''
+ const transitionDuration = Util.getTransitionDurationFromElement(this._element)
- dispose() {
- $.removeData(this._element, DATA_KEY)
+ $(this._element)
+ .one(Util.TRANSITION_END, complete)
+ .emulateTransitionEnd(transitionDuration)
+ }
- this._config = null
- this._parent = null
- this._element = null
- this._triggerArray = null
- this._isTransitioning = null
- }
+ setTransitioning(isTransitioning) {
+ this._isTransitioning = isTransitioning
+ }
- // Private
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
- _getConfig(config) {
- config = {
- ...Default,
- ...config
- }
- config.toggle = Boolean(config.toggle) // Coerce string values
- Util.typeCheckConfig(NAME, config, DefaultType)
- return config
- }
+ this._config = null
+ this._parent = null
+ this._element = null
+ this._triggerArray = null
+ this._isTransitioning = null
+ }
+
+ // Private
- _getDimension() {
- const hasWidth = $(this._element).hasClass(Dimension.WIDTH)
- return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT
+ _getConfig(config) {
+ config = {
+ ...Default,
+ ...config
}
+ config.toggle = Boolean(config.toggle) // Coerce string values
+ Util.typeCheckConfig(NAME, config, DefaultType)
+ return config
+ }
- _getParent() {
- let parent
+ _getDimension() {
+ const hasWidth = $(this._element).hasClass(Dimension.WIDTH)
+ return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT
+ }
- if (Util.isElement(this._config.parent)) {
- parent = this._config.parent
+ _getParent() {
+ let parent
- // It's a jQuery object
- if (typeof this._config.parent.jquery !== 'undefined') {
- parent = this._config.parent[0]
- }
- } else {
- parent = document.querySelector(this._config.parent)
+ if (Util.isElement(this._config.parent)) {
+ parent = this._config.parent
+
+ // It's a jQuery object
+ if (typeof this._config.parent.jquery !== 'undefined') {
+ parent = this._config.parent[0]
}
+ } else {
+ parent = document.querySelector(this._config.parent)
+ }
- const selector =
- `[data-toggle="collapse"][data-parent="${this._config.parent}"]`
+ const selector =
+ `[data-toggle="collapse"][data-parent="${this._config.parent}"]`
- const children = [].slice.call(parent.querySelectorAll(selector))
- $(children).each((i, element) => {
- this._addAriaAndCollapsedClass(
- Collapse._getTargetFromElement(element),
- [element]
- )
- })
+ const children = [].slice.call(parent.querySelectorAll(selector))
+ $(children).each((i, element) => {
+ this._addAriaAndCollapsedClass(
+ Collapse._getTargetFromElement(element),
+ [element]
+ )
+ })
- return parent
- }
+ return parent
+ }
- _addAriaAndCollapsedClass(element, triggerArray) {
- const isOpen = $(element).hasClass(ClassName.SHOW)
+ _addAriaAndCollapsedClass(element, triggerArray) {
+ const isOpen = $(element).hasClass(ClassName.SHOW)
- if (triggerArray.length) {
- $(triggerArray)
- .toggleClass(ClassName.COLLAPSED, !isOpen)
- .attr('aria-expanded', isOpen)
- }
+ if (triggerArray.length) {
+ $(triggerArray)
+ .toggleClass(ClassName.COLLAPSED, !isOpen)
+ .attr('aria-expanded', isOpen)
}
+ }
- // Static
+ // Static
- static _getTargetFromElement(element) {
- const selector = Util.getSelectorFromElement(element)
- return selector ? document.querySelector(selector) : null
- }
+ static _getTargetFromElement(element) {
+ const selector = Util.getSelectorFromElement(element)
+ return selector ? document.querySelector(selector) : null
+ }
- static _jQueryInterface(config) {
- return this.each(function () {
- const $this = $(this)
- let data = $this.data(DATA_KEY)
- const _config = {
- ...Default,
- ...$this.data(),
- ...typeof config === 'object' && config ? config : {}
- }
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ const $this = $(this)
+ let data = $this.data(DATA_KEY)
+ const _config = {
+ ...Default,
+ ...$this.data(),
+ ...typeof config === 'object' && config ? config : {}
+ }
- if (!data && _config.toggle && /show|hide/.test(config)) {
- _config.toggle = false
- }
+ if (!data && _config.toggle && /show|hide/.test(config)) {
+ _config.toggle = false
+ }
- if (!data) {
- data = new Collapse(this, _config)
- $this.data(DATA_KEY, data)
- }
+ if (!data) {
+ data = new Collapse(this, _config)
+ $this.data(DATA_KEY, data)
+ }
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
- }
+ data[config]()
+ }
+ })
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
-
// preventDefault only for <a> elements (which change the URL) not inside the collapsible element
- if (event.currentTarget.tagName === 'A') {
- event.preventDefault()
- }
+$(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
+ // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
+ if (event.currentTarget.tagName === 'A') {
+ event.preventDefault()
+ }
- const $trigger = $(this)
- const selector = Util.getSelectorFromElement(this)
- const selectors = [].slice.call(document.querySelectorAll(selector))
- $(selectors).each(function () {
- const $target = $(this)
- const data = $target.data(DATA_KEY)
- const config = data ? 'toggle' : $trigger.data()
- Collapse._jQueryInterface.call($target, config)
- })
+ const $trigger = $(this)
+ const selector = Util.getSelectorFromElement(this)
+ const selectors = [].slice.call(document.querySelectorAll(selector))
+ $(selectors).each(function () {
+ const $target = $(this)
+ const data = $target.data(DATA_KEY)
+ const config = data ? 'toggle' : $trigger.data()
+ Collapse._jQueryInterface.call($target, config)
})
+})
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Collapse._jQueryInterface
- $.fn[NAME].Constructor = Collapse
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Collapse._jQueryInterface
- }
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Collapse
-})($)
+$.fn[NAME] = Collapse._jQueryInterface
+$.fn[NAME].Constructor = Collapse
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Collapse._jQueryInterface
+}
export default Collapse
* --------------------------------------------------------------------------
*/
-const Dropdown = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'dropdown'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.dropdown'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
- const SPACE_KEYCODE = 32 // KeyboardEvent.which value for space key
- const TAB_KEYCODE = 9 // KeyboardEvent.which value for tab key
- const ARROW_UP_KEYCODE = 38 // KeyboardEvent.which value for up arrow key
- const ARROW_DOWN_KEYCODE = 40 // KeyboardEvent.which value for down arrow key
- const RIGHT_MOUSE_BUTTON_WHICH = 3 // MouseEvent.which value for the right button (assuming a right-handed mouse)
- const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEYCODE}|${ARROW_DOWN_KEYCODE}|${ESCAPE_KEYCODE}`)
-
- const Event = {
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- CLICK : `click${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`,
- KEYDOWN_DATA_API : `keydown${EVENT_KEY}${DATA_API_KEY}`,
- KEYUP_DATA_API : `keyup${EVENT_KEY}${DATA_API_KEY}`
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const ClassName = {
- DISABLED : 'disabled',
- SHOW : 'show',
- DROPUP : 'dropup',
- DROPRIGHT : 'dropright',
- DROPLEFT : 'dropleft',
- MENURIGHT : 'dropdown-menu-right',
- MENULEFT : 'dropdown-menu-left',
- POSITION_STATIC : 'position-static'
- }
+const NAME = 'dropdown'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.dropdown'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
+const SPACE_KEYCODE = 32 // KeyboardEvent.which value for space key
+const TAB_KEYCODE = 9 // KeyboardEvent.which value for tab key
+const ARROW_UP_KEYCODE = 38 // KeyboardEvent.which value for up arrow key
+const ARROW_DOWN_KEYCODE = 40 // KeyboardEvent.which value for down arrow key
+const RIGHT_MOUSE_BUTTON_WHICH = 3 // MouseEvent.which value for the right button (assuming a right-handed mouse)
+const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEYCODE}|${ARROW_DOWN_KEYCODE}|${ESCAPE_KEYCODE}`)
+
+const Event = {
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ CLICK : `click${EVENT_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`,
+ KEYDOWN_DATA_API : `keydown${EVENT_KEY}${DATA_API_KEY}`,
+ KEYUP_DATA_API : `keyup${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ DISABLED : 'disabled',
+ SHOW : 'show',
+ DROPUP : 'dropup',
+ DROPRIGHT : 'dropright',
+ DROPLEFT : 'dropleft',
+ MENURIGHT : 'dropdown-menu-right',
+ MENULEFT : 'dropdown-menu-left',
+ POSITION_STATIC : 'position-static'
+}
+
+const Selector = {
+ DATA_TOGGLE : '[data-toggle="dropdown"]',
+ FORM_CHILD : '.dropdown form',
+ MENU : '.dropdown-menu',
+ NAVBAR_NAV : '.navbar-nav',
+ VISIBLE_ITEMS : '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
+}
+
+const AttachmentMap = {
+ TOP : 'top-start',
+ TOPEND : 'top-end',
+ BOTTOM : 'bottom-start',
+ BOTTOMEND : 'bottom-end',
+ RIGHT : 'right-start',
+ RIGHTEND : 'right-end',
+ LEFT : 'left-start',
+ LEFTEND : 'left-end'
+}
+
+const Default = {
+ offset : 0,
+ flip : true,
+ boundary : 'scrollParent',
+ reference : 'toggle',
+ display : 'dynamic'
+}
+
+const DefaultType = {
+ offset : '(number|string|function)',
+ flip : 'boolean',
+ boundary : '(string|element)',
+ reference : '(string|element)',
+ display : 'string'
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- const Selector = {
- DATA_TOGGLE : '[data-toggle="dropdown"]',
- FORM_CHILD : '.dropdown form',
- MENU : '.dropdown-menu',
- NAVBAR_NAV : '.navbar-nav',
- VISIBLE_ITEMS : '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
+class Dropdown {
+ constructor(element, config) {
+ this._element = element
+ this._popper = null
+ this._config = this._getConfig(config)
+ this._menu = this._getMenuElement()
+ this._inNavbar = this._detectNavbar()
+
+ this._addEventListeners()
}
- const AttachmentMap = {
- TOP : 'top-start',
- TOPEND : 'top-end',
- BOTTOM : 'bottom-start',
- BOTTOMEND : 'bottom-end',
- RIGHT : 'right-start',
- RIGHTEND : 'right-end',
- LEFT : 'left-start',
- LEFTEND : 'left-end'
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- const Default = {
- offset : 0,
- flip : true,
- boundary : 'scrollParent',
- reference : 'toggle',
- display : 'dynamic'
+ static get Default() {
+ return Default
}
- const DefaultType = {
- offset : '(number|string|function)',
- flip : 'boolean',
- boundary : '(string|element)',
- reference : '(string|element)',
- display : 'string'
+ static get DefaultType() {
+ return DefaultType
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
-
- class Dropdown {
- constructor(element, config) {
- this._element = element
- this._popper = null
- this._config = this._getConfig(config)
- this._menu = this._getMenuElement()
- this._inNavbar = this._detectNavbar()
-
- this._addEventListeners()
+ // Public
+
+ toggle() {
+ if (this._element.disabled || $(this._element).hasClass(ClassName.DISABLED)) {
+ return
}
- // Getters
+ const parent = Dropdown._getParentFromElement(this._element)
+ const isActive = $(this._menu).hasClass(ClassName.SHOW)
- static get VERSION() {
- return VERSION
- }
+ Dropdown._clearMenus()
- static get Default() {
- return Default
+ if (isActive) {
+ return
}
- static get DefaultType() {
- return DefaultType
+ const relatedTarget = {
+ relatedTarget: this._element
}
+ const showEvent = $.Event(Event.SHOW, relatedTarget)
- // Public
-
- toggle() {
- if (this._element.disabled || $(this._element).hasClass(ClassName.DISABLED)) {
- return
- }
-
- const parent = Dropdown._getParentFromElement(this._element)
- const isActive = $(this._menu).hasClass(ClassName.SHOW)
+ $(parent).trigger(showEvent)
- Dropdown._clearMenus()
+ if (showEvent.isDefaultPrevented()) {
+ return
+ }
- if (isActive) {
- return
+ // Disable totally Popper.js for Dropdown in Navbar
+ if (!this._inNavbar) {
+ /**
+ * Check for Popper dependency
+ * Popper - https://popper.js.org
+ */
+ if (typeof Popper === 'undefined') {
+ throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)')
}
- const relatedTarget = {
- relatedTarget: this._element
- }
- const showEvent = $.Event(Event.SHOW, relatedTarget)
+ let referenceElement = this._element
- $(parent).trigger(showEvent)
+ if (this._config.reference === 'parent') {
+ referenceElement = parent
+ } else if (Util.isElement(this._config.reference)) {
+ referenceElement = this._config.reference
- if (showEvent.isDefaultPrevented()) {
- return
- }
-
- // Disable totally Popper.js for Dropdown in Navbar
- if (!this._inNavbar) {
- /**
- * Check for Popper dependency
- * Popper - https://popper.js.org
- */
- if (typeof Popper === 'undefined') {
- throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)')
+ // Check if it's jQuery element
+ if (typeof this._config.reference.jquery !== 'undefined') {
+ referenceElement = this._config.reference[0]
}
-
- let referenceElement = this._element
-
- if (this._config.reference === 'parent') {
- referenceElement = parent
- } else if (Util.isElement(this._config.reference)) {
- referenceElement = this._config.reference
-
- // Check if it's jQuery element
- if (typeof this._config.reference.jquery !== 'undefined') {
- referenceElement = this._config.reference[0]
- }
- }
-
- // If boundary is not `scrollParent`, then set position to `static`
- // to allow the menu to "escape" the scroll parent's boundaries
- // https://github.com/twbs/bootstrap/issues/24251
- if (this._config.boundary !== 'scrollParent') {
- $(parent).addClass(ClassName.POSITION_STATIC)
- }
- this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig())
}
- // 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
- if ('ontouchstart' in document.documentElement &&
- $(parent).closest(Selector.NAVBAR_NAV).length === 0) {
- $(document.body).children().on('mouseover', null, $.noop)
+ // If boundary is not `scrollParent`, then set position to `static`
+ // to allow the menu to "escape" the scroll parent's boundaries
+ // https://github.com/twbs/bootstrap/issues/24251
+ if (this._config.boundary !== 'scrollParent') {
+ $(parent).addClass(ClassName.POSITION_STATIC)
}
-
- this._element.focus()
- this._element.setAttribute('aria-expanded', true)
-
- $(this._menu).toggleClass(ClassName.SHOW)
- $(parent)
- .toggleClass(ClassName.SHOW)
- .trigger($.Event(Event.SHOWN, relatedTarget))
+ this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig())
}
- dispose() {
- $.removeData(this._element, DATA_KEY)
- $(this._element).off(EVENT_KEY)
- this._element = null
- this._menu = null
- if (this._popper !== null) {
- this._popper.destroy()
- this._popper = null
- }
+ // 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
+ if ('ontouchstart' in document.documentElement &&
+ $(parent).closest(Selector.NAVBAR_NAV).length === 0) {
+ $(document.body).children().on('mouseover', null, $.noop)
}
- update() {
- this._inNavbar = this._detectNavbar()
- if (this._popper !== null) {
- this._popper.scheduleUpdate()
- }
- }
+ this._element.focus()
+ this._element.setAttribute('aria-expanded', true)
- // Private
+ $(this._menu).toggleClass(ClassName.SHOW)
+ $(parent)
+ .toggleClass(ClassName.SHOW)
+ .trigger($.Event(Event.SHOWN, relatedTarget))
+ }
- _addEventListeners() {
- $(this._element).on(Event.CLICK, (event) => {
- event.preventDefault()
- event.stopPropagation()
- this.toggle()
- })
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
+ $(this._element).off(EVENT_KEY)
+ this._element = null
+ this._menu = null
+ if (this._popper !== null) {
+ this._popper.destroy()
+ this._popper = null
}
+ }
- _getConfig(config) {
- config = {
- ...this.constructor.Default,
- ...$(this._element).data(),
- ...config
- }
+ update() {
+ this._inNavbar = this._detectNavbar()
+ if (this._popper !== null) {
+ this._popper.scheduleUpdate()
+ }
+ }
- Util.typeCheckConfig(
- NAME,
- config,
- this.constructor.DefaultType
- )
+ // Private
+
+ _addEventListeners() {
+ $(this._element).on(Event.CLICK, (event) => {
+ event.preventDefault()
+ event.stopPropagation()
+ this.toggle()
+ })
+ }
- return config
+ _getConfig(config) {
+ config = {
+ ...this.constructor.Default,
+ ...$(this._element).data(),
+ ...config
}
- _getMenuElement() {
- if (!this._menu) {
- const parent = Dropdown._getParentFromElement(this._element)
- if (parent) {
- this._menu = parent.querySelector(Selector.MENU)
- }
+ Util.typeCheckConfig(
+ NAME,
+ config,
+ this.constructor.DefaultType
+ )
+
+ return config
+ }
+
+ _getMenuElement() {
+ if (!this._menu) {
+ const parent = Dropdown._getParentFromElement(this._element)
+ if (parent) {
+ this._menu = parent.querySelector(Selector.MENU)
}
- return this._menu
}
+ return this._menu
+ }
- _getPlacement() {
- const $parentDropdown = $(this._element.parentNode)
- let placement = AttachmentMap.BOTTOM
+ _getPlacement() {
+ const $parentDropdown = $(this._element.parentNode)
+ let placement = AttachmentMap.BOTTOM
- // Handle dropup
- if ($parentDropdown.hasClass(ClassName.DROPUP)) {
- placement = AttachmentMap.TOP
- if ($(this._menu).hasClass(ClassName.MENURIGHT)) {
- placement = AttachmentMap.TOPEND
- }
- } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
- placement = AttachmentMap.RIGHT
- } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
- placement = AttachmentMap.LEFT
- } else if ($(this._menu).hasClass(ClassName.MENURIGHT)) {
- placement = AttachmentMap.BOTTOMEND
+ // Handle dropup
+ if ($parentDropdown.hasClass(ClassName.DROPUP)) {
+ placement = AttachmentMap.TOP
+ if ($(this._menu).hasClass(ClassName.MENURIGHT)) {
+ placement = AttachmentMap.TOPEND
}
- return placement
+ } else if ($parentDropdown.hasClass(ClassName.DROPRIGHT)) {
+ placement = AttachmentMap.RIGHT
+ } else if ($parentDropdown.hasClass(ClassName.DROPLEFT)) {
+ placement = AttachmentMap.LEFT
+ } else if ($(this._menu).hasClass(ClassName.MENURIGHT)) {
+ placement = AttachmentMap.BOTTOMEND
}
+ return placement
+ }
- _detectNavbar() {
- return $(this._element).closest('.navbar').length > 0
- }
+ _detectNavbar() {
+ return $(this._element).closest('.navbar').length > 0
+ }
- _getPopperConfig() {
- const offsetConf = {}
- if (typeof this._config.offset === 'function') {
- offsetConf.fn = (data) => {
- data.offsets = {
- ...data.offsets,
- ...this._config.offset(data.offsets) || {}
- }
- return data
+ _getPopperConfig() {
+ const offsetConf = {}
+ if (typeof this._config.offset === 'function') {
+ offsetConf.fn = (data) => {
+ data.offsets = {
+ ...data.offsets,
+ ...this._config.offset(data.offsets) || {}
}
- } else {
- offsetConf.offset = this._config.offset
+ return data
}
+ } else {
+ offsetConf.offset = this._config.offset
+ }
- const popperConfig = {
- placement: this._getPlacement(),
- modifiers: {
- offset: offsetConf,
- flip: {
- enabled: this._config.flip
- },
- preventOverflow: {
- boundariesElement: this._config.boundary
- }
+ const popperConfig = {
+ placement: this._getPlacement(),
+ modifiers: {
+ offset: offsetConf,
+ flip: {
+ enabled: this._config.flip
+ },
+ preventOverflow: {
+ boundariesElement: this._config.boundary
}
}
+ }
- // Disable Popper.js if we have a static display
- if (this._config.display === 'static') {
- popperConfig.modifiers.applyStyle = {
- enabled: false
- }
+ // Disable Popper.js if we have a static display
+ if (this._config.display === 'static') {
+ popperConfig.modifiers.applyStyle = {
+ enabled: false
}
- return popperConfig
}
+ return popperConfig
+ }
- // Static
+ // Static
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- const _config = typeof config === 'object' ? config : null
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ const _config = typeof config === 'object' ? config : null
- if (!data) {
- data = new Dropdown(this, _config)
- $(this).data(DATA_KEY, data)
- }
+ if (!data) {
+ data = new Dropdown(this, _config)
+ $(this).data(DATA_KEY, data)
+ }
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
+ data[config]()
+ }
+ })
+ }
+
+ static _clearMenus(event) {
+ if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH ||
+ event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
+ return
}
- static _clearMenus(event) {
- if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH ||
- event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
- return
+ const toggles = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE))
+ for (let i = 0, len = toggles.length; i < len; i++) {
+ const parent = Dropdown._getParentFromElement(toggles[i])
+ const context = $(toggles[i]).data(DATA_KEY)
+ const relatedTarget = {
+ relatedTarget: toggles[i]
}
- const toggles = [].slice.call(document.querySelectorAll(Selector.DATA_TOGGLE))
- for (let i = 0, len = toggles.length; i < len; i++) {
- const parent = Dropdown._getParentFromElement(toggles[i])
- const context = $(toggles[i]).data(DATA_KEY)
- const relatedTarget = {
- relatedTarget: toggles[i]
- }
-
- if (event && event.type === 'click') {
- relatedTarget.clickEvent = event
- }
+ if (event && event.type === 'click') {
+ relatedTarget.clickEvent = event
+ }
- if (!context) {
- continue
- }
+ if (!context) {
+ continue
+ }
- const dropdownMenu = context._menu
- if (!$(parent).hasClass(ClassName.SHOW)) {
- continue
- }
+ const dropdownMenu = context._menu
+ if (!$(parent).hasClass(ClassName.SHOW)) {
+ continue
+ }
- if (event && (event.type === 'click' &&
- /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) &&
- $.contains(parent, event.target)) {
- continue
- }
+ if (event && (event.type === 'click' &&
+ /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) &&
+ $.contains(parent, event.target)) {
+ continue
+ }
- const hideEvent = $.Event(Event.HIDE, relatedTarget)
- $(parent).trigger(hideEvent)
- if (hideEvent.isDefaultPrevented()) {
- continue
- }
+ const hideEvent = $.Event(Event.HIDE, relatedTarget)
+ $(parent).trigger(hideEvent)
+ if (hideEvent.isDefaultPrevented()) {
+ continue
+ }
- // If this is a touch-enabled device we remove the extra
- // empty mouseover listeners we added for iOS support
- if ('ontouchstart' in document.documentElement) {
- $(document.body).children().off('mouseover', null, $.noop)
- }
+ // If this is a touch-enabled device we remove the extra
+ // empty mouseover listeners we added for iOS support
+ if ('ontouchstart' in document.documentElement) {
+ $(document.body).children().off('mouseover', null, $.noop)
+ }
- toggles[i].setAttribute('aria-expanded', 'false')
+ toggles[i].setAttribute('aria-expanded', 'false')
- $(dropdownMenu).removeClass(ClassName.SHOW)
- $(parent)
- .removeClass(ClassName.SHOW)
- .trigger($.Event(Event.HIDDEN, relatedTarget))
- }
+ $(dropdownMenu).removeClass(ClassName.SHOW)
+ $(parent)
+ .removeClass(ClassName.SHOW)
+ .trigger($.Event(Event.HIDDEN, relatedTarget))
}
+ }
- static _getParentFromElement(element) {
- let parent
- const selector = Util.getSelectorFromElement(element)
-
- if (selector) {
- parent = document.querySelector(selector)
- }
+ static _getParentFromElement(element) {
+ let parent
+ const selector = Util.getSelectorFromElement(element)
- return parent || element.parentNode
+ if (selector) {
+ parent = document.querySelector(selector)
}
- // eslint-disable-next-line complexity
- 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.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE &&
- (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE ||
- $(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
- return
- }
+ return parent || element.parentNode
+ }
- event.preventDefault()
- event.stopPropagation()
+ // eslint-disable-next-line complexity
+ 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.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE &&
+ (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE ||
+ $(event.target).closest(Selector.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) {
+ return
+ }
- if (this.disabled || $(this).hasClass(ClassName.DISABLED)) {
- return
- }
+ event.preventDefault()
+ event.stopPropagation()
- const parent = Dropdown._getParentFromElement(this)
- const isActive = $(parent).hasClass(ClassName.SHOW)
+ if (this.disabled || $(this).hasClass(ClassName.DISABLED)) {
+ return
+ }
- if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) ||
- isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
- if (event.which === ESCAPE_KEYCODE) {
- const toggle = parent.querySelector(Selector.DATA_TOGGLE)
- $(toggle).trigger('focus')
- }
+ const parent = Dropdown._getParentFromElement(this)
+ const isActive = $(parent).hasClass(ClassName.SHOW)
- $(this).trigger('click')
- return
+ if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) ||
+ isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
+ if (event.which === ESCAPE_KEYCODE) {
+ const toggle = parent.querySelector(Selector.DATA_TOGGLE)
+ $(toggle).trigger('focus')
}
- const items = [].slice.call(parent.querySelectorAll(Selector.VISIBLE_ITEMS))
+ $(this).trigger('click')
+ return
+ }
- if (items.length === 0) {
- return
- }
+ const items = [].slice.call(parent.querySelectorAll(Selector.VISIBLE_ITEMS))
- let index = items.indexOf(event.target)
+ if (items.length === 0) {
+ return
+ }
- if (event.which === ARROW_UP_KEYCODE && index > 0) { // Up
- index--
- }
+ let index = items.indexOf(event.target)
- if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { // Down
- index++
- }
+ if (event.which === ARROW_UP_KEYCODE && index > 0) { // Up
+ index--
+ }
- if (index < 0) {
- index = 0
- }
+ if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { // Down
+ index++
+ }
- items[index].focus()
+ if (index < 0) {
+ index = 0
}
+
+ items[index].focus()
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
-
- $(document)
- .on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler)
- .on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler)
- .on(`${Event.CLICK_DATA_API} ${Event.KEYUP_DATA_API}`, Dropdown._clearMenus)
- .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
- event.preventDefault()
- event.stopPropagation()
- Dropdown._jQueryInterface.call($(this), 'toggle')
- })
- .on(Event.CLICK_DATA_API, Selector.FORM_CHILD, (e) => {
- e.stopPropagation()
- })
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Dropdown._jQueryInterface
- $.fn[NAME].Constructor = Dropdown
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Dropdown._jQueryInterface
- }
+$(document)
+ .on(Event.KEYDOWN_DATA_API, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler)
+ .on(Event.KEYDOWN_DATA_API, Selector.MENU, Dropdown._dataApiKeydownHandler)
+ .on(`${Event.CLICK_DATA_API} ${Event.KEYUP_DATA_API}`, Dropdown._clearMenus)
+ .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
+ event.preventDefault()
+ event.stopPropagation()
+ Dropdown._jQueryInterface.call($(this), 'toggle')
+ })
+ .on(Event.CLICK_DATA_API, Selector.FORM_CHILD, (e) => {
+ e.stopPropagation()
+ })
+
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
+
+$.fn[NAME] = Dropdown._jQueryInterface
+$.fn[NAME].Constructor = Dropdown
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Dropdown._jQueryInterface
+}
- return Dropdown
-})($, Popper)
export default Dropdown
* --------------------------------------------------------------------------
*/
-(($) => {
+(() => {
if (typeof $ === 'undefined') {
throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.')
}
if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0')
}
-})($)
+})()
export {
Util,
* --------------------------------------------------------------------------
*/
-const Modal = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'modal'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.modal'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
-
- const Default = {
- backdrop : true,
- keyboard : true,
- focus : true,
- show : true
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const DefaultType = {
- backdrop : '(boolean|string)',
- keyboard : 'boolean',
- focus : 'boolean',
- show : 'boolean'
- }
+const NAME = 'modal'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.modal'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
+
+const Default = {
+ backdrop : true,
+ keyboard : true,
+ focus : true,
+ show : true
+}
+
+const DefaultType = {
+ backdrop : '(boolean|string)',
+ keyboard : 'boolean',
+ focus : 'boolean',
+ show : 'boolean'
+}
+
+const Event = {
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ FOCUSIN : `focusin${EVENT_KEY}`,
+ RESIZE : `resize${EVENT_KEY}`,
+ CLICK_DISMISS : `click.dismiss${EVENT_KEY}`,
+ KEYDOWN_DISMISS : `keydown.dismiss${EVENT_KEY}`,
+ MOUSEUP_DISMISS : `mouseup.dismiss${EVENT_KEY}`,
+ MOUSEDOWN_DISMISS : `mousedown.dismiss${EVENT_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ SCROLLBAR_MEASURER : 'modal-scrollbar-measure',
+ BACKDROP : 'modal-backdrop',
+ OPEN : 'modal-open',
+ FADE : 'fade',
+ SHOW : 'show'
+}
+
+const Selector = {
+ DIALOG : '.modal-dialog',
+ DATA_TOGGLE : '[data-toggle="modal"]',
+ DATA_DISMISS : '[data-dismiss="modal"]',
+ FIXED_CONTENT : '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
+ STICKY_CONTENT : '.sticky-top'
+}
- const Event = {
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- FOCUSIN : `focusin${EVENT_KEY}`,
- RESIZE : `resize${EVENT_KEY}`,
- CLICK_DISMISS : `click.dismiss${EVENT_KEY}`,
- KEYDOWN_DISMISS : `keydown.dismiss${EVENT_KEY}`,
- MOUSEUP_DISMISS : `mouseup.dismiss${EVENT_KEY}`,
- MOUSEDOWN_DISMISS : `mousedown.dismiss${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
- }
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- const ClassName = {
- SCROLLBAR_MEASURER : 'modal-scrollbar-measure',
- BACKDROP : 'modal-backdrop',
- OPEN : 'modal-open',
- FADE : 'fade',
- SHOW : 'show'
+class Modal {
+ constructor(element, config) {
+ this._config = this._getConfig(config)
+ this._element = element
+ this._dialog = element.querySelector(Selector.DIALOG)
+ this._backdrop = null
+ this._isShown = false
+ this._isBodyOverflowing = false
+ this._ignoreBackdropClick = false
+ this._scrollbarWidth = 0
}
- const Selector = {
- DIALOG : '.modal-dialog',
- DATA_TOGGLE : '[data-toggle="modal"]',
- DATA_DISMISS : '[data-dismiss="modal"]',
- FIXED_CONTENT : '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
- STICKY_CONTENT : '.sticky-top'
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
-
- class Modal {
- constructor(element, config) {
- this._config = this._getConfig(config)
- this._element = element
- this._dialog = element.querySelector(Selector.DIALOG)
- this._backdrop = null
- this._isShown = false
- this._isBodyOverflowing = false
- this._ignoreBackdropClick = false
- this._scrollbarWidth = 0
- }
+ static get Default() {
+ return Default
+ }
- // Getters
+ // Public
- static get VERSION() {
- return VERSION
- }
+ toggle(relatedTarget) {
+ return this._isShown ? this.hide() : this.show(relatedTarget)
+ }
- static get Default() {
- return Default
+ show(relatedTarget) {
+ if (this._isTransitioning || this._isShown) {
+ return
}
- // Public
-
- toggle(relatedTarget) {
- return this._isShown ? this.hide() : this.show(relatedTarget)
+ if ($(this._element).hasClass(ClassName.FADE)) {
+ this._isTransitioning = true
}
- show(relatedTarget) {
- if (this._isTransitioning || this._isShown) {
- return
- }
+ const showEvent = $.Event(Event.SHOW, {
+ relatedTarget
+ })
- if ($(this._element).hasClass(ClassName.FADE)) {
- this._isTransitioning = true
- }
+ $(this._element).trigger(showEvent)
- const showEvent = $.Event(Event.SHOW, {
- relatedTarget
- })
+ if (this._isShown || showEvent.isDefaultPrevented()) {
+ return
+ }
- $(this._element).trigger(showEvent)
+ this._isShown = true
- if (this._isShown || showEvent.isDefaultPrevented()) {
- return
- }
+ this._checkScrollbar()
+ this._setScrollbar()
- this._isShown = true
+ this._adjustDialog()
- this._checkScrollbar()
- this._setScrollbar()
+ $(document.body).addClass(ClassName.OPEN)
- this._adjustDialog()
+ this._setEscapeEvent()
+ this._setResizeEvent()
- $(document.body).addClass(ClassName.OPEN)
+ $(this._element).on(
+ Event.CLICK_DISMISS,
+ Selector.DATA_DISMISS,
+ (event) => this.hide(event)
+ )
- this._setEscapeEvent()
- this._setResizeEvent()
+ $(this._dialog).on(Event.MOUSEDOWN_DISMISS, () => {
+ $(this._element).one(Event.MOUSEUP_DISMISS, (event) => {
+ if ($(event.target).is(this._element)) {
+ this._ignoreBackdropClick = true
+ }
+ })
+ })
- $(this._element).on(
- Event.CLICK_DISMISS,
- Selector.DATA_DISMISS,
- (event) => this.hide(event)
- )
+ this._showBackdrop(() => this._showElement(relatedTarget))
+ }
- $(this._dialog).on(Event.MOUSEDOWN_DISMISS, () => {
- $(this._element).one(Event.MOUSEUP_DISMISS, (event) => {
- if ($(event.target).is(this._element)) {
- this._ignoreBackdropClick = true
- }
- })
- })
+ hide(event) {
+ if (event) {
+ event.preventDefault()
+ }
- this._showBackdrop(() => this._showElement(relatedTarget))
+ if (this._isTransitioning || !this._isShown) {
+ return
}
- hide(event) {
- if (event) {
- event.preventDefault()
- }
+ const hideEvent = $.Event(Event.HIDE)
- if (this._isTransitioning || !this._isShown) {
- return
- }
+ $(this._element).trigger(hideEvent)
- const hideEvent = $.Event(Event.HIDE)
+ if (!this._isShown || hideEvent.isDefaultPrevented()) {
+ return
+ }
- $(this._element).trigger(hideEvent)
+ this._isShown = false
+ const transition = $(this._element).hasClass(ClassName.FADE)
- if (!this._isShown || hideEvent.isDefaultPrevented()) {
- return
- }
+ if (transition) {
+ this._isTransitioning = true
+ }
- this._isShown = false
- const transition = $(this._element).hasClass(ClassName.FADE)
+ this._setEscapeEvent()
+ this._setResizeEvent()
- if (transition) {
- this._isTransitioning = true
- }
+ $(document).off(Event.FOCUSIN)
- this._setEscapeEvent()
- this._setResizeEvent()
+ $(this._element).removeClass(ClassName.SHOW)
- $(document).off(Event.FOCUSIN)
+ $(this._element).off(Event.CLICK_DISMISS)
+ $(this._dialog).off(Event.MOUSEDOWN_DISMISS)
- $(this._element).removeClass(ClassName.SHOW)
- $(this._element).off(Event.CLICK_DISMISS)
- $(this._dialog).off(Event.MOUSEDOWN_DISMISS)
+ if (transition) {
+ const transitionDuration = Util.getTransitionDurationFromElement(this._element)
+ $(this._element)
+ .one(Util.TRANSITION_END, (event) => this._hideModal(event))
+ .emulateTransitionEnd(transitionDuration)
+ } else {
+ this._hideModal()
+ }
+ }
- if (transition) {
- const transitionDuration = Util.getTransitionDurationFromElement(this._element)
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
- $(this._element)
- .one(Util.TRANSITION_END, (event) => this._hideModal(event))
- .emulateTransitionEnd(transitionDuration)
- } else {
- this._hideModal()
- }
- }
+ $(window, document, this._element, this._backdrop).off(EVENT_KEY)
- dispose() {
- $.removeData(this._element, DATA_KEY)
+ this._config = null
+ this._element = null
+ this._dialog = null
+ this._backdrop = null
+ this._isShown = null
+ this._isBodyOverflowing = null
+ this._ignoreBackdropClick = null
+ this._scrollbarWidth = null
+ }
- $(window, document, this._element, this._backdrop).off(EVENT_KEY)
+ handleUpdate() {
+ this._adjustDialog()
+ }
- this._config = null
- this._element = null
- this._dialog = null
- this._backdrop = null
- this._isShown = null
- this._isBodyOverflowing = null
- this._ignoreBackdropClick = null
- this._scrollbarWidth = null
- }
+ // Private
- handleUpdate() {
- this._adjustDialog()
+ _getConfig(config) {
+ config = {
+ ...Default,
+ ...config
}
+ Util.typeCheckConfig(NAME, config, DefaultType)
+ return config
+ }
- // Private
+ _showElement(relatedTarget) {
+ const transition = $(this._element).hasClass(ClassName.FADE)
- _getConfig(config) {
- config = {
- ...Default,
- ...config
- }
- Util.typeCheckConfig(NAME, config, DefaultType)
- return config
+ if (!this._element.parentNode ||
+ this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
+ // Don't move modal's DOM position
+ document.body.appendChild(this._element)
}
- _showElement(relatedTarget) {
- const transition = $(this._element).hasClass(ClassName.FADE)
+ this._element.style.display = 'block'
+ this._element.removeAttribute('aria-hidden')
+ this._element.scrollTop = 0
- if (!this._element.parentNode ||
- this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
- // Don't move modal's DOM position
- document.body.appendChild(this._element)
- }
+ if (transition) {
+ Util.reflow(this._element)
+ }
- this._element.style.display = 'block'
- this._element.removeAttribute('aria-hidden')
- this._element.scrollTop = 0
+ $(this._element).addClass(ClassName.SHOW)
- if (transition) {
- Util.reflow(this._element)
- }
+ if (this._config.focus) {
+ this._enforceFocus()
+ }
- $(this._element).addClass(ClassName.SHOW)
+ const shownEvent = $.Event(Event.SHOWN, {
+ relatedTarget
+ })
+ const transitionComplete = () => {
if (this._config.focus) {
- this._enforceFocus()
+ this._element.focus()
}
+ this._isTransitioning = false
+ $(this._element).trigger(shownEvent)
+ }
- const shownEvent = $.Event(Event.SHOWN, {
- relatedTarget
- })
+ if (transition) {
+ const transitionDuration = Util.getTransitionDurationFromElement(this._element)
- const transitionComplete = () => {
- if (this._config.focus) {
+ $(this._dialog)
+ .one(Util.TRANSITION_END, transitionComplete)
+ .emulateTransitionEnd(transitionDuration)
+ } else {
+ transitionComplete()
+ }
+ }
+
+ _enforceFocus() {
+ $(document)
+ .off(Event.FOCUSIN) // Guard against infinite focus loop
+ .on(Event.FOCUSIN, (event) => {
+ if (document !== event.target &&
+ this._element !== event.target &&
+ $(this._element).has(event.target).length === 0) {
this._element.focus()
}
- this._isTransitioning = false
- $(this._element).trigger(shownEvent)
- }
-
- if (transition) {
- const transitionDuration = Util.getTransitionDurationFromElement(this._element)
+ })
+ }
- $(this._dialog)
- .one(Util.TRANSITION_END, transitionComplete)
- .emulateTransitionEnd(transitionDuration)
- } else {
- transitionComplete()
- }
+ _setEscapeEvent() {
+ if (this._isShown && this._config.keyboard) {
+ $(this._element).on(Event.KEYDOWN_DISMISS, (event) => {
+ if (event.which === ESCAPE_KEYCODE) {
+ event.preventDefault()
+ this.hide()
+ }
+ })
+ } else if (!this._isShown) {
+ $(this._element).off(Event.KEYDOWN_DISMISS)
}
+ }
- _enforceFocus() {
- $(document)
- .off(Event.FOCUSIN) // Guard against infinite focus loop
- .on(Event.FOCUSIN, (event) => {
- if (document !== event.target &&
- this._element !== event.target &&
- $(this._element).has(event.target).length === 0) {
- this._element.focus()
- }
- })
+ _setResizeEvent() {
+ if (this._isShown) {
+ $(window).on(Event.RESIZE, (event) => this.handleUpdate(event))
+ } else {
+ $(window).off(Event.RESIZE)
}
+ }
- _setEscapeEvent() {
- if (this._isShown && this._config.keyboard) {
- $(this._element).on(Event.KEYDOWN_DISMISS, (event) => {
- if (event.which === ESCAPE_KEYCODE) {
- event.preventDefault()
- this.hide()
- }
- })
- } else if (!this._isShown) {
- $(this._element).off(Event.KEYDOWN_DISMISS)
- }
+ _hideModal() {
+ this._element.style.display = 'none'
+ this._element.setAttribute('aria-hidden', true)
+ this._isTransitioning = false
+ this._showBackdrop(() => {
+ $(document.body).removeClass(ClassName.OPEN)
+ this._resetAdjustments()
+ this._resetScrollbar()
+ $(this._element).trigger(Event.HIDDEN)
+ })
+ }
+
+ _removeBackdrop() {
+ if (this._backdrop) {
+ $(this._backdrop).remove()
+ this._backdrop = null
}
+ }
- _setResizeEvent() {
- if (this._isShown) {
- $(window).on(Event.RESIZE, (event) => this.handleUpdate(event))
- } else {
- $(window).off(Event.RESIZE)
+ _showBackdrop(callback) {
+ const animate = $(this._element).hasClass(ClassName.FADE)
+ ? ClassName.FADE : ''
+
+ if (this._isShown && this._config.backdrop) {
+ this._backdrop = document.createElement('div')
+ this._backdrop.className = ClassName.BACKDROP
+
+ if (animate) {
+ this._backdrop.classList.add(animate)
}
- }
- _hideModal() {
- this._element.style.display = 'none'
- this._element.setAttribute('aria-hidden', true)
- this._isTransitioning = false
- this._showBackdrop(() => {
- $(document.body).removeClass(ClassName.OPEN)
- this._resetAdjustments()
- this._resetScrollbar()
- $(this._element).trigger(Event.HIDDEN)
+ $(this._backdrop).appendTo(document.body)
+
+ $(this._element).on(Event.CLICK_DISMISS, (event) => {
+ if (this._ignoreBackdropClick) {
+ this._ignoreBackdropClick = false
+ return
+ }
+ if (event.target !== event.currentTarget) {
+ return
+ }
+ if (this._config.backdrop === 'static') {
+ this._element.focus()
+ } else {
+ this.hide()
+ }
})
- }
- _removeBackdrop() {
- if (this._backdrop) {
- $(this._backdrop).remove()
- this._backdrop = null
+ if (animate) {
+ Util.reflow(this._backdrop)
}
- }
-
- _showBackdrop(callback) {
- const animate = $(this._element).hasClass(ClassName.FADE)
- ? ClassName.FADE : ''
- if (this._isShown && this._config.backdrop) {
- this._backdrop = document.createElement('div')
- this._backdrop.className = ClassName.BACKDROP
+ $(this._backdrop).addClass(ClassName.SHOW)
- if (animate) {
- this._backdrop.classList.add(animate)
- }
+ if (!callback) {
+ return
+ }
- $(this._backdrop).appendTo(document.body)
-
- $(this._element).on(Event.CLICK_DISMISS, (event) => {
- if (this._ignoreBackdropClick) {
- this._ignoreBackdropClick = false
- return
- }
- if (event.target !== event.currentTarget) {
- return
- }
- if (this._config.backdrop === 'static') {
- this._element.focus()
- } else {
- this.hide()
- }
- })
-
- if (animate) {
- Util.reflow(this._backdrop)
- }
+ if (!animate) {
+ callback()
+ return
+ }
- $(this._backdrop).addClass(ClassName.SHOW)
+ const backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop)
- if (!callback) {
- return
- }
+ $(this._backdrop)
+ .one(Util.TRANSITION_END, callback)
+ .emulateTransitionEnd(backdropTransitionDuration)
+ } else if (!this._isShown && this._backdrop) {
+ $(this._backdrop).removeClass(ClassName.SHOW)
- if (!animate) {
+ const callbackRemove = () => {
+ this._removeBackdrop()
+ if (callback) {
callback()
- return
}
+ }
+ if ($(this._element).hasClass(ClassName.FADE)) {
const backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop)
$(this._backdrop)
- .one(Util.TRANSITION_END, callback)
+ .one(Util.TRANSITION_END, callbackRemove)
.emulateTransitionEnd(backdropTransitionDuration)
- } else if (!this._isShown && this._backdrop) {
- $(this._backdrop).removeClass(ClassName.SHOW)
-
- const callbackRemove = () => {
- this._removeBackdrop()
- if (callback) {
- callback()
- }
- }
-
- if ($(this._element).hasClass(ClassName.FADE)) {
- const backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop)
-
- $(this._backdrop)
- .one(Util.TRANSITION_END, callbackRemove)
- .emulateTransitionEnd(backdropTransitionDuration)
- } else {
- callbackRemove()
- }
- } else if (callback) {
- callback()
+ } else {
+ callbackRemove()
}
+ } else if (callback) {
+ callback()
}
+ }
- // ----------------------------------------------------------------------
- // the following methods are used to handle overflowing modals
- // todo (fat): these should probably be refactored out of modal.js
- // ----------------------------------------------------------------------
-
- _adjustDialog() {
- const isModalOverflowing =
- this._element.scrollHeight > document.documentElement.clientHeight
+ // ----------------------------------------------------------------------
+ // the following methods are used to handle overflowing modals
+ // todo (fat): these should probably be refactored out of modal.js
+ // ----------------------------------------------------------------------
- if (!this._isBodyOverflowing && isModalOverflowing) {
- this._element.style.paddingLeft = `${this._scrollbarWidth}px`
- }
+ _adjustDialog() {
+ const isModalOverflowing =
+ this._element.scrollHeight > document.documentElement.clientHeight
- if (this._isBodyOverflowing && !isModalOverflowing) {
- this._element.style.paddingRight = `${this._scrollbarWidth}px`
- }
+ if (!this._isBodyOverflowing && isModalOverflowing) {
+ this._element.style.paddingLeft = `${this._scrollbarWidth}px`
}
- _resetAdjustments() {
- this._element.style.paddingLeft = ''
- this._element.style.paddingRight = ''
+ if (this._isBodyOverflowing && !isModalOverflowing) {
+ this._element.style.paddingRight = `${this._scrollbarWidth}px`
}
+ }
- _checkScrollbar() {
- const rect = document.body.getBoundingClientRect()
- this._isBodyOverflowing = rect.left + rect.right < window.innerWidth
- this._scrollbarWidth = this._getScrollbarWidth()
- }
+ _resetAdjustments() {
+ this._element.style.paddingLeft = ''
+ this._element.style.paddingRight = ''
+ }
- _setScrollbar() {
- if (this._isBodyOverflowing) {
- // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
- // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
- const fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT))
- const stickyContent = [].slice.call(document.querySelectorAll(Selector.STICKY_CONTENT))
-
- // Adjust fixed content padding
- $(fixedContent).each((index, element) => {
- const actualPadding = element.style.paddingRight
- const calculatedPadding = $(element).css('padding-right')
- $(element)
- .data('padding-right', actualPadding)
- .css('padding-right', `${parseFloat(calculatedPadding) + this._scrollbarWidth}px`)
- })
-
- // Adjust sticky content margin
- $(stickyContent).each((index, element) => {
- const actualMargin = element.style.marginRight
- const calculatedMargin = $(element).css('margin-right')
- $(element)
- .data('margin-right', actualMargin)
- .css('margin-right', `${parseFloat(calculatedMargin) - this._scrollbarWidth}px`)
- })
-
- // Adjust body padding
- const actualPadding = document.body.style.paddingRight
- const calculatedPadding = $(document.body).css('padding-right')
- $(document.body)
- .data('padding-right', actualPadding)
- .css('padding-right', `${parseFloat(calculatedPadding) + this._scrollbarWidth}px`)
- }
- }
+ _checkScrollbar() {
+ const rect = document.body.getBoundingClientRect()
+ this._isBodyOverflowing = rect.left + rect.right < window.innerWidth
+ this._scrollbarWidth = this._getScrollbarWidth()
+ }
- _resetScrollbar() {
- // Restore fixed content padding
+ _setScrollbar() {
+ if (this._isBodyOverflowing) {
+ // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
+ // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
const fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT))
+ const stickyContent = [].slice.call(document.querySelectorAll(Selector.STICKY_CONTENT))
+
+ // Adjust fixed content padding
$(fixedContent).each((index, element) => {
- const padding = $(element).data('padding-right')
- $(element).removeData('padding-right')
- element.style.paddingRight = padding ? padding : ''
+ const actualPadding = element.style.paddingRight
+ const calculatedPadding = $(element).css('padding-right')
+ $(element)
+ .data('padding-right', actualPadding)
+ .css('padding-right', `${parseFloat(calculatedPadding) + this._scrollbarWidth}px`)
})
- // Restore sticky content
- const elements = [].slice.call(document.querySelectorAll(`${Selector.STICKY_CONTENT}`))
- $(elements).each((index, element) => {
- const margin = $(element).data('margin-right')
- if (typeof margin !== 'undefined') {
- $(element).css('margin-right', margin).removeData('margin-right')
- }
+ // Adjust sticky content margin
+ $(stickyContent).each((index, element) => {
+ const actualMargin = element.style.marginRight
+ const calculatedMargin = $(element).css('margin-right')
+ $(element)
+ .data('margin-right', actualMargin)
+ .css('margin-right', `${parseFloat(calculatedMargin) - this._scrollbarWidth}px`)
})
- // Restore body padding
- const padding = $(document.body).data('padding-right')
- $(document.body).removeData('padding-right')
- document.body.style.paddingRight = padding ? padding : ''
+ // Adjust body padding
+ const actualPadding = document.body.style.paddingRight
+ const calculatedPadding = $(document.body).css('padding-right')
+ $(document.body)
+ .data('padding-right', actualPadding)
+ .css('padding-right', `${parseFloat(calculatedPadding) + this._scrollbarWidth}px`)
}
+ }
- _getScrollbarWidth() { // thx d.walsh
- const scrollDiv = document.createElement('div')
- scrollDiv.className = ClassName.SCROLLBAR_MEASURER
- document.body.appendChild(scrollDiv)
- const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth
- document.body.removeChild(scrollDiv)
- return scrollbarWidth
- }
+ _resetScrollbar() {
+ // Restore fixed content padding
+ const fixedContent = [].slice.call(document.querySelectorAll(Selector.FIXED_CONTENT))
+ $(fixedContent).each((index, element) => {
+ const padding = $(element).data('padding-right')
+ $(element).removeData('padding-right')
+ element.style.paddingRight = padding ? padding : ''
+ })
+
+ // Restore sticky content
+ const elements = [].slice.call(document.querySelectorAll(`${Selector.STICKY_CONTENT}`))
+ $(elements).each((index, element) => {
+ const margin = $(element).data('margin-right')
+ if (typeof margin !== 'undefined') {
+ $(element).css('margin-right', margin).removeData('margin-right')
+ }
+ })
- // Static
+ // Restore body padding
+ const padding = $(document.body).data('padding-right')
+ $(document.body).removeData('padding-right')
+ document.body.style.paddingRight = padding ? padding : ''
+ }
- static _jQueryInterface(config, relatedTarget) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- const _config = {
- ...Default,
- ...$(this).data(),
- ...typeof config === 'object' && config ? config : {}
- }
+ _getScrollbarWidth() { // thx d.walsh
+ const scrollDiv = document.createElement('div')
+ scrollDiv.className = ClassName.SCROLLBAR_MEASURER
+ document.body.appendChild(scrollDiv)
+ const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth
+ document.body.removeChild(scrollDiv)
+ return scrollbarWidth
+ }
- if (!data) {
- data = new Modal(this, _config)
- $(this).data(DATA_KEY, data)
- }
+ // Static
+
+ static _jQueryInterface(config, relatedTarget) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ const _config = {
+ ...Default,
+ ...$(this).data(),
+ ...typeof config === 'object' && config ? config : {}
+ }
+
+ if (!data) {
+ data = new Modal(this, _config)
+ $(this).data(DATA_KEY, data)
+ }
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config](relatedTarget)
- } else if (_config.show) {
- data.show(relatedTarget)
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
- }
+ data[config](relatedTarget)
+ } else if (_config.show) {
+ data.show(relatedTarget)
+ }
+ })
}
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+$(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
+ let target
+ const selector = Util.getSelectorFromElement(this)
- $(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
- let target
- const selector = Util.getSelectorFromElement(this)
+ if (selector) {
+ target = document.querySelector(selector)
+ }
- if (selector) {
- target = document.querySelector(selector)
+ const config = $(target).data(DATA_KEY)
+ ? 'toggle' : {
+ ...$(target).data(),
+ ...$(this).data()
}
- const config = $(target).data(DATA_KEY)
- ? 'toggle' : {
- ...$(target).data(),
- ...$(this).data()
- }
+ if (this.tagName === 'A' || this.tagName === 'AREA') {
+ event.preventDefault()
+ }
- if (this.tagName === 'A' || this.tagName === 'AREA') {
- event.preventDefault()
+ const $target = $(target).one(Event.SHOW, (showEvent) => {
+ if (showEvent.isDefaultPrevented()) {
+ // Only register focus restorer if modal will actually get shown
+ return
}
- const $target = $(target).one(Event.SHOW, (showEvent) => {
- if (showEvent.isDefaultPrevented()) {
- // Only register focus restorer if modal will actually get shown
- return
+ $target.one(Event.HIDDEN, () => {
+ if ($(this).is(':visible')) {
+ this.focus()
}
-
- $target.one(Event.HIDDEN, () => {
- if ($(this).is(':visible')) {
- this.focus()
- }
- })
})
-
- Modal._jQueryInterface.call($(target), config, this)
})
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Modal._jQueryInterface
- $.fn[NAME].Constructor = Modal
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Modal._jQueryInterface
- }
+ Modal._jQueryInterface.call($(target), config, this)
+})
+
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Modal
-})($)
+$.fn[NAME] = Modal._jQueryInterface
+$.fn[NAME].Constructor = Modal
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Modal._jQueryInterface
+}
export default Modal
* --------------------------------------------------------------------------
*/
-const Popover = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'popover'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.popover'
- const EVENT_KEY = `.${DATA_KEY}`
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- const CLASS_PREFIX = 'bs-popover'
- const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
-
- const Default = {
- ...Tooltip.Default,
- placement : 'right',
- trigger : 'click',
- content : '',
- template : '<div class="popover" role="tooltip">' +
- '<div class="arrow"></div>' +
- '<h3 class="popover-header"></h3>' +
- '<div class="popover-body"></div></div>'
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const NAME = 'popover'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.popover'
+const EVENT_KEY = `.${DATA_KEY}`
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+const CLASS_PREFIX = 'bs-popover'
+const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
+
+const Default = {
+ ...Tooltip.Default,
+ placement : 'right',
+ trigger : 'click',
+ content : '',
+ template : '<div class="popover" role="tooltip">' +
+ '<div class="arrow"></div>' +
+ '<h3 class="popover-header"></h3>' +
+ '<div class="popover-body"></div></div>'
+}
+
+const DefaultType = {
+ ...Tooltip.DefaultType,
+ content : '(string|element|function)'
+}
+
+const ClassName = {
+ FADE : 'fade',
+ SHOW : 'show'
+}
+
+const Selector = {
+ TITLE : '.popover-header',
+ CONTENT : '.popover-body'
+}
+
+const Event = {
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ INSERTED : `inserted${EVENT_KEY}`,
+ CLICK : `click${EVENT_KEY}`,
+ FOCUSIN : `focusin${EVENT_KEY}`,
+ FOCUSOUT : `focusout${EVENT_KEY}`,
+ MOUSEENTER : `mouseenter${EVENT_KEY}`,
+ MOUSELEAVE : `mouseleave${EVENT_KEY}`
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
+
+class Popover extends Tooltip {
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- const DefaultType = {
- ...Tooltip.DefaultType,
- content : '(string|element|function)'
+ static get Default() {
+ return Default
}
- const ClassName = {
- FADE : 'fade',
- SHOW : 'show'
+ static get NAME() {
+ return NAME
}
- const Selector = {
- TITLE : '.popover-header',
- CONTENT : '.popover-body'
+ static get DATA_KEY() {
+ return DATA_KEY
}
- const Event = {
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- INSERTED : `inserted${EVENT_KEY}`,
- CLICK : `click${EVENT_KEY}`,
- FOCUSIN : `focusin${EVENT_KEY}`,
- FOCUSOUT : `focusout${EVENT_KEY}`,
- MOUSEENTER : `mouseenter${EVENT_KEY}`,
- MOUSELEAVE : `mouseleave${EVENT_KEY}`
+ static get Event() {
+ return Event
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
+ static get EVENT_KEY() {
+ return EVENT_KEY
+ }
- class Popover extends Tooltip {
- // Getters
+ static get DefaultType() {
+ return DefaultType
+ }
- static get VERSION() {
- return VERSION
- }
+ // Overrides
- static get Default() {
- return Default
- }
+ isWithContent() {
+ return this.getTitle() || this._getContent()
+ }
- static get NAME() {
- return NAME
- }
+ addAttachmentClass(attachment) {
+ $(this.getTipElement()).addClass(`${CLASS_PREFIX}-${attachment}`)
+ }
- static get DATA_KEY() {
- return DATA_KEY
- }
+ getTipElement() {
+ this.tip = this.tip || $(this.config.template)[0]
+ return this.tip
+ }
- static get Event() {
- return Event
- }
+ setContent() {
+ const $tip = $(this.getTipElement())
- static get EVENT_KEY() {
- return EVENT_KEY
+ // We use append for html objects to maintain js events
+ this.setElementContent($tip.find(Selector.TITLE), this.getTitle())
+ let content = this._getContent()
+ if (typeof content === 'function') {
+ content = content.call(this.element)
}
+ this.setElementContent($tip.find(Selector.CONTENT), content)
- static get DefaultType() {
- return DefaultType
- }
+ $tip.removeClass(`${ClassName.FADE} ${ClassName.SHOW}`)
+ }
- // Overrides
+ // Private
- isWithContent() {
- return this.getTitle() || this._getContent()
- }
+ _getContent() {
+ return this.element.getAttribute('data-content') ||
+ this.config.content
+ }
- addAttachmentClass(attachment) {
- $(this.getTipElement()).addClass(`${CLASS_PREFIX}-${attachment}`)
+ _cleanTipClass() {
+ const $tip = $(this.getTipElement())
+ const tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX)
+ if (tabClass !== null && tabClass.length > 0) {
+ $tip.removeClass(tabClass.join(''))
}
+ }
- getTipElement() {
- this.tip = this.tip || $(this.config.template)[0]
- return this.tip
- }
+ // Static
- setContent() {
- const $tip = $(this.getTipElement())
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ const _config = typeof config === 'object' ? config : null
- // We use append for html objects to maintain js events
- this.setElementContent($tip.find(Selector.TITLE), this.getTitle())
- let content = this._getContent()
- if (typeof content === 'function') {
- content = content.call(this.element)
+ if (!data && /dispose|hide/.test(config)) {
+ return
}
- this.setElementContent($tip.find(Selector.CONTENT), content)
-
- $tip.removeClass(`${ClassName.FADE} ${ClassName.SHOW}`)
- }
- // Private
-
- _getContent() {
- return this.element.getAttribute('data-content') ||
- this.config.content
- }
-
- _cleanTipClass() {
- const $tip = $(this.getTipElement())
- const tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX)
- if (tabClass !== null && tabClass.length > 0) {
- $tip.removeClass(tabClass.join(''))
+ if (!data) {
+ data = new Popover(this, _config)
+ $(this).data(DATA_KEY, data)
}
- }
-
- // Static
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- const _config = typeof config === 'object' ? config : null
-
- if (!data && /dispose|hide/.test(config)) {
- return
- }
-
- if (!data) {
- data = new Popover(this, _config)
- $(this).data(DATA_KEY, data)
- }
-
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
- }
+ data[config]()
+ }
+ })
}
+}
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Popover._jQueryInterface
- $.fn[NAME].Constructor = Popover
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Popover._jQueryInterface
- }
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Popover
-})($)
+$.fn[NAME] = Popover._jQueryInterface
+$.fn[NAME].Constructor = Popover
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Popover._jQueryInterface
+}
export default Popover
* --------------------------------------------------------------------------
*/
-const ScrollSpy = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'scrollspy'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.scrollspy'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
-
- const Default = {
- offset : 10,
- method : 'auto',
- target : ''
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- const DefaultType = {
- offset : 'number',
- method : 'string',
- target : '(string|element)'
- }
+const NAME = 'scrollspy'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.scrollspy'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+
+const Default = {
+ offset : 10,
+ method : 'auto',
+ target : ''
+}
+
+const DefaultType = {
+ offset : 'number',
+ method : 'string',
+ target : '(string|element)'
+}
+
+const Event = {
+ ACTIVATE : `activate${EVENT_KEY}`,
+ SCROLL : `scroll${EVENT_KEY}`,
+ LOAD_DATA_API : `load${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ DROPDOWN_ITEM : 'dropdown-item',
+ DROPDOWN_MENU : 'dropdown-menu',
+ ACTIVE : 'active'
+}
+
+const Selector = {
+ DATA_SPY : '[data-spy="scroll"]',
+ ACTIVE : '.active',
+ NAV_LIST_GROUP : '.nav, .list-group',
+ NAV_LINKS : '.nav-link',
+ NAV_ITEMS : '.nav-item',
+ LIST_ITEMS : '.list-group-item',
+ DROPDOWN : '.dropdown',
+ DROPDOWN_ITEMS : '.dropdown-item',
+ DROPDOWN_TOGGLE : '.dropdown-toggle'
+}
+
+const OffsetMethod = {
+ OFFSET : 'offset',
+ POSITION : 'position'
+}
- const Event = {
- ACTIVATE : `activate${EVENT_KEY}`,
- SCROLL : `scroll${EVENT_KEY}`,
- LOAD_DATA_API : `load${EVENT_KEY}${DATA_API_KEY}`
- }
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- const ClassName = {
- DROPDOWN_ITEM : 'dropdown-item',
- DROPDOWN_MENU : 'dropdown-menu',
- ACTIVE : 'active'
+class ScrollSpy {
+ constructor(element, config) {
+ this._element = element
+ this._scrollElement = element.tagName === 'BODY' ? window : element
+ this._config = this._getConfig(config)
+ this._selector = `${this._config.target} ${Selector.NAV_LINKS},` +
+ `${this._config.target} ${Selector.LIST_ITEMS},` +
+ `${this._config.target} ${Selector.DROPDOWN_ITEMS}`
+ this._offsets = []
+ this._targets = []
+ this._activeTarget = null
+ this._scrollHeight = 0
+
+ $(this._scrollElement).on(Event.SCROLL, (event) => this._process(event))
+
+ this.refresh()
+ this._process()
}
- const Selector = {
- DATA_SPY : '[data-spy="scroll"]',
- ACTIVE : '.active',
- NAV_LIST_GROUP : '.nav, .list-group',
- NAV_LINKS : '.nav-link',
- NAV_ITEMS : '.nav-item',
- LIST_ITEMS : '.list-group-item',
- DROPDOWN : '.dropdown',
- DROPDOWN_ITEMS : '.dropdown-item',
- DROPDOWN_TOGGLE : '.dropdown-toggle'
- }
+ // Getters
- const OffsetMethod = {
- OFFSET : 'offset',
- POSITION : 'position'
+ static get VERSION() {
+ return VERSION
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
-
- class ScrollSpy {
- constructor(element, config) {
- this._element = element
- this._scrollElement = element.tagName === 'BODY' ? window : element
- this._config = this._getConfig(config)
- this._selector = `${this._config.target} ${Selector.NAV_LINKS},` +
- `${this._config.target} ${Selector.LIST_ITEMS},` +
- `${this._config.target} ${Selector.DROPDOWN_ITEMS}`
- this._offsets = []
- this._targets = []
- this._activeTarget = null
- this._scrollHeight = 0
-
- $(this._scrollElement).on(Event.SCROLL, (event) => this._process(event))
-
- this.refresh()
- this._process()
- }
-
- // Getters
-
- static get VERSION() {
- return VERSION
- }
-
- static get Default() {
- return Default
- }
+ static get Default() {
+ return Default
+ }
- // Public
+ // Public
- refresh() {
- const autoMethod = this._scrollElement === this._scrollElement.window
- ? OffsetMethod.OFFSET : OffsetMethod.POSITION
+ refresh() {
+ const autoMethod = this._scrollElement === this._scrollElement.window
+ ? OffsetMethod.OFFSET : OffsetMethod.POSITION
- const offsetMethod = this._config.method === 'auto'
- ? autoMethod : this._config.method
+ const offsetMethod = this._config.method === 'auto'
+ ? autoMethod : this._config.method
- const offsetBase = offsetMethod === OffsetMethod.POSITION
- ? this._getScrollTop() : 0
+ const offsetBase = offsetMethod === OffsetMethod.POSITION
+ ? this._getScrollTop() : 0
- this._offsets = []
- this._targets = []
+ this._offsets = []
+ this._targets = []
- this._scrollHeight = this._getScrollHeight()
+ this._scrollHeight = this._getScrollHeight()
- const targets = [].slice.call(document.querySelectorAll(this._selector))
+ const targets = [].slice.call(document.querySelectorAll(this._selector))
- targets
- .map((element) => {
- let target
- const targetSelector = Util.getSelectorFromElement(element)
+ targets
+ .map((element) => {
+ let target
+ const targetSelector = Util.getSelectorFromElement(element)
- if (targetSelector) {
- target = document.querySelector(targetSelector)
- }
+ if (targetSelector) {
+ target = document.querySelector(targetSelector)
+ }
- if (target) {
- const targetBCR = target.getBoundingClientRect()
- if (targetBCR.width || targetBCR.height) {
- // TODO (fat): remove sketch reliance on jQuery position/offset
- return [
- $(target)[offsetMethod]().top + offsetBase,
- targetSelector
- ]
- }
+ if (target) {
+ const targetBCR = target.getBoundingClientRect()
+ if (targetBCR.width || targetBCR.height) {
+ // TODO (fat): remove sketch reliance on jQuery position/offset
+ return [
+ $(target)[offsetMethod]().top + offsetBase,
+ targetSelector
+ ]
}
- return null
- })
- .filter((item) => item)
- .sort((a, b) => a[0] - b[0])
- .forEach((item) => {
- this._offsets.push(item[0])
- this._targets.push(item[1])
- })
- }
-
- dispose() {
- $.removeData(this._element, DATA_KEY)
- $(this._scrollElement).off(EVENT_KEY)
-
- this._element = null
- this._scrollElement = null
- this._config = null
- this._selector = null
- this._offsets = null
- this._targets = null
- this._activeTarget = null
- this._scrollHeight = null
- }
-
- // Private
-
- _getConfig(config) {
- config = {
- ...Default,
- ...typeof config === 'object' && config ? config : {}
- }
-
- if (typeof config.target !== 'string') {
- let id = $(config.target).attr('id')
- if (!id) {
- id = Util.getUID(NAME)
- $(config.target).attr('id', id)
}
- config.target = `#${id}`
- }
+ return null
+ })
+ .filter((item) => item)
+ .sort((a, b) => a[0] - b[0])
+ .forEach((item) => {
+ this._offsets.push(item[0])
+ this._targets.push(item[1])
+ })
+ }
- Util.typeCheckConfig(NAME, config, DefaultType)
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
+ $(this._scrollElement).off(EVENT_KEY)
+
+ this._element = null
+ this._scrollElement = null
+ this._config = null
+ this._selector = null
+ this._offsets = null
+ this._targets = null
+ this._activeTarget = null
+ this._scrollHeight = null
+ }
- return config
- }
+ // Private
- _getScrollTop() {
- return this._scrollElement === window
- ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop
+ _getConfig(config) {
+ config = {
+ ...Default,
+ ...typeof config === 'object' && config ? config : {}
}
- _getScrollHeight() {
- return this._scrollElement.scrollHeight || Math.max(
- document.body.scrollHeight,
- document.documentElement.scrollHeight
- )
+ if (typeof config.target !== 'string') {
+ let id = $(config.target).attr('id')
+ if (!id) {
+ id = Util.getUID(NAME)
+ $(config.target).attr('id', id)
+ }
+ config.target = `#${id}`
}
- _getOffsetHeight() {
- return this._scrollElement === window
- ? window.innerHeight : this._scrollElement.getBoundingClientRect().height
- }
+ Util.typeCheckConfig(NAME, config, DefaultType)
- _process() {
- const scrollTop = this._getScrollTop() + this._config.offset
- const scrollHeight = this._getScrollHeight()
- const maxScroll = this._config.offset +
- scrollHeight -
- this._getOffsetHeight()
+ return config
+ }
- if (this._scrollHeight !== scrollHeight) {
- this.refresh()
- }
+ _getScrollTop() {
+ return this._scrollElement === window
+ ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop
+ }
- if (scrollTop >= maxScroll) {
- const target = this._targets[this._targets.length - 1]
+ _getScrollHeight() {
+ return this._scrollElement.scrollHeight || Math.max(
+ document.body.scrollHeight,
+ document.documentElement.scrollHeight
+ )
+ }
- if (this._activeTarget !== target) {
- this._activate(target)
- }
- return
- }
+ _getOffsetHeight() {
+ return this._scrollElement === window
+ ? window.innerHeight : this._scrollElement.getBoundingClientRect().height
+ }
- if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
- this._activeTarget = null
- this._clear()
- return
- }
+ _process() {
+ const scrollTop = this._getScrollTop() + this._config.offset
+ const scrollHeight = this._getScrollHeight()
+ const maxScroll = this._config.offset +
+ scrollHeight -
+ this._getOffsetHeight()
- const offsetLength = this._offsets.length
- for (let i = offsetLength; i--;) {
- const isActiveTarget = this._activeTarget !== this._targets[i] &&
- scrollTop >= this._offsets[i] &&
- (typeof this._offsets[i + 1] === 'undefined' ||
- scrollTop < this._offsets[i + 1])
+ if (this._scrollHeight !== scrollHeight) {
+ this.refresh()
+ }
- if (isActiveTarget) {
- this._activate(this._targets[i])
- }
+ if (scrollTop >= maxScroll) {
+ const target = this._targets[this._targets.length - 1]
+
+ if (this._activeTarget !== target) {
+ this._activate(target)
}
+ return
}
- _activate(target) {
- this._activeTarget = target
-
+ if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
+ this._activeTarget = null
this._clear()
+ return
+ }
- let queries = this._selector.split(',')
- // eslint-disable-next-line arrow-body-style
- queries = queries.map((selector) => {
- return `${selector}[data-target="${target}"],` +
- `${selector}[href="${target}"]`
- })
+ const offsetLength = this._offsets.length
+ for (let i = offsetLength; i--;) {
+ const isActiveTarget = this._activeTarget !== this._targets[i] &&
+ scrollTop >= this._offsets[i] &&
+ (typeof this._offsets[i + 1] === 'undefined' ||
+ scrollTop < this._offsets[i + 1])
- const $link = $([].slice.call(document.querySelectorAll(queries.join(','))))
-
- if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
- $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE)
- $link.addClass(ClassName.ACTIVE)
- } else {
- // Set triggered link as active
- $link.addClass(ClassName.ACTIVE)
- // Set triggered links parents as active
- // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
- $link.parents(Selector.NAV_LIST_GROUP).prev(`${Selector.NAV_LINKS}, ${Selector.LIST_ITEMS}`).addClass(ClassName.ACTIVE)
- // Handle special case when .nav-link is inside .nav-item
- $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE)
+ if (isActiveTarget) {
+ this._activate(this._targets[i])
}
-
- $(this._scrollElement).trigger(Event.ACTIVATE, {
- relatedTarget: target
- })
}
+ }
- _clear() {
- const nodes = [].slice.call(document.querySelectorAll(this._selector))
- $(nodes).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE)
+ _activate(target) {
+ this._activeTarget = target
+
+ this._clear()
+
+ let queries = this._selector.split(',')
+ // eslint-disable-next-line arrow-body-style
+ queries = queries.map((selector) => {
+ return `${selector}[data-target="${target}"],` +
+ `${selector}[href="${target}"]`
+ })
+
+ const $link = $([].slice.call(document.querySelectorAll(queries.join(','))))
+
+ if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
+ $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE)
+ $link.addClass(ClassName.ACTIVE)
+ } else {
+ // Set triggered link as active
+ $link.addClass(ClassName.ACTIVE)
+ // Set triggered links parents as active
+ // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
+ $link.parents(Selector.NAV_LIST_GROUP).prev(`${Selector.NAV_LINKS}, ${Selector.LIST_ITEMS}`).addClass(ClassName.ACTIVE)
+ // Handle special case when .nav-link is inside .nav-item
+ $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE)
}
- // Static
+ $(this._scrollElement).trigger(Event.ACTIVATE, {
+ relatedTarget: target
+ })
+ }
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- const _config = typeof config === 'object' && config
+ _clear() {
+ const nodes = [].slice.call(document.querySelectorAll(this._selector))
+ $(nodes).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE)
+ }
- if (!data) {
- data = new ScrollSpy(this, _config)
- $(this).data(DATA_KEY, data)
- }
+ // Static
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ const _config = typeof config === 'object' && config
+
+ if (!data) {
+ data = new ScrollSpy(this, _config)
+ $(this).data(DATA_KEY, data)
+ }
+
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
- }
+ data[config]()
+ }
+ })
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- $(window).on(Event.LOAD_DATA_API, () => {
- const scrollSpys = [].slice.call(document.querySelectorAll(Selector.DATA_SPY))
+$(window).on(Event.LOAD_DATA_API, () => {
+ const scrollSpys = [].slice.call(document.querySelectorAll(Selector.DATA_SPY))
- const scrollSpysLength = scrollSpys.length
- for (let i = scrollSpysLength; i--;) {
- const $spy = $(scrollSpys[i])
- ScrollSpy._jQueryInterface.call($spy, $spy.data())
- }
- })
-
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = ScrollSpy._jQueryInterface
- $.fn[NAME].Constructor = ScrollSpy
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return ScrollSpy._jQueryInterface
+ const scrollSpysLength = scrollSpys.length
+ for (let i = scrollSpysLength; i--;) {
+ const $spy = $(scrollSpys[i])
+ ScrollSpy._jQueryInterface.call($spy, $spy.data())
}
+})
+
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return ScrollSpy
-})($)
+$.fn[NAME] = ScrollSpy._jQueryInterface
+$.fn[NAME].Constructor = ScrollSpy
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return ScrollSpy._jQueryInterface
+}
export default ScrollSpy
* --------------------------------------------------------------------------
*/
-const Tab = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'tab'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.tab'
- const EVENT_KEY = `.${DATA_KEY}`
- const DATA_API_KEY = '.data-api'
- const JQUERY_NO_CONFLICT = $.fn[NAME]
-
- const Event = {
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
- }
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const NAME = 'tab'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.tab'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+
+const Event = {
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+}
+
+const ClassName = {
+ DROPDOWN_MENU : 'dropdown-menu',
+ ACTIVE : 'active',
+ DISABLED : 'disabled',
+ FADE : 'fade',
+ SHOW : 'show'
+}
+
+const Selector = {
+ DROPDOWN : '.dropdown',
+ NAV_LIST_GROUP : '.nav, .list-group',
+ ACTIVE : '.active',
+ ACTIVE_UL : '> li > .active',
+ DATA_TOGGLE : '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
+ DROPDOWN_TOGGLE : '.dropdown-toggle',
+ DROPDOWN_ACTIVE_CHILD : '> .dropdown-menu .active'
+}
- const ClassName = {
- DROPDOWN_MENU : 'dropdown-menu',
- ACTIVE : 'active',
- DISABLED : 'disabled',
- FADE : 'fade',
- SHOW : 'show'
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
+
+class Tab {
+ constructor(element) {
+ this._element = element
}
- const Selector = {
- DROPDOWN : '.dropdown',
- NAV_LIST_GROUP : '.nav, .list-group',
- ACTIVE : '.active',
- ACTIVE_UL : '> li > .active',
- DATA_TOGGLE : '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
- DROPDOWN_TOGGLE : '.dropdown-toggle',
- DROPDOWN_ACTIVE_CHILD : '> .dropdown-menu .active'
+ // Getters
+
+ static get VERSION() {
+ return VERSION
}
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
+ // Public
- class Tab {
- constructor(element) {
- this._element = element
+ show() {
+ if (this._element.parentNode &&
+ this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
+ $(this._element).hasClass(ClassName.ACTIVE) ||
+ $(this._element).hasClass(ClassName.DISABLED)) {
+ return
}
- // Getters
+ let target
+ let previous
+ const listElement = $(this._element).closest(Selector.NAV_LIST_GROUP)[0]
+ const selector = Util.getSelectorFromElement(this._element)
- static get VERSION() {
- return VERSION
+ if (listElement) {
+ const itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE
+ previous = $.makeArray($(listElement).find(itemSelector))
+ previous = previous[previous.length - 1]
}
- // Public
+ const hideEvent = $.Event(Event.HIDE, {
+ relatedTarget: this._element
+ })
- show() {
- if (this._element.parentNode &&
- this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
- $(this._element).hasClass(ClassName.ACTIVE) ||
- $(this._element).hasClass(ClassName.DISABLED)) {
- return
- }
+ const showEvent = $.Event(Event.SHOW, {
+ relatedTarget: previous
+ })
- let target
- let previous
- const listElement = $(this._element).closest(Selector.NAV_LIST_GROUP)[0]
- const selector = Util.getSelectorFromElement(this._element)
+ if (previous) {
+ $(previous).trigger(hideEvent)
+ }
- if (listElement) {
- const itemSelector = listElement.nodeName === 'UL' ? Selector.ACTIVE_UL : Selector.ACTIVE
- previous = $.makeArray($(listElement).find(itemSelector))
- previous = previous[previous.length - 1]
- }
+ $(this._element).trigger(showEvent)
+
+ if (showEvent.isDefaultPrevented() ||
+ hideEvent.isDefaultPrevented()) {
+ return
+ }
- const hideEvent = $.Event(Event.HIDE, {
+ if (selector) {
+ target = document.querySelector(selector)
+ }
+
+ this._activate(
+ this._element,
+ listElement
+ )
+
+ const complete = () => {
+ const hiddenEvent = $.Event(Event.HIDDEN, {
relatedTarget: this._element
})
- const showEvent = $.Event(Event.SHOW, {
+ const shownEvent = $.Event(Event.SHOWN, {
relatedTarget: previous
})
- if (previous) {
- $(previous).trigger(hideEvent)
- }
+ $(previous).trigger(hiddenEvent)
+ $(this._element).trigger(shownEvent)
+ }
- $(this._element).trigger(showEvent)
+ if (target) {
+ this._activate(target, target.parentNode, complete)
+ } else {
+ complete()
+ }
+ }
- if (showEvent.isDefaultPrevented() ||
- hideEvent.isDefaultPrevented()) {
- return
- }
+ dispose() {
+ $.removeData(this._element, DATA_KEY)
+ this._element = null
+ }
- if (selector) {
- target = document.querySelector(selector)
- }
+ // Private
- this._activate(
- this._element,
- listElement
- )
+ _activate(element, container, callback) {
+ let activeElements
+ if (container.nodeName === 'UL') {
+ activeElements = $(container).find(Selector.ACTIVE_UL)
+ } else {
+ activeElements = $(container).children(Selector.ACTIVE)
+ }
- const complete = () => {
- const hiddenEvent = $.Event(Event.HIDDEN, {
- relatedTarget: this._element
- })
+ const active = activeElements[0]
+ const isTransitioning = callback &&
+ (active && $(active).hasClass(ClassName.FADE))
- const shownEvent = $.Event(Event.SHOWN, {
- relatedTarget: previous
- })
+ const complete = () => this._transitionComplete(
+ element,
+ active,
+ callback
+ )
- $(previous).trigger(hiddenEvent)
- $(this._element).trigger(shownEvent)
- }
+ if (active && isTransitioning) {
+ const transitionDuration = Util.getTransitionDurationFromElement(active)
- if (target) {
- this._activate(target, target.parentNode, complete)
- } else {
- complete()
- }
+ $(active)
+ .one(Util.TRANSITION_END, complete)
+ .emulateTransitionEnd(transitionDuration)
+ } else {
+ complete()
}
+ }
- dispose() {
- $.removeData(this._element, DATA_KEY)
- this._element = null
- }
+ _transitionComplete(element, active, callback) {
+ if (active) {
+ $(active).removeClass(`${ClassName.SHOW} ${ClassName.ACTIVE}`)
- // Private
+ const dropdownChild = $(active.parentNode).find(
+ Selector.DROPDOWN_ACTIVE_CHILD
+ )[0]
- _activate(element, container, callback) {
- let activeElements
- if (container.nodeName === 'UL') {
- activeElements = $(container).find(Selector.ACTIVE_UL)
- } else {
- activeElements = $(container).children(Selector.ACTIVE)
+ if (dropdownChild) {
+ $(dropdownChild).removeClass(ClassName.ACTIVE)
}
- const active = activeElements[0]
- const isTransitioning = callback &&
- (active && $(active).hasClass(ClassName.FADE))
-
- const complete = () => this._transitionComplete(
- element,
- active,
- callback
- )
-
- if (active && isTransitioning) {
- const transitionDuration = Util.getTransitionDurationFromElement(active)
-
- $(active)
- .one(Util.TRANSITION_END, complete)
- .emulateTransitionEnd(transitionDuration)
- } else {
- complete()
+ if (active.getAttribute('role') === 'tab') {
+ active.setAttribute('aria-selected', false)
}
}
- _transitionComplete(element, active, callback) {
- if (active) {
- $(active).removeClass(`${ClassName.SHOW} ${ClassName.ACTIVE}`)
-
- const dropdownChild = $(active.parentNode).find(
- Selector.DROPDOWN_ACTIVE_CHILD
- )[0]
+ $(element).addClass(ClassName.ACTIVE)
+ if (element.getAttribute('role') === 'tab') {
+ element.setAttribute('aria-selected', true)
+ }
- if (dropdownChild) {
- $(dropdownChild).removeClass(ClassName.ACTIVE)
- }
+ Util.reflow(element)
+ $(element).addClass(ClassName.SHOW)
- if (active.getAttribute('role') === 'tab') {
- active.setAttribute('aria-selected', false)
- }
+ if (element.parentNode &&
+ $(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
+ const dropdownElement = $(element).closest(Selector.DROPDOWN)[0]
+ if (dropdownElement) {
+ const dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector.DROPDOWN_TOGGLE))
+ $(dropdownToggleList).addClass(ClassName.ACTIVE)
}
- $(element).addClass(ClassName.ACTIVE)
- if (element.getAttribute('role') === 'tab') {
- element.setAttribute('aria-selected', true)
- }
-
- Util.reflow(element)
- $(element).addClass(ClassName.SHOW)
-
- if (element.parentNode &&
- $(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
- const dropdownElement = $(element).closest(Selector.DROPDOWN)[0]
- if (dropdownElement) {
- const dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector.DROPDOWN_TOGGLE))
- $(dropdownToggleList).addClass(ClassName.ACTIVE)
- }
-
- element.setAttribute('aria-expanded', true)
- }
+ element.setAttribute('aria-expanded', true)
+ }
- if (callback) {
- callback()
- }
+ if (callback) {
+ callback()
}
+ }
- // Static
+ // Static
- static _jQueryInterface(config) {
- return this.each(function () {
- const $this = $(this)
- let data = $this.data(DATA_KEY)
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ const $this = $(this)
+ let data = $this.data(DATA_KEY)
- if (!data) {
- data = new Tab(this)
- $this.data(DATA_KEY, data)
- }
+ if (!data) {
+ data = new Tab(this)
+ $this.data(DATA_KEY, data)
+ }
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
}
- })
- }
+ data[config]()
+ }
+ })
}
+}
- /**
- * ------------------------------------------------------------------------
- * Data Api implementation
- * ------------------------------------------------------------------------
- */
+/**
+ * ------------------------------------------------------------------------
+ * Data Api implementation
+ * ------------------------------------------------------------------------
+ */
- $(document)
- .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
- event.preventDefault()
- Tab._jQueryInterface.call($(this), 'show')
- })
+$(document)
+ .on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
+ event.preventDefault()
+ Tab._jQueryInterface.call($(this), 'show')
+ })
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
-
- $.fn[NAME] = Tab._jQueryInterface
- $.fn[NAME].Constructor = Tab
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Tab._jQueryInterface
- }
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Tab
-})($)
+$.fn[NAME] = Tab._jQueryInterface
+$.fn[NAME].Constructor = Tab
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Tab._jQueryInterface
+}
export default Tab
* --------------------------------------------------------------------------
*/
-const Tooltip = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Constants
- * ------------------------------------------------------------------------
- */
-
- const NAME = 'tooltip'
- const VERSION = '4.1.3'
- const DATA_KEY = 'bs.tooltip'
- const EVENT_KEY = `.${DATA_KEY}`
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- const CLASS_PREFIX = 'bs-tooltip'
- const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
-
- const DefaultType = {
- animation : 'boolean',
- template : 'string',
- title : '(string|element|function)',
- trigger : 'string',
- delay : '(number|object)',
- html : 'boolean',
- selector : '(string|boolean)',
- placement : '(string|function)',
- offset : '(number|string)',
- container : '(string|element|boolean)',
- fallbackPlacement : '(string|array)',
- boundary : '(string|element)'
- }
-
- const AttachmentMap = {
- AUTO : 'auto',
- TOP : 'top',
- RIGHT : 'right',
- BOTTOM : 'bottom',
- LEFT : 'left'
- }
-
- const Default = {
- animation : true,
- template : '<div class="tooltip" role="tooltip">' +
- '<div class="arrow"></div>' +
- '<div class="tooltip-inner"></div></div>',
- trigger : 'hover focus',
- title : '',
- delay : 0,
- html : false,
- selector : false,
- placement : 'top',
- offset : 0,
- container : false,
- fallbackPlacement : 'flip',
- boundary : 'scrollParent'
- }
-
- const HoverState = {
- SHOW : 'show',
- OUT : 'out'
- }
-
- const Event = {
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`,
- INSERTED : `inserted${EVENT_KEY}`,
- CLICK : `click${EVENT_KEY}`,
- FOCUSIN : `focusin${EVENT_KEY}`,
- FOCUSOUT : `focusout${EVENT_KEY}`,
- MOUSEENTER : `mouseenter${EVENT_KEY}`,
- MOUSELEAVE : `mouseleave${EVENT_KEY}`
- }
-
- const ClassName = {
- FADE : 'fade',
- SHOW : 'show'
- }
-
- const Selector = {
- TOOLTIP : '.tooltip',
- TOOLTIP_INNER : '.tooltip-inner',
- ARROW : '.arrow'
- }
-
- const Trigger = {
- HOVER : 'hover',
- FOCUS : 'focus',
- CLICK : 'click',
- MANUAL : 'manual'
- }
-
-
- /**
- * ------------------------------------------------------------------------
- * Class Definition
- * ------------------------------------------------------------------------
- */
-
- class Tooltip {
- constructor(element, config) {
- /**
- * Check for Popper dependency
- * Popper - https://popper.js.org
- */
- if (typeof Popper === 'undefined') {
- throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)')
- }
-
- // private
- this._isEnabled = true
- this._timeout = 0
- this._hoverState = ''
- this._activeTrigger = {}
- this._popper = null
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
- // Protected
- this.element = element
- this.config = this._getConfig(config)
- this.tip = null
+const NAME = 'tooltip'
+const VERSION = '4.1.3'
+const DATA_KEY = 'bs.tooltip'
+const EVENT_KEY = `.${DATA_KEY}`
+const JQUERY_NO_CONFLICT = $.fn[NAME]
+const CLASS_PREFIX = 'bs-tooltip'
+const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
+
+const DefaultType = {
+ animation : 'boolean',
+ template : 'string',
+ title : '(string|element|function)',
+ trigger : 'string',
+ delay : '(number|object)',
+ html : 'boolean',
+ selector : '(string|boolean)',
+ placement : '(string|function)',
+ offset : '(number|string)',
+ container : '(string|element|boolean)',
+ fallbackPlacement : '(string|array)',
+ boundary : '(string|element)'
+}
+
+const AttachmentMap = {
+ AUTO : 'auto',
+ TOP : 'top',
+ RIGHT : 'right',
+ BOTTOM : 'bottom',
+ LEFT : 'left'
+}
+
+const Default = {
+ animation : true,
+ template : '<div class="tooltip" role="tooltip">' +
+ '<div class="arrow"></div>' +
+ '<div class="tooltip-inner"></div></div>',
+ trigger : 'hover focus',
+ title : '',
+ delay : 0,
+ html : false,
+ selector : false,
+ placement : 'top',
+ offset : 0,
+ container : false,
+ fallbackPlacement : 'flip',
+ boundary : 'scrollParent'
+}
+
+const HoverState = {
+ SHOW : 'show',
+ OUT : 'out'
+}
+
+const Event = {
+ HIDE : `hide${EVENT_KEY}`,
+ HIDDEN : `hidden${EVENT_KEY}`,
+ SHOW : `show${EVENT_KEY}`,
+ SHOWN : `shown${EVENT_KEY}`,
+ INSERTED : `inserted${EVENT_KEY}`,
+ CLICK : `click${EVENT_KEY}`,
+ FOCUSIN : `focusin${EVENT_KEY}`,
+ FOCUSOUT : `focusout${EVENT_KEY}`,
+ MOUSEENTER : `mouseenter${EVENT_KEY}`,
+ MOUSELEAVE : `mouseleave${EVENT_KEY}`
+}
+
+const ClassName = {
+ FADE : 'fade',
+ SHOW : 'show'
+}
+
+const Selector = {
+ TOOLTIP : '.tooltip',
+ TOOLTIP_INNER : '.tooltip-inner',
+ ARROW : '.arrow'
+}
+
+const Trigger = {
+ HOVER : 'hover',
+ FOCUS : 'focus',
+ CLICK : 'click',
+ MANUAL : 'manual'
+}
- this._setListeners()
- }
- // Getters
+/**
+ * ------------------------------------------------------------------------
+ * Class Definition
+ * ------------------------------------------------------------------------
+ */
- static get VERSION() {
- return VERSION
+class Tooltip {
+ constructor(element, config) {
+ /**
+ * Check for Popper dependency
+ * Popper - https://popper.js.org
+ */
+ if (typeof Popper === 'undefined') {
+ throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)')
}
- static get Default() {
- return Default
- }
+ // private
+ this._isEnabled = true
+ this._timeout = 0
+ this._hoverState = ''
+ this._activeTrigger = {}
+ this._popper = null
- static get NAME() {
- return NAME
- }
+ // Protected
+ this.element = element
+ this.config = this._getConfig(config)
+ this.tip = null
- static get DATA_KEY() {
- return DATA_KEY
- }
+ this._setListeners()
+ }
- static get Event() {
- return Event
- }
+ // Getters
- static get EVENT_KEY() {
- return EVENT_KEY
- }
+ static get VERSION() {
+ return VERSION
+ }
- static get DefaultType() {
- return DefaultType
- }
+ static get Default() {
+ return Default
+ }
- // Public
+ static get NAME() {
+ return NAME
+ }
- enable() {
- this._isEnabled = true
- }
+ static get DATA_KEY() {
+ return DATA_KEY
+ }
- disable() {
- this._isEnabled = false
- }
+ static get Event() {
+ return Event
+ }
- toggleEnabled() {
- this._isEnabled = !this._isEnabled
- }
+ static get EVENT_KEY() {
+ return EVENT_KEY
+ }
- toggle(event) {
- if (!this._isEnabled) {
- return
- }
+ static get DefaultType() {
+ return DefaultType
+ }
- if (event) {
- const dataKey = this.constructor.DATA_KEY
- let context = $(event.currentTarget).data(dataKey)
+ // Public
- if (!context) {
- context = new this.constructor(
- event.currentTarget,
- this._getDelegateConfig()
- )
- $(event.currentTarget).data(dataKey, context)
- }
+ enable() {
+ this._isEnabled = true
+ }
- context._activeTrigger.click = !context._activeTrigger.click
+ disable() {
+ this._isEnabled = false
+ }
- if (context._isWithActiveTrigger()) {
- context._enter(null, context)
- } else {
- context._leave(null, context)
- }
- } else {
- if ($(this.getTipElement()).hasClass(ClassName.SHOW)) {
- this._leave(null, this)
- return
- }
+ toggleEnabled() {
+ this._isEnabled = !this._isEnabled
+ }
- this._enter(null, this)
- }
+ toggle(event) {
+ if (!this._isEnabled) {
+ return
}
- dispose() {
- clearTimeout(this._timeout)
+ if (event) {
+ const dataKey = this.constructor.DATA_KEY
+ let context = $(event.currentTarget).data(dataKey)
- $.removeData(this.element, this.constructor.DATA_KEY)
+ if (!context) {
+ context = new this.constructor(
+ event.currentTarget,
+ this._getDelegateConfig()
+ )
+ $(event.currentTarget).data(dataKey, context)
+ }
- $(this.element).off(this.constructor.EVENT_KEY)
- $(this.element).closest('.modal').off('hide.bs.modal')
+ context._activeTrigger.click = !context._activeTrigger.click
- if (this.tip) {
- $(this.tip).remove()
+ if (context._isWithActiveTrigger()) {
+ context._enter(null, context)
+ } else {
+ context._leave(null, context)
}
-
- this._isEnabled = null
- this._timeout = null
- this._hoverState = null
- this._activeTrigger = null
- if (this._popper !== null) {
- this._popper.destroy()
+ } else {
+ if ($(this.getTipElement()).hasClass(ClassName.SHOW)) {
+ this._leave(null, this)
+ return
}
- this._popper = null
- this.element = null
- this.config = null
- this.tip = null
+ this._enter(null, this)
}
+ }
- show() {
- if ($(this.element).css('display') === 'none') {
- throw new Error('Please use show on visible elements')
- }
+ dispose() {
+ clearTimeout(this._timeout)
- const showEvent = $.Event(this.constructor.Event.SHOW)
- if (this.isWithContent() && this._isEnabled) {
- $(this.element).trigger(showEvent)
+ $.removeData(this.element, this.constructor.DATA_KEY)
- const isInTheDom = $.contains(
- this.element.ownerDocument.documentElement,
- this.element
- )
+ $(this.element).off(this.constructor.EVENT_KEY)
+ $(this.element).closest('.modal').off('hide.bs.modal')
- if (showEvent.isDefaultPrevented() || !isInTheDom) {
- return
- }
+ if (this.tip) {
+ $(this.tip).remove()
+ }
+
+ this._isEnabled = null
+ this._timeout = null
+ this._hoverState = null
+ this._activeTrigger = null
+ if (this._popper !== null) {
+ this._popper.destroy()
+ }
- const tip = this.getTipElement()
- const tipId = Util.getUID(this.constructor.NAME)
+ this._popper = null
+ this.element = null
+ this.config = null
+ this.tip = null
+ }
- tip.setAttribute('id', tipId)
- this.element.setAttribute('aria-describedby', tipId)
+ show() {
+ if ($(this.element).css('display') === 'none') {
+ throw new Error('Please use show on visible elements')
+ }
- this.setContent()
+ const showEvent = $.Event(this.constructor.Event.SHOW)
+ if (this.isWithContent() && this._isEnabled) {
+ $(this.element).trigger(showEvent)
- if (this.config.animation) {
- $(tip).addClass(ClassName.FADE)
- }
+ const isInTheDom = $.contains(
+ this.element.ownerDocument.documentElement,
+ this.element
+ )
- const placement = typeof this.config.placement === 'function'
- ? this.config.placement.call(this, tip, this.element)
- : this.config.placement
+ if (showEvent.isDefaultPrevented() || !isInTheDom) {
+ return
+ }
- const attachment = this._getAttachment(placement)
- this.addAttachmentClass(attachment)
+ const tip = this.getTipElement()
+ const tipId = Util.getUID(this.constructor.NAME)
- const container = this.config.container === false ? document.body : $(document).find(this.config.container)
+ tip.setAttribute('id', tipId)
+ this.element.setAttribute('aria-describedby', tipId)
- $(tip).data(this.constructor.DATA_KEY, this)
+ this.setContent()
- if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) {
- $(tip).appendTo(container)
- }
+ if (this.config.animation) {
+ $(tip).addClass(ClassName.FADE)
+ }
- $(this.element).trigger(this.constructor.Event.INSERTED)
-
- this._popper = new Popper(this.element, tip, {
- placement: attachment,
- modifiers: {
- offset: {
- offset: this.config.offset
- },
- flip: {
- behavior: this.config.fallbackPlacement
- },
- arrow: {
- element: Selector.ARROW
- },
- preventOverflow: {
- boundariesElement: this.config.boundary
- }
- },
- onCreate: (data) => {
- if (data.originalPlacement !== data.placement) {
- this._handlePopperPlacementChange(data)
- }
- },
- onUpdate: (data) => {
- this._handlePopperPlacementChange(data)
- }
- })
+ const placement = typeof this.config.placement === 'function'
+ ? this.config.placement.call(this, tip, this.element)
+ : this.config.placement
- $(tip).addClass(ClassName.SHOW)
+ const attachment = this._getAttachment(placement)
+ this.addAttachmentClass(attachment)
- // 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
- if ('ontouchstart' in document.documentElement) {
- $(document.body).children().on('mouseover', null, $.noop)
- }
+ const container = this.config.container === false ? document.body : $(document).find(this.config.container)
- const complete = () => {
- if (this.config.animation) {
- this._fixTransition()
- }
- const prevHoverState = this._hoverState
- this._hoverState = null
+ $(tip).data(this.constructor.DATA_KEY, this)
+
+ if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) {
+ $(tip).appendTo(container)
+ }
- $(this.element).trigger(this.constructor.Event.SHOWN)
+ $(this.element).trigger(this.constructor.Event.INSERTED)
- if (prevHoverState === HoverState.OUT) {
- this._leave(null, this)
+ this._popper = new Popper(this.element, tip, {
+ placement: attachment,
+ modifiers: {
+ offset: {
+ offset: this.config.offset
+ },
+ flip: {
+ behavior: this.config.fallbackPlacement
+ },
+ arrow: {
+ element: Selector.ARROW
+ },
+ preventOverflow: {
+ boundariesElement: this.config.boundary
+ }
+ },
+ onCreate: (data) => {
+ if (data.originalPlacement !== data.placement) {
+ this._handlePopperPlacementChange(data)
}
+ },
+ onUpdate: (data) => {
+ this._handlePopperPlacementChange(data)
}
+ })
- if ($(this.tip).hasClass(ClassName.FADE)) {
- const transitionDuration = Util.getTransitionDurationFromElement(this.tip)
+ $(tip).addClass(ClassName.SHOW)
- $(this.tip)
- .one(Util.TRANSITION_END, complete)
- .emulateTransitionEnd(transitionDuration)
- } else {
- complete()
- }
+ // 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
+ if ('ontouchstart' in document.documentElement) {
+ $(document.body).children().on('mouseover', null, $.noop)
}
- }
- hide(callback) {
- const tip = this.getTipElement()
- const hideEvent = $.Event(this.constructor.Event.HIDE)
const complete = () => {
- if (this._hoverState !== HoverState.SHOW && tip.parentNode) {
- tip.parentNode.removeChild(tip)
+ if (this.config.animation) {
+ this._fixTransition()
}
+ const prevHoverState = this._hoverState
+ this._hoverState = null
- this._cleanTipClass()
- this.element.removeAttribute('aria-describedby')
- $(this.element).trigger(this.constructor.Event.HIDDEN)
- if (this._popper !== null) {
- this._popper.destroy()
- }
+ $(this.element).trigger(this.constructor.Event.SHOWN)
- if (callback) {
- callback()
+ if (prevHoverState === HoverState.OUT) {
+ this._leave(null, this)
}
}
- $(this.element).trigger(hideEvent)
-
- if (hideEvent.isDefaultPrevented()) {
- return
- }
-
- $(tip).removeClass(ClassName.SHOW)
-
- // If this is a touch-enabled device we remove the extra
- // empty mouseover listeners we added for iOS support
- if ('ontouchstart' in document.documentElement) {
- $(document.body).children().off('mouseover', null, $.noop)
- }
-
- this._activeTrigger[Trigger.CLICK] = false
- this._activeTrigger[Trigger.FOCUS] = false
- this._activeTrigger[Trigger.HOVER] = false
-
if ($(this.tip).hasClass(ClassName.FADE)) {
- const transitionDuration = Util.getTransitionDurationFromElement(tip)
+ const transitionDuration = Util.getTransitionDurationFromElement(this.tip)
- $(tip)
+ $(this.tip)
.one(Util.TRANSITION_END, complete)
.emulateTransitionEnd(transitionDuration)
} else {
complete()
}
-
- this._hoverState = ''
}
+ }
- update() {
- if (this._popper !== null) {
- this._popper.scheduleUpdate()
+ hide(callback) {
+ const tip = this.getTipElement()
+ const hideEvent = $.Event(this.constructor.Event.HIDE)
+ const complete = () => {
+ if (this._hoverState !== HoverState.SHOW && tip.parentNode) {
+ tip.parentNode.removeChild(tip)
}
- }
- // Protected
+ this._cleanTipClass()
+ this.element.removeAttribute('aria-describedby')
+ $(this.element).trigger(this.constructor.Event.HIDDEN)
+ if (this._popper !== null) {
+ this._popper.destroy()
+ }
- isWithContent() {
- return Boolean(this.getTitle())
+ if (callback) {
+ callback()
+ }
}
- addAttachmentClass(attachment) {
- $(this.getTipElement()).addClass(`${CLASS_PREFIX}-${attachment}`)
- }
+ $(this.element).trigger(hideEvent)
- getTipElement() {
- this.tip = this.tip || $(this.config.template)[0]
- return this.tip
+ if (hideEvent.isDefaultPrevented()) {
+ return
}
- setContent() {
- const tip = this.getTipElement()
- this.setElementContent($(tip.querySelectorAll(Selector.TOOLTIP_INNER)), this.getTitle())
- $(tip).removeClass(`${ClassName.FADE} ${ClassName.SHOW}`)
- }
+ $(tip).removeClass(ClassName.SHOW)
- setElementContent($element, content) {
- const html = this.config.html
- if (typeof content === 'object' && (content.nodeType || content.jquery)) {
- // Content is a DOM node or a jQuery
- if (html) {
- if (!$(content).parent().is($element)) {
- $element.empty().append(content)
- }
- } else {
- $element.text($(content).text())
- }
- } else {
- $element[html ? 'html' : 'text'](content)
- }
+ // If this is a touch-enabled device we remove the extra
+ // empty mouseover listeners we added for iOS support
+ if ('ontouchstart' in document.documentElement) {
+ $(document.body).children().off('mouseover', null, $.noop)
}
- getTitle() {
- let title = this.element.getAttribute('data-original-title')
+ this._activeTrigger[Trigger.CLICK] = false
+ this._activeTrigger[Trigger.FOCUS] = false
+ this._activeTrigger[Trigger.HOVER] = false
- if (!title) {
- title = typeof this.config.title === 'function'
- ? this.config.title.call(this.element)
- : this.config.title
- }
+ if ($(this.tip).hasClass(ClassName.FADE)) {
+ const transitionDuration = Util.getTransitionDurationFromElement(tip)
- return title
+ $(tip)
+ .one(Util.TRANSITION_END, complete)
+ .emulateTransitionEnd(transitionDuration)
+ } else {
+ complete()
}
- // Private
+ this._hoverState = ''
+ }
- _getAttachment(placement) {
- return AttachmentMap[placement.toUpperCase()]
+ update() {
+ if (this._popper !== null) {
+ this._popper.scheduleUpdate()
}
+ }
- _setListeners() {
- const triggers = this.config.trigger.split(' ')
+ // Protected
- triggers.forEach((trigger) => {
- if (trigger === 'click') {
- $(this.element).on(
- 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
-
- $(this.element)
- .on(
- eventIn,
- this.config.selector,
- (event) => this._enter(event)
- )
- .on(
- eventOut,
- this.config.selector,
- (event) => this._leave(event)
- )
- }
+ isWithContent() {
+ return Boolean(this.getTitle())
+ }
- $(this.element).closest('.modal').on(
- 'hide.bs.modal',
- () => this.hide()
- )
- })
+ addAttachmentClass(attachment) {
+ $(this.getTipElement()).addClass(`${CLASS_PREFIX}-${attachment}`)
+ }
- if (this.config.selector) {
- this.config = {
- ...this.config,
- trigger: 'manual',
- selector: ''
+ getTipElement() {
+ this.tip = this.tip || $(this.config.template)[0]
+ return this.tip
+ }
+
+ setContent() {
+ const tip = this.getTipElement()
+ this.setElementContent($(tip.querySelectorAll(Selector.TOOLTIP_INNER)), this.getTitle())
+ $(tip).removeClass(`${ClassName.FADE} ${ClassName.SHOW}`)
+ }
+
+ setElementContent($element, content) {
+ const html = this.config.html
+ if (typeof content === 'object' && (content.nodeType || content.jquery)) {
+ // Content is a DOM node or a jQuery
+ if (html) {
+ if (!$(content).parent().is($element)) {
+ $element.empty().append(content)
}
} else {
- this._fixTitle()
+ $element.text($(content).text())
}
+ } else {
+ $element[html ? 'html' : 'text'](content)
}
+ }
- _fixTitle() {
- const titleType = typeof this.element.getAttribute('data-original-title')
- if (this.element.getAttribute('title') ||
- titleType !== 'string') {
- this.element.setAttribute(
- 'data-original-title',
- this.element.getAttribute('title') || ''
- )
- this.element.setAttribute('title', '')
- }
+ getTitle() {
+ let title = this.element.getAttribute('data-original-title')
+
+ if (!title) {
+ title = typeof this.config.title === 'function'
+ ? this.config.title.call(this.element)
+ : this.config.title
}
- _enter(event, context) {
- const dataKey = this.constructor.DATA_KEY
+ return title
+ }
- context = context || $(event.currentTarget).data(dataKey)
+ // Private
- if (!context) {
- context = new this.constructor(
- event.currentTarget,
- this._getDelegateConfig()
+ _getAttachment(placement) {
+ return AttachmentMap[placement.toUpperCase()]
+ }
+
+ _setListeners() {
+ const triggers = this.config.trigger.split(' ')
+
+ triggers.forEach((trigger) => {
+ if (trigger === 'click') {
+ $(this.element).on(
+ this.constructor.Event.CLICK,
+ this.config.selector,
+ (event) => this.toggle(event)
)
- $(event.currentTarget).data(dataKey, context)
+ } 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
+
+ $(this.element)
+ .on(
+ eventIn,
+ this.config.selector,
+ (event) => this._enter(event)
+ )
+ .on(
+ eventOut,
+ this.config.selector,
+ (event) => this._leave(event)
+ )
}
- if (event) {
- context._activeTrigger[
- event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER
- ] = true
- }
+ $(this.element).closest('.modal').on(
+ 'hide.bs.modal',
+ () => this.hide()
+ )
+ })
- if ($(context.getTipElement()).hasClass(ClassName.SHOW) ||
- context._hoverState === HoverState.SHOW) {
- context._hoverState = HoverState.SHOW
- return
+ if (this.config.selector) {
+ this.config = {
+ ...this.config,
+ trigger: 'manual',
+ selector: ''
}
+ } else {
+ this._fixTitle()
+ }
+ }
- clearTimeout(context._timeout)
+ _fixTitle() {
+ const titleType = typeof this.element.getAttribute('data-original-title')
+ if (this.element.getAttribute('title') ||
+ titleType !== 'string') {
+ this.element.setAttribute(
+ 'data-original-title',
+ this.element.getAttribute('title') || ''
+ )
+ this.element.setAttribute('title', '')
+ }
+ }
- context._hoverState = HoverState.SHOW
+ _enter(event, context) {
+ const dataKey = this.constructor.DATA_KEY
- if (!context.config.delay || !context.config.delay.show) {
- context.show()
- return
- }
+ context = context || $(event.currentTarget).data(dataKey)
- context._timeout = setTimeout(() => {
- if (context._hoverState === HoverState.SHOW) {
- context.show()
- }
- }, context.config.delay.show)
+ if (!context) {
+ context = new this.constructor(
+ event.currentTarget,
+ this._getDelegateConfig()
+ )
+ $(event.currentTarget).data(dataKey, context)
}
- _leave(event, context) {
- const dataKey = this.constructor.DATA_KEY
+ if (event) {
+ context._activeTrigger[
+ event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER
+ ] = true
+ }
- context = context || $(event.currentTarget).data(dataKey)
+ if ($(context.getTipElement()).hasClass(ClassName.SHOW) ||
+ context._hoverState === HoverState.SHOW) {
+ context._hoverState = HoverState.SHOW
+ return
+ }
- if (!context) {
- context = new this.constructor(
- event.currentTarget,
- this._getDelegateConfig()
- )
- $(event.currentTarget).data(dataKey, context)
- }
+ clearTimeout(context._timeout)
- if (event) {
- context._activeTrigger[
- event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER
- ] = false
- }
+ context._hoverState = HoverState.SHOW
- if (context._isWithActiveTrigger()) {
- return
- }
+ if (!context.config.delay || !context.config.delay.show) {
+ context.show()
+ return
+ }
- clearTimeout(context._timeout)
+ context._timeout = setTimeout(() => {
+ if (context._hoverState === HoverState.SHOW) {
+ context.show()
+ }
+ }, context.config.delay.show)
+ }
- context._hoverState = HoverState.OUT
+ _leave(event, context) {
+ const dataKey = this.constructor.DATA_KEY
- if (!context.config.delay || !context.config.delay.hide) {
- context.hide()
- return
- }
+ context = context || $(event.currentTarget).data(dataKey)
- context._timeout = setTimeout(() => {
- if (context._hoverState === HoverState.OUT) {
- context.hide()
- }
- }, context.config.delay.hide)
+ if (!context) {
+ context = new this.constructor(
+ event.currentTarget,
+ this._getDelegateConfig()
+ )
+ $(event.currentTarget).data(dataKey, context)
}
- _isWithActiveTrigger() {
- for (const trigger in this._activeTrigger) {
- if (this._activeTrigger[trigger]) {
- return true
- }
- }
+ if (event) {
+ context._activeTrigger[
+ event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER
+ ] = false
+ }
- return false
+ if (context._isWithActiveTrigger()) {
+ return
}
- _getConfig(config) {
- config = {
- ...this.constructor.Default,
- ...$(this.element).data(),
- ...typeof config === 'object' && config ? config : {}
- }
+ clearTimeout(context._timeout)
- if (typeof config.delay === 'number') {
- config.delay = {
- show: config.delay,
- hide: config.delay
- }
- }
+ context._hoverState = HoverState.OUT
- if (typeof config.title === 'number') {
- config.title = config.title.toString()
- }
+ if (!context.config.delay || !context.config.delay.hide) {
+ context.hide()
+ return
+ }
- if (typeof config.content === 'number') {
- config.content = config.content.toString()
+ context._timeout = setTimeout(() => {
+ if (context._hoverState === HoverState.OUT) {
+ context.hide()
}
+ }, context.config.delay.hide)
+ }
- Util.typeCheckConfig(
- NAME,
- config,
- this.constructor.DefaultType
- )
-
- return config
+ _isWithActiveTrigger() {
+ for (const trigger in this._activeTrigger) {
+ if (this._activeTrigger[trigger]) {
+ return true
+ }
}
- _getDelegateConfig() {
- const config = {}
-
- if (this.config) {
- for (const key in this.config) {
- if (this.constructor.Default[key] !== this.config[key]) {
- config[key] = this.config[key]
- }
- }
- }
+ return false
+ }
- return config
+ _getConfig(config) {
+ config = {
+ ...this.constructor.Default,
+ ...$(this.element).data(),
+ ...typeof config === 'object' && config ? config : {}
}
- _cleanTipClass() {
- const $tip = $(this.getTipElement())
- const tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX)
- if (tabClass !== null && tabClass.length) {
- $tip.removeClass(tabClass.join(''))
+ if (typeof config.delay === 'number') {
+ config.delay = {
+ show: config.delay,
+ hide: config.delay
}
}
- _handlePopperPlacementChange(popperData) {
- const popperInstance = popperData.instance
- this.tip = popperInstance.popper
- this._cleanTipClass()
- this.addAttachmentClass(this._getAttachment(popperData.placement))
+ if (typeof config.title === 'number') {
+ config.title = config.title.toString()
}
- _fixTransition() {
- const tip = this.getTipElement()
- const initConfigAnimation = this.config.animation
- if (tip.getAttribute('x-placement') !== null) {
- return
- }
- $(tip).removeClass(ClassName.FADE)
- this.config.animation = false
- this.hide()
- this.show()
- this.config.animation = initConfigAnimation
+ if (typeof config.content === 'number') {
+ config.content = config.content.toString()
}
- // Static
+ Util.typeCheckConfig(
+ NAME,
+ config,
+ this.constructor.DefaultType
+ )
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- const _config = typeof config === 'object' && config
+ return config
+ }
- if (!data && /dispose|hide/.test(config)) {
- return
- }
+ _getDelegateConfig() {
+ const config = {}
- if (!data) {
- data = new Tooltip(this, _config)
- $(this).data(DATA_KEY, data)
+ if (this.config) {
+ for (const key in this.config) {
+ if (this.constructor.Default[key] !== this.config[key]) {
+ config[key] = this.config[key]
}
+ }
+ }
- if (typeof config === 'string') {
- if (typeof data[config] === 'undefined') {
- throw new TypeError(`No method named "${config}"`)
- }
- data[config]()
- }
- })
+ return config
+ }
+
+ _cleanTipClass() {
+ const $tip = $(this.getTipElement())
+ const tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX)
+ if (tabClass !== null && tabClass.length) {
+ $tip.removeClass(tabClass.join(''))
}
}
- /**
- * ------------------------------------------------------------------------
- * jQuery
- * ------------------------------------------------------------------------
- */
+ _handlePopperPlacementChange(popperData) {
+ const popperInstance = popperData.instance
+ this.tip = popperInstance.popper
+ this._cleanTipClass()
+ this.addAttachmentClass(this._getAttachment(popperData.placement))
+ }
+
+ _fixTransition() {
+ const tip = this.getTipElement()
+ const initConfigAnimation = this.config.animation
+ if (tip.getAttribute('x-placement') !== null) {
+ return
+ }
+ $(tip).removeClass(ClassName.FADE)
+ this.config.animation = false
+ this.hide()
+ this.show()
+ this.config.animation = initConfigAnimation
+ }
+
+ // Static
+
+ static _jQueryInterface(config) {
+ return this.each(function () {
+ let data = $(this).data(DATA_KEY)
+ const _config = typeof config === 'object' && config
+
+ if (!data && /dispose|hide/.test(config)) {
+ return
+ }
+
+ if (!data) {
+ data = new Tooltip(this, _config)
+ $(this).data(DATA_KEY, data)
+ }
- $.fn[NAME] = Tooltip._jQueryInterface
- $.fn[NAME].Constructor = Tooltip
- $.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Tooltip._jQueryInterface
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+ data[config]()
+ }
+ })
}
+}
+
+/**
+ * ------------------------------------------------------------------------
+ * jQuery
+ * ------------------------------------------------------------------------
+ */
- return Tooltip
-})($, Popper)
+$.fn[NAME] = Tooltip._jQueryInterface
+$.fn[NAME].Constructor = Tooltip
+$.fn[NAME].noConflict = () => {
+ $.fn[NAME] = JQUERY_NO_CONFLICT
+ return Tooltip._jQueryInterface
+}
export default Tooltip
* --------------------------------------------------------------------------
*/
-const Util = (($) => {
- /**
- * ------------------------------------------------------------------------
- * Private TransitionEnd Helpers
- * ------------------------------------------------------------------------
- */
-
- const TRANSITION_END = 'transitionend'
- const MAX_UID = 1000000
- const MILLISECONDS_MULTIPLIER = 1000
-
- // Shoutout AngusCroll (https://goo.gl/pxwQGp)
- function toType(obj) {
- return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase()
- }
- function getSpecialTransitionEndEvent() {
- return {
- bindType: TRANSITION_END,
- delegateType: TRANSITION_END,
- handle(event) {
- if ($(event.target).is(this)) {
- return event.handleObj.handler.apply(this, arguments) // eslint-disable-line prefer-rest-params
- }
- return undefined // eslint-disable-line no-undefined
+/**
+ * ------------------------------------------------------------------------
+ * Private TransitionEnd Helpers
+ * ------------------------------------------------------------------------
+ */
+
+const TRANSITION_END = 'transitionend'
+const MAX_UID = 1000000
+const MILLISECONDS_MULTIPLIER = 1000
+
+// Shoutout AngusCroll (https://goo.gl/pxwQGp)
+function toType(obj) {
+ return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase()
+}
+
+function getSpecialTransitionEndEvent() {
+ return {
+ bindType: TRANSITION_END,
+ delegateType: TRANSITION_END,
+ handle(event) {
+ if ($(event.target).is(this)) {
+ return event.handleObj.handler.apply(this, arguments) // eslint-disable-line prefer-rest-params
}
+ return undefined // eslint-disable-line no-undefined
}
}
+}
- function transitionEndEmulator(duration) {
- let called = false
+function transitionEndEmulator(duration) {
+ let called = false
- $(this).one(Util.TRANSITION_END, () => {
- called = true
- })
+ $(this).one(Util.TRANSITION_END, () => {
+ called = true
+ })
- setTimeout(() => {
- if (!called) {
- Util.triggerTransitionEnd(this)
- }
- }, duration)
+ setTimeout(() => {
+ if (!called) {
+ Util.triggerTransitionEnd(this)
+ }
+ }, duration)
- return this
- }
+ return this
+}
- function setTransitionEndSupport() {
- $.fn.emulateTransitionEnd = transitionEndEmulator
- $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent()
- }
+function setTransitionEndSupport() {
+ $.fn.emulateTransitionEnd = transitionEndEmulator
+ $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent()
+}
- /**
- * --------------------------------------------------------------------------
- * Public Util Api
- * --------------------------------------------------------------------------
- */
+/**
+ * --------------------------------------------------------------------------
+ * Public Util Api
+ * --------------------------------------------------------------------------
+ */
- const Util = {
+const Util = {
- TRANSITION_END: 'bsTransitionEnd',
+ TRANSITION_END: 'bsTransitionEnd',
- getUID(prefix) {
- do {
- // eslint-disable-next-line no-bitwise
- prefix += ~~(Math.random() * MAX_UID) // "~~" acts like a faster Math.floor() here
- } while (document.getElementById(prefix))
- return prefix
- },
+ getUID(prefix) {
+ do {
+ // eslint-disable-next-line no-bitwise
+ prefix += ~~(Math.random() * MAX_UID) // "~~" acts like a faster Math.floor() here
+ } while (document.getElementById(prefix))
+ return prefix
+ },
- getSelectorFromElement(element) {
- let selector = element.getAttribute('data-target')
+ getSelectorFromElement(element) {
+ let selector = element.getAttribute('data-target')
- if (!selector || selector === '#') {
- const hrefAttr = element.getAttribute('href')
- selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''
- }
+ if (!selector || selector === '#') {
+ const hrefAttr = element.getAttribute('href')
+ selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''
+ }
- return selector && document.querySelector(selector) ? selector : null
- },
+ return selector && document.querySelector(selector) ? selector : null
+ },
- getTransitionDurationFromElement(element) {
- if (!element) {
- return 0
- }
+ getTransitionDurationFromElement(element) {
+ if (!element) {
+ return 0
+ }
- // Get transition-duration of the element
- let transitionDuration = $(element).css('transition-duration')
- const floatTransitionDuration = parseFloat(transitionDuration)
+ // Get transition-duration of the element
+ let transitionDuration = $(element).css('transition-duration')
+ const floatTransitionDuration = parseFloat(transitionDuration)
- // Return 0 if element or transition duration is not found
- if (!floatTransitionDuration) {
- return 0
- }
+ // Return 0 if element or transition duration is not found
+ if (!floatTransitionDuration) {
+ return 0
+ }
- // If multiple durations are defined, take the first
- transitionDuration = transitionDuration.split(',')[0]
-
- return parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER
- },
-
- reflow(element) {
- return element.offsetHeight
- },
-
- triggerTransitionEnd(element) {
- $(element).trigger(TRANSITION_END)
- },
-
- // TODO: Remove in v5
- supportsTransitionEnd() {
- return Boolean(TRANSITION_END)
- },
-
- isElement(obj) {
- return (obj[0] || obj).nodeType
- },
-
- typeCheckConfig(componentName, config, configTypes) {
- for (const property in configTypes) {
- if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
- const expectedTypes = configTypes[property]
- const value = config[property]
- const valueType = value && Util.isElement(value)
- ? 'element' : toType(value)
-
- if (!new RegExp(expectedTypes).test(valueType)) {
- throw new Error(
- `${componentName.toUpperCase()}: ` +
- `Option "${property}" provided type "${valueType}" ` +
- `but expected type "${expectedTypes}".`)
- }
+ // If multiple durations are defined, take the first
+ transitionDuration = transitionDuration.split(',')[0]
+
+ return parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER
+ },
+
+ reflow(element) {
+ return element.offsetHeight
+ },
+
+ triggerTransitionEnd(element) {
+ $(element).trigger(TRANSITION_END)
+ },
+
+ // TODO: Remove in v5
+ supportsTransitionEnd() {
+ return Boolean(TRANSITION_END)
+ },
+
+ isElement(obj) {
+ return (obj[0] || obj).nodeType
+ },
+
+ typeCheckConfig(componentName, config, configTypes) {
+ for (const property in configTypes) {
+ if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
+ const expectedTypes = configTypes[property]
+ const value = config[property]
+ const valueType = value && Util.isElement(value)
+ ? 'element' : toType(value)
+
+ if (!new RegExp(expectedTypes).test(valueType)) {
+ throw new Error(
+ `${componentName.toUpperCase()}: ` +
+ `Option "${property}" provided type "${valueType}" ` +
+ `but expected type "${expectedTypes}".`)
}
}
}
}
+}
- setTransitionEndSupport()
-
- return Util
-})($)
+setTransitionEndSupport()
export default Util
projects / thirdparty / bootstrap.git / commitdiff
