'use strict'
-const path = require('path')
-const rollup = require('rollup')
-const babel = require('rollup-plugin-babel')
-const banner = require('./banner.js')
+const path = require('path')
+const rollup = require('rollup')
+const babel = require('rollup-plugin-babel')
+const banner = require('./banner.js')
-const TEST = process.env.NODE_ENV === 'test'
+const TEST = process.env.NODE_ENV === 'test'
const plugins = [
babel({
- exclude: 'node_modules/**', // Only transpile our source code
- externalHelpersWhitelist: [ // Include only required helpers
+ // Only transpile our source code
+ exclude: 'node_modules/**',
+ // Include only required helpers
+ externalHelpersWhitelist: [
'defineProperties',
'createClass',
'inheritsLoose',
function build(plugin) {
console.log(`Building ${plugin} plugin...`)
- const config = getConfigByPluginKey(plugin)
- const external = config.external
- const globals = config.globals
+ const { external, globals } = getConfigByPluginKey(plugin)
let pluginPath = rootPath
const utilObjects = [
input: bsPlugins[plugin],
plugins,
external
- }).then((bundle) => {
+ }).then(bundle => {
bundle.write({
banner: banner(pluginFilename),
format: 'umd',
file: path.resolve(__dirname, `${pluginPath}${pluginFilename}`)
})
.then(() => console.log(`Building ${plugin} plugin... Done!`))
- .catch((err) => console.error(`${plugin}: ${err}`))
+ .catch(error => console.error(`${plugin}: ${error}`))
})
}
-Object.keys(bsPlugins).forEach((plugin) => build(plugin))
+Object.keys(bsPlugins).forEach(plugin => build(plugin))
if (excludedDirectories.has(path.parse(directory).base)) {
return
}
+
fs.readdir(directory, (err, names) => {
if (err) {
errback(err)
return
}
- names.forEach((name) => {
+
+ names.forEach(name => {
const filepath = path.join(directory, name)
fs.lstat(filepath, (err, stats) => {
if (err) {
process.nextTick(errback, err)
return
}
+
if (stats.isDirectory()) {
process.nextTick(walkAsync, filepath, excludedDirectories, fileCallback, errback)
} else if (stats.isFile()) {
function replaceRecursively(directory, excludedDirectories, allowedExtensions, original, replacement) {
original = new RegExp(regExpQuote(original), 'g')
replacement = regExpQuoteReplacement(replacement)
- const updateFile = DRY_RUN ? (filepath) => {
- if (allowedExtensions.has(path.parse(filepath).ext)) {
- console.log(`FILE: ${filepath}`)
- } else {
- console.log(`EXCLUDED:${filepath}`)
- }
- } : (filepath) => {
- if (allowedExtensions.has(path.parse(filepath).ext)) {
- sh.sed('-i', original, replacement, filepath)
+ const updateFile = DRY_RUN ?
+ filepath => {
+ if (allowedExtensions.has(path.parse(filepath).ext)) {
+ console.log(`FILE: ${filepath}`)
+ } else {
+ console.log(`EXCLUDED:${filepath}`)
+ }
+ } :
+ filepath => {
+ if (allowedExtensions.has(path.parse(filepath).ext)) {
+ sh.sed('-i', original, replacement, filepath)
+ }
}
- }
- walkAsync(directory, excludedDirectories, updateFile, (err) => {
+
+ walkAsync(directory, excludedDirectories, updateFile, err => {
console.error('ERROR while traversing directory!:')
console.error(err)
process.exit(1)
console.error('Got arguments:', args)
process.exit(1)
}
+
const oldVersion = args[0]
const newVersion = args[1]
const EXCLUDED_DIRS = new Set([
}
]
-files.forEach((file) => {
+files.forEach(file => {
fs.readFile(file.file, 'utf8', (err, data) => {
if (err) {
throw err
'use strict'
-module.exports = (ctx) => ({
- map: ctx.file.dirname.includes('examples') ? false : {
- inline: false,
- annotation: true,
- sourcesContent: true
- },
+module.exports = ctx => ({
+ map: ctx.file.dirname.includes('examples') ?
+ false :
+ {
+ inline: false,
+ annotation: true,
+ sourcesContent: true
+ },
plugins: {
autoprefixer: {
cascade: false
'use strict'
-const path = require('path')
-const babel = require('rollup-plugin-babel')
+const path = require('path')
+const babel = require('rollup-plugin-babel')
const resolve = require('rollup-plugin-node-resolve')
-const banner = require('./banner.js')
+const banner = require('./banner.js')
-const BUNDLE = process.env.BUNDLE === 'true'
+const BUNDLE = process.env.BUNDLE === 'true'
-let fileDest = 'bootstrap.js'
+let fileDest = 'bootstrap.js'
const external = ['popper.js']
const plugins = [
babel({
- exclude: 'node_modules/**', // Only transpile our source code
- externalHelpersWhitelist: [ // Include only required helpers
+ // Only transpile our source code
+ exclude: 'node_modules/**',
+ // Include only required helpers
+ externalHelpersWhitelist: [
'defineProperties',
'createClass',
'inheritsLoose',
* ------------------------------------------------------------------------
*/
-const NAME = 'alert'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.alert'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
+const NAME = 'alert'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.alert'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
const Selector = {
- DISMISS : '[data-dismiss="alert"]'
+ DISMISS: '[data-dismiss="alert"]'
}
const Event = {
- CLOSE : `close${EVENT_KEY}`,
- CLOSED : `closed${EVENT_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+ 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'
+ ALERT: 'alert',
+ FADE: 'fade',
+ SHOW: 'show'
}
/**
_getRootElement(element) {
const selector = getSelectorFromElement(element)
- let parent = false
+ let parent = false
if (selector) {
parent = SelectorEngine.findOne(selector)
const transitionDuration = getTransitionDurationFromElement(element)
EventHandler
- .one(element, TRANSITION_END, (event) => this._destroyElement(element, event))
+ .one(element, TRANSITION_END, event => this._destroyElement(element, event))
emulateTransitionEnd(element, transitionDuration)
}
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Alert._jQueryInterface
- $.fn[NAME].Constructor = Alert
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Alert._jQueryInterface
+ $.fn[NAME].Constructor = Alert
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Alert._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'button'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.button'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
+const NAME = 'button'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.button'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
const ClassName = {
- ACTIVE : 'active',
- BUTTON : 'btn',
- FOCUS : 'focus'
+ ACTIVE: 'active',
+ BUTTON: 'btn',
+ FOCUS: 'focus'
}
const Selector = {
- DATA_TOGGLE_CARROT : '[data-toggle^="button"]',
- DATA_TOGGLE : '[data-toggle="buttons"]',
- INPUT : 'input:not([type="hidden"])',
- ACTIVE : '.active',
- BUTTON : '.btn'
+ DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
+ DATA_TOGGLE: '[data-toggle="buttons"]',
+ INPUT: 'input:not([type="hidden"])',
+ ACTIVE: '.active',
+ BUTTON: '.btn'
}
const Event = {
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`,
- FOCUS_DATA_API : `focus${EVENT_KEY}${DATA_API_KEY}`,
- BLUR_DATA_API : `blur${EVENT_KEY}${DATA_API_KEY}`
+ CLICK_DATA_API: `click${EVENT_KEY}${DATA_API_KEY}`,
+ FOCUS_DATA_API: `focus${EVENT_KEY}${DATA_API_KEY}`,
+ BLUR_DATA_API: `blur${EVENT_KEY}${DATA_API_KEY}`
}
/**
* ------------------------------------------------------------------------
*/
-EventHandler.on(document, Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
+EventHandler.on(document, Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, event => {
event.preventDefault()
let button = event.target
data = new Button(button)
Data.setData(button, DATA_KEY, data)
}
+
data.toggle()
})
-EventHandler.on(document, Event.FOCUS_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
+EventHandler.on(document, Event.FOCUS_DATA_API, Selector.DATA_TOGGLE_CARROT, event => {
const button = SelectorEngine.closest(event.target, Selector.BUTTON)
button.classList.add(ClassName.FOCUS)
})
-EventHandler.on(document, Event.BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, (event) => {
+EventHandler.on(document, Event.BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, event => {
const button = SelectorEngine.closest(event.target, Selector.BUTTON)
button.classList.remove(ClassName.FOCUS)
})
*/
if (typeof $ !== 'undefined') {
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Button._jQueryInterface
- $.fn[NAME].Constructor = Button
+ const JQUERY_NO_CONFLICT = $.fn[NAME]
+ $.fn[NAME] = Button._jQueryInterface
+ $.fn[NAME].Constructor = Button
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Button._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'carousel'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.carousel'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
-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 NAME = 'carousel'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.carousel'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+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 SWIPE_THRESHOLD = 40
+const SWIPE_THRESHOLD = 40
const Default = {
- interval : 5000,
- keyboard : true,
- slide : false,
- pause : 'hover',
- wrap : true,
- touch : true
+ interval: 5000,
+ keyboard: true,
+ slide: false,
+ pause: 'hover',
+ wrap: true,
+ touch: true
}
const DefaultType = {
- interval : '(number|boolean)',
- keyboard : 'boolean',
- slide : '(boolean|string)',
- pause : '(string|boolean)',
- wrap : 'boolean',
- touch : 'boolean'
+ interval: '(number|boolean)',
+ keyboard: 'boolean',
+ slide: '(boolean|string)',
+ pause: '(string|boolean)',
+ wrap: 'boolean',
+ touch: 'boolean'
}
const Direction = {
- NEXT : 'next',
- PREV : 'prev',
- LEFT : 'left',
- RIGHT : 'right'
+ 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}`,
- TOUCHSTART : `touchstart${EVENT_KEY}`,
- TOUCHMOVE : `touchmove${EVENT_KEY}`,
- TOUCHEND : `touchend${EVENT_KEY}`,
- POINTERDOWN : `pointerdown${EVENT_KEY}`,
- POINTERUP : `pointerup${EVENT_KEY}`,
- DRAG_START : `dragstart${EVENT_KEY}`,
- LOAD_DATA_API : `load${EVENT_KEY}${DATA_API_KEY}`,
- CLICK_DATA_API : `click${EVENT_KEY}${DATA_API_KEY}`
+ SLIDE: `slide${EVENT_KEY}`,
+ SLID: `slid${EVENT_KEY}`,
+ KEYDOWN: `keydown${EVENT_KEY}`,
+ MOUSEENTER: `mouseenter${EVENT_KEY}`,
+ MOUSELEAVE: `mouseleave${EVENT_KEY}`,
+ TOUCHSTART: `touchstart${EVENT_KEY}`,
+ TOUCHMOVE: `touchmove${EVENT_KEY}`,
+ TOUCHEND: `touchend${EVENT_KEY}`,
+ POINTERDOWN: `pointerdown${EVENT_KEY}`,
+ POINTERUP: `pointerup${EVENT_KEY}`,
+ DRAG_START: `dragstart${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',
- POINTER_EVENT : 'pointer-event'
+ 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',
+ POINTER_EVENT: 'pointer-event'
}
const Selector = {
- ACTIVE : '.active',
- ACTIVE_ITEM : '.active.carousel-item',
- ITEM : '.carousel-item',
- ITEM_IMG : '.carousel-item img',
- NEXT_PREV : '.carousel-item-next, .carousel-item-prev',
- INDICATORS : '.carousel-indicators',
- DATA_SLIDE : '[data-slide], [data-slide-to]',
- DATA_RIDE : '[data-ride="carousel"]'
+ ACTIVE: '.active',
+ ACTIVE_ITEM: '.active.carousel-item',
+ ITEM: '.carousel-item',
+ ITEM_IMG: '.carousel-item img',
+ NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
+ INDICATORS: '.carousel-indicators',
+ DATA_SLIDE: '[data-slide], [data-slide-to]',
+ DATA_RIDE: '[data-ride="carousel"]'
}
const PointerType = {
- TOUCH : 'touch',
- PEN : 'pen'
+ TOUCH: 'touch',
+ PEN: 'pen'
}
/**
*/
class Carousel {
constructor(element, config) {
- this._items = null
- this._interval = null
+ this._items = null
+ this._interval = null
this._activeElement = null
- this._isPaused = false
- this._isSliding = false
- this.touchTimeout = null
- this.touchStartX = 0
- this.touchDeltaX = 0
-
- this._config = this._getConfig(config)
- this._element = element
+ this._isPaused = false
+ this._isSliding = false
+ this.touchTimeout = null
+ this.touchStartX = 0
+ this.touchDeltaX = 0
+
+ this._config = this._getConfig(config)
+ this._element = element
this._indicatorsElement = SelectorEngine.findOne(Selector.INDICATORS, this._element)
- this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0
- this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent)
+ this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0
+ this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent)
this._addEventListeners()
Data.setData(element, DATA_KEY, this)
return
}
- const direction = index > activeIndex
- ? Direction.NEXT
- : Direction.PREV
+ const direction = index > activeIndex ?
+ Direction.NEXT :
+ Direction.PREV
this._slide(direction, this._items[index])
}
EventHandler.off(this._element, EVENT_KEY)
Data.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._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) {
EventHandler
- .on(this._element, Event.KEYDOWN, (event) => this._keydown(event))
+ .on(this._element, Event.KEYDOWN, event => this._keydown(event))
}
if (this._config.pause === 'hover') {
EventHandler
- .on(this._element, Event.MOUSEENTER, (event) => this.pause(event))
+ .on(this._element, Event.MOUSEENTER, event => this.pause(event))
EventHandler
- .on(this._element, Event.MOUSELEAVE, (event) => this.cycle(event))
+ .on(this._element, Event.MOUSELEAVE, event => this.cycle(event))
}
if (this._config.touch) {
return
}
- const start = (event) => {
+ const start = event => {
if (this._pointerEvent && PointerType[event.pointerType.toUpperCase()]) {
this.touchStartX = event.clientX
} else if (!this._pointerEvent) {
}
}
- const move = (event) => {
+ const move = event => {
// ensure swiping with one touch and not pinching
if (event.touches && event.touches.length > 1) {
this.touchDeltaX = 0
}
}
- const end = (event) => {
+ const end = event => {
if (this._pointerEvent && PointerType[event.pointerType.toUpperCase()]) {
this.touchDeltaX = event.clientX - this.touchStartX
}
if (this.touchTimeout) {
clearTimeout(this.touchTimeout)
}
- this.touchTimeout = setTimeout((event) => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval)
+
+ this.touchTimeout = setTimeout(event => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval)
}
}
- makeArray(SelectorEngine.find(Selector.ITEM_IMG, this._element)).forEach((itemImg) => {
- EventHandler.on(itemImg, Event.DRAG_START, (e) => e.preventDefault())
+ makeArray(SelectorEngine.find(Selector.ITEM_IMG, this._element)).forEach(itemImg => {
+ EventHandler.on(itemImg, Event.DRAG_START, e => e.preventDefault())
})
if (this._pointerEvent) {
- EventHandler.on(this._element, Event.POINTERDOWN, (event) => start(event))
- EventHandler.on(this._element, Event.POINTERUP, (event) => end(event))
+ EventHandler.on(this._element, Event.POINTERDOWN, event => start(event))
+ EventHandler.on(this._element, Event.POINTERUP, event => end(event))
this._element.classList.add(ClassName.POINTER_EVENT)
} else {
- EventHandler.on(this._element, Event.TOUCHSTART, (event) => start(event))
- EventHandler.on(this._element, Event.TOUCHMOVE, (event) => move(event))
- EventHandler.on(this._element, Event.TOUCHEND, (event) => end(event))
+ EventHandler.on(this._element, Event.TOUCHSTART, event => start(event))
+ EventHandler.on(this._element, Event.TOUCHMOVE, event => move(event))
+ EventHandler.on(this._element, Event.TOUCHEND, event => end(event))
}
}
}
_getItemIndex(element) {
- this._items = element && element.parentNode
- ? makeArray(SelectorEngine.find(Selector.ITEM, element.parentNode))
- : []
+ this._items = element && element.parentNode ?
+ makeArray(SelectorEngine.find(Selector.ITEM, element.parentNode)) :
+ []
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 ||
+ 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
}
- const delta = direction === Direction.PREV ? -1 : 1
+ 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) {
_slide(direction, element) {
const activeElement = SelectorEngine.findOne(Selector.ACTIVE_ITEM, this._element)
const activeElementIndex = this._getItemIndex(activeElement)
- const nextElement = element || activeElement &&
+ const nextElement = element || activeElement &&
this._getItemByDirection(direction, activeElement)
const nextElementIndex = this._getItemIndex(nextElement)
// Static
static _carouselInterface(element, config) {
- let data = Data.getData(element, DATA_KEY)
+ let data = Data.getData(element, DATA_KEY)
let _config = {
...Default,
...Manipulator.getDataAttributes(element)
data.to(config)
} else if (typeof action === 'string') {
if (typeof data[action] === 'undefined') {
- throw new Error(`No method named "${action}"`)
+ throw new TypeError(`No method named "${action}"`)
}
+
data[action]()
} else if (_config.interval && _config.ride) {
data.pause()
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Carousel._jQueryInterface
- $.fn[NAME].Constructor = Carousel
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Carousel._jQueryInterface
+ $.fn[NAME].Constructor = Carousel
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Carousel._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'collapse'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.collapse'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
+const NAME = 'collapse'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.collapse'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
const Default = {
- toggle : true,
- parent : ''
+ toggle: true,
+ parent: ''
}
const DefaultType = {
- toggle : 'boolean',
- parent : '(string|element)'
+ 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}`
+ 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'
+ SHOW: 'show',
+ COLLAPSE: 'collapse',
+ COLLAPSING: 'collapsing',
+ COLLAPSED: 'collapsed'
}
const Dimension = {
- WIDTH : 'width',
- HEIGHT : 'height'
+ WIDTH: 'width',
+ HEIGHT: 'height'
}
const Selector = {
- ACTIVES : '.show, .collapsing',
- DATA_TOGGLE : '[data-toggle="collapse"]'
+ ACTIVES: '.show, .collapsing',
+ DATA_TOGGLE: '[data-toggle="collapse"]'
}
/**
class Collapse {
constructor(element, config) {
this._isTransitioning = false
- this._element = element
- this._config = this._getConfig(config)
- this._triggerArray = makeArray(SelectorEngine.find(
+ this._element = element
+ this._config = this._getConfig(config)
+ this._triggerArray = makeArray(SelectorEngine.find(
`[data-toggle="collapse"][href="#${element.id}"],` +
`[data-toggle="collapse"][data-target="#${element.id}"]`
))
const elem = toggleList[i]
const selector = getSelectorFromElement(elem)
const filterElement = makeArray(SelectorEngine.find(selector))
- .filter((foundElem) => foundElem === element)
+ .filter(foundElem => foundElem === element)
if (selector !== null && filterElement.length) {
this._selector = selector
if (this._parent) {
actives = makeArray(SelectorEngine.find(Selector.ACTIVES, this._parent))
- .filter((elem) => {
+ .filter(elem => {
if (typeof this._config.parent === 'string') {
return elem.getAttribute('data-parent') === this._config.parent
}
const container = SelectorEngine.findOne(this._selector)
if (actives) {
- const tempActiveData = actives.filter((elem) => container !== elem)
+ const tempActiveData = actives.filter(elem => container !== elem)
activesData = tempActiveData[0] ? Data.getData(tempActiveData[0], DATA_KEY) : null
if (activesData && activesData._isTransitioning) {
}
if (actives) {
- actives.forEach((elemActive) => {
+ actives.forEach(elemActive => {
if (container !== elemActive) {
Collapse._collapseInterface(elemActive, 'hide')
}
this._element.style[dimension] = 0
if (this._triggerArray.length) {
- this._triggerArray.forEach((element) => {
+ this._triggerArray.forEach(element => {
element.classList.remove(ClassName.COLLAPSED)
element.setAttribute('aria-expanded', true)
})
dispose() {
Data.removeData(this._element, DATA_KEY)
- this._config = null
- this._parent = null
- this._element = null
- this._triggerArray = null
+ this._config = null
+ this._parent = null
+ this._element = null
+ this._triggerArray = null
this._isTransitioning = null
}
let parent
if (isElement(this._config.parent)) {
- parent = this._config.parent
+ { parent } = this._config
// it's a jQuery object
if (typeof this._config.parent.jquery !== 'undefined' || typeof this._config.parent[0] !== 'undefined') {
parent = SelectorEngine.findOne(this._config.parent)
}
- const selector =
- `[data-toggle="collapse"][data-parent="${this._config.parent}"]`
+ const selector = `[data-toggle="collapse"][data-parent="${parent}"]`
makeArray(SelectorEngine.find(selector, parent))
- .forEach((element) => {
+ .forEach(element => {
this._addAriaAndCollapsedClass(
Collapse._getTargetFromElement(element),
[element]
const isOpen = element.classList.contains(ClassName.SHOW)
if (triggerArray.length) {
- triggerArray.forEach((elem) => {
- if (!isOpen) {
- elem.classList.add(ClassName.COLLAPSED)
- } else {
+ triggerArray.forEach(elem => {
+ if (isOpen) {
elem.classList.remove(ClassName.COLLAPSED)
+ } else {
+ elem.classList.add(ClassName.COLLAPSED)
}
+
elem.setAttribute('aria-expanded', isOpen)
})
}
}
static _collapseInterface(element, config) {
- let data = Data.getData(element, DATA_KEY)
+ let data = Data.getData(element, DATA_KEY)
const _config = {
...Default,
...Manipulator.getDataAttributes(element),
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
- throw new Error(`No method named "${config}"`)
+ throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
}
event.preventDefault()
}
- const triggerData = Manipulator.getDataAttributes(this)
- const selector = getSelectorFromElement(this)
+ const triggerData = Manipulator.getDataAttributes(this)
+ const selector = getSelectorFromElement(this)
const selectorElements = makeArray(SelectorEngine.find(selector))
- selectorElements.forEach((element) => {
+ selectorElements.forEach(element => {
const data = Data.getData(element, DATA_KEY)
let config
if (data) {
data._config.parent = triggerData.parent
data._parent = data._getParent()
}
+
config = 'toggle'
} else {
config = triggerData
*/
if (typeof $ !== 'undefined') {
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Collapse._jQueryInterface
- $.fn[NAME].Constructor = Collapse
- $.fn[NAME].noConflict = () => {
+ const JQUERY_NO_CONFLICT = $.fn[NAME]
+ $.fn[NAME] = Collapse._jQueryInterface
+ $.fn[NAME].Constructor = Collapse
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Collapse._jQueryInterface
}
if (keyProperties.key === key) {
return storeData[keyProperties.id]
}
+
return null
},
delete(element, key) {
const namespaceRegex = /[^.]*(?=\..*)\.|.*/
const stripNameRegex = /\..*/
-const keyEventRegex = /^key/
-const stripUidRegex = /::\d+$/
-const eventRegistry = {} // Events storage
-let uidEvent = 1
-const customEvents = {
+const keyEventRegex = /^key/
+const stripUidRegex = /::\d+$/
+const eventRegistry = {} // Events storage
+let uidEvent = 1
+const customEvents = {
mouseenter: 'mouseover',
mouseleave: 'mouseout'
}
-const nativeEvents = [
- 'click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu',
- 'mousewheel', 'DOMMouseScroll',
- 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend',
- 'keydown', 'keypress', 'keyup',
+const nativeEvents = [
+ 'click',
+ 'dblclick',
+ 'mouseup',
+ 'mousedown',
+ 'contextmenu',
+ 'mousewheel',
+ 'DOMMouseScroll',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'selectstart',
+ 'selectend',
+ 'keydown',
+ 'keypress',
+ 'keyup',
'orientationchange',
- 'touchstart', 'touchmove', 'touchend', 'touchcancel',
- 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel',
- 'gesturestart', 'gesturechange', 'gestureend',
- 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout',
- 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange',
- 'error', 'abort', 'scroll'
+ 'touchstart',
+ 'touchmove',
+ 'touchend',
+ 'touchcancel',
+ 'pointerdown',
+ 'pointermove',
+ 'pointerup',
+ 'pointerleave',
+ 'pointercancel',
+ 'gesturestart',
+ 'gesturechange',
+ 'gestureend',
+ 'focus',
+ 'blur',
+ 'change',
+ 'reset',
+ 'select',
+ 'submit',
+ 'focusin',
+ 'focusout',
+ 'load',
+ 'unload',
+ 'beforeunload',
+ 'resize',
+ 'move',
+ 'DOMContentLoaded',
+ 'readystatechange',
+ 'error',
+ 'abort',
+ 'scroll'
]
/**
function fixEvent(event, element) {
// Add which for key events
if (event.which === null && keyEventRegex.test(event.type)) {
- event.which = event.charCode !== null ? event.charCode : event.keyCode
+ event.which = event.charCode === null ? event.keyCode : event.charCode
}
event.delegateTarget = element
return function handler(event) {
const domElements = element.querySelectorAll(selector)
- for (let target = event.target; target && target !== this; target = target.parentNode) {
+ for (let { target } = event; target && target !== this; target = target.parentNode) {
for (let i = domElements.length; i--;) {
if (domElements[i] === target) {
fixEvent(event, target)
}
const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn)
- const events = getEvent(element)
- const handlers = events[typeEvent] || (events[typeEvent] = {})
+ const events = getEvent(element)
+ const handlers = events[typeEvent] || (events[typeEvent] = {})
const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null)
if (previousFn) {
}
const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''))
- const fn = !delegation ? bootstrapHandler(element, handler) : bootstrapDelegationHandler(element, handler, delegationFn)
+ const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler)
fn.delegationSelector = delegation ? handler : null
fn.originalHandler = originalHandler
const storeElementEvent = events[typeEvent] || {}
Object.keys(storeElementEvent)
- .forEach((handlerKey) => {
+ .forEach(handlerKey => {
if (handlerKey.indexOf(namespace) > -1) {
const event = storeElementEvent[handlerKey]
if (isNamespace) {
Object.keys(events)
- .forEach((elementEvent) => {
+ .forEach(elementEvent => {
removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.substr(1))
})
}
const storeElementEvent = events[typeEvent] || {}
Object.keys(storeElementEvent)
- .forEach((keyHandlers) => {
+ .forEach(keyHandlers => {
const handlerKey = keyHandlers.replace(stripUidRegex, '')
if (!inNamespace || originalTypeEvent.indexOf(handlerKey) > -1) {
return null
}
- const typeEvent = event.replace(stripNameRegex, '')
+ const typeEvent = event.replace(stripNameRegex, '')
const inNamespace = event !== typeEvent
- const isNative = nativeEvents.indexOf(typeEvent) > -1
+ const isNative = nativeEvents.indexOf(typeEvent) > -1
let jQueryEvent
let bubbles = true
// merge custom informations in our event
if (typeof args !== 'undefined') {
Object.keys(args)
- .forEach((key) => {
+ .forEach(key => {
Object.defineProperty(evt, key, {
get() {
return args[key]
}
function normalizeDataKey(key) {
- return key.replace(/[A-Z]/g, (chr) => chr.toLowerCase())
+ return key.replace(/[A-Z]/g, chr => chr.toLowerCase())
}
const Manipulator = {
...element.dataset
}
- Object.keys(attributes).forEach((key) => {
+ Object.keys(attributes).forEach(key => {
attributes[key] = normalizeData(attributes[key])
})
try {
element.querySelectorAll(':scope *')
- } catch (e) {
+ } catch (error) {
return false
}
* ------------------------------------------------------------------------
*/
-const findFn = Polyfill.find
-const findOne = Polyfill.findOne
+const { find: findFn, findOne } = Polyfill
const NODE_TEXT = 3
const SelectorEngine = {
const children = makeArray(element.children)
- return children.filter((child) => this.matches(child, selector))
+ return children.filter(child => this.matches(child, selector))
},
parents(element, selector) {
* ------------------------------------------------------------------------
*/
-const NAME = 'dropdown'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.dropdown'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
-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 NAME = 'dropdown'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.dropdown'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+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 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}`
+ 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'
+ 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)'
+ 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'
+ 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'
+ 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'
+ offset: '(number|string|function)',
+ flip: 'boolean',
+ boundary: '(string|element)',
+ reference: '(string|element)',
+ display: 'string'
}
/**
class Dropdown {
constructor(element, config) {
- this._element = element
- this._popper = null
- this._config = this._getConfig(config)
- this._menu = this._getMenuElement()
+ this._element = element
+ this._popper = null
+ this._config = this._getConfig(config)
+ this._menu = this._getMenuElement()
this._inNavbar = this._detectNavbar()
this._addEventListeners()
return
}
- const parent = Dropdown._getParentFromElement(this._element)
+ const parent = Dropdown._getParentFromElement(this._element)
const isActive = this._menu.classList.contains(ClassName.SHOW)
Dropdown._clearMenus()
if (this._config.boundary !== 'scrollParent') {
parent.classList.add(ClassName.POSITION_STATIC)
}
+
this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig())
}
if ('ontouchstart' in document.documentElement &&
!makeArray(SelectorEngine.closest(parent, Selector.NAVBAR_NAV)).length) {
makeArray(document.body.children)
- .forEach((elem) => EventHandler.on(elem, 'mouseover', null, noop()))
+ .forEach(elem => EventHandler.on(elem, 'mouseover', null, noop()))
}
this._element.focus()
// Private
_addEventListeners() {
- EventHandler.on(this._element, Event.CLICK, (event) => {
+ EventHandler.on(this._element, Event.CLICK, event => {
event.preventDefault()
event.stopPropagation()
this.toggle()
this._menu = SelectorEngine.findOne(Selector.MENU, parent)
}
}
+
return this._menu
}
_getPlacement() {
const parentDropdown = this._element.parentNode
- let placement = AttachmentMap.BOTTOM
+ let placement = AttachmentMap.BOTTOM
// Handle dropup
if (parentDropdown.classList.contains(ClassName.DROPUP)) {
} else if (this._menu.classList.contains(ClassName.MENURIGHT)) {
placement = AttachmentMap.BOTTOMEND
}
+
return placement
}
const offset = {}
if (typeof this._config.offset === 'function') {
- offset.fn = (data) => {
+ offset.fn = data => {
data.offsets = {
...data.offsets,
...this._config.offset(data.offsets, this._element) || {}
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
- throw new Error(`No method named "${config}"`)
+ throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
}
const toggles = makeArray(SelectorEngine.find(Selector.DATA_TOGGLE))
for (let i = 0, len = toggles.length; i < len; i++) {
- const parent = Dropdown._getParentFromElement(toggles[i])
- const context = Data.getData(toggles[i], DATA_KEY)
+ const parent = Dropdown._getParentFromElement(toggles[i])
+ const context = Data.getData(toggles[i], DATA_KEY)
const relatedTarget = {
relatedTarget: toggles[i]
}
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
makeArray(document.body.children)
- .forEach((elem) => EventHandler.off(elem, 'mouseover', null, noop()))
+ .forEach(elem => EventHandler.off(elem, 'mouseover', null, noop()))
}
toggles[i].setAttribute('aria-expanded', 'false')
// - 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 &&
+ 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 ||
- SelectorEngine.closest(event.target, Selector.MENU)) : !REGEXP_KEYDOWN.test(event.which)) {
+ SelectorEngine.closest(event.target, Selector.MENU)) :
+ !REGEXP_KEYDOWN.test(event.which)) {
return
}
return
}
- const parent = Dropdown._getParentFromElement(this)
+ const parent = Dropdown._getParentFromElement(this)
const isActive = parent.classList.contains(ClassName.SHOW)
if (!isActive || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
Dropdown._dropdownInterface(this, 'toggle')
})
EventHandler
- .on(document, Event.CLICK_DATA_API, Selector.FORM_CHILD, (e) => e.stopPropagation())
+ .on(document, Event.CLICK_DATA_API, Selector.FORM_CHILD, e => e.stopPropagation())
/**
* ------------------------------------------------------------------------
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Dropdown._jQueryInterface
- $.fn[NAME].Constructor = Dropdown
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Dropdown._jQueryInterface
+ $.fn[NAME].Constructor = Dropdown
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Dropdown._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'modal'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.modal'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
-const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
+const NAME = 'modal'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.modal'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const ESCAPE_KEYCODE = 27 // KeyboardEvent.which value for Escape (Esc) key
const Default = {
- backdrop : true,
- keyboard : true,
- focus : true,
- show : true
+ backdrop: true,
+ keyboard: true,
+ focus: true,
+ show: true
}
const DefaultType = {
- backdrop : '(boolean|string)',
- keyboard : 'boolean',
- focus : 'boolean',
- show : 'boolean'
+ 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}`
+ 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 = {
- SCROLLABLE : 'modal-dialog-scrollable',
- SCROLLBAR_MEASURER : 'modal-scrollbar-measure',
- BACKDROP : 'modal-backdrop',
- OPEN : 'modal-open',
- FADE : 'fade',
- SHOW : 'show'
+ SCROLLABLE: 'modal-dialog-scrollable',
+ SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
+ BACKDROP: 'modal-backdrop',
+ OPEN: 'modal-open',
+ FADE: 'fade',
+ SHOW: 'show'
}
const Selector = {
- DIALOG : '.modal-dialog',
- MODAL_BODY : '.modal-body',
- DATA_TOGGLE : '[data-toggle="modal"]',
- DATA_DISMISS : '[data-dismiss="modal"]',
- FIXED_CONTENT : '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
- STICKY_CONTENT : '.sticky-top'
+ DIALOG: '.modal-dialog',
+ MODAL_BODY: '.modal-body',
+ DATA_TOGGLE: '[data-toggle="modal"]',
+ DATA_DISMISS: '[data-dismiss="modal"]',
+ FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
+ STICKY_CONTENT: '.sticky-top'
}
/**
class Modal {
constructor(element, config) {
- this._config = this._getConfig(config)
- this._element = element
- this._dialog = SelectorEngine.findOne(Selector.DIALOG, element)
- this._backdrop = null
- this._isShown = false
- this._isBodyOverflowing = false
+ this._config = this._getConfig(config)
+ this._element = element
+ this._dialog = SelectorEngine.findOne(Selector.DIALOG, element)
+ this._backdrop = null
+ this._isShown = false
+ this._isBodyOverflowing = false
this._ignoreBackdropClick = false
- this._isTransitioning = false
- this._scrollbarWidth = 0
+ this._isTransitioning = false
+ this._scrollbarWidth = 0
Data.setData(element, DATA_KEY, this)
}
EventHandler.on(this._element,
Event.CLICK_DISMISS,
Selector.DATA_DISMISS,
- (event) => this.hide(event)
+ event => this.hide(event)
)
EventHandler.on(this._dialog, Event.MOUSEDOWN_DISMISS, () => {
- EventHandler.one(this._element, Event.MOUSEUP_DISMISS, (event) => {
+ EventHandler.one(this._element, Event.MOUSEUP_DISMISS, event => {
if (event.target === this._element) {
this._ignoreBackdropClick = true
}
EventHandler.off(this._element, Event.CLICK_DISMISS)
EventHandler.off(this._dialog, Event.MOUSEDOWN_DISMISS)
-
if (transition) {
const transitionDuration = getTransitionDurationFromElement(this._element)
- EventHandler.one(this._element, TRANSITION_END, (event) => this._hideModal(event))
+ EventHandler.one(this._element, TRANSITION_END, event => this._hideModal(event))
emulateTransitionEnd(this._element, transitionDuration)
} else {
this._hideModal()
dispose() {
[window, this._element, this._dialog]
- .forEach((htmlElement) => EventHandler.off(htmlElement, EVENT_KEY))
+ .forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY))
/**
* `document` has 2 events `Event.FOCUSIN` and `Event.CLICK_DATA_API`
Data.removeData(this._element, DATA_KEY)
- this._config = null
- this._element = null
- this._dialog = null
- this._backdrop = null
- this._isShown = null
- this._isBodyOverflowing = null
+ this._config = null
+ this._element = null
+ this._dialog = null
+ this._backdrop = null
+ this._isShown = null
+ this._isBodyOverflowing = null
this._ignoreBackdropClick = null
- this._isTransitioning = null
- this._scrollbarWidth = null
+ this._isTransitioning = null
+ this._scrollbarWidth = null
}
handleUpdate() {
if (this._config.focus) {
this._element.focus()
}
+
this._isTransitioning = false
EventHandler.trigger(this._element, Event.SHOWN, {
relatedTarget
}
if (transition) {
- const transitionDuration = getTransitionDurationFromElement(this._dialog)
+ const transitionDuration = getTransitionDurationFromElement(this._dialog)
EventHandler.one(this._dialog, TRANSITION_END, transitionComplete)
emulateTransitionEnd(this._dialog, transitionDuration)
_enforceFocus() {
EventHandler.off(document, Event.FOCUSIN) // guard against infinite focus loop
- EventHandler.on(document, Event.FOCUSIN, (event) => {
+ EventHandler.on(document, Event.FOCUSIN, event => {
if (document !== event.target &&
this._element !== event.target &&
!this._element.contains(event.target)) {
_setEscapeEvent() {
if (this._isShown && this._config.keyboard) {
- EventHandler.on(this._element, Event.KEYDOWN_DISMISS, (event) => {
+ EventHandler.on(this._element, Event.KEYDOWN_DISMISS, event => {
if (event.which === ESCAPE_KEYCODE) {
event.preventDefault()
this.hide()
_setResizeEvent() {
if (this._isShown) {
- EventHandler.on(window, Event.RESIZE, (event) => this.handleUpdate(event))
+ EventHandler.on(window, Event.RESIZE, event => this.handleUpdate(event))
} else {
EventHandler.off(window, Event.RESIZE)
}
}
_showBackdrop(callback) {
- const animate = this._element.classList.contains(ClassName.FADE)
- ? ClassName.FADE
- : ''
+ const animate = this._element.classList.contains(ClassName.FADE) ?
+ ClassName.FADE :
+ ''
if (this._isShown && this._config.backdrop) {
this._backdrop = document.createElement('div')
document.body.appendChild(this._backdrop)
- EventHandler.on(this._element, Event.CLICK_DISMISS, (event) => {
+ EventHandler.on(this._element, Event.CLICK_DISMISS, event => {
if (this._ignoreBackdropClick) {
this._ignoreBackdropClick = false
return
}
+
if (event.target !== event.currentTarget) {
return
}
+
if (this._config.backdrop === 'static') {
this._element.focus()
} else {
// Adjust fixed content padding
makeArray(SelectorEngine.find(Selector.FIXED_CONTENT))
- .forEach((element) => {
+ .forEach(element => {
const actualPadding = element.style.paddingRight
const calculatedPadding = window.getComputedStyle(element)['padding-right']
Manipulator.setDataAttribute(element, 'padding-right', actualPadding)
// Adjust sticky content margin
makeArray(SelectorEngine.find(Selector.STICKY_CONTENT))
- .forEach((element) => {
+ .forEach(element => {
const actualMargin = element.style.marginRight
const calculatedMargin = window.getComputedStyle(element)['margin-right']
Manipulator.setDataAttribute(element, 'margin-right', actualMargin)
_resetScrollbar() {
// Restore fixed content padding
makeArray(SelectorEngine.find(Selector.FIXED_CONTENT))
- .forEach((element) => {
+ .forEach(element => {
const padding = Manipulator.getDataAttribute(element, 'padding-right')
if (typeof padding !== 'undefined') {
Manipulator.removeDataAttribute(element, 'padding-right')
// Restore sticky content and navbar-toggler margin
makeArray(SelectorEngine.find(`${Selector.STICKY_CONTENT}`))
- .forEach((element) => {
+ .forEach(element => {
const margin = Manipulator.getDataAttribute(element, 'margin-right')
if (typeof margin !== 'undefined') {
Manipulator.removeDataAttribute(element, 'margin-right')
// Restore body padding
const padding = Manipulator.getDataAttribute(document.body, 'padding-right')
- if (typeof padding !== 'undefined') {
+ if (typeof padding === 'undefined') {
+ document.body.style.paddingRight = ''
+ } else {
Manipulator.removeDataAttribute(document.body, 'padding-right')
document.body.style.paddingRight = padding
- } else {
- document.body.style.paddingRight = ''
}
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`)
}
+
data[config](relatedTarget)
} else if (_config.show) {
data.show(relatedTarget)
target = SelectorEngine.findOne(selector)
}
- const config = Data.getData(target, DATA_KEY)
- ? 'toggle' : {
+ const config = Data.getData(target, DATA_KEY) ?
+ 'toggle' :
+ {
...Manipulator.getDataAttributes(target),
...Manipulator.getDataAttributes(this)
}
event.preventDefault()
}
- EventHandler.one(target, Event.SHOW, (showEvent) => {
+ EventHandler.one(target, Event.SHOW, showEvent => {
if (showEvent.defaultPrevented) {
// only register focus restorer if modal will actually get shown
return
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Modal._jQueryInterface
- $.fn[NAME].Constructor = Modal
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Modal._jQueryInterface
+ $.fn[NAME].Constructor = Modal
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Modal._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'popover'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.popover'
-const EVENT_KEY = `.${DATA_KEY}`
-const CLASS_PREFIX = 'bs-popover'
-const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
+const NAME = 'popover'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.popover'
+const EVENT_KEY = `.${DATA_KEY}`
+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">' +
+ placement: 'right',
+ trigger: 'click',
+ content: '',
+ template: '<div class="popover" role="tooltip">' +
'<div class="popover-arrow"></div>' +
'<h3 class="popover-header"></h3>' +
'<div class="popover-body"></div></div>'
const DefaultType = {
...Tooltip.DefaultType,
- content : '(string|element|function)'
+ content: '(string|element|function)'
}
const ClassName = {
- FADE : 'fade',
- SHOW : 'show'
+ FADE: 'fade',
+ SHOW: 'show'
}
const Selector = {
- TITLE : '.popover-header',
- CONTENT : '.popover-body'
+ 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}`
+ 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}`
}
/**
if (typeof content === 'function') {
content = content.call(this.element)
}
+
this.setElementContent(SelectorEngine.findOne(Selector.CONTENT, tip), content)
tip.classList.remove(ClassName.FADE)
const tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX)
if (tabClass !== null && tabClass.length > 0) {
- tabClass.map((token) => token.trim())
- .forEach((tClass) => tip.classList.remove(tClass))
+ tabClass.map(token => token.trim())
+ .forEach(tClass => tip.classList.remove(tClass))
}
}
static _jQueryInterface(config) {
return this.each(function () {
- let data = Data.getData(this, DATA_KEY)
+ let data = Data.getData(this, DATA_KEY)
const _config = typeof config === 'object' ? config : null
if (!data && /dispose|hide/.test(config)) {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
})
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Popover._jQueryInterface
- $.fn[NAME].Constructor = Popover
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Popover._jQueryInterface
+ $.fn[NAME].Constructor = Popover
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Popover._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'scrollspy'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.scrollspy'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
+const NAME = 'scrollspy'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.scrollspy'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
const Default = {
- offset : 10,
- method : 'auto',
- target : ''
+ offset: 10,
+ method: 'auto',
+ target: ''
}
const DefaultType = {
- offset : 'number',
- method : 'string',
- target : '(string|element)'
+ 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}`
+ 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'
+ 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'
+ 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'
+ OFFSET: 'offset',
+ POSITION: 'position'
}
/**
class ScrollSpy {
constructor(element, config) {
- this._element = element
+ 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 = 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._offsets = []
+ this._targets = []
+ this._activeTarget = null
+ this._scrollHeight = 0
- EventHandler.on(this._scrollElement, Event.SCROLL, (event) => this._process(event))
+ EventHandler.on(this._scrollElement, Event.SCROLL, event => this._process(event))
this.refresh()
this._process()
// Public
refresh() {
- const autoMethod = this._scrollElement === this._scrollElement.window
- ? OffsetMethod.OFFSET : OffsetMethod.POSITION
+ 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 = []
const targets = makeArray(SelectorEngine.find(this._selector))
targets
- .map((element) => {
+ .map(element => {
let target
const targetSelector = getSelectorFromElement(element)
]
}
}
+
return null
})
- .filter((item) => item)
+ .filter(item => item)
.sort((a, b) => a[0] - b[0])
- .forEach((item) => {
+ .forEach(item => {
this._offsets.push(item[0])
this._targets.push(item[1])
})
Data.removeData(this._element, DATA_KEY)
EventHandler.off(this._scrollElement, EVENT_KEY)
- this._element = null
+ this._element = null
this._scrollElement = null
- this._config = null
- this._selector = null
- this._offsets = null
- this._targets = null
- this._activeTarget = null
- this._scrollHeight = null
+ this._config = null
+ this._selector = null
+ this._offsets = null
+ this._targets = null
+ this._activeTarget = null
+ this._scrollHeight = null
}
// Private
}
if (typeof config.target !== 'string') {
- let id = config.target.id
+ let { id } = config.target
if (!id) {
id = getUID(NAME)
config.target.id = id
}
+
config.target = `#${id}`
}
}
_getScrollTop() {
- return this._scrollElement === window
- ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop
+ return this._scrollElement === window ?
+ this._scrollElement.pageYOffset :
+ this._scrollElement.scrollTop
}
_getScrollHeight() {
}
_getOffsetHeight() {
- return this._scrollElement === window
- ? window.innerHeight : this._scrollElement.getBoundingClientRect().height
+ return this._scrollElement === window ?
+ window.innerHeight :
+ this._scrollElement.getBoundingClientRect().height
}
_process() {
- const scrollTop = this._getScrollTop() + this._config.offset
+ const scrollTop = this._getScrollTop() + this._config.offset
const scrollHeight = this._getScrollHeight()
- const maxScroll = this._config.offset +
+ const maxScroll = this._config.offset +
scrollHeight -
this._getOffsetHeight()
if (this._activeTarget !== target) {
this._activate(target)
}
+
return
}
this._clear()
const queries = this._selector.split(',')
- .map((selector) => `${selector}[data-target="${target}"],${selector}[href="${target}"]`)
+ .map(selector => `${selector}[data-target="${target}"],${selector}[href="${target}"]`)
const link = SelectorEngine.findOne(queries.join(','))
SelectorEngine
.parents(link, Selector.NAV_LIST_GROUP)
- .forEach((listGroup) => {
+ .forEach(listGroup => {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
SelectorEngine.prev(listGroup, `${Selector.NAV_LINKS}, ${Selector.LIST_ITEMS}`)
- .forEach((item) => item.classList.add(ClassName.ACTIVE))
+ .forEach(item => item.classList.add(ClassName.ACTIVE))
// Handle special case when .nav-link is inside .nav-item
SelectorEngine.prev(listGroup, Selector.NAV_ITEMS)
- .forEach((navItem) => {
+ .forEach(navItem => {
SelectorEngine.children(navItem, Selector.NAV_LINKS)
- .forEach((item) => item.classList.add(ClassName.ACTIVE))
+ .forEach(item => item.classList.add(ClassName.ACTIVE))
})
})
}
_clear() {
makeArray(SelectorEngine.find(this._selector))
- .filter((node) => node.classList.contains(ClassName.ACTIVE))
- .forEach((node) => node.classList.remove(ClassName.ACTIVE))
+ .filter(node => node.classList.contains(ClassName.ACTIVE))
+ .forEach(node => node.classList.remove(ClassName.ACTIVE))
}
// Static
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
})
EventHandler.on(window, Event.LOAD_DATA_API, () => {
makeArray(SelectorEngine.find(Selector.DATA_SPY))
- .forEach((spy) => new ScrollSpy(spy, Manipulator.getDataAttributes(spy)))
+ .forEach(spy => new ScrollSpy(spy, Manipulator.getDataAttributes(spy)))
})
/**
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = ScrollSpy._jQueryInterface
- $.fn[NAME].Constructor = ScrollSpy
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = ScrollSpy._jQueryInterface
+ $.fn[NAME].Constructor = ScrollSpy
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return ScrollSpy._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'tab'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.tab'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
+const NAME = 'tab'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.tab'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
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}`
+ 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'
+ 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 : ':scope > li > .active',
- DATA_TOGGLE : '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
- DROPDOWN_TOGGLE : '.dropdown-toggle',
- DROPDOWN_ACTIVE_CHILD : ':scope > .dropdown-menu .active'
+ DROPDOWN: '.dropdown',
+ NAV_LIST_GROUP: '.nav, .list-group',
+ ACTIVE: '.active',
+ ACTIVE_UL: ':scope > li > .active',
+ DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
+ DROPDOWN_TOGGLE: '.dropdown-toggle',
+ DROPDOWN_ACTIVE_CHILD: ':scope > .dropdown-menu .active'
}
/**
// Private
_activate(element, container, callback) {
- const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL')
- ? SelectorEngine.find(Selector.ACTIVE_UL, container)
- : SelectorEngine.children(container, Selector.ACTIVE)
+ const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ?
+ SelectorEngine.find(Selector.ACTIVE_UL, container) :
+ SelectorEngine.children(container, Selector.ACTIVE)
- const active = activeElements[0]
+ const active = activeElements[0]
const isTransitioning = callback &&
(active && active.classList.contains(ClassName.FADE))
if (dropdownElement) {
makeArray(SelectorEngine.find(Selector.DROPDOWN_TOGGLE))
- .forEach((dropdown) => dropdown.classList.add(ClassName.ACTIVE))
+ .forEach(dropdown => dropdown.classList.add(ClassName.ACTIVE))
}
element.setAttribute('aria-expanded', true)
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
})
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Tab._jQueryInterface
- $.fn[NAME].Constructor = Tab
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Tab._jQueryInterface
+ $.fn[NAME].Constructor = Tab
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Tab._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'toast'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.toast'
+const NAME = 'toast'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.toast'
const EVENT_KEY = `.${DATA_KEY}`
const Event = {
- CLICK_DISMISS : `click.dismiss${EVENT_KEY}`,
- HIDE : `hide${EVENT_KEY}`,
- HIDDEN : `hidden${EVENT_KEY}`,
- SHOW : `show${EVENT_KEY}`,
- SHOWN : `shown${EVENT_KEY}`
+ CLICK_DISMISS: `click.dismiss${EVENT_KEY}`,
+ HIDE: `hide${EVENT_KEY}`,
+ HIDDEN: `hidden${EVENT_KEY}`,
+ SHOW: `show${EVENT_KEY}`,
+ SHOWN: `shown${EVENT_KEY}`
}
const ClassName = {
- FADE : 'fade',
- HIDE : 'hide',
- SHOW : 'show',
- SHOWING : 'showing'
+ FADE: 'fade',
+ HIDE: 'hide',
+ SHOW: 'show',
+ SHOWING: 'showing'
}
const DefaultType = {
- animation : 'boolean',
- autohide : 'boolean',
- delay : 'number'
+ animation: 'boolean',
+ autohide: 'boolean',
+ delay: 'number'
}
const Default = {
- animation : true,
- autohide : true,
- delay : 500
+ animation: true,
+ autohide: true,
+ delay: 500
}
const Selector = {
- DATA_DISMISS : '[data-dismiss="toast"]'
+ DATA_DISMISS: '[data-dismiss="toast"]'
}
/**
class Toast {
constructor(element, config) {
this._element = element
- this._config = this._getConfig(config)
+ this._config = this._getConfig(config)
this._timeout = null
this._setListeners()
Data.setData(element, DATA_KEY, this)
Data.removeData(this._element, DATA_KEY)
this._element = null
- this._config = null
+ this._config = null
}
// Private
static _jQueryInterface(config) {
return this.each(function () {
- let data = Data.getData(this, DATA_KEY)
- const _config = typeof config === 'object' && config
+ let data = Data.getData(this, DATA_KEY)
+ const _config = typeof config === 'object' && config
if (!data) {
data = new Toast(this, _config)
if (typeof $ !== 'undefined') {
const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Toast._jQueryInterface
- $.fn[NAME].Constructor = Toast
- $.fn[NAME].noConflict = () => {
+ $.fn[NAME] = Toast._jQueryInterface
+ $.fn[NAME].Constructor = Toast
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Toast._jQueryInterface
}
* ------------------------------------------------------------------------
*/
-const NAME = 'tooltip'
-const VERSION = '4.3.1'
-const DATA_KEY = 'bs.tooltip'
-const EVENT_KEY = `.${DATA_KEY}`
-const CLASS_PREFIX = 'bs-tooltip'
-const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
+const NAME = 'tooltip'
+const VERSION = '4.3.1'
+const DATA_KEY = 'bs.tooltip'
+const EVENT_KEY = `.${DATA_KEY}`
+const CLASS_PREFIX = 'bs-tooltip'
+const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g')
const DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']
-
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|function)',
- container : '(string|element|boolean)',
- fallbackPlacement : '(string|array)',
- boundary : '(string|element)',
- sanitize : 'boolean',
- sanitizeFn : '(null|function)',
- whiteList : 'object'
+ animation: 'boolean',
+ template: 'string',
+ title: '(string|element|function)',
+ trigger: 'string',
+ delay: '(number|object)',
+ html: 'boolean',
+ selector: '(string|boolean)',
+ placement: '(string|function)',
+ offset: '(number|string|function)',
+ container: '(string|element|boolean)',
+ fallbackPlacement: '(string|array)',
+ boundary: '(string|element)',
+ sanitize: 'boolean',
+ sanitizeFn: '(null|function)',
+ whiteList: 'object'
}
const AttachmentMap = {
- AUTO : 'auto',
- TOP : 'top',
- RIGHT : 'right',
- BOTTOM : 'bottom',
- LEFT : 'left'
+ AUTO: 'auto',
+ TOP: 'top',
+ RIGHT: 'right',
+ BOTTOM: 'bottom',
+ LEFT: 'left'
}
const Default = {
- animation : true,
- template
: '<div class="tooltip" role="tooltip">' +
+ animation: true,
+ template: '<div class="tooltip" role="tooltip">' +
'<div class="tooltip-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',
- sanitize : true,
- sanitizeFn : null,
- whiteList : DefaultWhitelist
+ trigger: 'hover focus',
+ title: '',
+ delay: 0,
+ html: false,
+ selector: false,
+ placement: 'top',
+ offset: 0,
+ container: false,
+ fallbackPlacement: 'flip',
+ boundary: 'scrollParent',
+ sanitize: true,
+ sanitizeFn: null,
+ whiteList: DefaultWhitelist
}
const HoverState = {
- SHOW : 'show',
- OUT : 'out'
+ 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}`
+ 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'
+ FADE: 'fade',
+ SHOW: 'show'
}
const Selector = {
- TOOLTIP : '.tooltip',
- TOOLTIP_INNER : '.tooltip-inner',
- TOOLTIP_ARROW : '.tooltip-arrow'
+ TOOLTIP: '.tooltip',
+ TOOLTIP_INNER: '.tooltip-inner',
+ TOOLTIP_ARROW: '.tooltip-arrow'
}
const Trigger = {
- HOVER : 'hover',
- FOCUS : 'focus',
- CLICK : 'click',
- MANUAL : 'manual'
+ HOVER: 'hover',
+ FOCUS: 'focus',
+ CLICK: 'click',
+ MANUAL: 'manual'
}
-
/**
* ------------------------------------------------------------------------
* Class Definition
}
// private
- this._isEnabled = true
- this._timeout = 0
- this._hoverState = ''
+ this._isEnabled = true
+ this._timeout = 0
+ this._hoverState = ''
this._activeTrigger = {}
- this._popper = null
+ this._popper = null
// Protected
this.element = element
- this.config = this._getConfig(config)
- this.tip = null
+ this.config = this._getConfig(config)
+ this.tip = null
this._setListeners()
Data.setData(element, this.constructor.DATA_KEY, this)
this.tip.parentNode.removeChild(this.tip)
}
- this._isEnabled = null
- this._timeout = null
- this._hoverState = null
+ this._isEnabled = null
+ this._timeout = null
+ this._hoverState = null
this._activeTrigger = null
if (this._popper !== null) {
this._popper.destroy()
this._popper = null
this.element = null
- this.config = null
- this.tip = null
+ this.config = null
+ this.tip = null
}
show() {
if (this.isWithContent() && this._isEnabled) {
const showEvent = EventHandler.trigger(this.element, this.constructor.Event.SHOW)
const shadowRoot = findShadowRoot(this.element)
- const isInTheDom = shadowRoot !== null
- ? shadowRoot.contains(this.element)
- : this.element.ownerDocument.documentElement.contains(this.element)
+ const isInTheDom = shadowRoot === null ?
+ this.element.ownerDocument.documentElement.contains(this.element) :
+ shadowRoot.contains(this.element)
if (showEvent.defaultPrevented || !isInTheDom) {
return
}
- const tip = this.getTipElement()
+ const tip = this.getTipElement()
const tipId = getUID(this.constructor.NAME)
tip.setAttribute('id', tipId)
tip.classList.add(ClassName.FADE)
}
- const placement = typeof this.config.placement === 'function'
- ? this.config.placement.call(this, tip, this.element)
- : this.config.placement
+ const placement = typeof this.config.placement === 'function' ?
+ this.config.placement.call(this, tip, this.element) :
+ this.config.placement
const attachment = this._getAttachment(placement)
this.addAttachmentClass(attachment)
boundariesElement: this.config.boundary
}
},
- onCreate: (data) => {
+ onCreate: data => {
if (data.originalPlacement !== data.placement) {
this._handlePopperPlacementChange(data)
}
},
- onUpdate: (data) => this._handlePopperPlacementChange(data)
+ onUpdate: data => this._handlePopperPlacementChange(data)
})
tip.classList.add(ClassName.SHOW)
// 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) {
- makeArray(document.body.children).forEach((element) => {
+ makeArray(document.body.children).forEach(element => {
EventHandler.on(element, 'mouseover', noop())
})
}
if (this.config.animation) {
this._fixTransition()
}
+
const prevHoverState = this._hoverState
- this._hoverState = null
+ this._hoverState = null
EventHandler.trigger(this.element, this.constructor.Event.SHOWN)
}
hide(callback) {
- const tip = this.getTipElement()
- const complete = () => {
+ const tip = this.getTipElement()
+ const complete = () => {
if (this._hoverState !== HoverState.SHOW && tip.parentNode) {
tip.parentNode.removeChild(tip)
}
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
makeArray(document.body.children)
- .forEach((element) => EventHandler.off(element, 'mouseover', noop))
+ .forEach(element => EventHandler.off(element, 'mouseover', noop))
}
this._activeTrigger[Trigger.CLICK] = false
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
+ title = typeof this.config.title === 'function' ?
+ this.config.title.call(this.element) :
+ this.config.title
}
return title
const offset = {}
if (typeof this.config.offset === 'function') {
- offset.fn = (data) => {
+ offset.fn = data => {
data.offsets = {
...data.offsets,
...this.config.offset(data.offsets, this.element) || {}
_setListeners() {
const triggers = this.config.trigger.split(' ')
- triggers.forEach((trigger) => {
+ triggers.forEach(trigger => {
if (trigger === 'click') {
EventHandler.on(this.element,
this.constructor.Event.CLICK,
this.config.selector,
- (event) => this.toggle(event)
+ 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
+ const eventIn = trigger === Trigger.HOVER ?
+ this.constructor.Event.MOUSEENTER :
+ this.constructor.Event.FOCUSIN
+ const eventOut = trigger === Trigger.HOVER ?
+ this.constructor.Event.MOUSELEAVE :
+ this.constructor.Event.FOCUSOUT
EventHandler.on(this.element,
eventIn,
this.config.selector,
- (event) => this._enter(event)
+ event => this._enter(event)
)
EventHandler.on(this.element,
eventOut,
this.config.selector,
- (event) => this._leave(event)
+ event => this._leave(event)
)
}
})
const dataAttributes = Manipulator.getDataAttributes(this.element)
Object.keys(dataAttributes)
- .forEach((dataAttr) => {
+ .forEach(dataAttr => {
if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) {
delete dataAttributes[dataAttr]
}
const tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX)
if (tabClass !== null && tabClass.length) {
tabClass
- .map((token) => token.trim())
- .forEach((tClass) => tip.classList.remove(tClass))
+ .map(token => token.trim())
+ .forEach(tClass => tip.classList.remove(tClass))
}
}
if (tip.getAttribute('x-placement') !== null) {
return
}
+
tip.classList.remove(ClassName.FADE)
this.config.animation = false
this.hide()
static _jQueryInterface(config) {
return this.each(function () {
- let data = Data.getData(this, DATA_KEY)
+ let data = Data.getData(this, DATA_KEY)
const _config = typeof config === 'object' && config
if (!data && /dispose|hide/.test(config)) {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`)
}
+
data[config]()
}
})
*/
if (typeof $ !== 'undefined') {
- const JQUERY_NO_CONFLICT = $.fn[NAME]
- $.fn[NAME] = Tooltip._jQueryInterface
- $.fn[NAME].Constructor = Tooltip
- $.fn[NAME].noConflict = () => {
+ const JQUERY_NO_CONFLICT = $.fn[NAME]
+ $.fn[NAME] = Tooltip._jQueryInterface
+ $.fn[NAME].Constructor = Tooltip
+ $.fn[NAME].noConflict = () => {
$.fn[NAME] = JQUERY_NO_CONFLICT
return Tooltip._jQueryInterface
}
const MAX_UID = 1000000
const MILLISECONDS_MULTIPLIER = 1000
const TRANSITION_END = 'transitionend'
-const jQuery = window.jQuery
+const { jQuery } = window
// Shoutout AngusCroll (https://goo.gl/pxwQGp)
-const toType = (obj) => ({}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase())
+const toType = obj => ({}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase())
/**
* --------------------------------------------------------------------------
* --------------------------------------------------------------------------
*/
-const getUID = (prefix) => {
+const 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
}
-const getSelectorFromElement = (element) => {
+const getSelectorFromElement = element => {
let selector = element.getAttribute('data-target')
if (!selector || selector === '#') {
try {
return document.querySelector(selector) ? selector : null
- } catch (err) {
+ } catch (error) {
return null
}
}
-const getTransitionDurationFromElement = (element) => {
+const getTransitionDurationFromElement = element => {
if (!element) {
return 0
}
return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER
}
-const triggerTransitionEnd = (element) => {
+const triggerTransitionEnd = element => {
element.dispatchEvent(new Event(TRANSITION_END))
}
-const isElement = (obj) => (obj[0] || obj).nodeType
+const isElement = obj => (obj[0] || obj).nodeType
const emulateTransitionEnd = (element, duration) => {
let called = false
const typeCheckConfig = (componentName, config, configTypes) => {
Object.keys(configTypes)
- .forEach((property) => {
+ .forEach(property => {
const expectedTypes = configTypes[property]
- const value = config[property]
- const valueType = value && isElement(value)
- ? 'element' : toType(value)
+ const value = config[property]
+ const valueType = value && isElement(value) ?
+ 'element' :
+ toType(value)
if (!new RegExp(expectedTypes).test(valueType)) {
throw new Error(
})
}
-const makeArray = (nodeList) => {
+const makeArray = nodeList => {
if (!nodeList) {
return []
}
return [].slice.call(nodeList)
}
-const isVisible = (element) => {
+const isVisible = element => {
if (!element) {
return false
}
return false
}
-const findShadowRoot = (element) => {
+const findShadowRoot = element => {
if (!document.documentElement.attachShadow) {
return null
}
// eslint-disable-next-line no-empty-function
const noop = () => function () {}
-const reflow = (element) => element.offsetHeight
+const reflow = element => element.offsetHeight
export {
jQuery,
return true
}
- const regExp = allowedAttributeList.filter((attrRegex) => attrRegex instanceof RegExp)
+ const regExp = allowedAttributeList.filter(attrRegex => attrRegex instanceof RegExp)
// Check if a regular expression validates the attribute.
for (let i = 0, l = regExp.length; i < l; i++) {
const attributeList = makeArray(el.attributes)
const whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || [])
- attributeList.forEach((attr) => {
+ attributeList.forEach(attr => {
if (!allowedAttribute(attr, whitelistedAttributes)) {
el.removeAttribute(attr.nodeName)
}
base: 'BrowserStack',
os: 'OS X',
os_version: 'High Sierra',
- browser : 'Chrome',
- browser_version : 'latest'
+ browser: 'Chrome',
+ browser_version: 'latest'
},
firefoxMac: {
base: 'BrowserStack',
import bootstrap from '../../../dist/js/bootstrap'
window.addEventListener('load', () => {
- Array.from(document.querySelectorAll('[data-toggle="tooltip"]'))
- .map((tooltipNode) => new bootstrap.Tooltip(tooltipNode))
+ [...document.querySelectorAll('[data-toggle="tooltip"]')]
+ .map(tooltipNode => new bootstrap.Tooltip(tooltipNode))
})
browsersKeys
} = require('./browsers')
-const env = process.env
+const { env } = process
const bundle = env.BUNDLE === 'true'
const browserStack = env.BROWSER === 'true'
const debug = env.DEBUG === 'true'
conf.reporters = reporters
conf.files = files
-module.exports = (karmaConfig) => {
+module.exports = karmaConfig => {
// possible values: karmaConfig.LOG_DISABLE || karmaConfig.LOG_ERROR || karmaConfig.LOG_WARN || karmaConfig.LOG_INFO || karmaConfig.LOG_DEBUG
conf.logLevel = karmaConfig.LOG_ERROR || karmaConfig.LOG_WARN
karmaConfig.set(conf)
$(function () {
'use strict'
- var Alert = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Alert : window.Alert
+ var Alert = typeof window.bootstrap === 'undefined' ? window.Alert : window.bootstrap.Alert
QUnit.module('alert plugin')
$(function () {
'use strict'
- var Button = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Button : window.Button
+ var Button = typeof window.bootstrap === 'undefined' ? window.Button : window.bootstrap.Button
QUnit.module('button plugin')
$(function () {
'use strict'
- window.Carousel = typeof bootstrap !== 'undefined' ? bootstrap.Carousel : Carousel
+ window.Carousel = typeof bootstrap === 'undefined' ? Carousel : bootstrap.Carousel
var originWinPointerEvent = window.PointerEvent
window.MSPointerEvent = null
$el.bootstrapCarousel()
try {
$el.bootstrapCarousel('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
try {
$('<div/>').bootstrapCarousel(config)
- } catch (err) {
- message = err.message
+ } catch (error) {
+ message = error.message
}
assert.ok(message === expectedMessage, 'correct error message')
try {
$('<div/>').bootstrapCarousel(config)
- } catch (err) {
- message = err.message
+ } catch (error) {
+ message = error.message
}
assert.ok(message === expectedMessage, 'correct error message')
}, 0)
$carousel[0].removeEventListener('slide.bs.carousel', onSlide)
}
+
$carousel[0].addEventListener('slide.bs.carousel', onSlide)
function onSlid() {
}, 0)
$carousel[0].removeEventListener('slid.bs.carousel', onSlid)
}
+
$carousel[0].addEventListener('slid.bs.carousel', onSlid)
$carousel.bootstrapCarousel('next')
assert.strictEqual(event.defaultPrevented, false)
$template[0].removeEventListener('keydown', handlerKeydown)
}
+
$template[0].addEventListener('keydown', handlerKeydown)
// arrow down
$template[0].addEventListener('keydown', handlerKeydown2)
done()
}
+
$template[0].addEventListener('keydown', handlerKeydown2)
// arrow up
$(function () {
'use strict'
- var Collapse = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Collapse : window.Collapse
+ var Collapse = typeof window.bootstrap === 'undefined' ? window.Collapse : window.bootstrap.Collapse
QUnit.module('collapse plugin')
$el.bootstrapCollapse()
try {
$el.bootstrapCollapse('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
'<div class="card"/>' +
'</div>'
var showFired = false
- var $groups = $(accordionHTML).appendTo('#qunit-fixture').find('.card')
+ var $groups = $(accordionHTML).appendTo('#qunit-fixture').find('.card')
var $target1 = $('<a role="button" data-toggle="collapse" href="#body1"/>').appendTo($groups.eq(0))
})
var $target2 = $('<a role="button" data-toggle="collapse" href="#body2"/>').appendTo($groups.eq(1))
- var $body2
= $('<div id="body2" class="collapse" data-parent="#accordion"/>').appendTo($groups.eq(1))
+ var $body2 = $('<div id="body2" class="collapse" data-parent="#accordion"/>').appendTo($groups.eq(1))
$target2[0].dispatchEvent(new Event('click'))
var $collapseTwoOne = $('#collapseTwoOne')
var $collapseTwoTwo = $('#collapseTwoTwo')
var collapsedElements = {
- one : false,
- two : false
+ one: false,
+ two: false
}
function firstTest() {
parent: $('.my-collapse')
})
assert.ok(true, 'collapse correctly created')
- } catch (err) {
+ } catch (error) {
assert.ok(false, 'collapse not created')
}
})
parent: $('.my-collapse')[0]
})
assert.ok(true, 'collapse correctly created')
- } catch (err) {
+ } catch (error) {
assert.ok(false, 'collapse not created')
}
})
$(function () {
'use strict'
- var Dropdown = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Dropdown : window.Dropdown
+ var Dropdown = typeof window.bootstrap === 'undefined' ? window.Dropdown : window.bootstrap.Dropdown
QUnit.module('dropdowns plugin')
$el.bootstrapDropdown()
try {
$el.bootstrapDropdown('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
$(function () {
'use strict'
- window.Util = typeof bootstrap !== 'undefined' ? bootstrap.Util : Util
- var Modal = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Modal : window.Modal
+ window.Util = typeof bootstrap === 'undefined' ? Util : bootstrap.Util
+ var Modal = typeof window.bootstrap === 'undefined' ? window.Modal : window.bootstrap.Modal
QUnit.module('modal plugin')
$el.bootstrapModal()
try {
$el.bootstrapModal('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
var originalPadding = $body.css('padding-right')
// Hide scrollbars to prevent the body overflowing
- $body.css('overflow', 'hidden') // Real scrollbar (for in-browser testing)
- $('html').css('padding-right', '0px') // Simulated scrollbar (for PhantomJS)
+ $body.css('overflow', 'hidden') // Real scrollbar (for in-browser testing)
+ $('html').css('padding-right', '0px') // Simulated scrollbar (for PhantomJS)
$('<div id="modal-test"><div class="modal-dialog" /></div>')
.on('shown.bs.modal', function () {
document.removeEventListener('focusin', focusInListener)
done()
}
+
document.addEventListener('focusin', focusInListener)
var focusInEvent = new Event('focusin')
$(function () {
'use strict'
- var Popover = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Popover : window.Popover
+ var Popover = typeof window.bootstrap === 'undefined' ? window.Popover : window.bootstrap.Popover
QUnit.module('popover plugin')
$el.bootstrapPopover()
try {
$el.bootstrapPopover('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
try {
$('<div data-toggle="popover" data-title="some title" data-content="@Johann-S" style="display: none"/>').bootstrapPopover('show')
- } catch (err) {
- assert.strictEqual(err.message, 'Please use show on visible elements')
+ } catch (error) {
+ assert.strictEqual(error.message, 'Please use show on visible elements')
done()
}
})
$(function () {
'use strict'
- var ScrollSpy = typeof window.bootstrap !== 'undefined' ? window.bootstrap.ScrollSpy : window.ScrollSpy
+ var ScrollSpy = typeof window.bootstrap === 'undefined' ? window.ScrollSpy : window.bootstrap.ScrollSpy
QUnit.module('scrollspy plugin')
$el.bootstrapScrollspy()
try {
$el.bootstrapScrollspy('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
$el.bootstrapTab()
try {
$el.bootstrapTab('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
QUnit.test('should activate element by tab id in nav list', function (assert) {
assert.expect(2)
- var tabsHTML = '<nav class="nav">' +
+ var tabsHTML = '<nav class="nav">' +
'<a href="#home">Home</a>' +
'<a href="#profile">Profile</a>' +
'</nav>'
QUnit.test('should activate element by tab id in list group', function (assert) {
assert.expect(2)
- var tabsHTML =
'<div class="list-group">' +
+ var tabsHTML = '<div class="list-group">' +
'<a href="#home">Home</a>' +
'<a href="#profile">Profile</a>' +
'</div>'
try {
$el.bootstrapToast('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
.bootstrapToast('show')
})
-
QUnit.test('should close toast when close element with data-dismiss attribute is set', function (assert) {
assert.expect(2)
var done = assert.async()
$(function () {
'use strict'
- var Tooltip = typeof window.bootstrap !== 'undefined' ? window.bootstrap.Tooltip : window.Tooltip
+ var Tooltip = typeof window.bootstrap === 'undefined' ? window.Tooltip : window.bootstrap.Tooltip
QUnit.module('tooltip plugin')
$el.bootstrapTooltip()
try {
$el.bootstrapTooltip('noMethod')
- } catch (err) {
- assert.strictEqual(err.message, 'No method named "noMethod"')
+ } catch (error) {
+ assert.strictEqual(error.message, 'No method named "noMethod"')
}
})
try {
$('<div title="tooltip title" style="display: none"/>').bootstrapTooltip('show')
- } catch (err) {
- assert.strictEqual(err.message, 'Please use show on visible elements')
+ } catch (error) {
+ assert.strictEqual(error.message, 'Please use show on visible elements')
done()
}
})
assert.expect(3)
var $tooltip = $('<div/>')
.bootstrapTooltip()
- .on('click.foo', function () {}) // eslint-disable-line no-empty-function
+ .on('click.foo', function () {}) // eslint-disable-line no-empty-function
assert.ok(Tooltip._getInstance($tooltip[0]), 'tooltip has data')
try {
$tooltip.bootstrapTooltip('show')
- } catch (err) {
+ } catch (error) {
passed = false
}
try {
Util.typeCheckConfig(namePlugin, config, defaultType)
- } catch (err) {
- assert.strictEqual(err.message, 'COLLAPSE: Option "parent" provided type "number" but expected type "(string|element)".')
+ } catch (error) {
+ assert.strictEqual(error.message, 'COLLAPSE: Option "parent" provided type "number" but expected type "(string|element)".')
}
})
assert.expect(1)
var $div = $('<div id="test"></div>').appendTo($('#qunit-fixture'))
- if (!document.documentElement.attachShadow) {
- assert.equal(null, Util.findShadowRoot($div[0]))
- } else {
+ if (document.documentElement.attachShadow) {
var sandbox = sinon.createSandbox()
sandbox.replace(document.documentElement, 'attachShadow', function () {
assert.equal(null, Util.findShadowRoot($div[0]))
sandbox.restore()
+ } else {
+ assert.equal(null, Util.findShadowRoot($div[0]))
}
})
})
bsCustomFileInput.init()
-}())
+})()
},
debug: false // Set debug to true if you want to inspect the dropdown
})
-}())
+})()
event.preventDefault()
event.stopPropagation()
}
+
form.classList.add('was-validated')
}, false)
})
}, false)
-}())
+})()
document.querySelector('[data-toggle="offcanvas"]').addEventListener('click', function () {
document.querySelector('.offcanvas-collapse').classList.toggle('open')
})
-}())
+})()
// IT'S ALL JUST JUNK FOR OUR DOCS!
// ++++++++++++++++++++++++++++++++++++++++++
+/* eslint-disable max-nested-callbacks */
+
(function () {
'use strict'
})
})
}
-}())
+})()
projects / thirdparty / bootstrap.git / commitdiff
