Proyectos de Subversion Moodle

 * Bootstrap (v4.6.2): tooltip.js

 * Bootstrap tooltip.js

import { DefaultWhitelist, sanitizeHtml } from './tools/sanitizer'

import * as Popper from 'core/popper2'

import $ from 'jquery'

import BaseComponent from './base-component'

import Popper from 'core/popper'

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

const JQUERY_NO_CONFLICT = $.fn[NAME]

 */

const CLASS_NAME_SHOW = 'show'

const TRIGGER_FOCUS = 'focus'

const EVENT_FOCUSOUT = 'focusout'

const TRIGGER_MANUAL = 'manual'

const EVENT_MOUSELEAVE = 'mouseleave'

  TOP: 'top',

  RIGHT: isRTL() ? 'left' : 'right',

  LEFT: 'left'

  BOTTOM: 'bottom',

}

  LEFT: isRTL() ? 'right' : 'left'

  animation: true,

  allowList: DefaultAllowlist,

                    '<div class="tooltip-inner"></div></div>',

  boundary: 'clippingParents',

  placement: 'top',

  delay: 0,

  offset: 0,

  sanitize: true,

  customClass: '',

            '<div class="tooltip-inner"></div>' +

  sanitize: true,

            '</div>',

  sanitizeFn: null,

  title: '',

}

