Proyectos de Subversion Moodle

 * Bootstrap (v4.6.2): carousel.js

 * Bootstrap carousel.js

import EventHandler from './dom/event-handler'

import $ from 'jquery'

} from './util/index'

const ARROW_RIGHT_KEYCODE = 39 // KeyboardEvent.which value for right arrow key

const DATA_KEY = 'bs.carousel'

const EVENT_KEY = `.${DATA_KEY}`

const CLASS_NAME_CAROUSEL = 'carousel'

const DATA_API_KEY = '.data-api'

const CLASS_NAME_LEFT = 'carousel-item-left'

const CLASS_NAME_NEXT = 'carousel-item-next'

const ARROW_LEFT_KEY = 'ArrowLeft'

const CLASS_NAME_PREV = 'carousel-item-prev'

const SELECTOR_ACTIVE = '.active'

const SELECTOR_DATA_SLIDE = '[data-slide], [data-slide-to]'

  [ARROW_LEFT_KEY]: DIRECTION_RIGHT,

const SELECTOR_DATA_RIDE = '[data-ride="carousel"]'

  [ARROW_RIGHT_KEY]: DIRECTION_LEFT

  interval: 5000,

  interval: 5000,

  wrap: true,

  ride: false,

  touch: true

  touch: true,

  keyboard: 'boolean',

  wrap: true

}

  keyboard: 'boolean',

const PointerType = {

  ride: '(boolean|string)',

 */

 * Class definition

    this.touchStartX = 0

class Carousel extends BaseComponent {

    this.touchDeltaX = 0

  constructor(element, config) {

    this._addEventListeners()

  // Getters

  static get VERSION() {

  }

    return DefaultType

    if (!this._isSliding) {

  }

  }

  // Public

  next() {

  nextWhenVisible() {

    this._slide(ORDER_NEXT)

    if (!document.hidden &&

      ($element.is(':visible') && $element.css('visibility') !== 'hidden')) {

  nextWhenVisible() {

      this.next()

    // Don't call next when the page isn't visible

    }

    // or the carousel or its parent isn't visible

  }

  prev() {

    if (!this._isSliding) {

  prev() {

    }

  }

  }

  pause() {

      this._isPaused = true

      triggerTransitionEnd(this._element)

    this._clearInterval()

    if (!event) {

  }

    if (this._interval) {

    this._updateInterval()

      this._interval = setInterval(

      return

      )

    }

      EventHandler.one(this._element, EVENT_SLID, () => this.cycle())

  to(index) {

      return

    if (index > this._items.length - 1 || index < 0) {

      return

      this.cycle()

  to(index) {

    config = {

    Util.typeCheckConfig(NAME, config, DefaultType)

      return

    return config

    }

    const activeIndex = this._getItemIndex(this._getActive())

      return

    const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV

    }

    const direction = absDeltax / this.touchDeltaX

  }

    this.touchDeltaX = 0

  dispose() {

    }

    }

    // swipe right

    super.dispose()

    if (direction < 0) {

  }

      this.next()

  // Private

  }

  _configAfterMerge(config) {

    config.defaultInterval = config.interval

  _addEventListeners() {

    return config

    if (!this._touchSupported) {

        this.touchStartX = event.originalEvent.clientX

    if (this._config.keyboard) {

        this.touchStartX = event.originalEvent.touches[0].clientX

      EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event))

    }

    }

      }

  }

      this._handleSwipe()

        // part of the mouse compatibility events on first tap - the carousel

  _addTouchEventListeners() {

        // would stop cycling until user tapped out of it;

    for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {

        }

    const endCallBack = () => {

      if (this._config.pause !== 'hover') {

      case ARROW_RIGHT_KEYCODE:

      }

        event.preventDefault()

      // part of the mouse compatibility events on first tap - the carousel

        break

      // would stop cycling until user tapped out of it;

  }

      // here, we listen for touchend, explicitly pause the carousel

      // (as if it's the second time we tap on it, mouseenter compat event

      [].slice.call(element.parentNode.querySelectorAll(SELECTOR_ITEM)) :

      // is NOT fired) and after a timeout (to allow for mouse compatibility

      []

      // events to fire) we explicitly restart cycling

    return this._items.indexOf(element)

    const isNextDirection = direction === DIRECTION_NEXT

      }

    const isGoingToWrap = isPrevDirection && activeIndex === 0 ||

    }

    const swipeConfig = {

    const itemIndex = (activeIndex + delta) % this._items.length

      rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),

      relatedTarget,

      endCallback: endCallBack

    $(this._element).trigger(slideEvent)

    }

  _setActiveIndicatorElement(element) {

    this._swipeHelper = new Swipe(this._element, swipeConfig)

    if (this._indicatorsElement) {

  }

      const nextIndicator = this._indicatorsElement.children[

    if (!this._indicatorsElement) {

    }

    const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement)

  }

    const element = this._activeElement || this._element.querySelector(SELECTOR_ACTIVE_ITEM)

    if (newActiveIndicator) {

    if (!element) {

      newActiveIndicator.setAttribute('aria-current', 'true')

      this._config.defaultInterval = this._config.defaultInterval || this._config.interval

    }

  }

  }

    const nextElement = element || activeElement &&

  _updateInterval() {

      this._getItemByDirection(direction, activeElement)

    const element = this._activeElement || this._getActive()

    const nextElementIndex = this._getItemIndex(nextElement)

    if (!element) {

    if (direction === DIRECTION_NEXT) {

    }

      eventDirectionName = DIRECTION_LEFT

    if (isCycling) {

    }

    const activeElement = this._getActive()

    const isNext = order === ORDER_NEXT

    this._activeElement = nextElement

    const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap)

      relatedTarget: nextElement,

      direction: eventDirectionName,

    if (nextElement === activeElement) {

      from: activeElementIndex,

      return

      to: nextElementIndex

    }

      Util.reflow(nextElement)

    const triggerEvent = eventName => {

      $(activeElement).addClass(directionalClassName)

        from: this._getItemIndex(activeElement),

      $(nextElement).addClass(directionalClassName)

        to: nextElementIndex

      const transitionDuration = Util.getTransitionDurationFromElement(activeElement)

      $(activeElement)

    if (slideEvent.defaultPrevented) {

            .removeClass(`${directionalClassName} ${orderClassName}`)

    if (!activeElement || !nextElement) {

      // Some weirdness is happening, so we bail

          this._isSliding = false

      // TODO: change tests that use empty divs to avoid this check

      return

          setTimeout(() => $(this._element).trigger(slidEvent), 0)

        })

    this._isSliding = true

        .emulateTransitionEnd(transitionDuration)

    this._setActiveIndicatorElement(nextElementIndex)

    } else {

    this._activeElement = nextElement

      $(activeElement).removeClass(CLASS_NAME_ACTIVE)

    activeElement.classList.add(directionalClassName)

    if (isCycling) {

  }

      this.cycle()

  }

    return SelectorEngine.find(SELECTOR_ITEM, this._element)

  }

        ...$(this).data()

    }