You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
473 lines
16 KiB
473 lines
16 KiB
/*! |
|
* Bootstrap dropdown.js v5.2.2 (https://getbootstrap.com/) |
|
* Copyright 2011-2022 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('./util/index'), require('./dom/event-handler'), require('./dom/manipulator'), require('./dom/selector-engine'), require('./base-component')) : |
|
typeof define === 'function' && define.amd ? define(['@popperjs/core', './util/index', './dom/event-handler', './dom/manipulator', './dom/selector-engine', './base-component'], factory) : |
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Dropdown = factory(global["@popperjs/core"], global.Index, global.EventHandler, global.Manipulator, global.SelectorEngine, global.BaseComponent)); |
|
})(this, (function (Popper, index, 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, { [Symbol.toStringTag]: { value: 'Module' } }); |
|
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 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.2.2): dropdown.js |
|
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
|
* -------------------------------------------------------------------------- |
|
*/ |
|
/** |
|
* Constants |
|
*/ |
|
|
|
const NAME = 'dropdown'; |
|
const DATA_KEY = 'bs.dropdown'; |
|
const EVENT_KEY = `.${DATA_KEY}`; |
|
const DATA_API_KEY = '.data-api'; |
|
const ESCAPE_KEY = 'Escape'; |
|
const TAB_KEY = 'Tab'; |
|
const ARROW_UP_KEY = 'ArrowUp'; |
|
const ARROW_DOWN_KEY = 'ArrowDown'; |
|
const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button |
|
|
|
const EVENT_HIDE = `hide${EVENT_KEY}`; |
|
const EVENT_HIDDEN = `hidden${EVENT_KEY}`; |
|
const EVENT_SHOW = `show${EVENT_KEY}`; |
|
const EVENT_SHOWN = `shown${EVENT_KEY}`; |
|
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; |
|
const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY}${DATA_API_KEY}`; |
|
const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY}${DATA_API_KEY}`; |
|
const CLASS_NAME_SHOW = 'show'; |
|
const CLASS_NAME_DROPUP = 'dropup'; |
|
const CLASS_NAME_DROPEND = 'dropend'; |
|
const CLASS_NAME_DROPSTART = 'dropstart'; |
|
const CLASS_NAME_DROPUP_CENTER = 'dropup-center'; |
|
const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center'; |
|
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)'; |
|
const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE}.${CLASS_NAME_SHOW}`; |
|
const SELECTOR_MENU = '.dropdown-menu'; |
|
const SELECTOR_NAVBAR = '.navbar'; |
|
const SELECTOR_NAVBAR_NAV = '.navbar-nav'; |
|
const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; |
|
const PLACEMENT_TOP = index.isRTL() ? 'top-end' : 'top-start'; |
|
const PLACEMENT_TOPEND = index.isRTL() ? 'top-start' : 'top-end'; |
|
const PLACEMENT_BOTTOM = index.isRTL() ? 'bottom-end' : 'bottom-start'; |
|
const PLACEMENT_BOTTOMEND = index.isRTL() ? 'bottom-start' : 'bottom-end'; |
|
const PLACEMENT_RIGHT = index.isRTL() ? 'left-start' : 'right-start'; |
|
const PLACEMENT_LEFT = index.isRTL() ? 'right-start' : 'left-start'; |
|
const PLACEMENT_TOPCENTER = 'top'; |
|
const PLACEMENT_BOTTOMCENTER = 'bottom'; |
|
const Default = { |
|
autoClose: true, |
|
boundary: 'clippingParents', |
|
display: 'dynamic', |
|
offset: [0, 2], |
|
popperConfig: null, |
|
reference: 'toggle' |
|
}; |
|
const DefaultType = { |
|
autoClose: '(boolean|string)', |
|
boundary: '(string|element)', |
|
display: 'string', |
|
offset: '(array|string|function)', |
|
popperConfig: '(null|object|function)', |
|
reference: '(string|element|object)' |
|
}; |
|
/** |
|
* Class definition |
|
*/ |
|
|
|
class Dropdown extends BaseComponent__default.default { |
|
constructor(element, config) { |
|
super(element, config); |
|
this._popper = null; |
|
this._parent = this._element.parentNode; // dropdown wrapper |
|
// todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/ |
|
|
|
this._menu = SelectorEngine__default.default.next(this._element, SELECTOR_MENU)[0] || SelectorEngine__default.default.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine__default.default.findOne(SELECTOR_MENU, this._parent); |
|
this._inNavbar = this._detectNavbar(); |
|
} // Getters |
|
|
|
|
|
static get Default() { |
|
return Default; |
|
} |
|
|
|
static get DefaultType() { |
|
return DefaultType; |
|
} |
|
|
|
static get NAME() { |
|
return NAME; |
|
} // Public |
|
|
|
|
|
toggle() { |
|
return this._isShown() ? this.hide() : this.show(); |
|
} |
|
|
|
show() { |
|
if (index.isDisabled(this._element) || this._isShown()) { |
|
return; |
|
} |
|
|
|
const relatedTarget = { |
|
relatedTarget: this._element |
|
}; |
|
const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, relatedTarget); |
|
|
|
if (showEvent.defaultPrevented) { |
|
return; |
|
} |
|
|
|
this._createPopper(); // 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 && !this._parent.closest(SELECTOR_NAVBAR_NAV)) { |
|
for (const element of [].concat(...document.body.children)) { |
|
EventHandler__default.default.on(element, 'mouseover', index.noop); |
|
} |
|
} |
|
|
|
this._element.focus(); |
|
|
|
this._element.setAttribute('aria-expanded', true); |
|
|
|
this._menu.classList.add(CLASS_NAME_SHOW); |
|
|
|
this._element.classList.add(CLASS_NAME_SHOW); |
|
|
|
EventHandler__default.default.trigger(this._element, EVENT_SHOWN, relatedTarget); |
|
} |
|
|
|
hide() { |
|
if (index.isDisabled(this._element) || !this._isShown()) { |
|
return; |
|
} |
|
|
|
const relatedTarget = { |
|
relatedTarget: this._element |
|
}; |
|
|
|
this._completeHide(relatedTarget); |
|
} |
|
|
|
dispose() { |
|
if (this._popper) { |
|
this._popper.destroy(); |
|
} |
|
|
|
super.dispose(); |
|
} |
|
|
|
update() { |
|
this._inNavbar = this._detectNavbar(); |
|
|
|
if (this._popper) { |
|
this._popper.update(); |
|
} |
|
} // Private |
|
|
|
|
|
_completeHide(relatedTarget) { |
|
const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE, relatedTarget); |
|
|
|
if (hideEvent.defaultPrevented) { |
|
return; |
|
} // If this is a touch-enabled device we remove the extra |
|
// empty mouseover listeners we added for iOS support |
|
|
|
|
|
if ('ontouchstart' in document.documentElement) { |
|
for (const element of [].concat(...document.body.children)) { |
|
EventHandler__default.default.off(element, 'mouseover', index.noop); |
|
} |
|
} |
|
|
|
if (this._popper) { |
|
this._popper.destroy(); |
|
} |
|
|
|
this._menu.classList.remove(CLASS_NAME_SHOW); |
|
|
|
this._element.classList.remove(CLASS_NAME_SHOW); |
|
|
|
this._element.setAttribute('aria-expanded', 'false'); |
|
|
|
Manipulator__default.default.removeDataAttribute(this._menu, 'popper'); |
|
EventHandler__default.default.trigger(this._element, EVENT_HIDDEN, relatedTarget); |
|
} |
|
|
|
_getConfig(config) { |
|
config = super._getConfig(config); |
|
|
|
if (typeof config.reference === 'object' && !index.isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { |
|
// Popper virtual elements require a getBoundingClientRect method |
|
throw new TypeError(`${NAME.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); |
|
} |
|
|
|
return config; |
|
} |
|
|
|
_createPopper() { |
|
if (typeof Popper__namespace === 'undefined') { |
|
throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); |
|
} |
|
|
|
let referenceElement = this._element; |
|
|
|
if (this._config.reference === 'parent') { |
|
referenceElement = this._parent; |
|
} else if (index.isElement(this._config.reference)) { |
|
referenceElement = index.getElement(this._config.reference); |
|
} else if (typeof this._config.reference === 'object') { |
|
referenceElement = this._config.reference; |
|
} |
|
|
|
const popperConfig = this._getPopperConfig(); |
|
|
|
this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig); |
|
} |
|
|
|
_isShown() { |
|
return this._menu.classList.contains(CLASS_NAME_SHOW); |
|
} |
|
|
|
_getPlacement() { |
|
const parentDropdown = this._parent; |
|
|
|
if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { |
|
return PLACEMENT_RIGHT; |
|
} |
|
|
|
if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { |
|
return PLACEMENT_LEFT; |
|
} |
|
|
|
if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) { |
|
return PLACEMENT_TOPCENTER; |
|
} |
|
|
|
if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) { |
|
return PLACEMENT_BOTTOMCENTER; |
|
} // We need to trim the value because custom properties can also include spaces |
|
|
|
|
|
const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; |
|
|
|
if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { |
|
return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; |
|
} |
|
|
|
return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; |
|
} |
|
|
|
_detectNavbar() { |
|
return this._element.closest(SELECTOR_NAVBAR) !== null; |
|
} |
|
|
|
_getOffset() { |
|
const { |
|
offset |
|
} = this._config; |
|
|
|
if (typeof offset === 'string') { |
|
return offset.split(',').map(value => Number.parseInt(value, 10)); |
|
} |
|
|
|
if (typeof offset === 'function') { |
|
return popperData => offset(popperData, this._element); |
|
} |
|
|
|
return offset; |
|
} |
|
|
|
_getPopperConfig() { |
|
const defaultBsPopperConfig = { |
|
placement: this._getPlacement(), |
|
modifiers: [{ |
|
name: 'preventOverflow', |
|
options: { |
|
boundary: this._config.boundary |
|
} |
|
}, { |
|
name: 'offset', |
|
options: { |
|
offset: this._getOffset() |
|
} |
|
}] |
|
}; // Disable Popper if we have a static display or Dropdown is in Navbar |
|
|
|
if (this._inNavbar || this._config.display === 'static') { |
|
Manipulator__default.default.setDataAttribute(this._menu, 'popper', 'static'); // todo:v6 remove |
|
|
|
defaultBsPopperConfig.modifiers = [{ |
|
name: 'applyStyles', |
|
enabled: false |
|
}]; |
|
} |
|
|
|
return { ...defaultBsPopperConfig, |
|
...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) |
|
}; |
|
} |
|
|
|
_selectMenuItem({ |
|
key, |
|
target |
|
}) { |
|
const items = SelectorEngine__default.default.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => index.isVisible(element)); |
|
|
|
if (!items.length) { |
|
return; |
|
} // if target isn't included in items (e.g. when expanding the dropdown) |
|
// allow cycling to get the last item in case key equals ARROW_UP_KEY |
|
|
|
|
|
index.getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus(); |
|
} // Static |
|
|
|
|
|
static jQueryInterface(config) { |
|
return this.each(function () { |
|
const data = Dropdown.getOrCreateInstance(this, config); |
|
|
|
if (typeof config !== 'string') { |
|
return; |
|
} |
|
|
|
if (typeof data[config] === 'undefined') { |
|
throw new TypeError(`No method named "${config}"`); |
|
} |
|
|
|
data[config](); |
|
}); |
|
} |
|
|
|
static clearMenus(event) { |
|
if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY) { |
|
return; |
|
} |
|
|
|
const openToggles = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE_SHOWN); |
|
|
|
for (const toggle of openToggles) { |
|
const context = Dropdown.getInstance(toggle); |
|
|
|
if (!context || context._config.autoClose === false) { |
|
continue; |
|
} |
|
|
|
const composedPath = event.composedPath(); |
|
const isMenuTarget = composedPath.includes(context._menu); |
|
|
|
if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { |
|
continue; |
|
} // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu |
|
|
|
|
|
if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY || /input|select|option|textarea|form/i.test(event.target.tagName))) { |
|
continue; |
|
} |
|
|
|
const relatedTarget = { |
|
relatedTarget: context._element |
|
}; |
|
|
|
if (event.type === 'click') { |
|
relatedTarget.clickEvent = event; |
|
} |
|
|
|
context._completeHide(relatedTarget); |
|
} |
|
} |
|
|
|
static dataApiKeydownHandler(event) { |
|
// If not an UP | DOWN | ESCAPE key => not a dropdown command |
|
// If input/textarea && if key is other than ESCAPE => not a dropdown command |
|
const isInput = /input|textarea/i.test(event.target.tagName); |
|
const isEscapeEvent = event.key === ESCAPE_KEY; |
|
const isUpOrDownEvent = [ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key); |
|
|
|
if (!isUpOrDownEvent && !isEscapeEvent) { |
|
return; |
|
} |
|
|
|
if (isInput && !isEscapeEvent) { |
|
return; |
|
} |
|
|
|
event.preventDefault(); // todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/ |
|
|
|
const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE) ? this : SelectorEngine__default.default.prev(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine__default.default.next(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine__default.default.findOne(SELECTOR_DATA_TOGGLE, event.delegateTarget.parentNode); |
|
const instance = Dropdown.getOrCreateInstance(getToggleButton); |
|
|
|
if (isUpOrDownEvent) { |
|
event.stopPropagation(); |
|
instance.show(); |
|
|
|
instance._selectMenuItem(event); |
|
|
|
return; |
|
} |
|
|
|
if (instance._isShown()) { |
|
// else is escape and we check if it is shown |
|
event.stopPropagation(); |
|
instance.hide(); |
|
getToggleButton.focus(); |
|
} |
|
} |
|
|
|
} |
|
/** |
|
* Data API implementation |
|
*/ |
|
|
|
|
|
EventHandler__default.default.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE, Dropdown.dataApiKeydownHandler); |
|
EventHandler__default.default.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); |
|
EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, Dropdown.clearMenus); |
|
EventHandler__default.default.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); |
|
EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { |
|
event.preventDefault(); |
|
Dropdown.getOrCreateInstance(this).toggle(); |
|
}); |
|
/** |
|
* jQuery |
|
*/ |
|
|
|
index.defineJQueryPlugin(Dropdown); |
|
|
|
return Dropdown; |
|
|
|
})); |
|
//# sourceMappingURL=dropdown.js.map
|
|
|