const DefaultType = {

const DefaultType = {

  animation: 'boolean',

  placement: '(string|function)',

  customClass: '(string|function)',

  boundary: '(string|element)',

  delay: '(number|object)',

  whiteList: 'object',

  fallbackPlacements: 'array',

}

  html: 'boolean',

  CLICK: `click${EVENT_KEY}`,

  sanitizeFn: '(null|function)',

 * Class definition

    // Private

    this._isEnabled = true

    // Private

    this._timeout = 0

    this._isEnabled = true

  }

  }

        $(event.currentTarget).data(dataKey, context)

      return

    }

      }

    } else {

    this._activeTrigger.click = !this._activeTrigger.click

    clearTimeout(this._timeout)

  }

      $(this.tip).remove()

  dispose() {

    this._timeout = null

    if (this._popper) {

    EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler)

      this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'))

    this.tip = null

    this._disposePopper()

      $(this.element).trigger(showEvent)

    super.dispose()

      const tipId = Util.getUID(this.constructor.NAME)

  }

      const placement = typeof this.config.placement === 'function' ?

        this.config.placement.call(this, tip, this.element) :

  show() {

      throw new Error('Please use show on visible elements')

      const attachment = this._getAttachment(placement)

    if (!(this._isWithContent() && this._isEnabled)) {

    }

      $(tip).data(this.constructor.DATA_KEY, this)

      $(this.element).trigger(this.constructor.Event.INSERTED)

    const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW))

      $(tip).addClass(CLASS_NAME_SHOW)

    const shadowRoot = findShadowRoot(this._element)

      $(tip).addClass(this.config.customClass)

    const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element)

      // If this is a touch-enabled device we add extra

      // only needed because of broken event delegation on iOS

      return

        $(document.body).children().on('mouseover', null, $.noop)

    }

      const complete = () => {

    // TODO: v6 remove this or make it optional

        if (this.config.animation) {

    this._disposePopper()

          this._fixTransition()

    const tip = this._getTipElement()

        }

    this._element.setAttribute('aria-describedby', tip.getAttribute('id'))

          this._leave(null, this)

    if (!this._element.ownerDocument.documentElement.contains(this.tip)) {

      container.append(tip)

        $(this.tip)

      EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED))

          .emulateTransitionEnd(transitionDuration)

    }

    // empty mouseover listeners to the body's immediate children;

  }

      for (const element of [].concat(...document.body.children)) {

    const tip = this.getTipElement()

        tip.parentNode.removeChild(tip)

        this._leave()

      $(this.element).trigger(this.constructor.Event.HIDDEN)

  }

      if (this._popper !== null) {

        this._popper.destroy()

      return

      }

    }

      if (callback) {

        callback()

    if (hideEvent.defaultPrevented) {

    }

    if (hideEvent.isDefaultPrevented()) {

    // If this is a touch-enabled device we remove the extra

    $(tip).removeClass(CLASS_NAME_SHOW)

        EventHandler.off(element, 'mouseover', noop)

      }

    // empty mouseover listeners we added for iOS support

    if ('ontouchstart' in document.documentElement) {

    this._activeTrigger[TRIGGER_FOCUS] = false

      $(document.body).children().off('mouseover', null, $.noop)

    this._activeTrigger[TRIGGER_HOVER] = false

    this._activeTrigger[TRIGGER_HOVER] = false

    const complete = () => {

      if (this._isWithActiveTrigger()) {

    }

        return

      }

    this._hoverState = ''

      if (!this._isHovered) {

  update() {

  }

      this._popper.scheduleUpdate()

    if (this._popper) {

      this._popper.update()

  // Protected

  }

  isWithContent() {

    return Boolean(this.getTitle())

  // Protected

  addAttachmentClass(attachment) {

      this.tip = this._createTipElement(this._newContent || this._getContentForTemplate())

    $(this.getTipElement()).addClass(`${CLASS_PREFIX}-${attachment}`)

  _createTipElement(content) {

  }

    // TODO: remove this check in v6

    }

  getTipElement() {

    this.tip = this.tip || $(this.config.template)[0]

    tip.classList.remove(CLASS_NAME_FADE, CLASS_NAME_SHOW)

  }

    const tip = this.getTipElement()

      if (this.config.sanitize) {

    if (this._isAnimated()) {

        content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn)

      tip.classList.add(CLASS_NAME_FADE)

      }

    }

      $element.html(content)

  setContent(content) {

    } else {

    this._newContent = content

  }

    if (this._templateFactory) {

      this._templateFactory.changeContent(content)

    if (!title) {

    } else {

      title = typeof this.config.title === 'function' ?

      this._templateFactory = new TemplateFactory({

        this.config.title.call(this.element) :

        ...this._config,

        // the `content` var has to be after `this._config`

  // Private

      })

    const defaultBsConfig = {

    }

      placement: attachment,

      modifiers: {

  }

        offset: this._getOffset(),

    return this._config.animation || (this.tip && this.tip.classList.contains(CLASS_NAME_FADE))

        },

      return popperData => offset(popperData, this._element)

          element: SELECTOR_ARROW

    }

        },

        }

  _resolvePossibleFunction(arg) {

      },

    return execute(arg, [this._element])

          this._handlePopperPlacementChange(data)

        }

  _getPopperConfig(attachment) {

      },

    const defaultBsPopperConfig = {

      onUpdate: data => this._handlePopperPlacementChange(data)

      placement: attachment,

    return {

          name: 'flip',

      ...defaultBsConfig,

          options: {

    }

          }

  }

        },

          }

  _getOffset() {

        },

    if (typeof this.config.offset === 'function') {

          name: 'arrow',

        data.offsets = {

            element: `.${this.constructor.NAME}-arrow`

          name: 'preSetPlacement',

          fn: data => {

  }

            // Pre-set Popper's placement attribute in order to read the arrow sizes properly.

      if (trigger === 'click') {

          }

          this.constructor.Event.CLICK,

        }

      } else if (trigger !== TRIGGER_MANUAL) {

    }

        const eventIn = trigger === TRIGGER_HOVER ?

          this.constructor.Event.MOUSEENTER :

    return {

          this.constructor.Event.FOCUSIN

      ...execute(this._config.popperConfig, [defaultBsPopperConfig])

        const eventOut = trigger === TRIGGER_HOVER ?

    }

  _setListeners() {

      if (this.element) {

    const triggers = this._config.trigger.split(' ')

        this.hide()

      }

    for (const trigger of triggers) {

        EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK), this._config.selector, event => {

  _fixTitle() {

          context.toggle()

        this.element.getAttribute('title') || ''

        })

  }

          this.constructor.eventName(EVENT_MOUSEENTER) :

    if (!context) {

          this.constructor.eventName(EVENT_FOCUSIN)

      context = new this.constructor(

        const eventOut = trigger === TRIGGER_HOVER ?

        event.currentTarget,

          this.constructor.eventName(EVENT_MOUSELEAVE) :

      )

    }

          const context = this._initializeOnDelegatedTarget(event)

          context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true

    if (event) {

          context._enter()

      ] = true

        })

    }

        EventHandler.on(this._element, eventOut, this._config.selector, event => {

      context._hoverState = HOVER_STATE_SHOW

      return

          context._leave()

        })

    clearTimeout(context._timeout)

      }

    }

    context._hoverState = HOVER_STATE_SHOW

  _getDelegateConfig() {

    const config = {}

  _getDelegateConfig() {

    const config = {}

      }

    // In the future can be replaced with:

    }

    // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])

    return config

    // `Object.fromEntries(keysWithDifferentValues)`

  }

    return config

  _handlePopperPlacementChange(popperData) {

  _disposePopper() {

  }

    if (this._popper) {

    $(tip).removeClass(CLASS_NAME_FADE)

    this.config.animation = initConfigAnimation

      this.tip.remove()

  }

      this.tip = null

  static _jQueryInterface(config) {

    return this.each(function () {

  // Static

    return this.each(function () {

        }

      if (typeof data[config] === 'undefined') {