| /*! |
| * Bootstrap tooltip.js v5.1.3 (https://getbootstrap.com/) |
| * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core'), require('./dom/data.js'), require('./dom/event-handler.js'), require('./dom/manipulator.js'), require('./dom/selector-engine.js'), require('./base-component.js')) : |
| typeof define === 'function' && define.amd ? define(['@popperjs/core', './dom/data', './dom/event-handler', './dom/manipulator', './dom/selector-engine', './base-component'], factory) : |
| (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Tooltip = factory(global.Popper, global.Data, global.EventHandler, global.Manipulator, global.SelectorEngine, global.Base)); |
| })(this, (function (Popper, Data, EventHandler, Manipulator, SelectorEngine, BaseComponent) { 'use strict'; |
| |
| const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; |
| |
| function _interopNamespace(e) { |
| if (e && e.__esModule) return e; |
| const n = Object.create(null); |
| if (e) { |
| for (const k in e) { |
| if (k !== 'default') { |
| const d = Object.getOwnPropertyDescriptor(e, k); |
| Object.defineProperty(n, k, d.get ? d : { |
| enumerable: true, |
| get: () => e[k] |
| }); |
| } |
| } |
| } |
| n.default = e; |
| return Object.freeze(n); |
| } |
| |
| const Popper__namespace = /*#__PURE__*/_interopNamespace(Popper); |
| const Data__default = /*#__PURE__*/_interopDefaultLegacy(Data); |
| const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); |
| const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); |
| const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); |
| const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); |
| |
| /** |
| * -------------------------------------------------------------------------- |
| * Bootstrap (v5.1.3): util/index.js |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| * -------------------------------------------------------------------------- |
| */ |
| const MAX_UID = 1000000; |
| |
| const toType = obj => { |
| if (obj === null || obj === undefined) { |
| return `${obj}`; |
| } |
| |
| return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); |
| }; |
| /** |
| * -------------------------------------------------------------------------- |
| * Public Util Api |
| * -------------------------------------------------------------------------- |
| */ |
| |
| |
| const getUID = prefix => { |
| do { |
| prefix += Math.floor(Math.random() * MAX_UID); |
| } while (document.getElementById(prefix)); |
| |
| return prefix; |
| }; |
| |
| const isElement = obj => { |
| if (!obj || typeof obj !== 'object') { |
| return false; |
| } |
| |
| if (typeof obj.jquery !== 'undefined') { |
| obj = obj[0]; |
| } |
| |
| return typeof obj.nodeType !== 'undefined'; |
| }; |
| |
| const getElement = obj => { |
| if (isElement(obj)) { |
| // it's a jQuery object or a node element |
| return obj.jquery ? obj[0] : obj; |
| } |
| |
| if (typeof obj === 'string' && obj.length > 0) { |
| return document.querySelector(obj); |
| } |
| |
| return null; |
| }; |
| |
| const typeCheckConfig = (componentName, config, configTypes) => { |
| Object.keys(configTypes).forEach(property => { |
| const expectedTypes = configTypes[property]; |
| const value = config[property]; |
| const valueType = value && isElement(value) ? 'element' : toType(value); |
| |
| if (!new RegExp(expectedTypes).test(valueType)) { |
| throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); |
| } |
| }); |
| }; |
| |
| const findShadowRoot = element => { |
| if (!document.documentElement.attachShadow) { |
| return null; |
| } // Can find the shadow root otherwise it'll return the document |
| |
| |
| if (typeof element.getRootNode === 'function') { |
| const root = element.getRootNode(); |
| return root instanceof ShadowRoot ? root : null; |
| } |
| |
| if (element instanceof ShadowRoot) { |
| return element; |
| } // when we don't find a shadow root |
| |
| |
| if (!element.parentNode) { |
| return null; |
| } |
| |
| return findShadowRoot(element.parentNode); |
| }; |
| |
| const noop = () => {}; |
| |
| const getjQuery = () => { |
| const { |
| jQuery |
| } = window; |
| |
| if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { |
| return jQuery; |
| } |
| |
| return null; |
| }; |
| |
| const DOMContentLoadedCallbacks = []; |
| |
| const onDOMContentLoaded = callback => { |
| if (document.readyState === 'loading') { |
| // add listener on the first call when the document is in loading state |
| if (!DOMContentLoadedCallbacks.length) { |
| document.addEventListener('DOMContentLoaded', () => { |
| DOMContentLoadedCallbacks.forEach(callback => callback()); |
| }); |
| } |
| |
| DOMContentLoadedCallbacks.push(callback); |
| } else { |
| callback(); |
| } |
| }; |
| |
| const isRTL = () => document.documentElement.dir === 'rtl'; |
| |
| const defineJQueryPlugin = plugin => { |
| onDOMContentLoaded(() => { |
| const $ = getjQuery(); |
| /* istanbul ignore if */ |
| |
| if ($) { |
| const name = plugin.NAME; |
| const JQUERY_NO_CONFLICT = $.fn[name]; |
| $.fn[name] = plugin.jQueryInterface; |
| $.fn[name].Constructor = plugin; |
| |
| $.fn[name].noConflict = () => { |
| $.fn[name] = JQUERY_NO_CONFLICT; |
| return plugin.jQueryInterface; |
| }; |
| } |
| }); |
| }; |
| |
| /** |
| * -------------------------------------------------------------------------- |
| * Bootstrap (v5.1.3): util/sanitizer.js |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| * -------------------------------------------------------------------------- |
| */ |
| const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); |
| const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; |
| /** |
| * A pattern that recognizes a commonly useful subset of URLs that are safe. |
| * |
| * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts |
| */ |
| |
| const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i; |
| /** |
| * A pattern that matches safe data URLs. Only matches image, video and audio types. |
| * |
| * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts |
| */ |
| |
| const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; |
| |
| const allowedAttribute = (attribute, allowedAttributeList) => { |
| const attributeName = attribute.nodeName.toLowerCase(); |
| |
| if (allowedAttributeList.includes(attributeName)) { |
| if (uriAttributes.has(attributeName)) { |
| return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue)); |
| } |
| |
| return true; |
| } |
| |
| const regExp = allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp); // Check if a regular expression validates the attribute. |
| |
| for (let i = 0, len = regExp.length; i < len; i++) { |
| if (regExp[i].test(attributeName)) { |
| return true; |
| } |
| } |
| |
| return false; |
| }; |
| |
| const DefaultAllowlist = { |
| // Global attributes allowed on any supplied element below. |
| '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], |
| a: ['target', 'href', 'title', 'rel'], |
| area: [], |
| b: [], |
| br: [], |
| col: [], |
| code: [], |
| div: [], |
| em: [], |
| hr: [], |
| h1: [], |
| h2: [], |
| h3: [], |
| h4: [], |
| h5: [], |
| h6: [], |
| i: [], |
| img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], |
| li: [], |
| ol: [], |
| p: [], |
| pre: [], |
| s: [], |
| small: [], |
| span: [], |
| sub: [], |
| sup: [], |
| strong: [], |
| u: [], |
| ul: [] |
| }; |
| function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) { |
| if (!unsafeHtml.length) { |
| return unsafeHtml; |
| } |
| |
| if (sanitizeFn && typeof sanitizeFn === 'function') { |
| return sanitizeFn(unsafeHtml); |
| } |
| |
| const domParser = new window.DOMParser(); |
| const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); |
| const elements = [].concat(...createdDocument.body.querySelectorAll('*')); |
| |
| for (let i = 0, len = elements.length; i < len; i++) { |
| const element = elements[i]; |
| const elementName = element.nodeName.toLowerCase(); |
| |
| if (!Object.keys(allowList).includes(elementName)) { |
| element.remove(); |
| continue; |
| } |
| |
| const attributeList = [].concat(...element.attributes); |
| const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []); |
| attributeList.forEach(attribute => { |
| if (!allowedAttribute(attribute, allowedAttributes)) { |
| element.removeAttribute(attribute.nodeName); |
| } |
| }); |
| } |
| |
| return createdDocument.body.innerHTML; |
| } |
| |
| /** |
| * -------------------------------------------------------------------------- |
| * Bootstrap (v5.1.3): tooltip.js |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| * -------------------------------------------------------------------------- |
| */ |
| /** |
| * ------------------------------------------------------------------------ |
| * Constants |
| * ------------------------------------------------------------------------ |
| */ |
| |
| const NAME = 'tooltip'; |
| const DATA_KEY = 'bs.tooltip'; |
| const EVENT_KEY = `.${DATA_KEY}`; |
| const CLASS_PREFIX = 'bs-tooltip'; |
| const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', '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: '(array|string|function)', |
| container: '(string|element|boolean)', |
| fallbackPlacements: 'array', |
| boundary: '(string|element)', |
| customClass: '(string|function)', |
| sanitize: 'boolean', |
| sanitizeFn: '(null|function)', |
| allowList: 'object', |
| popperConfig: '(null|object|function)' |
| }; |
| const AttachmentMap = { |
| AUTO: 'auto', |
| TOP: 'top', |
| RIGHT: isRTL() ? 'left' : 'right', |
| BOTTOM: 'bottom', |
| LEFT: isRTL() ? 'right' : 'left' |
| }; |
| const Default = { |
| 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, 0], |
| container: false, |
| fallbackPlacements: ['top', 'right', 'bottom', 'left'], |
| boundary: 'clippingParents', |
| customClass: '', |
| sanitize: true, |
| sanitizeFn: null, |
| allowList: DefaultAllowlist, |
| popperConfig: null |
| }; |
| const Event = { |
| HIDE: `hide${EVENT_KEY}`, |
| HIDDEN: `hidden${EVENT_KEY}`, |
| SHOW: `show${EVENT_KEY}`, |
| SHOWN: `shown${EVENT_KEY}`, |
| INSERTED: `inserted${EVENT_KEY}`, |
| CLICK: `click${EVENT_KEY}`, |
| FOCUSIN: `focusin${EVENT_KEY}`, |
| FOCUSOUT: `focusout${EVENT_KEY}`, |
| MOUSEENTER: `mouseenter${EVENT_KEY}`, |
| MOUSELEAVE: `mouseleave${EVENT_KEY}` |
| }; |
| const CLASS_NAME_FADE = 'fade'; |
| const CLASS_NAME_MODAL = 'modal'; |
| const CLASS_NAME_SHOW = 'show'; |
| const HOVER_STATE_SHOW = 'show'; |
| const HOVER_STATE_OUT = 'out'; |
| const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; |
| const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`; |
| const EVENT_MODAL_HIDE = 'hide.bs.modal'; |
| const TRIGGER_HOVER = 'hover'; |
| const TRIGGER_FOCUS = 'focus'; |
| const TRIGGER_CLICK = 'click'; |
| const TRIGGER_MANUAL = 'manual'; |
| /** |
| * ------------------------------------------------------------------------ |
| * Class Definition |
| * ------------------------------------------------------------------------ |
| */ |
| |
| class Tooltip extends BaseComponent__default.default { |
| constructor(element, config) { |
| if (typeof Popper__namespace === 'undefined') { |
| throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); |
| } |
| |
| super(element); // private |
| |
| this._isEnabled = true; |
| this._timeout = 0; |
| this._hoverState = ''; |
| this._activeTrigger = {}; |
| this._popper = null; // Protected |
| |
| this._config = this._getConfig(config); |
| this.tip = null; |
| |
| this._setListeners(); |
| } // Getters |
| |
| |
| static get Default() { |
| return Default; |
| } |
| |
| static get NAME() { |
| return NAME; |
| } |
| |
| static get Event() { |
| return Event; |
| } |
| |
| static get DefaultType() { |
| return DefaultType; |
| } // Public |
| |
| |
| enable() { |
| this._isEnabled = true; |
| } |
| |
| disable() { |
| this._isEnabled = false; |
| } |
| |
| toggleEnabled() { |
| this._isEnabled = !this._isEnabled; |
| } |
| |
| toggle(event) { |
| if (!this._isEnabled) { |
| return; |
| } |
| |
| if (event) { |
| const context = this._initializeOnDelegatedTarget(event); |
| |
| context._activeTrigger.click = !context._activeTrigger.click; |
| |
| if (context._isWithActiveTrigger()) { |
| context._enter(null, context); |
| } else { |
| context._leave(null, context); |
| } |
| } else { |
| if (this.getTipElement().classList.contains(CLASS_NAME_SHOW)) { |
| this._leave(null, this); |
| |
| return; |
| } |
| |
| this._enter(null, this); |
| } |
| } |
| |
| dispose() { |
| clearTimeout(this._timeout); |
| EventHandler__default.default.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); |
| |
| if (this.tip) { |
| this.tip.remove(); |
| } |
| |
| this._disposePopper(); |
| |
| super.dispose(); |
| } |
| |
| show() { |
| if (this._element.style.display === 'none') { |
| throw new Error('Please use show on visible elements'); |
| } |
| |
| if (!(this.isWithContent() && this._isEnabled)) { |
| return; |
| } |
| |
| const showEvent = EventHandler__default.default.trigger(this._element, this.constructor.Event.SHOW); |
| const shadowRoot = findShadowRoot(this._element); |
| const isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element); |
| |
| if (showEvent.defaultPrevented || !isInTheDom) { |
| return; |
| } // A trick to recreate a tooltip in case a new title is given by using the NOT documented `data-bs-original-title` |
| // This will be removed later in favor of a `setContent` method |
| |
| |
| if (this.constructor.NAME === 'tooltip' && this.tip && this.getTitle() !== this.tip.querySelector(SELECTOR_TOOLTIP_INNER).innerHTML) { |
| this._disposePopper(); |
| |
| this.tip.remove(); |
| this.tip = null; |
| } |
| |
| const tip = this.getTipElement(); |
| const tipId = getUID(this.constructor.NAME); |
| tip.setAttribute('id', tipId); |
| |
| this._element.setAttribute('aria-describedby', tipId); |
| |
| if (this._config.animation) { |
| tip.classList.add(CLASS_NAME_FADE); |
| } |
| |
| 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); |
| |
| const { |
| container |
| } = this._config; |
| Data__default.default.set(tip, this.constructor.DATA_KEY, this); |
| |
| if (!this._element.ownerDocument.documentElement.contains(this.tip)) { |
| container.append(tip); |
| EventHandler__default.default.trigger(this._element, this.constructor.Event.INSERTED); |
| } |
| |
| if (this._popper) { |
| this._popper.update(); |
| } else { |
| this._popper = Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment)); |
| } |
| |
| tip.classList.add(CLASS_NAME_SHOW); |
| |
| const customClass = this._resolvePossibleFunction(this._config.customClass); |
| |
| if (customClass) { |
| tip.classList.add(...customClass.split(' ')); |
| } // If this is a touch-enabled device we add extra |
| // empty mouseover listeners to the body's immediate children; |
| // only needed because of broken event delegation on iOS |
| // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html |
| |
| |
| if ('ontouchstart' in document.documentElement) { |
| [].concat(...document.body.children).forEach(element => { |
| EventHandler__default.default.on(element, 'mouseover', noop); |
| }); |
| } |
| |
| const complete = () => { |
| const prevHoverState = this._hoverState; |
| this._hoverState = null; |
| EventHandler__default.default.trigger(this._element, this.constructor.Event.SHOWN); |
| |
| if (prevHoverState === HOVER_STATE_OUT) { |
| this._leave(null, this); |
| } |
| }; |
| |
| const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE); |
| |
| this._queueCallback(complete, this.tip, isAnimated); |
| } |
| |
| hide() { |
| if (!this._popper) { |
| return; |
| } |
| |
| const tip = this.getTipElement(); |
| |
| const complete = () => { |
| if (this._isWithActiveTrigger()) { |
| return; |
| } |
| |
| if (this._hoverState !== HOVER_STATE_SHOW) { |
| tip.remove(); |
| } |
| |
| this._cleanTipClass(); |
| |
| this._element.removeAttribute('aria-describedby'); |
| |
| EventHandler__default.default.trigger(this._element, this.constructor.Event.HIDDEN); |
| |
| this._disposePopper(); |
| }; |
| |
| const hideEvent = EventHandler__default.default.trigger(this._element, this.constructor.Event.HIDE); |
| |
| if (hideEvent.defaultPrevented) { |
| return; |
| } |
| |
| tip.classList.remove(CLASS_NAME_SHOW); // If this is a touch-enabled device we remove the extra |
| // empty mouseover listeners we added for iOS support |
| |
| if ('ontouchstart' in document.documentElement) { |
| [].concat(...document.body.children).forEach(element => EventHandler__default.default.off(element, 'mouseover', noop)); |
| } |
| |
| this._activeTrigger[TRIGGER_CLICK] = false; |
| this._activeTrigger[TRIGGER_FOCUS] = false; |
| this._activeTrigger[TRIGGER_HOVER] = false; |
| const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE); |
| |
| this._queueCallback(complete, this.tip, isAnimated); |
| |
| this._hoverState = ''; |
| } |
| |
| update() { |
| if (this._popper !== null) { |
| this._popper.update(); |
| } |
| } // Protected |
| |
| |
| isWithContent() { |
| return Boolean(this.getTitle()); |
| } |
| |
| getTipElement() { |
| if (this.tip) { |
| return this.tip; |
| } |
| |
| const element = document.createElement('div'); |
| element.innerHTML = this._config.template; |
| const tip = element.children[0]; |
| this.setContent(tip); |
| tip.classList.remove(CLASS_NAME_FADE, CLASS_NAME_SHOW); |
| this.tip = tip; |
| return this.tip; |
| } |
| |
| setContent(tip) { |
| this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TOOLTIP_INNER); |
| } |
| |
| _sanitizeAndSetContent(template, content, selector) { |
| const templateElement = SelectorEngine__default.default.findOne(selector, template); |
| |
| if (!content && templateElement) { |
| templateElement.remove(); |
| return; |
| } // we use append for html objects to maintain js events |
| |
| |
| this.setElementContent(templateElement, content); |
| } |
| |
| setElementContent(element, content) { |
| if (element === null) { |
| return; |
| } |
| |
| if (isElement(content)) { |
| content = getElement(content); // content is a DOM node or a jQuery |
| |
| if (this._config.html) { |
| if (content.parentNode !== element) { |
| element.innerHTML = ''; |
| element.append(content); |
| } |
| } else { |
| element.textContent = content.textContent; |
| } |
| |
| return; |
| } |
| |
| if (this._config.html) { |
| if (this._config.sanitize) { |
| content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn); |
| } |
| |
| element.innerHTML = content; |
| } else { |
| element.textContent = content; |
| } |
| } |
| |
| getTitle() { |
| const title = this._element.getAttribute('data-bs-original-title') || this._config.title; |
| |
| return this._resolvePossibleFunction(title); |
| } |
| |
| updateAttachment(attachment) { |
| if (attachment === 'right') { |
| return 'end'; |
| } |
| |
| if (attachment === 'left') { |
| return 'start'; |
| } |
| |
| return attachment; |
| } // Private |
| |
| |
| _initializeOnDelegatedTarget(event, context) { |
| return context || this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig()); |
| } |
| |
| _getOffset() { |
| const { |
| offset |
| } = this._config; |
| |
| if (typeof offset === 'string') { |
| return offset.split(',').map(val => Number.parseInt(val, 10)); |
| } |
| |
| if (typeof offset === 'function') { |
| return popperData => offset(popperData, this._element); |
| } |
| |
| return offset; |
| } |
| |
| _resolvePossibleFunction(content) { |
| return typeof content === 'function' ? content.call(this._element) : content; |
| } |
| |
| _getPopperConfig(attachment) { |
| const defaultBsPopperConfig = { |
| placement: attachment, |
| modifiers: [{ |
| name: 'flip', |
| options: { |
| fallbackPlacements: this._config.fallbackPlacements |
| } |
| }, { |
| name: 'offset', |
| options: { |
| offset: this._getOffset() |
| } |
| }, { |
| name: 'preventOverflow', |
| options: { |
| boundary: this._config.boundary |
| } |
| }, { |
| name: 'arrow', |
| options: { |
| element: `.${this.constructor.NAME}-arrow` |
| } |
| }, { |
| name: 'onChange', |
| enabled: true, |
| phase: 'afterWrite', |
| fn: data => this._handlePopperPlacementChange(data) |
| }], |
| onFirstUpdate: data => { |
| if (data.options.placement !== data.placement) { |
| this._handlePopperPlacementChange(data); |
| } |
| } |
| }; |
| return { ...defaultBsPopperConfig, |
| ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) |
| }; |
| } |
| |
| _addAttachmentClass(attachment) { |
| this.getTipElement().classList.add(`${this._getBasicClassPrefix()}-${this.updateAttachment(attachment)}`); |
| } |
| |
| _getAttachment(placement) { |
| return AttachmentMap[placement.toUpperCase()]; |
| } |
| |
| _setListeners() { |
| const triggers = this._config.trigger.split(' '); |
| |
| triggers.forEach(trigger => { |
| if (trigger === 'click') { |
| EventHandler__default.default.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event)); |
| } else if (trigger !== TRIGGER_MANUAL) { |
| const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN; |
| const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT; |
| EventHandler__default.default.on(this._element, eventIn, this._config.selector, event => this._enter(event)); |
| EventHandler__default.default.on(this._element, eventOut, this._config.selector, event => this._leave(event)); |
| } |
| }); |
| |
| this._hideModalHandler = () => { |
| if (this._element) { |
| this.hide(); |
| } |
| }; |
| |
| EventHandler__default.default.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); |
| |
| if (this._config.selector) { |
| this._config = { ...this._config, |
| trigger: 'manual', |
| selector: '' |
| }; |
| } else { |
| this._fixTitle(); |
| } |
| } |
| |
| _fixTitle() { |
| const title = this._element.getAttribute('title'); |
| |
| const originalTitleType = typeof this._element.getAttribute('data-bs-original-title'); |
| |
| if (title || originalTitleType !== 'string') { |
| this._element.setAttribute('data-bs-original-title', title || ''); |
| |
| if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) { |
| this._element.setAttribute('aria-label', title); |
| } |
| |
| this._element.setAttribute('title', ''); |
| } |
| } |
| |
| _enter(event, context) { |
| context = this._initializeOnDelegatedTarget(event, context); |
| |
| if (event) { |
| context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; |
| } |
| |
| if (context.getTipElement().classList.contains(CLASS_NAME_SHOW) || context._hoverState === HOVER_STATE_SHOW) { |
| context._hoverState = HOVER_STATE_SHOW; |
| return; |
| } |
| |
| clearTimeout(context._timeout); |
| context._hoverState = HOVER_STATE_SHOW; |
| |
| if (!context._config.delay || !context._config.delay.show) { |
| context.show(); |
| return; |
| } |
| |
| context._timeout = setTimeout(() => { |
| if (context._hoverState === HOVER_STATE_SHOW) { |
| context.show(); |
| } |
| }, context._config.delay.show); |
| } |
| |
| _leave(event, context) { |
| context = this._initializeOnDelegatedTarget(event, context); |
| |
| if (event) { |
| context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); |
| } |
| |
| if (context._isWithActiveTrigger()) { |
| return; |
| } |
| |
| clearTimeout(context._timeout); |
| context._hoverState = HOVER_STATE_OUT; |
| |
| if (!context._config.delay || !context._config.delay.hide) { |
| context.hide(); |
| return; |
| } |
| |
| context._timeout = setTimeout(() => { |
| if (context._hoverState === HOVER_STATE_OUT) { |
| context.hide(); |
| } |
| }, context._config.delay.hide); |
| } |
| |
| _isWithActiveTrigger() { |
| for (const trigger in this._activeTrigger) { |
| if (this._activeTrigger[trigger]) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| _getConfig(config) { |
| const dataAttributes = Manipulator__default.default.getDataAttributes(this._element); |
| Object.keys(dataAttributes).forEach(dataAttr => { |
| if (DISALLOWED_ATTRIBUTES.has(dataAttr)) { |
| delete dataAttributes[dataAttr]; |
| } |
| }); |
| config = { ...this.constructor.Default, |
| ...dataAttributes, |
| ...(typeof config === 'object' && config ? config : {}) |
| }; |
| config.container = config.container === false ? document.body : getElement(config.container); |
| |
| if (typeof config.delay === 'number') { |
| config.delay = { |
| show: config.delay, |
| hide: config.delay |
| }; |
| } |
| |
| if (typeof config.title === 'number') { |
| config.title = config.title.toString(); |
| } |
| |
| if (typeof config.content === 'number') { |
| config.content = config.content.toString(); |
| } |
| |
| typeCheckConfig(NAME, config, this.constructor.DefaultType); |
| |
| if (config.sanitize) { |
| config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn); |
| } |
| |
| return config; |
| } |
| |
| _getDelegateConfig() { |
| const config = {}; |
| |
| for (const key in this._config) { |
| if (this.constructor.Default[key] !== this._config[key]) { |
| config[key] = this._config[key]; |
| } |
| } // In the future can be replaced with: |
| // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]]) |
| // `Object.fromEntries(keysWithDifferentValues)` |
| |
| |
| return config; |
| } |
| |
| _cleanTipClass() { |
| const tip = this.getTipElement(); |
| const basicClassPrefixRegex = new RegExp(`(^|\\s)${this._getBasicClassPrefix()}\\S+`, 'g'); |
| const tabClass = tip.getAttribute('class').match(basicClassPrefixRegex); |
| |
| if (tabClass !== null && tabClass.length > 0) { |
| tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass)); |
| } |
| } |
| |
| _getBasicClassPrefix() { |
| return CLASS_PREFIX; |
| } |
| |
| _handlePopperPlacementChange(popperData) { |
| const { |
| state |
| } = popperData; |
| |
| if (!state) { |
| return; |
| } |
| |
| this.tip = state.elements.popper; |
| |
| this._cleanTipClass(); |
| |
| this._addAttachmentClass(this._getAttachment(state.placement)); |
| } |
| |
| _disposePopper() { |
| if (this._popper) { |
| this._popper.destroy(); |
| |
| this._popper = null; |
| } |
| } // Static |
| |
| |
| static jQueryInterface(config) { |
| return this.each(function () { |
| const data = Tooltip.getOrCreateInstance(this, config); |
| |
| if (typeof config === 'string') { |
| if (typeof data[config] === 'undefined') { |
| throw new TypeError(`No method named "${config}"`); |
| } |
| |
| data[config](); |
| } |
| }); |
| } |
| |
| } |
| /** |
| * ------------------------------------------------------------------------ |
| * jQuery |
| * ------------------------------------------------------------------------ |
| * add .Tooltip to jQuery only if jQuery is present |
| */ |
| |
| |
| defineJQueryPlugin(Tooltip); |
| |
| return Tooltip; |
| |
| })); |
| //# sourceMappingURL=tooltip.js.map |
