aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/twbs/bootstrap/js/src/carousel.js
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/twbs/bootstrap/js/src/carousel.js')
-rw-r--r--vendor/twbs/bootstrap/js/src/carousel.js435
1 files changed, 204 insertions, 231 deletions
diff --git a/vendor/twbs/bootstrap/js/src/carousel.js b/vendor/twbs/bootstrap/js/src/carousel.js
index b63d406bd..fe43f53eb 100644
--- a/vendor/twbs/bootstrap/js/src/carousel.js
+++ b/vendor/twbs/bootstrap/js/src/carousel.js
@@ -1,12 +1,24 @@
/**
* --------------------------------------------------------------------------
- * Bootstrap (v4.6.0): carousel.js
+ * Bootstrap (v5.0.2): carousel.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
-import $ from 'jquery'
-import Util from './util'
+import {
+ defineJQueryPlugin,
+ getElementFromSelector,
+ isRTL,
+ isVisible,
+ getNextActiveElement,
+ reflow,
+ triggerTransitionEnd,
+ typeCheckConfig
+} from './util/index'
+import EventHandler from './dom/event-handler'
+import Manipulator from './dom/manipulator'
+import SelectorEngine from './dom/selector-engine'
+import BaseComponent from './base-component'
/**
* ------------------------------------------------------------------------
@@ -15,13 +27,12 @@ import Util from './util'
*/
const NAME = 'carousel'
-const VERSION = '4.6.0'
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 ARROW_LEFT_KEY = 'ArrowLeft'
+const ARROW_RIGHT_KEY = 'ArrowRight'
const TOUCHEVENT_COMPAT_WAIT = 500 // Time for mouse compat events to fire after touch
const SWIPE_THRESHOLD = 40
@@ -43,11 +54,16 @@ const DefaultType = {
touch: 'boolean'
}
-const DIRECTION_NEXT = 'next'
-const DIRECTION_PREV = 'prev'
+const ORDER_NEXT = 'next'
+const ORDER_PREV = 'prev'
const DIRECTION_LEFT = 'left'
const DIRECTION_RIGHT = 'right'
+const KEY_TO_DIRECTION = {
+ [ARROW_LEFT_KEY]: DIRECTION_RIGHT,
+ [ARROW_RIGHT_KEY]: DIRECTION_LEFT
+}
+
const EVENT_SLIDE = `slide${EVENT_KEY}`
const EVENT_SLID = `slid${EVENT_KEY}`
const EVENT_KEYDOWN = `keydown${EVENT_KEY}`
@@ -65,8 +81,8 @@ const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
const CLASS_NAME_CAROUSEL = 'carousel'
const CLASS_NAME_ACTIVE = 'active'
const CLASS_NAME_SLIDE = 'slide'
-const CLASS_NAME_RIGHT = 'carousel-item-right'
-const CLASS_NAME_LEFT = 'carousel-item-left'
+const CLASS_NAME_END = 'carousel-item-end'
+const CLASS_NAME_START = 'carousel-item-start'
const CLASS_NAME_NEXT = 'carousel-item-next'
const CLASS_NAME_PREV = 'carousel-item-prev'
const CLASS_NAME_POINTER_EVENT = 'pointer-event'
@@ -77,21 +93,22 @@ const SELECTOR_ITEM = '.carousel-item'
const SELECTOR_ITEM_IMG = '.carousel-item img'
const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'
const SELECTOR_INDICATORS = '.carousel-indicators'
-const SELECTOR_DATA_SLIDE = '[data-slide], [data-slide-to]'
-const SELECTOR_DATA_RIDE = '[data-ride="carousel"]'
+const SELECTOR_INDICATOR = '[data-bs-target]'
+const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'
+const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'
-const PointerType = {
- TOUCH: 'touch',
- PEN: 'pen'
-}
+const POINTER_TYPE_TOUCH = 'touch'
+const POINTER_TYPE_PEN = 'pen'
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
*/
-class Carousel {
+class Carousel extends BaseComponent {
constructor(element, config) {
+ super(element)
+
this._items = null
this._interval = null
this._activeElement = null
@@ -102,46 +119,39 @@ class Carousel {
this.touchDeltaX = 0
this._config = this._getConfig(config)
- this._element = element
- this._indicatorsElement = this._element.querySelector(SELECTOR_INDICATORS)
+ 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._pointerEvent = Boolean(window.PointerEvent)
this._addEventListeners()
}
// Getters
- static get VERSION() {
- return VERSION
- }
-
static get Default() {
return Default
}
+ static get NAME() {
+ return NAME
+ }
+
// Public
next() {
- if (!this._isSliding) {
- this._slide(DIRECTION_NEXT)
- }
+ this._slide(ORDER_NEXT)
}
nextWhenVisible() {
- const $element = $(this._element)
// Don't call next when the page isn't visible
// or the carousel or its parent isn't visible
- if (!document.hidden &&
- ($element.is(':visible') && $element.css('visibility') !== 'hidden')) {
+ if (!document.hidden && isVisible(this._element)) {
this.next()
}
}
prev() {
- if (!this._isSliding) {
- this._slide(DIRECTION_PREV)
- }
+ this._slide(ORDER_PREV)
}
pause(event) {
@@ -149,8 +159,8 @@ class Carousel {
this._isPaused = true
}
- if (this._element.querySelector(SELECTOR_NEXT_PREV)) {
- Util.triggerTransitionEnd(this._element)
+ if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
+ triggerTransitionEnd(this._element)
this.cycle(true)
}
@@ -168,7 +178,7 @@ class Carousel {
this._interval = null
}
- if (this._config.interval && !this._isPaused) {
+ if (this._config && this._config.interval && !this._isPaused) {
this._updateInterval()
this._interval = setInterval(
@@ -179,8 +189,7 @@ class Carousel {
}
to(index) {
- this._activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM)
-
+ this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
const activeIndex = this._getItemIndex(this._activeElement)
if (index > this._items.length - 1 || index < 0) {
@@ -188,7 +197,7 @@ class Carousel {
}
if (this._isSliding) {
- $(this._element).one(EVENT_SLID, () => this.to(index))
+ EventHandler.one(this._element, EVENT_SLID, () => this.to(index))
return
}
@@ -198,25 +207,11 @@ class Carousel {
return
}
- const direction = index > activeIndex ?
- DIRECTION_NEXT :
- DIRECTION_PREV
+ const order = index > activeIndex ?
+ ORDER_NEXT :
+ ORDER_PREV
- this._slide(direction, this._items[index])
- }
-
- 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
+ this._slide(order, this._items[index])
}
// Private
@@ -224,9 +219,10 @@ class Carousel {
_getConfig(config) {
config = {
...Default,
- ...config
+ ...Manipulator.getDataAttributes(this._element),
+ ...(typeof config === 'object' ? config : {})
}
- Util.typeCheckConfig(NAME, config, DefaultType)
+ typeCheckConfig(NAME, config, DefaultType)
return config
}
@@ -241,58 +237,47 @@ class Carousel {
this.touchDeltaX = 0
- // swipe left
- if (direction > 0) {
- this.prev()
+ if (!direction) {
+ return
}
- // swipe right
- if (direction < 0) {
- this.next()
- }
+ this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT)
}
_addEventListeners() {
if (this._config.keyboard) {
- $(this._element).on(EVENT_KEYDOWN, event => this._keydown(event))
+ EventHandler.on(this._element, 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))
+ EventHandler.on(this._element, EVENT_MOUSEENTER, event => this.pause(event))
+ EventHandler.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event))
}
- if (this._config.touch) {
+ if (this._config.touch && this._touchSupported) {
this._addTouchEventListeners()
}
}
_addTouchEventListeners() {
- if (!this._touchSupported) {
- return
- }
-
const start = event => {
- if (this._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
- this.touchStartX = event.originalEvent.clientX
+ if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+ this.touchStartX = event.clientX
} else if (!this._pointerEvent) {
- this.touchStartX = event.originalEvent.touches[0].clientX
+ this.touchStartX = event.touches[0].clientX
}
}
const move = event => {
// ensure swiping with one touch and not pinching
- if (event.originalEvent.touches && event.originalEvent.touches.length > 1) {
- this.touchDeltaX = 0
- } else {
- this.touchDeltaX = event.originalEvent.touches[0].clientX - this.touchStartX
- }
+ this.touchDeltaX = event.touches && event.touches.length > 1 ?
+ 0 :
+ event.touches[0].clientX - this.touchStartX
}
const end = event => {
- if (this._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
- this.touchDeltaX = event.originalEvent.clientX - this.touchStartX
+ if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+ this.touchDeltaX = event.clientX - this.touchStartX
}
this._handleSwipe()
@@ -314,18 +299,19 @@ class Carousel {
}
}
- $(this._element.querySelectorAll(SELECTOR_ITEM_IMG))
- .on(EVENT_DRAG_START, e => e.preventDefault())
+ SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => {
+ EventHandler.on(itemImg, EVENT_DRAG_START, e => e.preventDefault())
+ })
if (this._pointerEvent) {
- $(this._element).on(EVENT_POINTERDOWN, event => start(event))
- $(this._element).on(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(CLASS_NAME_POINTER_EVENT)
} else {
- $(this._element).on(EVENT_TOUCHSTART, event => start(event))
- $(this._element).on(EVENT_TOUCHMOVE, event => move(event))
- $(this._element).on(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))
}
}
@@ -334,83 +320,65 @@ class Carousel {
return
}
- switch (event.which) {
- case ARROW_LEFT_KEYCODE:
- event.preventDefault()
- this.prev()
- break
- case ARROW_RIGHT_KEYCODE:
- event.preventDefault()
- this.next()
- break
- default:
+ const direction = KEY_TO_DIRECTION[event.key]
+ if (direction) {
+ event.preventDefault()
+ this._slide(direction)
}
}
_getItemIndex(element) {
this._items = element && element.parentNode ?
- [].slice.call(element.parentNode.querySelectorAll(SELECTOR_ITEM)) :
+ 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 ||
- isNextDirection && activeIndex === lastItemIndex
-
- if (isGoingToWrap && !this._config.wrap) {
- return activeElement
- }
-
- 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]
+ _getItemByOrder(order, activeElement) {
+ const isNext = order === ORDER_NEXT
+ return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap)
}
_triggerSlideEvent(relatedTarget, eventDirectionName) {
const targetIndex = this._getItemIndex(relatedTarget)
- const fromIndex = this._getItemIndex(this._element.querySelector(SELECTOR_ACTIVE_ITEM))
- const slideEvent = $.Event(EVENT_SLIDE, {
+ const fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element))
+
+ return EventHandler.trigger(this._element, EVENT_SLIDE, {
relatedTarget,
direction: eventDirectionName,
from: fromIndex,
to: targetIndex
})
-
- $(this._element).trigger(slideEvent)
-
- return slideEvent
}
_setActiveIndicatorElement(element) {
if (this._indicatorsElement) {
- const indicators = [].slice.call(this._indicatorsElement.querySelectorAll(SELECTOR_ACTIVE))
- $(indicators).removeClass(CLASS_NAME_ACTIVE)
+ const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement)
+
+ activeIndicator.classList.remove(CLASS_NAME_ACTIVE)
+ activeIndicator.removeAttribute('aria-current')
- const nextIndicator = this._indicatorsElement.children[
- this._getItemIndex(element)
- ]
+ const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement)
- if (nextIndicator) {
- $(nextIndicator).addClass(CLASS_NAME_ACTIVE)
+ for (let i = 0; i < indicators.length; i++) {
+ if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
+ indicators[i].classList.add(CLASS_NAME_ACTIVE)
+ indicators[i].setAttribute('aria-current', 'true')
+ break
+ }
}
}
}
_updateInterval() {
- const element = this._activeElement || this._element.querySelector(SELECTOR_ACTIVE_ITEM)
+ const element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
if (!element) {
return
}
- const elementInterval = parseInt(element.getAttribute('data-interval'), 10)
+ const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10)
if (elementInterval) {
this._config.defaultInterval = this._config.defaultInterval || this._config.interval
@@ -420,35 +388,31 @@ class Carousel {
}
}
- _slide(direction, element) {
- const activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM)
+ _slide(directionOrOrder, element) {
+ const order = this._directionToOrder(directionOrOrder)
+ const activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
const activeElementIndex = this._getItemIndex(activeElement)
- const nextElement = element || activeElement &&
- this._getItemByDirection(direction, activeElement)
+ const nextElement = element || this._getItemByOrder(order, activeElement)
+
const nextElementIndex = this._getItemIndex(nextElement)
const isCycling = Boolean(this._interval)
- let directionalClassName
- let orderClassName
- let eventDirectionName
+ const isNext = order === ORDER_NEXT
+ const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END
+ const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV
+ const eventDirectionName = this._orderToDirection(order)
- if (direction === DIRECTION_NEXT) {
- directionalClassName = CLASS_NAME_LEFT
- orderClassName = CLASS_NAME_NEXT
- eventDirectionName = DIRECTION_LEFT
- } else {
- directionalClassName = CLASS_NAME_RIGHT
- orderClassName = CLASS_NAME_PREV
- eventDirectionName = DIRECTION_RIGHT
+ if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) {
+ this._isSliding = false
+ return
}
- if (nextElement && $(nextElement).hasClass(CLASS_NAME_ACTIVE)) {
- this._isSliding = false
+ if (this._isSliding) {
return
}
const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName)
- if (slideEvent.isDefaultPrevented()) {
+ if (slideEvent.defaultPrevented) {
return
}
@@ -466,42 +430,41 @@ class Carousel {
this._setActiveIndicatorElement(nextElement)
this._activeElement = nextElement
- const slidEvent = $.Event(EVENT_SLID, {
- relatedTarget: nextElement,
- direction: eventDirectionName,
- from: activeElementIndex,
- to: nextElementIndex
- })
+ const triggerSlidEvent = () => {
+ EventHandler.trigger(this._element, EVENT_SLID, {
+ relatedTarget: nextElement,
+ direction: eventDirectionName,
+ from: activeElementIndex,
+ to: nextElementIndex
+ })
+ }
- if ($(this._element).hasClass(CLASS_NAME_SLIDE)) {
- $(nextElement).addClass(orderClassName)
+ if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
+ nextElement.classList.add(orderClassName)
- Util.reflow(nextElement)
+ reflow(nextElement)
- $(activeElement).addClass(directionalClassName)
- $(nextElement).addClass(directionalClassName)
+ activeElement.classList.add(directionalClassName)
+ nextElement.classList.add(directionalClassName)
- const transitionDuration = Util.getTransitionDurationFromElement(activeElement)
+ const completeCallBack = () => {
+ nextElement.classList.remove(directionalClassName, orderClassName)
+ nextElement.classList.add(CLASS_NAME_ACTIVE)
- $(activeElement)
- .one(Util.TRANSITION_END, () => {
- $(nextElement)
- .removeClass(`${directionalClassName} ${orderClassName}`)
- .addClass(CLASS_NAME_ACTIVE)
+ activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName)
- $(activeElement).removeClass(`${CLASS_NAME_ACTIVE} ${orderClassName} ${directionalClassName}`)
+ this._isSliding = false
- this._isSliding = false
+ setTimeout(triggerSlidEvent, 0)
+ }
- setTimeout(() => $(this._element).trigger(slidEvent), 0)
- })
- .emulateTransitionEnd(transitionDuration)
+ this._queueCallback(completeCallBack, activeElement, true)
} else {
- $(activeElement).removeClass(CLASS_NAME_ACTIVE)
- $(nextElement).addClass(CLASS_NAME_ACTIVE)
+ activeElement.classList.remove(CLASS_NAME_ACTIVE)
+ nextElement.classList.add(CLASS_NAME_ACTIVE)
this._isSliding = false
- $(this._element).trigger(slidEvent)
+ triggerSlidEvent()
}
if (isCycling) {
@@ -509,72 +472,86 @@ class Carousel {
}
}
+ _directionToOrder(direction) {
+ if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
+ return direction
+ }
+
+ if (isRTL()) {
+ return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT
+ }
+
+ return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV
+ }
+
+ _orderToDirection(order) {
+ if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
+ return order
+ }
+
+ if (isRTL()) {
+ return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT
+ }
+
+ return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT
+ }
+
// Static
- static _jQueryInterface(config) {
- return this.each(function () {
- let data = $(this).data(DATA_KEY)
- let _config = {
- ...Default,
- ...$(this).data()
- }
+ static carouselInterface(element, config) {
+ const data = Carousel.getOrCreateInstance(element, config)
- if (typeof config === 'object') {
- _config = {
- ..._config,
- ...config
- }
+ let { _config } = data
+ 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 (typeof config === 'number') {
+ data.to(config)
+ } else if (typeof action === 'string') {
+ if (typeof data[action] === 'undefined') {
+ throw new TypeError(`No method named "${action}"`)
}
- if (typeof config === 'number') {
- data.to(config)
- } else if (typeof action === 'string') {
- if (typeof data[action] === 'undefined') {
- throw new TypeError(`No method named "${action}"`)
- }
+ data[action]()
+ } else if (_config.interval && _config.ride) {
+ data.pause()
+ data.cycle()
+ }
+ }
- data[action]()
- } else if (_config.interval && _config.ride) {
- data.pause()
- data.cycle()
- }
+ static jQueryInterface(config) {
+ return this.each(function () {
+ Carousel.carouselInterface(this, config)
})
}
- static _dataApiClickHandler(event) {
- const selector = Util.getSelectorFromElement(this)
+ static dataApiClickHandler(event) {
+ const target = getElementFromSelector(this)
- if (!selector) {
- return
- }
-
- const target = $(selector)[0]
-
- if (!target || !$(target).hasClass(CLASS_NAME_CAROUSEL)) {
+ if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
return
}
const config = {
- ...$(target).data(),
- ...$(this).data()
+ ...Manipulator.getDataAttributes(target),
+ ...Manipulator.getDataAttributes(this)
}
- const slideIndex = this.getAttribute('data-slide-to')
+ const slideIndex = this.getAttribute('data-bs-slide-to')
if (slideIndex) {
config.interval = false
}
- Carousel._jQueryInterface.call($(target), config)
+ Carousel.carouselInterface(target, config)
if (slideIndex) {
- $(target).data(DATA_KEY).to(slideIndex)
+ Carousel.getInstance(target).to(slideIndex)
}
event.preventDefault()
@@ -587,13 +564,13 @@ class Carousel {
* ------------------------------------------------------------------------
*/
-$(document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel._dataApiClickHandler)
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler)
+
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+ const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE)
-$(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())
+ Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]))
}
})
@@ -601,13 +578,9 @@ $(window).on(EVENT_LOAD_DATA_API, () => {
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
+ * add .Carousel to jQuery only if jQuery is present
*/
-$.fn[NAME] = Carousel._jQueryInterface
-$.fn[NAME].Constructor = Carousel
-$.fn[NAME].noConflict = () => {
- $.fn[NAME] = JQUERY_NO_CONFLICT
- return Carousel._jQueryInterface
-}
+defineJQueryPlugin(Carousel)
export default Carousel