mdbootstrap/mdb-ui-kit
1
1
Fork 0
mirror of https://github.com/mdbootstrap/mdb-ui-kit.git synced 2024-09-20 19:09:15 +03:00
Code Issues Packages Projects Releases Wiki Activity

release 6.0.0

Browse Source
This commit is contained in:
Mikolaj Smolenski 2022-10-31 08:25:26 +01:00
parent ed3cddbc9f
commit f24a3bf224
271 changed files with 13944 additions and 13467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.txt
View File

@ -1,5 +1,5 @@
MDB5
Version: FREE 5.0.0
Version: FREE 6.0.0
Documentation:
https://mdbootstrap.com/docs/standard/

8
css/mdb.dark.min.css vendored
View File

File diff suppressed because one or more lines are too long

2
css/mdb.dark.min.css.map
View File

File diff suppressed because one or more lines are too long

4
css/mdb.dark.rtl.min.css vendored
View File

File diff suppressed because one or more lines are too long

2
css/mdb.dark.rtl.min.css.map
View File

File diff suppressed because one or more lines are too long

10
css/mdb.min.css vendored
View File

File diff suppressed because one or more lines are too long

2
css/mdb.min.css.map
View File

File diff suppressed because one or more lines are too long

4
css/mdb.rtl.min.css vendored
View File

File diff suppressed because one or more lines are too long

2
css/mdb.rtl.min.css.map
View File

File diff suppressed because one or more lines are too long

4
js/mdb.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
js/mdb.min.js.map
View File

File diff suppressed because one or more lines are too long

2
package.json
View File

@ -1,6 +1,6 @@
{
"name": "mdb-ui-kit",
"version": "5.0.0",
"version": "6.0.0",
"main": "js/mdb.min.js",
"homepage": "https://mdbootstrap.com/docs/standard/",
"repository": "https://github.com/mdbootstrap/mdb-ui-kit.git",

172
src/js/bootstrap/dist/alert.js vendored
View File

@ -1,16 +1,29 @@
/*!
* Bootstrap alert.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap alert.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('./dom/event-handler.js'), require('./base-component.js')))
? (module.exports = factory(
require('./util/index'),
require('./dom/event-handler'),
require('./base-component'),
require('./util/component-functions')
))
: typeof define === 'function' && define.amd
? define(['./dom/event-handler', './base-component'], factory)
? define(
['./util/index', './dom/event-handler', './base-component', './util/component-functions'],
factory
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Alert = factory(global.EventHandler, global.Base)));
})(this, function (EventHandler, BaseComponent) {
(global.Alert = factory(
global.Index,
global.EventHandler,
global.BaseComponent,
global.ComponentFunctions
)));
})(this, function (index, EventHandler, BaseComponent, componentFunctions) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -21,142 +34,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
const isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
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 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/component-functions.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const enableDismissTrigger = (component, method = 'hide') => {
const clickEvent = `click.dismiss${component.EVENT_KEY}`;
const name = component.NAME;
EventHandler__default.default.on(
document,
clickEvent,
`[data-bs-dismiss="${name}"]`,
function (event) {
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
const target = getElementFromSelector(this) || this.closest(`.${name}`);
const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
instance[method]();
}
);
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): alert.js
* Bootstrap (v5.2.2): alert.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'alert';
@ -167,9 +50,7 @@
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Alert extends BaseComponent__default.default {
@ -216,20 +97,15 @@
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
enableDismissTrigger(Alert, 'close');
componentFunctions.enableDismissTrigger(Alert, 'close');
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Alert to jQuery only if jQuery is present
*/
defineJQueryPlugin(Alert);
index.defineJQueryPlugin(Alert);
return Alert;
});

2
src/js/bootstrap/dist/alert.js.map vendored
View File

File diff suppressed because one or more lines are too long

162
src/js/bootstrap/dist/base-component.js vendored
View File

@ -1,16 +1,26 @@
/*!
* Bootstrap base-component.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap base-component.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('./dom/data.js'), require('./dom/event-handler.js')))
? (module.exports = factory(
require('./dom/data'),
require('./util/index'),
require('./dom/event-handler'),
require('./util/config')
))
: typeof define === 'function' && define.amd
? define(['./dom/data', './dom/event-handler'], factory)
? define(['./dom/data', './util/index', './dom/event-handler', './util/config'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Base = factory(global.Data, global.EventHandler)));
})(this, function (Data, EventHandler) {
(global.BaseComponent = factory(
global.Data,
global.Index,
global.EventHandler,
global.Config
)));
})(this, function (Data, index, EventHandler, Config) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -18,141 +28,61 @@
const Data__default = /*#__PURE__*/ _interopDefaultLegacy(Data);
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
const Config__default = /*#__PURE__*/ _interopDefaultLegacy(Config);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const MILLISECONDS_MULTIPLIER = 1000;
const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
const getTransitionDurationFromElement = (element) => {
if (!element) {
return 0;
} // Get transition-duration of the element
let { transitionDuration, transitionDelay } = window.getComputedStyle(element);
const floatTransitionDuration = Number.parseFloat(transitionDuration);
const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
if (!floatTransitionDuration && !floatTransitionDelay) {
return 0;
} // If multiple durations are defined, take the first
transitionDuration = transitionDuration.split(',')[0];
transitionDelay = transitionDelay.split(',')[0];
return (
(Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) *
MILLISECONDS_MULTIPLIER
);
};
const triggerTransitionEnd = (element) => {
element.dispatchEvent(new Event(TRANSITION_END));
};
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 execute = (callback) => {
if (typeof callback === 'function') {
callback();
}
};
const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
if (!waitForTransition) {
execute(callback);
return;
}
const durationPadding = 5;
const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
let called = false;
const handler = ({ target }) => {
if (target !== transitionElement) {
return;
}
called = true;
transitionElement.removeEventListener(TRANSITION_END, handler);
execute(callback);
};
transitionElement.addEventListener(TRANSITION_END, handler);
setTimeout(() => {
if (!called) {
triggerTransitionEnd(transitionElement);
}
}, emulatedDuration);
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): base-component.js
* Bootstrap (v5.2.2): base-component.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const VERSION = '5.1.3';
const VERSION = '5.2.2';
/**
* Class definition
*/
class BaseComponent {
constructor(element) {
element = getElement(element);
class BaseComponent extends Config__default.default {
constructor(element, config) {
super();
element = index.getElement(element);
if (!element) {
return;
}
this._element = element;
this._config = this._getConfig(config);
Data__default.default.set(this._element, this.constructor.DATA_KEY, this);
}
} // Public
dispose() {
Data__default.default.remove(this._element, this.constructor.DATA_KEY);
EventHandler__default.default.off(this._element, this.constructor.EVENT_KEY);
Object.getOwnPropertyNames(this).forEach((propertyName) => {
for (const propertyName of Object.getOwnPropertyNames(this)) {
this[propertyName] = null;
});
}
}
_queueCallback(callback, element, isAnimated = true) {
executeAfterTransition(callback, element, isAnimated);
index.executeAfterTransition(callback, element, isAnimated);
}
/** Static */
_getConfig(config) {
config = this._mergeConfigObj(config, this._element);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
} // Static
static getInstance(element) {
return Data__default.default.get(getElement(element), this.DATA_KEY);
return Data__default.default.get(index.getElement(element), this.DATA_KEY);
}
static getOrCreateInstance(element, config = {}) {
@ -165,10 +95,6 @@
return VERSION;
}
static get NAME() {
throw new Error('You have to implement the static method "NAME", for each component!');
}
static get DATA_KEY() {
return `bs.${this.NAME}`;
}
@ -176,6 +102,10 @@
static get EVENT_KEY() {
return `.${this.DATA_KEY}`;
}
static eventName(name) {
return `${name}${this.EVENT_KEY}`;
}
}
return BaseComponent;

2
src/js/bootstrap/dist/base-component.js.map vendored
View File

File diff suppressed because one or more lines are too long

86
src/js/bootstrap/dist/button.js vendored
View File

@ -1,16 +1,20 @@
/*!
* Bootstrap button.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap button.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('./dom/event-handler.js'), require('./base-component.js')))
? (module.exports = factory(
require('./util/index'),
require('./dom/event-handler'),
require('./base-component')
))
: typeof define === 'function' && define.amd
? define(['./dom/event-handler', './base-component'], factory)
? define(['./util/index', './dom/event-handler', './base-component'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Button = factory(global.EventHandler, global.Base)));
})(this, function (EventHandler, BaseComponent) {
(global.Button = factory(global.Index, global.EventHandler, global.BaseComponent)));
})(this, function (index, EventHandler, BaseComponent) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -21,67 +25,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
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 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): button.js
* Bootstrap (v5.2.2): button.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'button';
@ -92,9 +41,7 @@
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]';
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Button extends BaseComponent__default.default {
@ -119,9 +66,7 @@
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler__default.default.on(
@ -136,13 +81,10 @@
}
);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Button to jQuery only if jQuery is present
*/
defineJQueryPlugin(Button);
index.defineJQueryPlugin(Button);
return Button;
});

2
src/js/bootstrap/dist/button.js.map vendored
View File

File diff suppressed because one or more lines are too long

800
src/js/bootstrap/dist/carousel.js vendored
View File

File diff suppressed because it is too large Load Diff

2
src/js/bootstrap/dist/carousel.js.map vendored
View File

File diff suppressed because one or more lines are too long

354
src/js/bootstrap/dist/collapse.js vendored
View File

@ -1,226 +1,52 @@
/*!
* Bootstrap collapse.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap collapse.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('./dom/data.js'),
require('./dom/event-handler.js'),
require('./dom/manipulator.js'),
require('./dom/selector-engine.js'),
require('./base-component.js')
require('./util/index'),
require('./dom/event-handler'),
require('./dom/selector-engine'),
require('./base-component')
))
: typeof define === 'function' && define.amd
? define(
[
'./dom/data',
'./dom/event-handler',
'./dom/manipulator',
'./dom/selector-engine',
'./base-component',
],
['./util/index', './dom/event-handler', './dom/selector-engine', './base-component'],
factory
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Collapse = factory(
global.Data,
global.Index,
global.EventHandler,
global.Manipulator,
global.SelectorEngine,
global.Base
global.BaseComponent
)));
})(this, function (Data, EventHandler, Manipulator, SelectorEngine, BaseComponent) {
})(this, function (index, EventHandler, SelectorEngine, BaseComponent) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
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 toType = (obj) => {
if (obj === null || obj === undefined) {
return `${obj}`;
}
return {}.toString
.call(obj)
.match(/\s([a-z]+)/i)[1]
.toLowerCase();
};
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getSelectorFromElement = (element) => {
const selector = getSelector(element);
if (selector) {
return document.querySelector(selector) ? selector : null;
}
return null;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
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}".`
);
}
});
};
/**
* Trick to restart an element's animation
*
* @param {HTMLElement} element
* @return void
*
* @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
*/
const reflow = (element) => {
// eslint-disable-next-line no-unused-expressions
element.offsetHeight;
};
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 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): collapse.js
* Bootstrap (v5.2.2): collapse.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'collapse';
const DATA_KEY = 'bs.collapse';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const Default = {
toggle: true,
parent: null,
};
const DefaultType = {
toggle: 'boolean',
parent: '(null|element)',
};
const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_HIDE = `hide${EVENT_KEY}`;
@ -236,30 +62,32 @@
const HEIGHT = 'height';
const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="collapse"]';
const Default = {
parent: null,
toggle: true,
};
const DefaultType = {
parent: '(null|element)',
toggle: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Collapse extends BaseComponent__default.default {
constructor(element, config) {
super(element);
super(element, config);
this._isTransitioning = false;
this._config = this._getConfig(config);
this._triggerArray = [];
const toggleList = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE);
for (let i = 0, len = toggleList.length; i < len; i++) {
const elem = toggleList[i];
const selector = getSelectorFromElement(elem);
for (const elem of toggleList) {
const selector = index.getSelectorFromElement(elem);
const filterElement = SelectorEngine__default.default
.find(selector)
.filter((foundElem) => foundElem === this._element);
.filter((foundElement) => foundElement === this._element);
if (selector !== null && filterElement.length) {
this._selector = selector;
this._triggerArray.push(elem);
}
}
@ -279,6 +107,10 @@
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
@ -296,28 +128,20 @@
return;
}
let actives = [];
let activesData;
let activeChildren = []; // find active children
if (this._config.parent) {
const children = SelectorEngine__default.default.find(
CLASS_NAME_DEEPER_CHILDREN,
this._config.parent
);
actives = SelectorEngine__default.default
.find(SELECTOR_ACTIVES, this._config.parent)
.filter((elem) => !children.includes(elem)); // remove children if greater depth
activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES)
.filter((element) => element !== this._element)
.map((element) =>
Collapse.getOrCreateInstance(element, {
toggle: false,
})
);
}
const container = SelectorEngine__default.default.findOne(this._selector);
if (actives.length) {
const tempActiveData = actives.find((elem) => container !== elem);
activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
if (activesData && activesData._isTransitioning) {
return;
}
if (activeChildren.length && activeChildren[0]._isTransitioning) {
return;
}
const startEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW);
@ -326,17 +150,9 @@
return;
}
actives.forEach((elemActive) => {
if (container !== elemActive) {
Collapse.getOrCreateInstance(elemActive, {
toggle: false,
}).hide();
}
if (!activesData) {
Data__default.default.set(elemActive, DATA_KEY, null);
}
});
for (const activeInstance of activeChildren) {
activeInstance.hide();
}
const dimension = this._getDimension();
@ -383,19 +199,16 @@
const dimension = this._getDimension();
this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
reflow(this._element);
index.reflow(this._element);
this._element.classList.add(CLASS_NAME_COLLAPSING);
this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW);
const triggerArrayLength = this._triggerArray.length;
for (const trigger of this._triggerArray) {
const element = index.getElementFromSelector(trigger);
for (let i = 0; i < triggerArrayLength; i++) {
const trigger = this._triggerArray[i];
const elem = getElementFromSelector(trigger);
if (elem && !this._isShown(elem)) {
if (element && !this._isShown(element)) {
this._addAriaAndCollapsedClass([trigger], false);
}
}
@ -421,16 +234,10 @@
return element.classList.contains(CLASS_NAME_SHOW);
} // Private
_getConfig(config) {
config = {
...Default,
...Manipulator__default.default.getDataAttributes(this._element),
...config,
};
_configAfterMerge(config) {
config.toggle = Boolean(config.toggle); // Coerce string values
config.parent = getElement(config.parent);
typeCheckConfig(NAME, config, DefaultType);
config.parent = index.getElement(config.parent);
return config;
}
@ -443,20 +250,26 @@
return;
}
const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE);
for (const element of children) {
const selected = index.getElementFromSelector(element);
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
}
}
_getFirstLevelChildren(selector) {
const children = SelectorEngine__default.default.find(
CLASS_NAME_DEEPER_CHILDREN,
this._config.parent
);
SelectorEngine__default.default
.find(SELECTOR_DATA_TOGGLE, this._config.parent)
.filter((elem) => !children.includes(elem))
.forEach((element) => {
const selected = getElementFromSelector(element);
); // remove children if greater depth
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
});
return SelectorEngine__default.default
.find(selector, this._config.parent)
.filter((element) => !children.includes(element));
}
_addAriaAndCollapsedClass(triggerArray, isOpen) {
@ -464,25 +277,20 @@
return;
}
triggerArray.forEach((elem) => {
if (isOpen) {
elem.classList.remove(CLASS_NAME_COLLAPSED);
} else {
elem.classList.add(CLASS_NAME_COLLAPSED);
}
elem.setAttribute('aria-expanded', isOpen);
});
for (const element of triggerArray) {
element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
element.setAttribute('aria-expanded', isOpen);
}
} // Static
static jQueryInterface(config) {
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
return this.each(function () {
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
const data = Collapse.getOrCreateInstance(this, _config);
if (typeof config === 'string') {
@ -496,9 +304,7 @@
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler__default.default.on(
@ -514,23 +320,21 @@
event.preventDefault();
}
const selector = getSelectorFromElement(this);
const selector = index.getSelectorFromElement(this);
const selectorElements = SelectorEngine__default.default.find(selector);
selectorElements.forEach((element) => {
for (const element of selectorElements) {
Collapse.getOrCreateInstance(element, {
toggle: false,
}).toggle();
});
}
}
);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Collapse to jQuery only if jQuery is present
*/
defineJQueryPlugin(Collapse);
index.defineJQueryPlugin(Collapse);
return Collapse;
});

2
src/js/bootstrap/dist/collapse.js.map vendored
View File

File diff suppressed because one or more lines are too long

8
src/js/bootstrap/dist/dom/data.js vendored
View File

@ -1,6 +1,6 @@
/*!
* Bootstrap data.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap data.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) {
@ -15,15 +15,13 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/data.js
* Bootstrap (v5.2.2): dom/data.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const elementMap = new Map();
const data = {

2
src/js/bootstrap/dist/dom/data.js.map vendored
View File

@ -1 +1 @@
{"version":3,"file":"data.js","sources":["../../src/dom/data.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.1.3): dom/data.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n/**\n * ------------------------------------------------------------------------\n * Constants\n * ------------------------------------------------------------------------\n */\n\nconst elementMap = new Map()\n\nexport default {\n set(element, key, instance) {\n if (!elementMap.has(element)) {\n elementMap.set(element, new Map())\n }\n\n const instanceMap = elementMap.get(element)\n\n // make it clear we only want one instance per element\n // can be removed later when multiple key/instances are fine to be used\n if (!instanceMap.has(key) && instanceMap.size !== 0) {\n // eslint-disable-next-line no-console\n console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`)\n return\n }\n\n instanceMap.set(key, instance)\n },\n\n get(element, key) {\n if (elementMap.has(element)) {\n return elementMap.get(element).get(key) || null\n }\n\n return null\n },\n\n remove(element, key) {\n if (!elementMap.has(element)) {\n return\n }\n\n const instanceMap = elementMap.get(element)\n\n instanceMap.delete(key)\n\n // free up element references if there are no instances left for an element\n if (instanceMap.size === 0) {\n elementMap.delete(element)\n }\n }\n}\n"],"names":["elementMap","Map","set","element","key","instance","has","instanceMap","get","size","console","error","Array","from","keys","remove","delete"],"mappings":";;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EAEA,MAAMA,UAAU,GAAG,IAAIC,GAAJ,EAAnB;AAEA,eAAe;EACbC,EAAAA,GAAG,CAACC,OAAD,EAAUC,GAAV,EAAeC,QAAf,EAAyB;EAC1B,QAAI,CAACL,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAL,EAA8B;EAC5BH,MAAAA,UAAU,CAACE,GAAX,CAAeC,OAAf,EAAwB,IAAIF,GAAJ,EAAxB;EACD;;EAED,UAAMM,WAAW,GAAGP,UAAU,CAACQ,GAAX,CAAeL,OAAf,CAApB,CAL0B;EAQ1B;;EACA,QAAI,CAACI,WAAW,CAACD,GAAZ,CAAgBF,GAAhB,CAAD,IAAyBG,WAAW,CAACE,IAAZ,KAAqB,CAAlD,EAAqD;EACnD;EACAC,MAAAA,OAAO,CAACC,KAAR,CAAe,+EAA8EC,KAAK,CAACC,IAAN,CAAWN,WAAW,CAACO,IAAZ,EAAX,EAA+B,CAA/B,CAAkC,GAA/H;EACA;EACD;;EAEDP,IAAAA,WAAW,CAACL,GAAZ,CAAgBE,GAAhB,EAAqBC,QAArB;EACD,GAjBY;;EAmBbG,EAAAA,GAAG,CAACL,OAAD,EAAUC,GAAV,EAAe;EAChB,QAAIJ,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAJ,EAA6B;EAC3B,aAAOH,UAAU,CAACQ,GAAX,CAAeL,OAAf,EAAwBK,GAAxB,CAA4BJ,GAA5B,KAAoC,IAA3C;EACD;;EAED,WAAO,IAAP;EACD,GAzBY;;EA2BbW,EAAAA,MAAM,CAACZ,OAAD,EAAUC,GAAV,EAAe;EACnB,QAAI,CAACJ,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAL,EAA8B;EAC5B;EACD;;EAED,UAAMI,WAAW,GAAGP,UAAU,CAACQ,GAAX,CAAeL,OAAf,CAApB;EAEAI,IAAAA,WAAW,CAACS,MAAZ,CAAmBZ,GAAnB,EAPmB;;EAUnB,QAAIG,WAAW,CAACE,IAAZ,KAAqB,CAAzB,EAA4B;EAC1BT,MAAAA,UAAU,CAACgB,MAAX,CAAkBb,OAAlB;EACD;EACF;;EAxCY,CAAf;;;;;;;;"}
{"version":3,"file":"data.js","sources":["../../src/dom/data.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.2.2): dom/data.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n/**\n * Constants\n */\n\nconst elementMap = new Map()\n\nexport default {\n set(element, key, instance) {\n if (!elementMap.has(element)) {\n elementMap.set(element, new Map())\n }\n\n const instanceMap = elementMap.get(element)\n\n // make it clear we only want one instance per element\n // can be removed later when multiple key/instances are fine to be used\n if (!instanceMap.has(key) && instanceMap.size !== 0) {\n // eslint-disable-next-line no-console\n console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`)\n return\n }\n\n instanceMap.set(key, instance)\n },\n\n get(element, key) {\n if (elementMap.has(element)) {\n return elementMap.get(element).get(key) || null\n }\n\n return null\n },\n\n remove(element, key) {\n if (!elementMap.has(element)) {\n return\n }\n\n const instanceMap = elementMap.get(element)\n\n instanceMap.delete(key)\n\n // free up element references if there are no instances left for an element\n if (instanceMap.size === 0) {\n elementMap.delete(element)\n }\n }\n}\n"],"names":["elementMap","Map","set","element","key","instance","has","instanceMap","get","size","console","error","Array","from","keys","remove","delete"],"mappings":";;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EAEA,MAAMA,UAAU,GAAG,IAAIC,GAAJ,EAAnB,CAAA;AAEA,eAAe;EACbC,EAAAA,GAAG,CAACC,OAAD,EAAUC,GAAV,EAAeC,QAAf,EAAyB;EAC1B,IAAA,IAAI,CAACL,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAL,EAA8B;EAC5BH,MAAAA,UAAU,CAACE,GAAX,CAAeC,OAAf,EAAwB,IAAIF,GAAJ,EAAxB,CAAA,CAAA;EACD,KAAA;;MAED,MAAMM,WAAW,GAAGP,UAAU,CAACQ,GAAX,CAAeL,OAAf,CAApB,CAL0B;EAQ1B;;EACA,IAAA,IAAI,CAACI,WAAW,CAACD,GAAZ,CAAgBF,GAAhB,CAAD,IAAyBG,WAAW,CAACE,IAAZ,KAAqB,CAAlD,EAAqD;EACnD;EACAC,MAAAA,OAAO,CAACC,KAAR,CAAe,CAAA,4EAAA,EAA8EC,KAAK,CAACC,IAAN,CAAWN,WAAW,CAACO,IAAZ,EAAX,CAA+B,CAAA,CAA/B,CAAkC,CAA/H,CAAA,CAAA,CAAA,CAAA;EACA,MAAA,OAAA;EACD,KAAA;;EAEDP,IAAAA,WAAW,CAACL,GAAZ,CAAgBE,GAAhB,EAAqBC,QAArB,CAAA,CAAA;KAhBW;;EAmBbG,EAAAA,GAAG,CAACL,OAAD,EAAUC,GAAV,EAAe;EAChB,IAAA,IAAIJ,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAJ,EAA6B;QAC3B,OAAOH,UAAU,CAACQ,GAAX,CAAeL,OAAf,EAAwBK,GAAxB,CAA4BJ,GAA5B,CAAA,IAAoC,IAA3C,CAAA;EACD,KAAA;;EAED,IAAA,OAAO,IAAP,CAAA;KAxBW;;EA2BbW,EAAAA,MAAM,CAACZ,OAAD,EAAUC,GAAV,EAAe;EACnB,IAAA,IAAI,CAACJ,UAAU,CAACM,GAAX,CAAeH,OAAf,CAAL,EAA8B;EAC5B,MAAA,OAAA;EACD,KAAA;;EAED,IAAA,MAAMI,WAAW,GAAGP,UAAU,CAACQ,GAAX,CAAeL,OAAf,CAApB,CAAA;EAEAI,IAAAA,WAAW,CAACS,MAAZ,CAAmBZ,GAAnB,EAPmB;;EAUnB,IAAA,IAAIG,WAAW,CAACE,IAAZ,KAAqB,CAAzB,EAA4B;QAC1BT,UAAU,CAACgB,MAAX,CAAkBb,OAAlB,CAAA,CAAA;EACD,KAAA;EACF,GAAA;;EAxCY,CAAf;;;;;;;;"}

247
src/js/bootstrap/dist/dom/event-handler.js vendored
View File

@ -1,45 +1,26 @@
/*!
* Bootstrap event-handler.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap event-handler.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())
? (module.exports = factory(require('../util/index')))
: typeof define === 'function' && define.amd
? define(factory)
? define(['../util/index'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.EventHandler = factory()));
})(this, function () {
(global.EventHandler = factory(global.Index)));
})(this, function (index) {
'use strict';
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const getjQuery = () => {
const { jQuery } = window;
if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
return jQuery;
}
return null;
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/event-handler.js
* Bootstrap (v5.2.2): dom/event-handler.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
@ -52,7 +33,6 @@
mouseenter: 'mouseover',
mouseleave: 'mouseout',
};
const customEventsRegex = /^(mouseenter|mouseleave)/i;
const nativeEvents = new Set([
'click',
'dblclick',
@ -102,17 +82,15 @@
'scroll',
]);
/**
* ------------------------------------------------------------------------
* Private methods
* ------------------------------------------------------------------------
*/
function getUidEvent(element, uid) {
function makeEventUid(element, uid) {
return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++;
}
function getEvent(element) {
const uid = getUidEvent(element);
function getElementEvents(element) {
const uid = makeEventUid(element);
element.uidEvent = uid;
eventRegistry[uid] = eventRegistry[uid] || {};
return eventRegistry[uid];
@ -120,7 +98,9 @@
function bootstrapHandler(element, fn) {
return function handler(event) {
event.delegateTarget = element;
hydrateObj(event, {
delegateTarget: element,
});
if (handler.oneOff) {
EventHandler.off(element, event.type, fn);
@ -135,63 +115,58 @@
const domElements = element.querySelectorAll(selector);
for (let { target } = event; target && target !== this; target = target.parentNode) {
for (let i = domElements.length; i--; ) {
if (domElements[i] === target) {
event.delegateTarget = target;
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
for (const domElement of domElements) {
if (domElement !== target) {
continue;
}
}
} // To please ESLint
return null;
hydrateObj(event, {
delegateTarget: target,
});
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
}
}
};
}
function findHandler(events, handler, delegationSelector = null) {
const uidEventList = Object.keys(events);
for (let i = 0, len = uidEventList.length; i < len; i++) {
const event = events[uidEventList[i]];
if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
return event;
}
}
return null;
function findHandler(events, callable, delegationSelector = null) {
return Object.values(events).find(
(event) => event.callable === callable && event.delegationSelector === delegationSelector
);
}
function normalizeParams(originalTypeEvent, handler, delegationFn) {
const delegation = typeof handler === 'string';
const originalHandler = delegation ? delegationFn : handler;
let typeEvent = getTypeEvent(originalTypeEvent);
const isNative = nativeEvents.has(typeEvent);
function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
const isDelegated = typeof handler === 'string'; // todo: tooltip passes `false` instead of selector, so we need to check
if (!isNative) {
const callable = isDelegated ? delegationFunction : handler || delegationFunction;
let typeEvent = getTypeEvent(originalTypeEvent);
if (!nativeEvents.has(typeEvent)) {
typeEvent = originalTypeEvent;
}
return [delegation, originalHandler, typeEvent];
return [isDelegated, callable, typeEvent];
}
function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
if (!handler) {
handler = delegationFn;
delegationFn = null;
} // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
let [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFunction
); // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
// this prevents the handler from being dispatched the same way as mouseover or mouseout does
if (customEventsRegex.test(originalTypeEvent)) {
const wrapFn = (fn) => {
if (originalTypeEvent in customEvents) {
const wrapFunction = (fn) => {
return function (event) {
if (
!event.relatedTarget ||
@ -203,37 +178,28 @@
};
};
if (delegationFn) {
delegationFn = wrapFn(delegationFn);
} else {
handler = wrapFn(handler);
}
callable = wrapFunction(callable);
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
originalTypeEvent,
handler,
delegationFn
);
const events = getEvent(element);
const events = getElementEvents(element);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
if (previousFn) {
previousFn.oneOff = previousFn.oneOff && oneOff;
if (previousFunction) {
previousFunction.oneOff = previousFunction.oneOff && oneOff;
return;
}
const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
const fn = delegation
? bootstrapDelegationHandler(element, handler, delegationFn)
: bootstrapHandler(element, handler);
fn.delegationSelector = delegation ? handler : null;
fn.originalHandler = originalHandler;
const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
const fn = isDelegated
? bootstrapDelegationHandler(element, handler, callable)
: bootstrapHandler(element, callable);
fn.delegationSelector = isDelegated ? handler : null;
fn.callable = callable;
fn.oneOff = oneOff;
fn.uidEvent = uid;
handlers[uid] = fn;
element.addEventListener(typeEvent, fn, delegation);
element.addEventListener(typeEvent, fn, isDelegated);
}
function removeHandler(element, events, typeEvent, handler, delegationSelector) {
@ -249,12 +215,13 @@
function removeNamespacedHandlers(element, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((handlerKey) => {
for (const handlerKey of Object.keys(storeElementEvent)) {
if (handlerKey.includes(namespace)) {
const event = storeElementEvent[handlerKey];
removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
}
function getTypeEvent(event) {
@ -264,59 +231,53 @@
}
const EventHandler = {
on(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, false);
on(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, false);
},
one(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, true);
one(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, true);
},
off(element, originalTypeEvent, handler, delegationFn) {
off(element, originalTypeEvent, handler, delegationFunction) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
const [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFn
delegationFunction
);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getEvent(element);
const events = getElementEvents(element);
const storeElementEvent = events[typeEvent] || {};
const isNamespace = originalTypeEvent.startsWith('.');
if (typeof originalHandler !== 'undefined') {
if (typeof callable !== 'undefined') {
// Simplest case: handler is passed, remove that listener ONLY.
if (!events || !events[typeEvent]) {
if (!Object.keys(storeElementEvent).length) {
return;
}
removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
return;
}
if (isNamespace) {
Object.keys(events).forEach((elementEvent) => {
for (const elementEvent of Object.keys(events)) {
removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
});
}
}
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((keyHandlers) => {
for (const keyHandlers of Object.keys(storeElementEvent)) {
const handlerKey = keyHandlers.replace(stripUidRegex, '');
if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
const event = storeElementEvent[keyHandlers];
removeHandler(
element,
events,
typeEvent,
event.originalHandler,
event.delegationSelector
);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
},
trigger(element, event, args) {
@ -324,15 +285,13 @@
return null;
}
const $ = getjQuery();
const $ = index.getjQuery();
const typeEvent = getTypeEvent(event);
const inNamespace = event !== typeEvent;
const isNative = nativeEvents.has(typeEvent);
let jQueryEvent;
let jQueryEvent = null;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
let evt = null;
if (inNamespace && $) {
jQueryEvent = $.Event(event, args);
@ -342,25 +301,11 @@
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
if (isNative) {
evt = document.createEvent('HTMLEvents');
evt.initEvent(typeEvent, bubbles, true);
} else {
evt = new CustomEvent(event, {
bubbles,
cancelable: true,
});
} // merge custom information in our event
if (typeof args !== 'undefined') {
Object.keys(args).forEach((key) => {
Object.defineProperty(evt, key, {
get() {
return args[key];
},
});
});
}
let evt = new Event(event, {
bubbles,
cancelable: true,
});
evt = hydrateObj(evt, args);
if (defaultPrevented) {
evt.preventDefault();
@ -370,7 +315,7 @@
element.dispatchEvent(evt);
}
if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
if (evt.defaultPrevented && jQueryEvent) {
jQueryEvent.preventDefault();
}
@ -378,6 +323,24 @@
},
};
function hydrateObj(obj, meta) {
for (const [key, value] of Object.entries(meta || {})) {
try {
obj[key] = value;
} catch (_unused) {
Object.defineProperty(obj, key, {
configurable: true,
get() {
return value;
},
});
}
}
return obj;
}
return EventHandler;
});
//# sourceMappingURL=event-handler.js.map

2
src/js/bootstrap/dist/dom/event-handler.js.map vendored
View File

File diff suppressed because one or more lines are too long

60
src/js/bootstrap/dist/dom/manipulator.js vendored
View File

@ -1,6 +1,6 @@
/*!
* Bootstrap manipulator.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap manipulator.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) {
@ -15,28 +15,36 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/manipulator.js
* Bootstrap (v5.2.2): dom/manipulator.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
function normalizeData(val) {
if (val === 'true') {
function normalizeData(value) {
if (value === 'true') {
return true;
}
if (val === 'false') {
if (value === 'false') {
return false;
}
if (val === Number(val).toString()) {
return Number(val);
if (value === Number(value).toString()) {
return Number(value);
}
if (val === '' || val === 'null') {
if (value === '' || value === 'null') {
return null;
}
return val;
if (typeof value !== 'string') {
return value;
}
try {
return JSON.parse(decodeURIComponent(value));
} catch (_unused) {
return value;
}
}
function normalizeDataKey(key) {
@ -58,34 +66,22 @@
}
const attributes = {};
Object.keys(element.dataset)
.filter((key) => key.startsWith('bs'))
.forEach((key) => {
let pureKey = key.replace(/^bs/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
});
const bsKeys = Object.keys(element.dataset).filter(
(key) => key.startsWith('bs') && !key.startsWith('bsConfig')
);
for (const key of bsKeys) {
let pureKey = key.replace(/^bs/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
}
return attributes;
},
getDataAttribute(element, key) {
return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
},
offset(element) {
const rect = element.getBoundingClientRect();
return {
top: rect.top + window.pageYOffset,
left: rect.left + window.pageXOffset,
};
},
position(element) {
return {
top: element.offsetTop,
left: element.offsetLeft,
};
},
};
return Manipulator;

2
src/js/bootstrap/dist/dom/manipulator.js.map vendored
View File

@ -1 +1 @@
{"version":3,"file":"manipulator.js","sources":["../../src/dom/manipulator.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.1.3): dom/manipulator.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nfunction normalizeData(val) {\n if (val === 'true') {\n return true\n }\n\n if (val === 'false') {\n return false\n }\n\n if (val === Number(val).toString()) {\n return Number(val)\n }\n\n if (val === '' || val === 'null') {\n return null\n }\n\n return val\n}\n\nfunction normalizeDataKey(key) {\n return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`)\n}\n\nconst Manipulator = {\n setDataAttribute(element, key, value) {\n element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value)\n },\n\n removeDataAttribute(element, key) {\n element.removeAttribute(`data-bs-${normalizeDataKey(key)}`)\n },\n\n getDataAttributes(element) {\n if (!element) {\n return {}\n }\n\n const attributes = {}\n\n Object.keys(element.dataset)\n .filter(key => key.startsWith('bs'))\n .forEach(key => {\n let pureKey = key.replace(/^bs/, '')\n pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length)\n attributes[pureKey] = normalizeData(element.dataset[key])\n })\n\n return attributes\n },\n\n getDataAttribute(element, key) {\n return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`))\n },\n\n offset(element) {\n const rect = element.getBoundingClientRect()\n\n return {\n top: rect.top + window.pageYOffset,\n left: rect.left + window.pageXOffset\n }\n },\n\n position(element) {\n return {\n top: element.offsetTop,\n left: element.offsetLeft\n }\n }\n}\n\nexport default Manipulator\n"],"names":["normalizeData","val","Number","toString","normalizeDataKey","key","replace","chr","toLowerCase","Manipulator","setDataAttribute","element","value","setAttribute","removeDataAttribute","removeAttribute","getDataAttributes","attributes","Object","keys","dataset","filter","startsWith","forEach","pureKey","charAt","slice","length","getDataAttribute","getAttribute","offset","rect","getBoundingClientRect","top","window","pageYOffset","left","pageXOffset","position","offsetTop","offsetLeft"],"mappings":";;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;EAEA,SAASA,aAAT,CAAuBC,GAAvB,EAA4B;EAC1B,MAAIA,GAAG,KAAK,MAAZ,EAAoB;EAClB,WAAO,IAAP;EACD;;EAED,MAAIA,GAAG,KAAK,OAAZ,EAAqB;EACnB,WAAO,KAAP;EACD;;EAED,MAAIA,GAAG,KAAKC,MAAM,CAACD,GAAD,CAAN,CAAYE,QAAZ,EAAZ,EAAoC;EAClC,WAAOD,MAAM,CAACD,GAAD,CAAb;EACD;;EAED,MAAIA,GAAG,KAAK,EAAR,IAAcA,GAAG,KAAK,MAA1B,EAAkC;EAChC,WAAO,IAAP;EACD;;EAED,SAAOA,GAAP;EACD;;EAED,SAASG,gBAAT,CAA0BC,GAA1B,EAA+B;EAC7B,SAAOA,GAAG,CAACC,OAAJ,CAAY,QAAZ,EAAsBC,GAAG,IAAK,IAAGA,GAAG,CAACC,WAAJ,EAAkB,EAAnD,CAAP;EACD;;QAEKC,WAAW,GAAG;EAClBC,EAAAA,gBAAgB,CAACC,OAAD,EAAUN,GAAV,EAAeO,KAAf,EAAsB;EACpCD,IAAAA,OAAO,CAACE,YAAR,CAAsB,WAAUT,gBAAgB,CAACC,GAAD,CAAM,EAAtD,EAAyDO,KAAzD;EACD,GAHiB;;EAKlBE,EAAAA,mBAAmB,CAACH,OAAD,EAAUN,GAAV,EAAe;EAChCM,IAAAA,OAAO,CAACI,eAAR,CAAyB,WAAUX,gBAAgB,CAACC,GAAD,CAAM,EAAzD;EACD,GAPiB;;EASlBW,EAAAA,iBAAiB,CAACL,OAAD,EAAU;EACzB,QAAI,CAACA,OAAL,EAAc;EACZ,aAAO,EAAP;EACD;;EAED,UAAMM,UAAU,GAAG,EAAnB;EAEAC,IAAAA,MAAM,CAACC,IAAP,CAAYR,OAAO,CAACS,OAApB,EACGC,MADH,CACUhB,GAAG,IAAIA,GAAG,CAACiB,UAAJ,CAAe,IAAf,CADjB,EAEGC,OAFH,CAEWlB,GAAG,IAAI;EACd,UAAImB,OAAO,GAAGnB,GAAG,CAACC,OAAJ,CAAY,KAAZ,EAAmB,EAAnB,CAAd;EACAkB,MAAAA,OAAO,GAAGA,OAAO,CAACC,MAAR,CAAe,CAAf,EAAkBjB,WAAlB,KAAkCgB,OAAO,CAACE,KAAR,CAAc,CAAd,EAAiBF,OAAO,CAACG,MAAzB,CAA5C;EACAV,MAAAA,UAAU,CAACO,OAAD,CAAV,GAAsBxB,aAAa,CAACW,OAAO,CAACS,OAAR,CAAgBf,GAAhB,CAAD,CAAnC;EACD,KANH;EAQA,WAAOY,UAAP;EACD,GAzBiB;;EA2BlBW,EAAAA,gBAAgB,CAACjB,OAAD,EAAUN,GAAV,EAAe;EAC7B,WAAOL,aAAa,CAACW,OAAO,CAACkB,YAAR,CAAsB,WAAUzB,gBAAgB,CAACC,GAAD,CAAM,EAAtD,CAAD,CAApB;EACD,GA7BiB;;EA+BlByB,EAAAA,MAAM,CAACnB,OAAD,EAAU;EACd,UAAMoB,IAAI,GAAGpB,OAAO,CAACqB,qBAAR,EAAb;EAEA,WAAO;EACLC,MAAAA,GAAG,EAAEF,IAAI,CAACE,GAAL,GAAWC,MAAM,CAACC,WADlB;EAELC,MAAAA,IAAI,EAAEL,IAAI,CAACK,IAAL,GAAYF,MAAM,CAACG;EAFpB,KAAP;EAID,GAtCiB;;EAwClBC,EAAAA,QAAQ,CAAC3B,OAAD,EAAU;EAChB,WAAO;EACLsB,MAAAA,GAAG,EAAEtB,OAAO,CAAC4B,SADR;EAELH,MAAAA,IAAI,EAAEzB,OAAO,CAAC6B;EAFT,KAAP;EAID;;EA7CiB;;;;;;;;"}
{"version":3,"file":"manipulator.js","sources":["../../src/dom/manipulator.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.2.2): dom/manipulator.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nfunction normalizeData(value) {\n if (value === 'true') {\n return true\n }\n\n if (value === 'false') {\n return false\n }\n\n if (value === Number(value).toString()) {\n return Number(value)\n }\n\n if (value === '' || value === 'null') {\n return null\n }\n\n if (typeof value !== 'string') {\n return value\n }\n\n try {\n return JSON.parse(decodeURIComponent(value))\n } catch {\n return value\n }\n}\n\nfunction normalizeDataKey(key) {\n return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`)\n}\n\nconst Manipulator = {\n setDataAttribute(element, key, value) {\n element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value)\n },\n\n removeDataAttribute(element, key) {\n element.removeAttribute(`data-bs-${normalizeDataKey(key)}`)\n },\n\n getDataAttributes(element) {\n if (!element) {\n return {}\n }\n\n const attributes = {}\n const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'))\n\n for (const key of bsKeys) {\n let pureKey = key.replace(/^bs/, '')\n pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length)\n attributes[pureKey] = normalizeData(element.dataset[key])\n }\n\n return attributes\n },\n\n getDataAttribute(element, key) {\n return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`))\n }\n}\n\nexport default Manipulator\n"],"names":["normalizeData","value","Number","toString","JSON","parse","decodeURIComponent","normalizeDataKey","key","replace","chr","toLowerCase","Manipulator","setDataAttribute","element","setAttribute","removeDataAttribute","removeAttribute","getDataAttributes","attributes","bsKeys","Object","keys","dataset","filter","startsWith","pureKey","charAt","slice","length","getDataAttribute","getAttribute"],"mappings":";;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;EAEA,SAASA,aAAT,CAAuBC,KAAvB,EAA8B;IAC5B,IAAIA,KAAK,KAAK,MAAd,EAAsB;EACpB,IAAA,OAAO,IAAP,CAAA;EACD,GAAA;;IAED,IAAIA,KAAK,KAAK,OAAd,EAAuB;EACrB,IAAA,OAAO,KAAP,CAAA;EACD,GAAA;;IAED,IAAIA,KAAK,KAAKC,MAAM,CAACD,KAAD,CAAN,CAAcE,QAAd,EAAd,EAAwC;MACtC,OAAOD,MAAM,CAACD,KAAD,CAAb,CAAA;EACD,GAAA;;EAED,EAAA,IAAIA,KAAK,KAAK,EAAV,IAAgBA,KAAK,KAAK,MAA9B,EAAsC;EACpC,IAAA,OAAO,IAAP,CAAA;EACD,GAAA;;EAED,EAAA,IAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;EAC7B,IAAA,OAAOA,KAAP,CAAA;EACD,GAAA;;IAED,IAAI;MACF,OAAOG,IAAI,CAACC,KAAL,CAAWC,kBAAkB,CAACL,KAAD,CAA7B,CAAP,CAAA;EACD,GAFD,CAEE,OAAM,OAAA,EAAA;EACN,IAAA,OAAOA,KAAP,CAAA;EACD,GAAA;EACF,CAAA;;EAED,SAASM,gBAAT,CAA0BC,GAA1B,EAA+B;EAC7B,EAAA,OAAOA,GAAG,CAACC,OAAJ,CAAY,QAAZ,EAAsBC,GAAG,IAAK,CAAA,CAAA,EAAGA,GAAG,CAACC,WAAJ,EAAkB,EAAnD,CAAP,CAAA;EACD,CAAA;;AAED,QAAMC,WAAW,GAAG;EAClBC,EAAAA,gBAAgB,CAACC,OAAD,EAAUN,GAAV,EAAeP,KAAf,EAAsB;MACpCa,OAAO,CAACC,YAAR,CAAsB,CAAUR,QAAAA,EAAAA,gBAAgB,CAACC,GAAD,CAAM,CAAtD,CAAA,EAAyDP,KAAzD,CAAA,CAAA;KAFgB;;EAKlBe,EAAAA,mBAAmB,CAACF,OAAD,EAAUN,GAAV,EAAe;MAChCM,OAAO,CAACG,eAAR,CAAyB,CAAA,QAAA,EAAUV,gBAAgB,CAACC,GAAD,CAAM,CAAzD,CAAA,CAAA,CAAA;KANgB;;IASlBU,iBAAiB,CAACJ,OAAD,EAAU;MACzB,IAAI,CAACA,OAAL,EAAc;EACZ,MAAA,OAAO,EAAP,CAAA;EACD,KAAA;;MAED,MAAMK,UAAU,GAAG,EAAnB,CAAA;MACA,MAAMC,MAAM,GAAGC,MAAM,CAACC,IAAP,CAAYR,OAAO,CAACS,OAApB,CAA6BC,CAAAA,MAA7B,CAAoChB,GAAG,IAAIA,GAAG,CAACiB,UAAJ,CAAe,IAAf,CAAwB,IAAA,CAACjB,GAAG,CAACiB,UAAJ,CAAe,UAAf,CAApE,CAAf,CAAA;;EAEA,IAAA,KAAK,MAAMjB,GAAX,IAAkBY,MAAlB,EAA0B;QACxB,IAAIM,OAAO,GAAGlB,GAAG,CAACC,OAAJ,CAAY,KAAZ,EAAmB,EAAnB,CAAd,CAAA;EACAiB,MAAAA,OAAO,GAAGA,OAAO,CAACC,MAAR,CAAe,CAAf,EAAkBhB,WAAlB,EAAA,GAAkCe,OAAO,CAACE,KAAR,CAAc,CAAd,EAAiBF,OAAO,CAACG,MAAzB,CAA5C,CAAA;EACAV,MAAAA,UAAU,CAACO,OAAD,CAAV,GAAsB1B,aAAa,CAACc,OAAO,CAACS,OAAR,CAAgBf,GAAhB,CAAD,CAAnC,CAAA;EACD,KAAA;;EAED,IAAA,OAAOW,UAAP,CAAA;KAvBgB;;EA0BlBW,EAAAA,gBAAgB,CAAChB,OAAD,EAAUN,GAAV,EAAe;EAC7B,IAAA,OAAOR,aAAa,CAACc,OAAO,CAACiB,YAAR,CAAsB,CAAUxB,QAAAA,EAAAA,gBAAgB,CAACC,GAAD,CAAM,CAAA,CAAtD,CAAD,CAApB,CAAA;EACD,GAAA;;EA5BiB;;;;;;;;"}

80
src/js/bootstrap/dist/dom/selector-engine.js vendored
View File

@ -1,68 +1,28 @@
/*!
* Bootstrap selector-engine.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap selector-engine.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())
? (module.exports = factory(require('../util/index')))
: typeof define === 'function' && define.amd
? define(factory)
? define(['../util/index'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.SelectorEngine = factory()));
})(this, function () {
(global.SelectorEngine = factory(global.Index)));
})(this, function (index) {
'use strict';
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Bootstrap (v5.2.2): dom/selector-engine.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const isElement = (obj) => {
if (!obj || typeof obj !== 'object') {
return false;
}
if (typeof obj.jquery !== 'undefined') {
obj = obj[0];
}
return typeof obj.nodeType !== 'undefined';
};
const isVisible = (element) => {
if (!isElement(element) || element.getClientRects().length === 0) {
return false;
}
return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
};
const isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/selector-engine.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
* Constants
*/
const NODE_TEXT = 3;
const SelectorEngine = {
find(selector, element = document.documentElement) {
return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
@ -78,18 +38,11 @@
parents(element, selector) {
const parents = [];
let ancestor = element.parentNode;
let ancestor = element.parentNode.closest(selector);
while (
ancestor &&
ancestor.nodeType === Node.ELEMENT_NODE &&
ancestor.nodeType !== NODE_TEXT
) {
if (ancestor.matches(selector)) {
parents.push(ancestor);
}
ancestor = ancestor.parentNode;
while (ancestor) {
parents.push(ancestor);
ancestor = ancestor.parentNode.closest(selector);
}
return parents;
@ -109,6 +62,7 @@
return [];
},
// TODO: this is now unused; remove later along with prev()
next(element, selector) {
let next = element.nextElementSibling;
@ -135,8 +89,10 @@
'[contenteditable="true"]',
]
.map((selector) => `${selector}:not([tabindex^="-"])`)
.join(', ');
return this.find(focusables, element).filter((el) => !isDisabled(el) && isVisible(el));
.join(',');
return this.find(focusables, element).filter(
(el) => !index.isDisabled(el) && index.isVisible(el)
);
},
};

2
src/js/bootstrap/dist/dom/selector-engine.js.map vendored
View File

File diff suppressed because one or more lines are too long

481
src/js/bootstrap/dist/dropdown.js vendored
View File

@ -1,21 +1,23 @@
/*!
* Bootstrap dropdown.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* 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('./dom/event-handler.js'),
require('./dom/manipulator.js'),
require('./dom/selector-engine.js'),
require('./base-component.js')
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',
@ -25,13 +27,14 @@
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Dropdown = factory(
global.Popper,
global['@popperjs/core'],
global.Index,
global.EventHandler,
global.Manipulator,
global.SelectorEngine,
global.Base
global.BaseComponent
)));
})(this, function (Popper, EventHandler, Manipulator, SelectorEngine, BaseComponent) {
})(this, function (Popper, index, EventHandler, Manipulator, SelectorEngine, BaseComponent) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -39,7 +42,7 @@
function _interopNamespace(e) {
if (e && e.__esModule) return e;
const n = Object.create(null);
const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
if (e) {
for (const k in e) {
if (k !== 'default') {
@ -69,199 +72,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const toType = (obj) => {
if (obj === null || obj === undefined) {
return `${obj}`;
}
return {}.toString
.call(obj)
.match(/\s([a-z]+)/i)[1]
.toLowerCase();
};
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
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 isVisible = (element) => {
if (!isElement(element) || element.getClientRects().length === 0) {
return false;
}
return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
};
const isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
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;
};
}
});
};
/**
* Return the previous/next element of a list.
*
* @param {array} list The list of elements
* @param activeElement The active element
* @param shouldGetNext Choose to get next or previous element
* @param isCycleAllowed
* @return {Element|elem} The proper element
*/
const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
let index = list.indexOf(activeElement); // if the element does not exist in the list return an element depending on the direction and if cycle is allowed
if (index === -1) {
return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0];
}
const listLength = list.length;
index += shouldGetNext ? 1 : -1;
if (isCycleAllowed) {
index = (index + listLength) % listLength;
}
return list[Math.max(0, Math.min(index, listLength - 1))];
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dropdown.js
* Bootstrap (v5.2.2): dropdown.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'dropdown';
@ -269,13 +85,11 @@
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const ESCAPE_KEY = 'Escape';
const SPACE_KEY = 'Space';
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 REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY}`);
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
const EVENT_SHOW = `show${EVENT_KEY}`;
@ -287,45 +101,53 @@
const CLASS_NAME_DROPUP = 'dropup';
const CLASS_NAME_DROPEND = 'dropend';
const CLASS_NAME_DROPSTART = 'dropstart';
const CLASS_NAME_NAVBAR = 'navbar';
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]';
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 = isRTL() ? 'top-end' : 'top-start';
const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
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 = {
offset: [0, 2],
boundary: 'clippingParents',
reference: 'toggle',
display: 'dynamic',
popperConfig: null,
autoClose: true,
boundary: 'clippingParents',
display: 'dynamic',
offset: [0, 2],
popperConfig: null,
reference: 'toggle',
};
const DefaultType = {
offset: '(array|string|function)',
boundary: '(string|element)',
reference: '(string|element|object)',
display: 'string',
popperConfig: '(null|object|function)',
autoClose: '(boolean|string)',
boundary: '(string|element)',
display: 'string',
offset: '(array|string|function)',
popperConfig: '(null|object|function)',
reference: '(string|element|object)',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Dropdown extends BaseComponent__default.default {
constructor(element, config) {
super(element);
super(element, config);
this._popper = null;
this._config = this._getConfig(config);
this._menu = this._getMenuElement();
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
@ -346,7 +168,7 @@
}
show() {
if (isDisabled(this._element) || this._isShown(this._menu)) {
if (index.isDisabled(this._element) || this._isShown()) {
return;
}
@ -363,21 +185,18 @@
return;
}
const parent = Dropdown.getParentFromElement(this._element); // Totally disable Popper for Dropdowns in Navbar
if (this._inNavbar) {
Manipulator__default.default.setDataAttribute(this._menu, 'popper', 'none');
} else {
this._createPopper(parent);
} // If this is a touch-enabled device we add extra
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 && !parent.closest(SELECTOR_NAVBAR_NAV)) {
[]
.concat(...document.body.children)
.forEach((elem) => EventHandler__default.default.on(elem, 'mouseover', noop));
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();
@ -392,7 +211,7 @@
}
hide() {
if (isDisabled(this._element) || !this._isShown(this._menu)) {
if (index.isDisabled(this._element) || !this._isShown()) {
return;
}
@ -432,9 +251,9 @@
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
[]
.concat(...document.body.children)
.forEach((elem) => EventHandler__default.default.off(elem, 'mouseover', noop));
for (const element of [].concat(...document.body.children)) {
EventHandler__default.default.off(element, 'mouseover', index.noop);
}
}
if (this._popper) {
@ -452,16 +271,11 @@
}
_getConfig(config) {
config = {
...this.constructor.Default,
...Manipulator__default.default.getDataAttributes(this._element),
...config,
};
typeCheckConfig(NAME, config, this.constructor.DefaultType);
config = super._getConfig(config);
if (
typeof config.reference === 'object' &&
!isElement(config.reference) &&
!index.isElement(config.reference) &&
typeof config.reference.getBoundingClientRect !== 'function'
) {
// Popper virtual elements require a getBoundingClientRect method
@ -473,7 +287,7 @@
return config;
}
_createPopper(parent) {
_createPopper() {
if (typeof Popper__namespace === 'undefined') {
throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
}
@ -481,35 +295,24 @@
let referenceElement = this._element;
if (this._config.reference === 'parent') {
referenceElement = parent;
} else if (isElement(this._config.reference)) {
referenceElement = getElement(this._config.reference);
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();
const isDisplayStatic = popperConfig.modifiers.find(
(modifier) => modifier.name === 'applyStyles' && modifier.enabled === false
);
this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);
if (isDisplayStatic) {
Manipulator__default.default.setDataAttribute(this._menu, 'popper', 'static');
}
}
_isShown(element = this._element) {
return element.classList.contains(CLASS_NAME_SHOW);
}
_getMenuElement() {
return SelectorEngine__default.default.next(this._element, SELECTOR_MENU)[0];
_isShown() {
return this._menu.classList.contains(CLASS_NAME_SHOW);
}
_getPlacement() {
const parentDropdown = this._element.parentNode;
const parentDropdown = this._parent;
if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
return PLACEMENT_RIGHT;
@ -517,6 +320,14 @@
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';
@ -529,14 +340,14 @@
}
_detectNavbar() {
return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
return this._element.closest(SELECTOR_NAVBAR) !== null;
}
_getOffset() {
const { offset } = this._config;
if (typeof offset === 'string') {
return offset.split(',').map((val) => Number.parseInt(val, 10));
return offset.split(',').map((value) => Number.parseInt(value, 10));
}
if (typeof offset === 'function') {
@ -563,9 +374,11 @@
},
},
],
}; // Disable Popper if we have a static display
}; // 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
if (this._config.display === 'static') {
defaultBsPopperConfig.modifiers = [
{
name: 'applyStyles',
@ -585,14 +398,16 @@
_selectMenuItem({ key, target }) {
const items = SelectorEngine__default.default
.find(SELECTOR_VISIBLE_ITEMS, this._menu)
.filter(isVisible);
.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
getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus();
index
.getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target))
.focus();
} // Static
static jQueryInterface(config) {
@ -613,22 +428,37 @@
static clearMenus(event) {
if (
event &&
(event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY))
event.button === RIGHT_MOUSE_BUTTON ||
(event.type === 'keyup' && event.key !== TAB_KEY)
) {
return;
}
const toggles = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE);
const openToggles = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE_SHOWN);
for (let i = 0, len = toggles.length; i < len; i++) {
const context = Dropdown.getInstance(toggles[i]);
for (const toggle of openToggles) {
const context = Dropdown.getInstance(toggle);
if (!context || context._config.autoClose === false) {
continue;
}
if (!context._isShown()) {
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;
}
@ -636,100 +466,60 @@
relatedTarget: context._element,
};
if (event) {
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;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
context._completeHide(relatedTarget);
}
}
static getParentFromElement(element) {
return getElementFromSelector(element) || element.parentNode;
}
static dataApiKeydownHandler(event) {
// If not input/textarea:
// - And not a key in REGEXP_KEYDOWN => not a dropdown command
// If input/textarea:
// - If space key => not a dropdown command
// - If key is other than escape
// - If key is not up or down => not a dropdown command
// - If trigger inside the menu => not a dropdown command
if (
/input|textarea/i.test(event.target.tagName)
? event.key === SPACE_KEY ||
(event.key !== ESCAPE_KEY &&
((event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY) ||
event.target.closest(SELECTOR_MENU)))
: !REGEXP_KEYDOWN.test(event.key)
) {
// 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;
}
const isActive = this.classList.contains(CLASS_NAME_SHOW);
if (!isActive && event.key === ESCAPE_KEY) {
if (isInput && !isEscapeEvent) {
return;
}
event.preventDefault();
event.stopPropagation();
if (isDisabled(this)) {
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.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 (event.key === ESCAPE_KEY) {
instance.hide();
return;
}
if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
if (!isActive) {
instance.show();
}
if (isUpOrDownEvent) {
event.stopPropagation();
instance.show();
instance._selectMenuItem(event);
return;
}
if (!isActive || event.key === SPACE_KEY) {
Dropdown.clearMenus();
if (instance._isShown()) {
// else is escape and we check if it is shown
event.stopPropagation();
instance.hide();
getToggleButton.focus();
}
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler__default.default.on(
@ -756,13 +546,10 @@
}
);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Dropdown to jQuery only if jQuery is present
*/
defineJQueryPlugin(Dropdown);
index.defineJQueryPlugin(Dropdown);
return Dropdown;
});

2
src/js/bootstrap/dist/dropdown.js.map vendored
View File

File diff suppressed because one or more lines are too long

1365
src/js/bootstrap/dist/modal.js vendored
View File

File diff suppressed because it is too large Load Diff

2
src/js/bootstrap/dist/modal.js.map vendored
View File

File diff suppressed because one or more lines are too long

1086
src/js/bootstrap/dist/offcanvas.js vendored
View File

File diff suppressed because it is too large Load Diff

2
src/js/bootstrap/dist/offcanvas.js.map vendored
View File

File diff suppressed because one or more lines are too long

150
src/js/bootstrap/dist/popover.js vendored
View File

@ -1,16 +1,16 @@
/*!
* Bootstrap popover.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap popover.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('./tooltip.js')))
? (module.exports = factory(require('./util/index'), require('./tooltip')))
: typeof define === 'function' && define.amd
? define(['./tooltip'], factory)
? define(['./util/index', './tooltip'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Popover = factory(global.Tooltip)));
})(this, function (Tooltip) {
(global.Popover = factory(global.Index, global.Tooltip)));
})(this, function (index, Tooltip) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -20,108 +20,36 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
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 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): popover.js
* Bootstrap (v5.2.2): popover.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'popover';
const DATA_KEY = 'bs.popover';
const EVENT_KEY = `.${DATA_KEY}`;
const CLASS_PREFIX = 'bs-popover';
const SELECTOR_TITLE = '.popover-header';
const SELECTOR_CONTENT = '.popover-body';
const Default = {
...Tooltip__default.default.Default,
placement: 'right',
offset: [0, 8],
trigger: 'click',
content: '',
offset: [0, 8],
placement: 'right',
template:
'<div class="popover" role="tooltip">' +
'<div class="popover-arrow"></div>' +
'<h3 class="popover-header"></h3>' +
'<div class="popover-body"></div>' +
'</div>',
trigger: 'click',
};
const DefaultType = {
...Tooltip__default.default.DefaultType,
content: '(string|element|function)',
content: '(null|string|element|function)',
};
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 SELECTOR_TITLE = '.popover-header';
const SELECTOR_CONTENT = '.popover-body';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Popover extends Tooltip__default.default {
@ -130,58 +58,50 @@
return Default;
}
static get NAME() {
return NAME;
}
static get Event() {
return Event;
}
static get DefaultType() {
return DefaultType;
} // Overrides
isWithContent() {
return this.getTitle() || this._getContent();
}
setContent(tip) {
this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE);
static get NAME() {
return NAME;
} // Overrides
this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT);
_isWithContent() {
return this._getTitle() || this._getContent();
} // Private
_getContentForTemplate() {
return {
[SELECTOR_TITLE]: this._getTitle(),
[SELECTOR_CONTENT]: this._getContent(),
};
}
_getContent() {
return this._resolvePossibleFunction(this._config.content);
}
_getBasicClassPrefix() {
return CLASS_PREFIX;
} // Static
static jQueryInterface(config) {
return this.each(function () {
const data = Popover.getOrCreateInstance(this, config);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Popover to jQuery only if jQuery is present
*/
defineJQueryPlugin(Popover);
index.defineJQueryPlugin(Popover);
return Popover;
});

2
src/js/bootstrap/dist/popover.js.map vendored
View File

File diff suppressed because one or more lines are too long

547
src/js/bootstrap/dist/scrollspy.js vendored
View File

@ -1,407 +1,307 @@
/*!
* Bootstrap scrollspy.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap scrollspy.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('./dom/event-handler.js'),
require('./dom/manipulator.js'),
require('./dom/selector-engine.js'),
require('./base-component.js')
require('./util/index'),
require('./dom/event-handler'),
require('./dom/selector-engine'),
require('./base-component')
))
: typeof define === 'function' && define.amd
? define(
['./dom/event-handler', './dom/manipulator', './dom/selector-engine', './base-component'],
['./util/index', './dom/event-handler', './dom/selector-engine', './base-component'],
factory
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.ScrollSpy = factory(
(global.Scrollspy = factory(
global.Index,
global.EventHandler,
global.Manipulator,
global.SelectorEngine,
global.Base
global.BaseComponent
)));
})(this, function (EventHandler, Manipulator, SelectorEngine, BaseComponent) {
})(this, function (index, EventHandler, SelectorEngine, BaseComponent) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
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 toType = (obj) => {
if (obj === null || obj === undefined) {
return `${obj}`;
}
return {}.toString
.call(obj)
.match(/\s([a-z]+)/i)[1]
.toLowerCase();
};
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getSelectorFromElement = (element) => {
const selector = getSelector(element);
if (selector) {
return document.querySelector(selector) ? selector : null;
}
return null;
};
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 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 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): scrollspy.js
* Bootstrap (v5.2.2): scrollspy.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'scrollspy';
const DATA_KEY = 'bs.scrollspy';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const Default = {
offset: 10,
method: 'auto',
target: '',
};
const DefaultType = {
offset: 'number',
method: 'string',
target: '(string|element)',
};
const EVENT_ACTIVATE = `activate${EVENT_KEY}`;
const EVENT_SCROLL = `scroll${EVENT_KEY}`;
const EVENT_CLICK = `click${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`;
const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
const CLASS_NAME_ACTIVE = 'active';
const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
const SELECTOR_TARGET_LINKS = '[href]';
const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
const SELECTOR_NAV_LINKS = '.nav-link';
const SELECTOR_NAV_ITEMS = '.nav-item';
const SELECTOR_LIST_ITEMS = '.list-group-item';
const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}, .${CLASS_NAME_DROPDOWN_ITEM}`;
const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
const SELECTOR_DROPDOWN = '.dropdown';
const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
const METHOD_OFFSET = 'offset';
const METHOD_POSITION = 'position';
const Default = {
offset: null,
// TODO: v6 @deprecated, keep it for backwards compatibility reasons
rootMargin: '0px 0px -25%',
smoothScroll: false,
target: null,
threshold: [0.1, 0.5, 1],
};
const DefaultType = {
offset: '(number|null)',
// TODO v6 @deprecated, keep it for backwards compatibility reasons
rootMargin: 'string',
smoothScroll: 'boolean',
target: 'element',
threshold: 'array',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class ScrollSpy extends BaseComponent__default.default {
constructor(element, config) {
super(element);
this._scrollElement = this._element.tagName === 'BODY' ? window : this._element;
this._config = this._getConfig(config);
this._offsets = [];
this._targets = [];
this._activeTarget = null;
this._scrollHeight = 0;
EventHandler__default.default.on(this._scrollElement, EVENT_SCROLL, () => this._process());
this.refresh();
super(element, config); // this._element is the observablesContainer and config.target the menu links wrapper
this._process();
this._targetLinks = new Map();
this._observableSections = new Map();
this._rootElement =
getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;
this._activeTarget = null;
this._observer = null;
this._previousScrollData = {
visibleEntryTop: 0,
parentScrollTop: 0,
};
this.refresh(); // initialize
} // Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
refresh() {
const autoMethod =
this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
this._offsets = [];
this._targets = [];
this._scrollHeight = this._getScrollHeight();
const targets = SelectorEngine__default.default.find(
SELECTOR_LINK_ITEMS,
this._config.target
);
targets
.map((element) => {
const targetSelector = getSelectorFromElement(element);
const target = targetSelector
? SelectorEngine__default.default.findOne(targetSelector)
: null;
this._initializeTargetsAndObservables();
if (target) {
const targetBCR = target.getBoundingClientRect();
this._maybeEnableSmoothScroll();
if (targetBCR.width || targetBCR.height) {
return [
Manipulator__default.default[offsetMethod](target).top + offsetBase,
targetSelector,
];
}
}
if (this._observer) {
this._observer.disconnect();
} else {
this._observer = this._getNewObserver();
}
return null;
})
.filter((item) => item)
.sort((a, b) => a[0] - b[0])
.forEach((item) => {
this._offsets.push(item[0]);
this._targets.push(item[1]);
});
for (const section of this._observableSections.values()) {
this._observer.observe(section);
}
}
dispose() {
EventHandler__default.default.off(this._scrollElement, EVENT_KEY);
this._observer.disconnect();
super.dispose();
} // Private
_getConfig(config) {
config = {
...Default,
...Manipulator__default.default.getDataAttributes(this._element),
...(typeof config === 'object' && config ? config : {}),
};
config.target = getElement(config.target) || document.documentElement;
typeCheckConfig(NAME, config, DefaultType);
_configAfterMerge(config) {
// TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
config.target = index.getElement(config.target) || document.body; // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;
if (typeof config.threshold === 'string') {
config.threshold = config.threshold.split(',').map((value) => Number.parseFloat(value));
}
return config;
}
_getScrollTop() {
return this._scrollElement === window
? this._scrollElement.pageYOffset
: this._scrollElement.scrollTop;
}
_getScrollHeight() {
return (
this._scrollElement.scrollHeight ||
Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)
);
}
_getOffsetHeight() {
return this._scrollElement === window
? window.innerHeight
: this._scrollElement.getBoundingClientRect().height;
}
_process() {
const scrollTop = this._getScrollTop() + this._config.offset;
const scrollHeight = this._getScrollHeight();
const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
if (this._scrollHeight !== scrollHeight) {
this.refresh();
}
if (scrollTop >= maxScroll) {
const target = this._targets[this._targets.length - 1];
if (this._activeTarget !== target) {
this._activate(target);
}
_maybeEnableSmoothScroll() {
if (!this._config.smoothScroll) {
return;
}
} // unregister any previous listeners
if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
this._activeTarget = null;
EventHandler__default.default.off(this._config.target, EVENT_CLICK);
EventHandler__default.default.on(
this._config.target,
EVENT_CLICK,
SELECTOR_TARGET_LINKS,
(event) => {
const observableSection = this._observableSections.get(event.target.hash);
this._clear();
if (observableSection) {
event.preventDefault();
const root = this._rootElement || window;
const height = observableSection.offsetTop - this._element.offsetTop;
return;
}
for (let i = this._offsets.length; i--; ) {
const isActiveTarget =
this._activeTarget !== this._targets[i] &&
scrollTop >= this._offsets[i] &&
(typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
if (isActiveTarget) {
this._activate(this._targets[i]);
}
}
}
_activate(target) {
this._activeTarget = target;
this._clear();
const queries = SELECTOR_LINK_ITEMS.split(',').map(
(selector) => `${selector}[data-bs-target="${target}"],${selector}[href="${target}"]`
);
const link = SelectorEngine__default.default.findOne(queries.join(','), this._config.target);
link.classList.add(CLASS_NAME_ACTIVE);
if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
SelectorEngine__default.default
.findOne(SELECTOR_DROPDOWN_TOGGLE, link.closest(SELECTOR_DROPDOWN))
.classList.add(CLASS_NAME_ACTIVE);
} else {
SelectorEngine__default.default
.parents(link, SELECTOR_NAV_LIST_GROUP)
.forEach((listGroup) => {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
SelectorEngine__default.default
.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`)
.forEach((item) => item.classList.add(CLASS_NAME_ACTIVE)); // Handle special case when .nav-link is inside .nav-item
SelectorEngine__default.default
.prev(listGroup, SELECTOR_NAV_ITEMS)
.forEach((navItem) => {
SelectorEngine__default.default
.children(navItem, SELECTOR_NAV_LINKS)
.forEach((item) => item.classList.add(CLASS_NAME_ACTIVE));
if (root.scrollTo) {
root.scrollTo({
top: height,
behavior: 'smooth',
});
});
return;
} // Chrome 60 doesn't support `scrollTo`
root.scrollTop = height;
}
}
);
}
_getNewObserver() {
const options = {
root: this._rootElement,
threshold: this._config.threshold,
rootMargin: this._config.rootMargin,
};
return new IntersectionObserver((entries) => this._observerCallback(entries), options);
} // The logic of selection
_observerCallback(entries) {
const targetElement = (entry) => this._targetLinks.get(`#${entry.target.id}`);
const activate = (entry) => {
this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
this._process(targetElement(entry));
};
const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
this._previousScrollData.parentScrollTop = parentScrollTop;
for (const entry of entries) {
if (!entry.isIntersecting) {
this._activeTarget = null;
this._clearActiveClass(targetElement(entry));
continue;
}
const entryIsLowerThanPrevious =
entry.target.offsetTop >= this._previousScrollData.visibleEntryTop; // if we are scrolling down, pick the bigger offsetTop
if (userScrollsDown && entryIsLowerThanPrevious) {
activate(entry); // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
if (!parentScrollTop) {
return;
}
continue;
} // if we are scrolling up, pick the smallest offsetTop
if (!userScrollsDown && !entryIsLowerThanPrevious) {
activate(entry);
}
}
}
_initializeTargetsAndObservables() {
this._targetLinks = new Map();
this._observableSections = new Map();
const targetLinks = SelectorEngine__default.default.find(
SELECTOR_TARGET_LINKS,
this._config.target
);
for (const anchor of targetLinks) {
// ensure that the anchor has an id and is not disabled
if (!anchor.hash || index.isDisabled(anchor)) {
continue;
}
const observableSection = SelectorEngine__default.default.findOne(
anchor.hash,
this._element
); // ensure that the observableSection exists & is visible
if (index.isVisible(observableSection)) {
this._targetLinks.set(anchor.hash, anchor);
this._observableSections.set(anchor.hash, observableSection);
}
}
}
_process(target) {
if (this._activeTarget === target) {
return;
}
EventHandler__default.default.trigger(this._scrollElement, EVENT_ACTIVATE, {
this._clearActiveClass(this._config.target);
this._activeTarget = target;
target.classList.add(CLASS_NAME_ACTIVE);
this._activateParents(target);
EventHandler__default.default.trigger(this._element, EVENT_ACTIVATE, {
relatedTarget: target,
});
}
_clear() {
SelectorEngine__default.default
.find(SELECTOR_LINK_ITEMS, this._config.target)
.filter((node) => node.classList.contains(CLASS_NAME_ACTIVE))
.forEach((node) => node.classList.remove(CLASS_NAME_ACTIVE));
_activateParents(target) {
// Activate dropdown parents
if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
SelectorEngine__default.default
.findOne(SELECTOR_DROPDOWN_TOGGLE, target.closest(SELECTOR_DROPDOWN))
.classList.add(CLASS_NAME_ACTIVE);
return;
}
for (const listGroup of SelectorEngine__default.default.parents(
target,
SELECTOR_NAV_LIST_GROUP
)) {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
for (const item of SelectorEngine__default.default.prev(listGroup, SELECTOR_LINK_ITEMS)) {
item.classList.add(CLASS_NAME_ACTIVE);
}
}
}
_clearActiveClass(parent) {
parent.classList.remove(CLASS_NAME_ACTIVE);
const activeNodes = SelectorEngine__default.default.find(
`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE}`,
parent
);
for (const node of activeNodes) {
node.classList.remove(CLASS_NAME_ACTIVE);
}
} // Static
static jQueryInterface(config) {
@ -412,7 +312,7 @@
return;
}
if (typeof data[config] === 'undefined') {
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
@ -421,22 +321,19 @@
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () => {
SelectorEngine__default.default.find(SELECTOR_DATA_SPY).forEach((spy) => new ScrollSpy(spy));
for (const spy of SelectorEngine__default.default.find(SELECTOR_DATA_SPY)) {
ScrollSpy.getOrCreateInstance(spy);
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .ScrollSpy to jQuery only if jQuery is present
*/
defineJQueryPlugin(ScrollSpy);
index.defineJQueryPlugin(ScrollSpy);
return ScrollSpy;
});

2
src/js/bootstrap/dist/scrollspy.js.map vendored
View File

File diff suppressed because one or more lines are too long

502
src/js/bootstrap/dist/tab.js vendored
View File

@ -1,20 +1,29 @@
/*!
* Bootstrap tab.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap tab.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('./dom/event-handler.js'),
require('./dom/selector-engine.js'),
require('./base-component.js')
require('./util/index'),
require('./dom/event-handler'),
require('./dom/selector-engine'),
require('./base-component')
))
: typeof define === 'function' && define.amd
? define(['./dom/event-handler', './dom/selector-engine', './base-component'], factory)
? define(
['./util/index', './dom/event-handler', './dom/selector-engine', './base-component'],
factory
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Tab = factory(global.EventHandler, global.SelectorEngine, global.Base)));
})(this, function (EventHandler, SelectorEngine, BaseComponent) {
(global.Tab = factory(
global.Index,
global.EventHandler,
global.SelectorEngine,
global.BaseComponent
)));
})(this, function (index, EventHandler, SelectorEngine, BaseComponent) {
'use strict';
const _interopDefaultLegacy = (e) =>
@ -26,302 +35,288 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
const isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
/**
* Trick to restart an element's animation
*
* @param {HTMLElement} element
* @return void
*
* @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
*/
const reflow = (element) => {
// eslint-disable-next-line no-unused-expressions
element.offsetHeight;
};
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 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): tab.js
* Bootstrap (v5.2.2): tab.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'tab';
const DATA_KEY = 'bs.tab';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
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 CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}`;
const EVENT_KEYDOWN = `keydown${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}`;
const ARROW_LEFT_KEY = 'ArrowLeft';
const ARROW_RIGHT_KEY = 'ArrowRight';
const ARROW_UP_KEY = 'ArrowUp';
const ARROW_DOWN_KEY = 'ArrowDown';
const CLASS_NAME_ACTIVE = 'active';
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
const SELECTOR_DROPDOWN = '.dropdown';
const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
const SELECTOR_ACTIVE = '.active';
const SELECTOR_ACTIVE_UL = ':scope > li > .active';
const SELECTOR_DATA_TOGGLE =
'[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
const CLASS_DROPDOWN = 'dropdown';
const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
const NOT_SELECTOR_DROPDOWN_TOGGLE = ':not(.dropdown-toggle)';
const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
const SELECTOR_OUTER = '.nav-item, .list-group-item';
const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
const SELECTOR_DATA_TOGGLE =
'[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // todo:v6: could be only `tab`
const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`;
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Tab extends BaseComponent__default.default {
// Getters
constructor(element) {
super(element);
this._parent = this._element.closest(SELECTOR_TAB_PANEL);
if (!this._parent) {
return; // todo: should Throw exception on v6
// throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
} // Set up initial aria attributes
this._setInitialAttributes(this._parent, this._getChildren());
EventHandler__default.default.on(this._element, EVENT_KEYDOWN, (event) =>
this._keydown(event)
);
} // Getters
static get NAME() {
return NAME;
} // Public
show() {
if (
this._element.parentNode &&
this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
this._element.classList.contains(CLASS_NAME_ACTIVE)
) {
// Shows this elem and deactivate the active sibling if exists
const innerElem = this._element;
if (this._elemIsActive(innerElem)) {
return;
}
} // Search for active tab on same parent to deactivate it
let previous;
const target = getElementFromSelector(this._element);
const active = this._getActiveElem();
const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);
if (listElement) {
const itemSelector =
listElement.nodeName === 'UL' || listElement.nodeName === 'OL'
? SELECTOR_ACTIVE_UL
: SELECTOR_ACTIVE;
previous = SelectorEngine__default.default.find(itemSelector, listElement);
previous = previous[previous.length - 1];
}
const hideEvent = previous
? EventHandler__default.default.trigger(previous, EVENT_HIDE, {
relatedTarget: this._element,
const hideEvent = active
? EventHandler__default.default.trigger(active, EVENT_HIDE, {
relatedTarget: innerElem,
})
: null;
const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, {
relatedTarget: previous,
const showEvent = EventHandler__default.default.trigger(innerElem, EVENT_SHOW, {
relatedTarget: active,
});
if (showEvent.defaultPrevented || (hideEvent !== null && hideEvent.defaultPrevented)) {
if (showEvent.defaultPrevented || (hideEvent && hideEvent.defaultPrevented)) {
return;
}
this._activate(this._element, listElement);
this._deactivate(active, innerElem);
const complete = () => {
EventHandler__default.default.trigger(previous, EVENT_HIDDEN, {
relatedTarget: this._element,
});
EventHandler__default.default.trigger(this._element, EVENT_SHOWN, {
relatedTarget: previous,
});
};
if (target) {
this._activate(target, target.parentNode, complete);
} else {
complete();
}
this._activate(innerElem, active);
} // Private
_activate(element, container, callback) {
const activeElements =
container && (container.nodeName === 'UL' || container.nodeName === 'OL')
? SelectorEngine__default.default.find(SELECTOR_ACTIVE_UL, container)
: SelectorEngine__default.default.children(container, SELECTOR_ACTIVE);
const active = activeElements[0];
const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE);
const complete = () => this._transitionComplete(element, active, callback);
if (active && isTransitioning) {
active.classList.remove(CLASS_NAME_SHOW);
this._queueCallback(complete, element, true);
} else {
complete();
}
}
_transitionComplete(element, active, callback) {
if (active) {
active.classList.remove(CLASS_NAME_ACTIVE);
const dropdownChild = SelectorEngine__default.default.findOne(
SELECTOR_DROPDOWN_ACTIVE_CHILD,
active.parentNode
);
if (dropdownChild) {
dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
}
if (active.getAttribute('role') === 'tab') {
active.setAttribute('aria-selected', false);
}
_activate(element, relatedElem) {
if (!element) {
return;
}
element.classList.add(CLASS_NAME_ACTIVE);
if (element.getAttribute('role') === 'tab') {
element.setAttribute('aria-selected', true);
}
this._activate(index.getElementFromSelector(element)); // Search and activate/show the proper section
reflow(element);
if (element.classList.contains(CLASS_NAME_FADE)) {
element.classList.add(CLASS_NAME_SHOW);
}
let parent = element.parentNode;
if (parent && parent.nodeName === 'LI') {
parent = parent.parentNode;
}
if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
const dropdownElement = element.closest(SELECTOR_DROPDOWN);
if (dropdownElement) {
SelectorEngine__default.default
.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement)
.forEach((dropdown) => dropdown.classList.add(CLASS_NAME_ACTIVE));
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.add(CLASS_NAME_SHOW);
return;
}
element.setAttribute('aria-expanded', true);
element.removeAttribute('tabindex');
element.setAttribute('aria-selected', true);
this._toggleDropDown(element, true);
EventHandler__default.default.trigger(element, EVENT_SHOWN, {
relatedTarget: relatedElem,
});
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE));
}
_deactivate(element, relatedElem) {
if (!element) {
return;
}
if (callback) {
callback();
element.classList.remove(CLASS_NAME_ACTIVE);
element.blur();
this._deactivate(index.getElementFromSelector(element)); // Search and deactivate the shown section too
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.remove(CLASS_NAME_SHOW);
return;
}
element.setAttribute('aria-selected', false);
element.setAttribute('tabindex', '-1');
this._toggleDropDown(element, false);
EventHandler__default.default.trigger(element, EVENT_HIDDEN, {
relatedTarget: relatedElem,
});
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE));
}
_keydown(event) {
if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key)) {
return;
}
event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
event.preventDefault();
const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
const nextActiveElement = index.getNextActiveElement(
this._getChildren().filter((element) => !index.isDisabled(element)),
event.target,
isNext,
true
);
if (nextActiveElement) {
nextActiveElement.focus({
preventScroll: true,
});
Tab.getOrCreateInstance(nextActiveElement).show();
}
}
_getChildren() {
// collection of inner elements
return SelectorEngine__default.default.find(SELECTOR_INNER_ELEM, this._parent);
}
_getActiveElem() {
return this._getChildren().find((child) => this._elemIsActive(child)) || null;
}
_setInitialAttributes(parent, children) {
this._setAttributeIfNotExists(parent, 'role', 'tablist');
for (const child of children) {
this._setInitialAttributesOnChild(child);
}
}
_setInitialAttributesOnChild(child) {
child = this._getInnerElement(child);
const isActive = this._elemIsActive(child);
const outerElem = this._getOuterElement(child);
child.setAttribute('aria-selected', isActive);
if (outerElem !== child) {
this._setAttributeIfNotExists(outerElem, 'role', 'presentation');
}
if (!isActive) {
child.setAttribute('tabindex', '-1');
}
this._setAttributeIfNotExists(child, 'role', 'tab'); // set attributes to the related panel too
this._setInitialAttributesOnTargetPanel(child);
}
_setInitialAttributesOnTargetPanel(child) {
const target = index.getElementFromSelector(child);
if (!target) {
return;
}
this._setAttributeIfNotExists(target, 'role', 'tabpanel');
if (child.id) {
this._setAttributeIfNotExists(target, 'aria-labelledby', `#${child.id}`);
}
}
_toggleDropDown(element, open) {
const outerElem = this._getOuterElement(element);
if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
return;
}
const toggle = (selector, className) => {
const element = SelectorEngine__default.default.findOne(selector, outerElem);
if (element) {
element.classList.toggle(className, open);
}
};
toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW);
outerElem.setAttribute('aria-expanded', open);
}
_setAttributeIfNotExists(element, attribute, value) {
if (!element.hasAttribute(attribute)) {
element.setAttribute(attribute, value);
}
}
_elemIsActive(elem) {
return elem.classList.contains(CLASS_NAME_ACTIVE);
} // Try to get the inner element (usually the .nav-link)
_getInnerElement(elem) {
return elem.matches(SELECTOR_INNER_ELEM)
? elem
: SelectorEngine__default.default.findOne(SELECTOR_INNER_ELEM, elem);
} // Try to get the outer element (usually the .nav-item)
_getOuterElement(elem) {
return elem.closest(SELECTOR_OUTER) || elem;
} // Static
static jQueryInterface(config) {
return this.each(function () {
const data = Tab.getOrCreateInstance(this);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
if (typeof config !== 'string') {
return;
}
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler__default.default.on(
@ -333,22 +328,27 @@
event.preventDefault();
}
if (isDisabled(this)) {
if (index.isDisabled(this)) {
return;
}
const data = Tab.getOrCreateInstance(this);
data.show();
Tab.getOrCreateInstance(this).show();
}
);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Tab to jQuery only if jQuery is present
* Initialize on focus
*/
defineJQueryPlugin(Tab);
EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () => {
for (const element of SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
Tab.getOrCreateInstance(element);
}
});
/**
* jQuery
*/
index.defineJQueryPlugin(Tab);
return Tab;
});

2
src/js/bootstrap/dist/tab.js.map vendored
View File

File diff suppressed because one or more lines are too long

271
src/js/bootstrap/dist/toast.js vendored
View File

@ -1,217 +1,45 @@
/*!
* Bootstrap toast.js v5.1.3 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Bootstrap toast.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('./dom/event-handler.js'),
require('./dom/manipulator.js'),
require('./base-component.js')
require('./util/index'),
require('./dom/event-handler'),
require('./base-component'),
require('./util/component-functions')
))
: typeof define === 'function' && define.amd
? define(['./dom/event-handler', './dom/manipulator', './base-component'], factory)
? define(
['./util/index', './dom/event-handler', './base-component', './util/component-functions'],
factory
)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Toast = factory(global.EventHandler, global.Manipulator, global.Base)));
})(this, function (EventHandler, Manipulator, BaseComponent) {
(global.Toast = factory(
global.Index,
global.EventHandler,
global.BaseComponent,
global.ComponentFunctions
)));
})(this, function (index, EventHandler, BaseComponent, componentFunctions) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
const Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
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 toType = (obj) => {
if (obj === null || obj === undefined) {
return `${obj}`;
}
return {}.toString
.call(obj)
.match(/\s([a-z]+)/i)[1]
.toLowerCase();
};
const getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
}
return selector;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
const isElement = (obj) => {
if (!obj || typeof obj !== 'object') {
return false;
}
if (typeof obj.jquery !== 'undefined') {
obj = obj[0];
}
return typeof obj.nodeType !== 'undefined';
};
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 isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
/**
* Trick to restart an element's animation
*
* @param {HTMLElement} element
* @return void
*
* @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
*/
const reflow = (element) => {
// eslint-disable-next-line no-unused-expressions
element.offsetHeight;
};
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 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/component-functions.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const enableDismissTrigger = (component, method = 'hide') => {
const clickEvent = `click.dismiss${component.EVENT_KEY}`;
const name = component.NAME;
EventHandler__default.default.on(
document,
clickEvent,
`[data-bs-dismiss="${name}"]`,
function (event) {
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
const target = getElementFromSelector(this) || this.closest(`.${name}`);
const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
instance[method]();
}
);
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): toast.js
* Bootstrap (v5.2.2): toast.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'toast';
@ -241,15 +69,12 @@
delay: 5000,
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Toast extends BaseComponent__default.default {
constructor(element, config) {
super(element);
this._config = this._getConfig(config);
super(element, config);
this._timeout = null;
this._hasMouseInteraction = false;
this._hasKeyboardInteraction = false;
@ -257,14 +82,14 @@
this._setListeners();
} // Getters
static get DefaultType() {
return DefaultType;
}
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
@ -292,17 +117,15 @@
this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
reflow(this._element);
index.reflow(this._element);
this._element.classList.add(CLASS_NAME_SHOW);
this._element.classList.add(CLASS_NAME_SHOWING);
this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
this._queueCallback(complete, this._element, this._config.animation);
}
hide() {
if (!this._element.classList.contains(CLASS_NAME_SHOW)) {
if (!this.isShown()) {
return;
}
@ -315,9 +138,7 @@
const complete = () => {
this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
this._element.classList.remove(CLASS_NAME_SHOWING);
this._element.classList.remove(CLASS_NAME_SHOW);
this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
EventHandler__default.default.trigger(this._element, EVENT_HIDDEN);
};
@ -330,23 +151,17 @@
dispose() {
this._clearTimeout();
if (this._element.classList.contains(CLASS_NAME_SHOW)) {
if (this.isShown()) {
this._element.classList.remove(CLASS_NAME_SHOW);
}
super.dispose();
} // Private
_getConfig(config) {
config = {
...Default,
...Manipulator__default.default.getDataAttributes(this._element),
...(typeof config === 'object' && config ? config : {}),
};
typeCheckConfig(NAME, config, this.constructor.DefaultType);
return config;
}
isShown() {
return this._element.classList.contains(CLASS_NAME_SHOW);
} // Private
_maybeScheduleHide() {
if (!this._config.autohide) {
return;
@ -364,14 +179,16 @@
_onInteraction(event, isInteracting) {
switch (event.type) {
case 'mouseover':
case 'mouseout':
case 'mouseout': {
this._hasMouseInteraction = isInteracting;
break;
}
case 'focusin':
case 'focusout':
case 'focusout': {
this._hasKeyboardInteraction = isInteracting;
break;
}
}
if (isInteracting) {
@ -423,16 +240,16 @@
});
}
}
enableDismissTrigger(Toast);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Toast to jQuery only if jQuery is present
* Data API implementation
*/
defineJQueryPlugin(Toast);
componentFunctions.enableDismissTrigger(Toast);
/**
* jQuery
*/
index.defineJQueryPlugin(Toast);
return Toast;
});

2
src/js/bootstrap/dist/toast.js.map vendored
View File

File diff suppressed because one or more lines are too long

1621
src/js/bootstrap/dist/tooltip.js vendored
View File

File diff suppressed because it is too large Load Diff

2
src/js/bootstrap/dist/tooltip.js.map vendored
View File

File diff suppressed because one or more lines are too long

169
src/js/bootstrap/dist/util/backdrop.js vendored Normal file
View File

@ -0,0 +1,169 @@
/*!
* Bootstrap backdrop.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('../dom/event-handler'),
require('./index'),
require('./config')
))
: typeof define === 'function' && define.amd
? define(['../dom/event-handler', './index', './config'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Backdrop = factory(global.EventHandler, global.Index, global.Config)));
})(this, function (EventHandler, index, Config) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
const Config__default = /*#__PURE__*/ _interopDefaultLegacy(Config);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/backdrop.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME = 'backdrop';
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`;
const Default = {
className: 'modal-backdrop',
clickCallback: null,
isAnimated: false,
isVisible: true,
// if false, we use the backdrop helper without adding any element to the dom
rootElement: 'body', // give the choice to place backdrop under different elements
};
const DefaultType = {
className: 'string',
clickCallback: '(function|null)',
isAnimated: 'boolean',
isVisible: 'boolean',
rootElement: '(element|string)',
};
/**
* Class definition
*/
class Backdrop extends Config__default.default {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isAppended = false;
this._element = null;
} // Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
show(callback) {
if (!this._config.isVisible) {
index.execute(callback);
return;
}
this._append();
const element = this._getElement();
if (this._config.isAnimated) {
index.reflow(element);
}
element.classList.add(CLASS_NAME_SHOW);
this._emulateAnimation(() => {
index.execute(callback);
});
}
hide(callback) {
if (!this._config.isVisible) {
index.execute(callback);
return;
}
this._getElement().classList.remove(CLASS_NAME_SHOW);
this._emulateAnimation(() => {
this.dispose();
index.execute(callback);
});
}
dispose() {
if (!this._isAppended) {
return;
}
EventHandler__default.default.off(this._element, EVENT_MOUSEDOWN);
this._element.remove();
this._isAppended = false;
} // Private
_getElement() {
if (!this._element) {
const backdrop = document.createElement('div');
backdrop.className = this._config.className;
if (this._config.isAnimated) {
backdrop.classList.add(CLASS_NAME_FADE);
}
this._element = backdrop;
}
return this._element;
}
_configAfterMerge(config) {
// use getElement() with the default "body" to get a fresh Element on each instantiation
config.rootElement = index.getElement(config.rootElement);
return config;
}
_append() {
if (this._isAppended) {
return;
}
const element = this._getElement();
this._config.rootElement.append(element);
EventHandler__default.default.on(element, EVENT_MOUSEDOWN, () => {
index.execute(this._config.clickCallback);
});
this._isAppended = true;
}
_emulateAnimation(callback) {
index.executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
}
}
return Backdrop;
});
//# sourceMappingURL=backdrop.js.map

1
src/js/bootstrap/dist/util/backdrop.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

59
src/js/bootstrap/dist/util/component-functions.js vendored Normal file
View File

@ -0,0 +1,59 @@
/*!
* Bootstrap component-functions.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'
? factory(exports, require('../dom/event-handler'), require('./index'))
: typeof define === 'function' && define.amd
? define(['exports', '../dom/event-handler', './index'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
factory((global.ComponentFunctions = {}), global.EventHandler, global.Index));
})(this, function (exports, EventHandler, index) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/component-functions.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const enableDismissTrigger = (component, method = 'hide') => {
const clickEvent = `click.dismiss${component.EVENT_KEY}`;
const name = component.NAME;
EventHandler__default.default.on(
document,
clickEvent,
`[data-bs-dismiss="${name}"]`,
function (event) {
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (index.isDisabled(this)) {
return;
}
const target = index.getElementFromSelector(this) || this.closest(`.${name}`);
const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
instance[method]();
}
);
};
exports.enableDismissTrigger = enableDismissTrigger;
Object.defineProperties(exports, {
__esModule: { value: true },
[Symbol.toStringTag]: { value: 'Module' },
});
});
//# sourceMappingURL=component-functions.js.map

1
src/js/bootstrap/dist/util/component-functions.js.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"component-functions.js","sources":["../../src/util/component-functions.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.2.2): util/component-functions.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nimport EventHandler from '../dom/event-handler'\nimport { getElementFromSelector, isDisabled } from './index'\n\nconst enableDismissTrigger = (component, method = 'hide') => {\n const clickEvent = `click.dismiss${component.EVENT_KEY}`\n const name = component.NAME\n\n EventHandler.on(document, clickEvent, `[data-bs-dismiss=\"${name}\"]`, function (event) {\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault()\n }\n\n if (isDisabled(this)) {\n return\n }\n\n const target = getElementFromSelector(this) || this.closest(`.${name}`)\n const instance = component.getOrCreateInstance(target)\n\n // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method\n instance[method]()\n })\n}\n\nexport {\n enableDismissTrigger\n}\n"],"names":["enableDismissTrigger","component","method","clickEvent","EVENT_KEY","name","NAME","EventHandler","on","document","event","includes","tagName","preventDefault","isDisabled","target","getElementFromSelector","closest","instance","getOrCreateInstance"],"mappings":";;;;;;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;;AAKMA,QAAAA,oBAAoB,GAAG,CAACC,SAAD,EAAYC,MAAM,GAAG,MAArB,KAAgC;EAC3D,EAAA,MAAMC,UAAU,GAAI,CAAA,aAAA,EAAeF,SAAS,CAACG,SAAU,CAAvD,CAAA,CAAA;EACA,EAAA,MAAMC,IAAI,GAAGJ,SAAS,CAACK,IAAvB,CAAA;EAEAC,EAAAA,6BAAY,CAACC,EAAb,CAAgBC,QAAhB,EAA0BN,UAA1B,EAAuC,CAAA,kBAAA,EAAoBE,IAAK,CAAA,EAAA,CAAhE,EAAqE,UAAUK,KAAV,EAAiB;MACpF,IAAI,CAAC,GAAD,EAAM,MAAN,CAAA,CAAcC,QAAd,CAAuB,IAAA,CAAKC,OAA5B,CAAJ,EAA0C;EACxCF,MAAAA,KAAK,CAACG,cAAN,EAAA,CAAA;EACD,KAAA;;EAED,IAAA,IAAIC,gBAAU,CAAC,IAAD,CAAd,EAAsB;EACpB,MAAA,OAAA;EACD,KAAA;;EAED,IAAA,MAAMC,MAAM,GAAGC,4BAAsB,CAAC,IAAD,CAAtB,IAAgC,IAAA,CAAKC,OAAL,CAAc,CAAGZ,CAAAA,EAAAA,IAAK,EAAtB,CAA/C,CAAA;MACA,MAAMa,QAAQ,GAAGjB,SAAS,CAACkB,mBAAV,CAA8BJ,MAA9B,CAAjB,CAVoF;;MAapFG,QAAQ,CAAChB,MAAD,CAAR,EAAA,CAAA;KAbF,CAAA,CAAA;EAeD;;;;;;;;;;"}

90
src/js/bootstrap/dist/util/config.js vendored Normal file
View File

@ -0,0 +1,90 @@
/*!
* Bootstrap config.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('./index'), require('../dom/manipulator')))
: typeof define === 'function' && define.amd
? define(['./index', '../dom/manipulator'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Config = factory(global.Index, global.Manipulator)));
})(this, function (index, Manipulator) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/config.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Class definition
*/
class Config {
// Getters
static get Default() {
return {};
}
static get DefaultType() {
return {};
}
static get NAME() {
throw new Error('You have to implement the static method "NAME", for each component!');
}
_getConfig(config) {
config = this._mergeConfigObj(config);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
_configAfterMerge(config) {
return config;
}
_mergeConfigObj(config, element) {
const jsonConfig = index.isElement(element)
? Manipulator__default.default.getDataAttribute(element, 'config')
: {}; // try to parse
return {
...this.constructor.Default,
...(typeof jsonConfig === 'object' ? jsonConfig : {}),
...(index.isElement(element)
? Manipulator__default.default.getDataAttributes(element)
: {}),
...(typeof config === 'object' ? config : {}),
};
}
_typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
for (const property of Object.keys(configTypes)) {
const expectedTypes = configTypes[property];
const value = config[property];
const valueType = index.isElement(value) ? 'element' : index.toType(value);
if (!new RegExp(expectedTypes).test(valueType)) {
throw new TypeError(
`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
);
}
}
}
}
return Config;
});
//# sourceMappingURL=config.js.map

1
src/js/bootstrap/dist/util/config.js.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"config.js","sources":["../../src/util/config.js"],"sourcesContent":["/**\n * --------------------------------------------------------------------------\n * Bootstrap (v5.2.2): util/config.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nimport { isElement, toType } from './index'\nimport Manipulator from '../dom/manipulator'\n\n/**\n * Class definition\n */\n\nclass Config {\n // Getters\n static get Default() {\n return {}\n }\n\n static get DefaultType() {\n return {}\n }\n\n static get NAME() {\n throw new Error('You have to implement the static method \"NAME\", for each component!')\n }\n\n _getConfig(config) {\n config = this._mergeConfigObj(config)\n config = this._configAfterMerge(config)\n this._typeCheckConfig(config)\n return config\n }\n\n _configAfterMerge(config) {\n return config\n }\n\n _mergeConfigObj(config, element) {\n const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {} // try to parse\n\n return {\n ...this.constructor.Default,\n ...(typeof jsonConfig === 'object' ? jsonConfig : {}),\n ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),\n ...(typeof config === 'object' ? config : {})\n }\n }\n\n _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {\n for (const property of Object.keys(configTypes)) {\n const expectedTypes = configTypes[property]\n const value = config[property]\n const valueType = isElement(value) ? 'element' : toType(value)\n\n if (!new RegExp(expectedTypes).test(valueType)) {\n throw new TypeError(\n `${this.constructor.NAME.toUpperCase()}: Option \"${property}\" provided type \"${valueType}\" but expected type \"${expectedTypes}\".`\n )\n }\n }\n }\n}\n\nexport default Config\n"],"names":["Config","Default","DefaultType","NAME","Error","_getConfig","config","_mergeConfigObj","_configAfterMerge","_typeCheckConfig","element","jsonConfig","isElement","Manipulator","getDataAttribute","constructor","getDataAttributes","configTypes","property","Object","keys","expectedTypes","value","valueType","toType","RegExp","test","TypeError","toUpperCase"],"mappings":";;;;;;;;;;;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;EAKA;EACA;EACA;;EAEA,MAAMA,MAAN,CAAa;EACX;EACkB,EAAA,WAAPC,OAAO,GAAG;EACnB,IAAA,OAAO,EAAP,CAAA;EACD,GAAA;;EAEqB,EAAA,WAAXC,WAAW,GAAG;EACvB,IAAA,OAAO,EAAP,CAAA;EACD,GAAA;;EAEc,EAAA,WAAJC,IAAI,GAAG;EAChB,IAAA,MAAM,IAAIC,KAAJ,CAAU,qEAAV,CAAN,CAAA;EACD,GAAA;;IAEDC,UAAU,CAACC,MAAD,EAAS;EACjBA,IAAAA,MAAM,GAAG,IAAA,CAAKC,eAAL,CAAqBD,MAArB,CAAT,CAAA;EACAA,IAAAA,MAAM,GAAG,IAAA,CAAKE,iBAAL,CAAuBF,MAAvB,CAAT,CAAA;;MACA,IAAKG,CAAAA,gBAAL,CAAsBH,MAAtB,CAAA,CAAA;;EACA,IAAA,OAAOA,MAAP,CAAA;EACD,GAAA;;IAEDE,iBAAiB,CAACF,MAAD,EAAS;EACxB,IAAA,OAAOA,MAAP,CAAA;EACD,GAAA;;EAEDC,EAAAA,eAAe,CAACD,MAAD,EAASI,OAAT,EAAkB;EAC/B,IAAA,MAAMC,UAAU,GAAGC,eAAS,CAACF,OAAD,CAAT,GAAqBG,4BAAW,CAACC,gBAAZ,CAA6BJ,OAA7B,EAAsC,QAAtC,CAArB,GAAuE,EAA1F,CAD+B;;EAG/B,IAAA,OAAO,EACL,GAAG,IAAKK,CAAAA,WAAL,CAAiBd,OADf;QAEL,IAAI,OAAOU,UAAP,KAAsB,QAAtB,GAAiCA,UAAjC,GAA8C,EAAlD,CAFK;EAGL,MAAA,IAAIC,eAAS,CAACF,OAAD,CAAT,GAAqBG,4BAAW,CAACG,iBAAZ,CAA8BN,OAA9B,CAArB,GAA8D,EAAlE,CAHK;EAIL,MAAA,IAAI,OAAOJ,MAAP,KAAkB,QAAlB,GAA6BA,MAA7B,GAAsC,EAA1C,CAAA;OAJF,CAAA;EAMD,GAAA;;IAEDG,gBAAgB,CAACH,MAAD,EAASW,WAAW,GAAG,IAAKF,CAAAA,WAAL,CAAiBb,WAAxC,EAAqD;MACnE,KAAK,MAAMgB,QAAX,IAAuBC,MAAM,CAACC,IAAP,CAAYH,WAAZ,CAAvB,EAAiD;EAC/C,MAAA,MAAMI,aAAa,GAAGJ,WAAW,CAACC,QAAD,CAAjC,CAAA;EACA,MAAA,MAAMI,KAAK,GAAGhB,MAAM,CAACY,QAAD,CAApB,CAAA;EACA,MAAA,MAAMK,SAAS,GAAGX,eAAS,CAACU,KAAD,CAAT,GAAmB,SAAnB,GAA+BE,YAAM,CAACF,KAAD,CAAvD,CAAA;;QAEA,IAAI,CAAC,IAAIG,MAAJ,CAAWJ,aAAX,EAA0BK,IAA1B,CAA+BH,SAA/B,CAAL,EAAgD;EAC9C,QAAA,MAAM,IAAII,SAAJ,CACH,GAAE,IAAKZ,CAAAA,WAAL,CAAiBZ,IAAjB,CAAsByB,WAAtB,EAAoC,aAAYV,QAAS,CAAA,iBAAA,EAAmBK,SAAU,CAAuBF,qBAAAA,EAAAA,aAAc,IAD1H,CAAN,CAAA;EAGD,OAAA;EACF,KAAA;EACF,GAAA;;EAhDU;;;;;;;;"}

139
src/js/bootstrap/dist/util/focustrap.js vendored Normal file
View File

@ -0,0 +1,139 @@
/*!
* Bootstrap focustrap.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('../dom/event-handler'),
require('../dom/selector-engine'),
require('./config')
))
: typeof define === 'function' && define.amd
? define(['../dom/event-handler', '../dom/selector-engine', './config'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Focustrap = factory(global.EventHandler, global.SelectorEngine, global.Config)));
})(this, function (EventHandler, SelectorEngine, Config) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
const SelectorEngine__default = /*#__PURE__*/ _interopDefaultLegacy(SelectorEngine);
const Config__default = /*#__PURE__*/ _interopDefaultLegacy(Config);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/focustrap.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME = 'focustrap';
const DATA_KEY = 'bs.focustrap';
const EVENT_KEY = `.${DATA_KEY}`;
const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY}`;
const TAB_KEY = 'Tab';
const TAB_NAV_FORWARD = 'forward';
const TAB_NAV_BACKWARD = 'backward';
const Default = {
autofocus: true,
trapElement: null, // The element to trap focus inside of
};
const DefaultType = {
autofocus: 'boolean',
trapElement: 'element',
};
/**
* Class definition
*/
class FocusTrap extends Config__default.default {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isActive = false;
this._lastTabNavDirection = null;
} // Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
activate() {
if (this._isActive) {
return;
}
if (this._config.autofocus) {
this._config.trapElement.focus();
}
EventHandler__default.default.off(document, EVENT_KEY); // guard against infinite focus loop
EventHandler__default.default.on(document, EVENT_FOCUSIN, (event) =>
this._handleFocusin(event)
);
EventHandler__default.default.on(document, EVENT_KEYDOWN_TAB, (event) =>
this._handleKeydown(event)
);
this._isActive = true;
}
deactivate() {
if (!this._isActive) {
return;
}
this._isActive = false;
EventHandler__default.default.off(document, EVENT_KEY);
} // Private
_handleFocusin(event) {
const { trapElement } = this._config;
if (
event.target === document ||
event.target === trapElement ||
trapElement.contains(event.target)
) {
return;
}
const elements = SelectorEngine__default.default.focusableChildren(trapElement);
if (elements.length === 0) {
trapElement.focus();
} else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
elements[elements.length - 1].focus();
} else {
elements[0].focus();
}
}
_handleKeydown(event) {
if (event.key !== TAB_KEY) {
return;
}
this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
}
}
return FocusTrap;
});
//# sourceMappingURL=focustrap.js.map

1
src/js/bootstrap/dist/util/focustrap.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

350
src/js/bootstrap/dist/util/index.js vendored Normal file
View File

@ -0,0 +1,350 @@
/*!
* Bootstrap index.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'
? factory(exports)
: typeof define === 'function' && define.amd
? define(['exports'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
factory((global.Index = {})));
})(this, function (exports) {
'use strict';
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const MAX_UID = 1000000;
const MILLISECONDS_MULTIPLIER = 1000;
const TRANSITION_END = 'transitionend'; // Shout-out Angus Croll (https://goo.gl/pxwQGp)
const toType = (object) => {
if (object === null || object === undefined) {
return `${object}`;
}
return Object.prototype.toString
.call(object)
.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 getSelector = (element) => {
let selector = element.getAttribute('data-bs-target');
if (!selector || selector === '#') {
let hrefAttribute = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttribute || (!hrefAttribute.includes('#') && !hrefAttribute.startsWith('.'))) {
return null;
} // Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
}
selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
}
return selector;
};
const getSelectorFromElement = (element) => {
const selector = getSelector(element);
if (selector) {
return document.querySelector(selector) ? selector : null;
}
return null;
};
const getElementFromSelector = (element) => {
const selector = getSelector(element);
return selector ? document.querySelector(selector) : null;
};
const getTransitionDurationFromElement = (element) => {
if (!element) {
return 0;
} // Get transition-duration of the element
let { transitionDuration, transitionDelay } = window.getComputedStyle(element);
const floatTransitionDuration = Number.parseFloat(transitionDuration);
const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
if (!floatTransitionDuration && !floatTransitionDelay) {
return 0;
} // If multiple durations are defined, take the first
transitionDuration = transitionDuration.split(',')[0];
transitionDelay = transitionDelay.split(',')[0];
return (
(Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) *
MILLISECONDS_MULTIPLIER
);
};
const triggerTransitionEnd = (element) => {
element.dispatchEvent(new Event(TRANSITION_END));
};
const isElement = (object) => {
if (!object || typeof object !== 'object') {
return false;
}
if (typeof object.jquery !== 'undefined') {
object = object[0];
}
return typeof object.nodeType !== 'undefined';
};
const getElement = (object) => {
// it's a jQuery object or a node element
if (isElement(object)) {
return object.jquery ? object[0] : object;
}
if (typeof object === 'string' && object.length > 0) {
return document.querySelector(object);
}
return null;
};
const isVisible = (element) => {
if (!isElement(element) || element.getClientRects().length === 0) {
return false;
}
const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'; // Handle `details` element as its content may falsie appear visible when it is closed
const closedDetails = element.closest('details:not([open])');
if (!closedDetails) {
return elementIsVisible;
}
if (closedDetails !== element) {
const summary = element.closest('summary');
if (summary && summary.parentNode !== closedDetails) {
return false;
}
if (summary === null) {
return false;
}
}
return elementIsVisible;
};
const isDisabled = (element) => {
if (!element || element.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element.classList.contains('disabled')) {
return true;
}
if (typeof element.disabled !== 'undefined') {
return element.disabled;
}
return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
};
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 = () => {};
/**
* Trick to restart an element's animation
*
* @param {HTMLElement} element
* @return void
*
* @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
*/
const reflow = (element) => {
element.offsetHeight; // eslint-disable-line no-unused-expressions
};
const getjQuery = () => {
if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
return window.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', () => {
for (const callback of DOMContentLoadedCallbacks) {
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;
};
}
});
};
const execute = (callback) => {
if (typeof callback === 'function') {
callback();
}
};
const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
if (!waitForTransition) {
execute(callback);
return;
}
const durationPadding = 5;
const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
let called = false;
const handler = ({ target }) => {
if (target !== transitionElement) {
return;
}
called = true;
transitionElement.removeEventListener(TRANSITION_END, handler);
execute(callback);
};
transitionElement.addEventListener(TRANSITION_END, handler);
setTimeout(() => {
if (!called) {
triggerTransitionEnd(transitionElement);
}
}, emulatedDuration);
};
/**
* Return the previous/next element of a list.
*
* @param {array} list The list of elements
* @param activeElement The active element
* @param shouldGetNext Choose to get next or previous element
* @param isCycleAllowed
* @return {Element|elem} The proper element
*/
const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
const listLength = list.length;
let index = list.indexOf(activeElement); // if the element does not exist in the list return an element
// depending on the direction and if cycle is allowed
if (index === -1) {
return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
}
index += shouldGetNext ? 1 : -1;
if (isCycleAllowed) {
index = (index + listLength) % listLength;
}
return list[Math.max(0, Math.min(index, listLength - 1))];
};
exports.defineJQueryPlugin = defineJQueryPlugin;
exports.execute = execute;
exports.executeAfterTransition = executeAfterTransition;
exports.findShadowRoot = findShadowRoot;
exports.getElement = getElement;
exports.getElementFromSelector = getElementFromSelector;
exports.getNextActiveElement = getNextActiveElement;
exports.getSelectorFromElement = getSelectorFromElement;
exports.getTransitionDurationFromElement = getTransitionDurationFromElement;
exports.getUID = getUID;
exports.getjQuery = getjQuery;
exports.isDisabled = isDisabled;
exports.isElement = isElement;
exports.isRTL = isRTL;
exports.isVisible = isVisible;
exports.noop = noop;
exports.onDOMContentLoaded = onDOMContentLoaded;
exports.reflow = reflow;
exports.toType = toType;
exports.triggerTransitionEnd = triggerTransitionEnd;
Object.defineProperties(exports, {
__esModule: { value: true },
[Symbol.toStringTag]: { value: 'Module' },
});
});
//# sourceMappingURL=index.js.map

1
src/js/bootstrap/dist/util/index.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

142
src/js/bootstrap/dist/util/sanitizer.js vendored Normal file
View File

@ -0,0 +1,142 @@
/*!
* Bootstrap sanitizer.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'
? factory(exports)
: typeof define === 'function' && define.amd
? define(['exports'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
factory((global.Sanitizer = {})));
})(this, function (exports) {
'use strict';
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): 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.
*
* Shout-out 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.
*
* Shout-out 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;
} // Check if a regular expression validates the attribute.
return allowedAttributeList
.filter((attributeRegex) => attributeRegex instanceof RegExp)
.some((regex) => regex.test(attributeName));
};
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, sanitizeFunction) {
if (!unsafeHtml.length) {
return unsafeHtml;
}
if (sanitizeFunction && typeof sanitizeFunction === 'function') {
return sanitizeFunction(unsafeHtml);
}
const domParser = new window.DOMParser();
const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
for (const element of elements) {
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] || []);
for (const attribute of attributeList) {
if (!allowedAttribute(attribute, allowedAttributes)) {
element.removeAttribute(attribute.nodeName);
}
}
}
return createdDocument.body.innerHTML;
}
exports.DefaultAllowlist = DefaultAllowlist;
exports.sanitizeHtml = sanitizeHtml;
Object.defineProperties(exports, {
__esModule: { value: true },
[Symbol.toStringTag]: { value: 'Module' },
});
});
//# sourceMappingURL=sanitizer.js.map

1
src/js/bootstrap/dist/util/sanitizer.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

157
src/js/bootstrap/dist/util/scrollbar.js vendored Normal file
View File

@ -0,0 +1,157 @@
/*!
* Bootstrap scrollbar.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('../dom/selector-engine'),
require('../dom/manipulator'),
require('./index')
))
: typeof define === 'function' && define.amd
? define(['../dom/selector-engine', '../dom/manipulator', './index'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Scrollbar = factory(global.SelectorEngine, global.Manipulator, global.Index)));
})(this, function (SelectorEngine, Manipulator, index) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const SelectorEngine__default = /*#__PURE__*/ _interopDefaultLegacy(SelectorEngine);
const Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/scrollBar.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
const SELECTOR_STICKY_CONTENT = '.sticky-top';
const PROPERTY_PADDING = 'padding-right';
const PROPERTY_MARGIN = 'margin-right';
/**
* Class definition
*/
class ScrollBarHelper {
constructor() {
this._element = document.body;
} // Public
getWidth() {
// https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
const documentWidth = document.documentElement.clientWidth;
return Math.abs(window.innerWidth - documentWidth);
}
hide() {
const width = this.getWidth();
this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width
this._setElementAttributes(
this._element,
PROPERTY_PADDING,
(calculatedValue) => calculatedValue + width
); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
this._setElementAttributes(
SELECTOR_FIXED_CONTENT,
PROPERTY_PADDING,
(calculatedValue) => calculatedValue + width
);
this._setElementAttributes(
SELECTOR_STICKY_CONTENT,
PROPERTY_MARGIN,
(calculatedValue) => calculatedValue - width
);
}
reset() {
this._resetElementAttributes(this._element, 'overflow');
this._resetElementAttributes(this._element, PROPERTY_PADDING);
this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
}
isOverflowing() {
return this.getWidth() > 0;
} // Private
_disableOverFlow() {
this._saveInitialAttribute(this._element, 'overflow');
this._element.style.overflow = 'hidden';
}
_setElementAttributes(selector, styleProperty, callback) {
const scrollbarWidth = this.getWidth();
const manipulationCallBack = (element) => {
if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
return;
}
this._saveInitialAttribute(element, styleProperty);
const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
element.style.setProperty(
styleProperty,
`${callback(Number.parseFloat(calculatedValue))}px`
);
};
this._applyManipulationCallback(selector, manipulationCallBack);
}
_saveInitialAttribute(element, styleProperty) {
const actualValue = element.style.getPropertyValue(styleProperty);
if (actualValue) {
Manipulator__default.default.setDataAttribute(element, styleProperty, actualValue);
}
}
_resetElementAttributes(selector, styleProperty) {
const manipulationCallBack = (element) => {
const value = Manipulator__default.default.getDataAttribute(element, styleProperty); // We only want to remove the property if the value is `null`; the value can also be zero
if (value === null) {
element.style.removeProperty(styleProperty);
return;
}
Manipulator__default.default.removeDataAttribute(element, styleProperty);
element.style.setProperty(styleProperty, value);
};
this._applyManipulationCallback(selector, manipulationCallBack);
}
_applyManipulationCallback(selector, callBack) {
if (index.isElement(selector)) {
callBack(selector);
return;
}
for (const sel of SelectorEngine__default.default.find(selector, this._element)) {
callBack(sel);
}
}
}
return ScrollBarHelper;
});
//# sourceMappingURL=scrollbar.js.map

1
src/js/bootstrap/dist/util/scrollbar.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

173
src/js/bootstrap/dist/util/swipe.js vendored Normal file
View File

@ -0,0 +1,173 @@
/*!
* Bootstrap swipe.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('./config'),
require('../dom/event-handler'),
require('./index')
))
: typeof define === 'function' && define.amd
? define(['./config', '../dom/event-handler', './index'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.Swipe = factory(global.Config, global.EventHandler, global.Index)));
})(this, function (Config, EventHandler, index) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const Config__default = /*#__PURE__*/ _interopDefaultLegacy(Config);
const EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/swipe.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME = 'swipe';
const EVENT_KEY = '.bs.swipe';
const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`;
const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`;
const EVENT_TOUCHEND = `touchend${EVENT_KEY}`;
const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`;
const EVENT_POINTERUP = `pointerup${EVENT_KEY}`;
const POINTER_TYPE_TOUCH = 'touch';
const POINTER_TYPE_PEN = 'pen';
const CLASS_NAME_POINTER_EVENT = 'pointer-event';
const SWIPE_THRESHOLD = 40;
const Default = {
endCallback: null,
leftCallback: null,
rightCallback: null,
};
const DefaultType = {
endCallback: '(function|null)',
leftCallback: '(function|null)',
rightCallback: '(function|null)',
};
/**
* Class definition
*/
class Swipe extends Config__default.default {
constructor(element, config) {
super();
this._element = element;
if (!element || !Swipe.isSupported()) {
return;
}
this._config = this._getConfig(config);
this._deltaX = 0;
this._supportPointerEvents = Boolean(window.PointerEvent);
this._initEvents();
} // Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
dispose() {
EventHandler__default.default.off(this._element, EVENT_KEY);
} // Private
_start(event) {
if (!this._supportPointerEvents) {
this._deltaX = event.touches[0].clientX;
return;
}
if (this._eventIsPointerPenTouch(event)) {
this._deltaX = event.clientX;
}
}
_end(event) {
if (this._eventIsPointerPenTouch(event)) {
this._deltaX = event.clientX - this._deltaX;
}
this._handleSwipe();
index.execute(this._config.endCallback);
}
_move(event) {
this._deltaX =
event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
}
_handleSwipe() {
const absDeltaX = Math.abs(this._deltaX);
if (absDeltaX <= SWIPE_THRESHOLD) {
return;
}
const direction = absDeltaX / this._deltaX;
this._deltaX = 0;
if (!direction) {
return;
}
index.execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
}
_initEvents() {
if (this._supportPointerEvents) {
EventHandler__default.default.on(this._element, EVENT_POINTERDOWN, (event) =>
this._start(event)
);
EventHandler__default.default.on(this._element, EVENT_POINTERUP, (event) =>
this._end(event)
);
this._element.classList.add(CLASS_NAME_POINTER_EVENT);
} else {
EventHandler__default.default.on(this._element, EVENT_TOUCHSTART, (event) =>
this._start(event)
);
EventHandler__default.default.on(this._element, EVENT_TOUCHMOVE, (event) =>
this._move(event)
);
EventHandler__default.default.on(this._element, EVENT_TOUCHEND, (event) =>
this._end(event)
);
}
}
_eventIsPointerPenTouch(event) {
return (
this._supportPointerEvents &&
(event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
);
} // Static
static isSupported() {
return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
}
}
return Swipe;
});
//# sourceMappingURL=swipe.js.map

1
src/js/bootstrap/dist/util/swipe.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

193
src/js/bootstrap/dist/util/template-factory.js vendored Normal file
View File

@ -0,0 +1,193 @@
/*!
* Bootstrap template-factory.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('./sanitizer'),
require('./index'),
require('../dom/selector-engine'),
require('./config')
))
: typeof define === 'function' && define.amd
? define(['./sanitizer', './index', '../dom/selector-engine', './config'], factory)
: ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
(global.TemplateFactory = factory(
global.Sanitizer,
global.Index,
global.SelectorEngine,
global.Config
)));
})(this, function (sanitizer, index, SelectorEngine, Config) {
'use strict';
const _interopDefaultLegacy = (e) =>
e && typeof e === 'object' && 'default' in e ? e : { default: e };
const SelectorEngine__default = /*#__PURE__*/ _interopDefaultLegacy(SelectorEngine);
const Config__default = /*#__PURE__*/ _interopDefaultLegacy(Config);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/template-factory.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME = 'TemplateFactory';
const Default = {
allowList: sanitizer.DefaultAllowlist,
content: {},
// { selector : text , selector2 : text2 , }
extraClass: '',
html: false,
sanitize: true,
sanitizeFn: null,
template: '<div></div>',
};
const DefaultType = {
allowList: 'object',
content: 'object',
extraClass: '(string|function)',
html: 'boolean',
sanitize: 'boolean',
sanitizeFn: '(null|function)',
template: 'string',
};
const DefaultContentType = {
entry: '(string|element|function|null)',
selector: '(string|element)',
};
/**
* Class definition
*/
class TemplateFactory extends Config__default.default {
constructor(config) {
super();
this._config = this._getConfig(config);
} // Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
} // Public
getContent() {
return Object.values(this._config.content)
.map((config) => this._resolvePossibleFunction(config))
.filter(Boolean);
}
hasContent() {
return this.getContent().length > 0;
}
changeContent(content) {
this._checkContent(content);
this._config.content = { ...this._config.content, ...content };
return this;
}
toHtml() {
const templateWrapper = document.createElement('div');
templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
for (const [selector, text] of Object.entries(this._config.content)) {
this._setContent(templateWrapper, text, selector);
}
const template = templateWrapper.children[0];
const extraClass = this._resolvePossibleFunction(this._config.extraClass);
if (extraClass) {
template.classList.add(...extraClass.split(' '));
}
return template;
} // Private
_typeCheckConfig(config) {
super._typeCheckConfig(config);
this._checkContent(config.content);
}
_checkContent(arg) {
for (const [selector, content] of Object.entries(arg)) {
super._typeCheckConfig(
{
selector,
entry: content,
},
DefaultContentType
);
}
}
_setContent(template, content, selector) {
const templateElement = SelectorEngine__default.default.findOne(selector, template);
if (!templateElement) {
return;
}
content = this._resolvePossibleFunction(content);
if (!content) {
templateElement.remove();
return;
}
if (index.isElement(content)) {
this._putElementInTemplate(index.getElement(content), templateElement);
return;
}
if (this._config.html) {
templateElement.innerHTML = this._maybeSanitize(content);
return;
}
templateElement.textContent = content;
}
_maybeSanitize(arg) {
return this._config.sanitize
? sanitizer.sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn)
: arg;
}
_resolvePossibleFunction(arg) {
return typeof arg === 'function' ? arg(this) : arg;
}
_putElementInTemplate(element, templateElement) {
if (this._config.html) {
templateElement.innerHTML = '';
templateElement.append(element);
return;
}
templateElement.textContent = element.textContent;
}
}
return TemplateFactory;
});
//# sourceMappingURL=template-factory.js.map

1
src/js/bootstrap/dist/util/template-factory.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long

18
src/js/bootstrap/mdb-prefix/alert.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): alert.js
* Bootstrap (v5.2.2): alert.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -11,9 +11,7 @@ import BaseComponent from './base-component';
import { enableDismissTrigger } from './util/component-functions';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'alert';
@ -26,20 +24,16 @@ const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Alert extends BaseComponent {
// Getters
static get NAME() {
return NAME;
}
// Public
close() {
const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
@ -61,7 +55,6 @@ class Alert extends BaseComponent {
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Alert.getOrCreateInstance(this);
@ -80,18 +73,13 @@ class Alert extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
enableDismissTrigger(Alert, 'close');
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Alert to jQuery only if jQuery is present
*/
defineJQueryPlugin(Alert);

41
src/js/bootstrap/mdb-prefix/base-component.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): base-component.js
* Bootstrap (v5.2.2): base-component.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,42 +8,55 @@
import Data from './dom/data';
import { executeAfterTransition, getElement } from './util/index';
import EventHandler from './dom/event-handler';
import Config from './util/config';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const VERSION = '5.1.3';
const VERSION = '5.2.2';
/**
* Class definition
*/
class BaseComponent extends Config {
constructor(element, config) {
super();
class BaseComponent {
constructor(element) {
element = getElement(element);
if (!element) {
return;
}
this._element = element;
this._config = this._getConfig(config);
Data.set(this._element, this.constructor.DATA_KEY, this);
}
// Public
dispose() {
Data.remove(this._element, this.constructor.DATA_KEY);
EventHandler.off(this._element, this.constructor.EVENT_KEY);
Object.getOwnPropertyNames(this).forEach((propertyName) => {
for (const propertyName of Object.getOwnPropertyNames(this)) {
this[propertyName] = null;
});
}
}
_queueCallback(callback, element, isAnimated = true) {
executeAfterTransition(callback, element, isAnimated);
}
/** Static */
_getConfig(config) {
config = this._mergeConfigObj(config, this._element);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
// Static
static getInstance(element) {
return Data.get(getElement(element), this.DATA_KEY);
}
@ -58,10 +71,6 @@ class BaseComponent {
return VERSION;
}
static get NAME() {
throw new Error('You have to implement the static method "NAME", for each component!');
}
static get DATA_KEY() {
return `bs.${this.NAME}`;
}
@ -69,6 +78,10 @@ class BaseComponent {
static get EVENT_KEY() {
return `.${this.DATA_KEY}`;
}
static eventName(name) {
return `${name}${this.EVENT_KEY}`;
}
}
export default BaseComponent;

20
src/js/bootstrap/mdb-prefix/button.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): button.js
* Bootstrap (v5.2.2): button.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -10,9 +10,7 @@ import EventHandler from './dom/event-handler';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'button';
@ -21,33 +19,26 @@ const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const CLASS_NAME_ACTIVE = 'active';
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="button"]';
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Button extends BaseComponent {
// Getters
static get NAME() {
return NAME;
}
// Public
toggle() {
// Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE));
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Button.getOrCreateInstance(this);
@ -60,9 +51,7 @@ class Button extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, (event) => {
@ -75,10 +64,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, (event) =>
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Button to jQuery only if jQuery is present
*/
defineJQueryPlugin(Button);

573
src/js/bootstrap/mdb-prefix/carousel.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): carousel.js
* Bootstrap (v5.2.2): carousel.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,22 +8,20 @@
import {
defineJQueryPlugin,
getElementFromSelector,
getNextActiveElement,
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 Swipe from './util/swipe';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'carousel';
@ -34,46 +32,17 @@ const DATA_API_KEY = '.data-api';
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;
const Default = {
interval: 5000,
keyboard: true,
slide: false,
pause: 'hover',
wrap: true,
touch: true,
};
const DefaultType = {
interval: '(number|boolean)',
keyboard: 'boolean',
slide: '(boolean|string)',
pause: '(string|boolean)',
wrap: 'boolean',
touch: 'boolean',
};
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}`;
const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY}`;
const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY}`;
const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`;
const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`;
const EVENT_TOUCHEND = `touchend${EVENT_KEY}`;
const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`;
const EVENT_POINTERUP = `pointerup${EVENT_KEY}`;
const EVENT_DRAG_START = `dragstart${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
@ -85,65 +54,80 @@ 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';
const SELECTOR_ACTIVE = '.active';
const SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
const SELECTOR_ITEM = '.carousel-item';
const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_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_INDICATOR = '[data-mdb-target]';
const SELECTOR_DATA_SLIDE = '[data-mdb-slide], [data-mdb-slide-to]';
const SELECTOR_DATA_RIDE = '[data-mdb-ride="carousel"]';
const POINTER_TYPE_TOUCH = 'touch';
const POINTER_TYPE_PEN = 'pen';
const KEY_TO_DIRECTION = {
[ARROW_LEFT_KEY]: DIRECTION_RIGHT,
[ARROW_RIGHT_KEY]: DIRECTION_LEFT,
};
const Default = {
interval: 5000,
keyboard: true,
pause: 'hover',
ride: false,
touch: true,
wrap: true,
};
const DefaultType = {
interval: '(number|boolean)', // TODO:v6 remove boolean support
keyboard: 'boolean',
pause: '(string|boolean)',
ride: '(boolean|string)',
touch: 'boolean',
wrap: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Carousel extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._items = null;
this._interval = null;
this._activeElement = null;
this._isPaused = false;
this._isSliding = false;
this.touchTimeout = null;
this.touchStartX = 0;
this.touchDeltaX = 0;
this._swipeHelper = null;
this._config = this._getConfig(config);
this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
this._touchSupported =
'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
this._pointerEvent = Boolean(window.PointerEvent);
this._addEventListeners();
if (this._config.ride === CLASS_NAME_CAROUSEL) {
this.cycle();
}
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
next() {
this._slide(ORDER_NEXT);
}
nextWhenVisible() {
// FIXME TODO use `document.visibilityState`
// Don't call next when the page isn't visible
// or the carousel or its parent isn't visible
if (!document.hidden && isVisible(this._element)) {
@ -155,45 +139,37 @@ class Carousel extends BaseComponent {
this._slide(ORDER_PREV);
}
pause(event) {
if (!event) {
this._isPaused = true;
}
if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
pause() {
if (this._isSliding) {
triggerTransitionEnd(this._element);
this.cycle(true);
}
clearInterval(this._interval);
this._interval = null;
this._clearInterval();
}
cycle(event) {
if (!event) {
this._isPaused = false;
cycle() {
this._clearInterval();
this._updateInterval();
this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
}
_maybeEnableCycle() {
if (!this._config.ride) {
return;
}
if (this._interval) {
clearInterval(this._interval);
this._interval = null;
if (this._isSliding) {
EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
return;
}
if (this._config && this._config.interval && !this._isPaused) {
this._updateInterval();
this._interval = setInterval(
(document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
this._config.interval
);
}
this.cycle();
}
to(index) {
this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
const activeIndex = this._getItemIndex(this._activeElement);
if (index > this._items.length - 1 || index < 0) {
const items = this._getItems();
if (index > items.length - 1 || index < 0) {
return;
}
@ -202,125 +178,81 @@ class Carousel extends BaseComponent {
return;
}
const activeIndex = this._getItemIndex(this._getActive());
if (activeIndex === index) {
this.pause();
this.cycle();
return;
}
const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
this._slide(order, this._items[index]);
this._slide(order, items[index]);
}
dispose() {
if (this._swipeHelper) {
this._swipeHelper.dispose();
}
super.dispose();
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' ? config : {}),
};
typeCheckConfig(NAME, config, DefaultType);
_configAfterMerge(config) {
config.defaultInterval = config.interval;
return config;
}
_handleSwipe() {
const absDeltax = Math.abs(this.touchDeltaX);
if (absDeltax <= SWIPE_THRESHOLD) {
return;
}
const direction = absDeltax / this.touchDeltaX;
this.touchDeltaX = 0;
if (!direction) {
return;
}
this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
}
_addEventListeners() {
if (this._config.keyboard) {
EventHandler.on(this._element, EVENT_KEYDOWN, (event) => this._keydown(event));
}
if (this._config.pause === 'hover') {
EventHandler.on(this._element, EVENT_MOUSEENTER, (event) => this.pause(event));
EventHandler.on(this._element, EVENT_MOUSELEAVE, (event) => this.cycle(event));
EventHandler.on(this._element, EVENT_MOUSEENTER, () => this.pause());
EventHandler.on(this._element, EVENT_MOUSELEAVE, () => this._maybeEnableCycle());
}
if (this._config.touch && this._touchSupported) {
if (this._config.touch && Swipe.isSupported()) {
this._addTouchEventListeners();
}
}
_addTouchEventListeners() {
const hasPointerPenTouch = (event) => {
return (
this._pointerEvent &&
(event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
EventHandler.on(img, EVENT_DRAG_START, (event) => event.preventDefault());
}
const endCallBack = () => {
if (this._config.pause !== 'hover') {
return;
}
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// 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
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
this.pause();
if (this.touchTimeout) {
clearTimeout(this.touchTimeout);
}
this.touchTimeout = setTimeout(
() => this._maybeEnableCycle(),
TOUCHEVENT_COMPAT_WAIT + this._config.interval
);
};
const start = (event) => {
if (hasPointerPenTouch(event)) {
this.touchStartX = event.clientX;
} else if (!this._pointerEvent) {
this.touchStartX = event.touches[0].clientX;
}
const swipeConfig = {
leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
endCallback: endCallBack,
};
const move = (event) => {
// ensure swiping with one touch and not pinching
this.touchDeltaX =
event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX;
};
const end = (event) => {
if (hasPointerPenTouch(event)) {
this.touchDeltaX = event.clientX - this.touchStartX;
}
this._handleSwipe();
if (this._config.pause === 'hover') {
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// 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
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
this.pause();
if (this.touchTimeout) {
clearTimeout(this.touchTimeout);
}
this.touchTimeout = setTimeout(
(event) => this.cycle(event),
TOUCHEVENT_COMPAT_WAIT + this._config.interval
);
}
};
SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach((itemImg) => {
EventHandler.on(itemImg, EVENT_DRAG_START, (event) => event.preventDefault());
});
if (this._pointerEvent) {
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 {
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));
}
this._swipeHelper = new Swipe(this._element, swipeConfig);
}
_keydown(event) {
@ -331,61 +263,37 @@ class Carousel extends BaseComponent {
const direction = KEY_TO_DIRECTION[event.key];
if (direction) {
event.preventDefault();
this._slide(direction);
this._slide(this._directionToOrder(direction));
}
}
_getItemIndex(element) {
this._items =
element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
return this._items.indexOf(element);
return this._getItems().indexOf(element);
}
_getItemByOrder(order, activeElement) {
const isNext = order === ORDER_NEXT;
return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap);
}
_setActiveIndicatorElement(index) {
if (!this._indicatorsElement) {
return;
}
_triggerSlideEvent(relatedTarget, eventDirectionName) {
const targetIndex = this._getItemIndex(relatedTarget);
const fromIndex = this._getItemIndex(
SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
activeIndicator.removeAttribute('aria-current');
const newActiveIndicator = SelectorEngine.findOne(
`[data-mdb-slide-to="${index}"]`,
this._indicatorsElement
);
return EventHandler.trigger(this._element, EVENT_SLIDE, {
relatedTarget,
direction: eventDirectionName,
from: fromIndex,
to: targetIndex,
});
}
_setActiveIndicatorElement(element) {
if (this._indicatorsElement) {
const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
activeIndicator.removeAttribute('aria-current');
const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
for (let i = 0; i < indicators.length; i++) {
if (
Number.parseInt(indicators[i].getAttribute('data-mdb-slide-to'), 10) ===
this._getItemIndex(element)
) {
indicators[i].classList.add(CLASS_NAME_ACTIVE);
indicators[i].setAttribute('aria-current', 'true');
break;
}
}
if (newActiveIndicator) {
newActiveIndicator.classList.add(CLASS_NAME_ACTIVE);
newActiveIndicator.setAttribute('aria-current', 'true');
}
}
_updateInterval() {
const element =
this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
const element = this._activeElement || this._getActive();
if (!element) {
return;
@ -393,103 +301,102 @@ class Carousel extends BaseComponent {
const elementInterval = Number.parseInt(element.getAttribute('data-mdb-interval'), 10);
if (elementInterval) {
this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
this._config.interval = elementInterval;
} else {
this._config.interval = this._config.defaultInterval || this._config.interval;
}
this._config.interval = elementInterval || this._config.defaultInterval;
}
_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 || this._getItemByOrder(order, activeElement);
const nextElementIndex = this._getItemIndex(nextElement);
const isCycling = Boolean(this._interval);
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 (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) {
this._isSliding = false;
return;
}
_slide(order, element = null) {
if (this._isSliding) {
return;
}
const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
const activeElement = this._getActive();
const isNext = order === ORDER_NEXT;
const nextElement =
element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
if (nextElement === activeElement) {
return;
}
const nextElementIndex = this._getItemIndex(nextElement);
const triggerEvent = (eventName) => {
return EventHandler.trigger(this._element, eventName, {
relatedTarget: nextElement,
direction: this._orderToDirection(order),
from: this._getItemIndex(activeElement),
to: nextElementIndex,
});
};
const slideEvent = triggerEvent(EVENT_SLIDE);
if (slideEvent.defaultPrevented) {
return;
}
if (!activeElement || !nextElement) {
// Some weirdness is happening, so we bail
// todo: change tests that use empty divs to avoid this check
return;
}
const isCycling = Boolean(this._interval);
this.pause();
this._isSliding = true;
if (isCycling) {
this.pause();
}
this._setActiveIndicatorElement(nextElement);
this._setActiveIndicatorElement(nextElementIndex);
this._activeElement = nextElement;
const triggerSlidEvent = () => {
EventHandler.trigger(this._element, EVENT_SLID, {
relatedTarget: nextElement,
direction: eventDirectionName,
from: activeElementIndex,
to: nextElementIndex,
});
};
const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
nextElement.classList.add(orderClassName);
nextElement.classList.add(orderClassName);
reflow(nextElement);
reflow(nextElement);
activeElement.classList.add(directionalClassName);
nextElement.classList.add(directionalClassName);
activeElement.classList.add(directionalClassName);
nextElement.classList.add(directionalClassName);
const completeCallBack = () => {
nextElement.classList.remove(directionalClassName, orderClassName);
nextElement.classList.add(CLASS_NAME_ACTIVE);
activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName);
this._isSliding = false;
setTimeout(triggerSlidEvent, 0);
};
this._queueCallback(completeCallBack, activeElement, true);
} else {
activeElement.classList.remove(CLASS_NAME_ACTIVE);
const completeCallBack = () => {
nextElement.classList.remove(directionalClassName, orderClassName);
nextElement.classList.add(CLASS_NAME_ACTIVE);
activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName);
this._isSliding = false;
triggerSlidEvent();
}
triggerEvent(EVENT_SLID);
};
this._queueCallback(completeCallBack, activeElement, this._isAnimated());
if (isCycling) {
this.cycle();
}
}
_directionToOrder(direction) {
if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
return direction;
}
_isAnimated() {
return this._element.classList.contains(CLASS_NAME_SLIDE);
}
_getActive() {
return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
}
_getItems() {
return SelectorEngine.find(SELECTOR_ITEM, this._element);
}
_clearInterval() {
if (this._interval) {
clearInterval(this._interval);
this._interval = null;
}
}
_directionToOrder(direction) {
if (isRTL()) {
return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
}
@ -498,10 +405,6 @@ class Carousel extends BaseComponent {
}
_orderToDirection(order) {
if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
return order;
}
if (isRTL()) {
return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
}
@ -510,88 +413,68 @@ class Carousel extends BaseComponent {
}
// Static
static carouselInterface(element, config) {
const data = Carousel.getOrCreateInstance(element, config);
let { _config } = data;
if (typeof config === 'object') {
_config = {
..._config,
...config,
};
}
const action = typeof config === 'string' ? config : _config.slide;
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();
}
}
static jQueryInterface(config) {
return this.each(function () {
Carousel.carouselInterface(this, config);
const data = Carousel.getOrCreateInstance(this, config);
if (typeof config === 'number') {
data.to(config);
return;
}
if (typeof config === 'string') {
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
}
});
}
static dataApiClickHandler(event) {
const target = getElementFromSelector(this);
if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
return;
}
const config = {
...Manipulator.getDataAttributes(target),
...Manipulator.getDataAttributes(this),
};
const slideIndex = this.getAttribute('data-mdb-slide-to');
if (slideIndex) {
config.interval = false;
}
Carousel.carouselInterface(target, config);
if (slideIndex) {
Carousel.getInstance(target).to(slideIndex);
}
event.preventDefault();
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (event) {
const target = getElementFromSelector(this);
if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
return;
}
event.preventDefault();
const carousel = Carousel.getOrCreateInstance(target);
const slideIndex = this.getAttribute('data-mdb-slide-to');
if (slideIndex) {
carousel.to(slideIndex);
carousel._maybeEnableCycle();
return;
}
if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
carousel.next();
carousel._maybeEnableCycle();
return;
}
carousel.prev();
carousel._maybeEnableCycle();
});
EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
for (let i = 0, len = carousels.length; i < len; i++) {
Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]));
for (const carousel of carousels) {
Carousel.getOrCreateInstance(carousel);
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Carousel to jQuery only if jQuery is present
*/
defineJQueryPlugin(Carousel);

158
src/js/bootstrap/mdb-prefix/collapse.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): collapse.js
* Bootstrap (v5.2.2): collapse.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,21 +8,16 @@
import {
defineJQueryPlugin,
getElement,
getSelectorFromElement,
getElementFromSelector,
getSelectorFromElement,
reflow,
typeCheckConfig,
} from './util/index';
import Data from './dom/data';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
import SelectorEngine from './dom/selector-engine';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'collapse';
@ -30,16 +25,6 @@ const DATA_KEY = 'bs.collapse';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const Default = {
toggle: true,
parent: null,
};
const DefaultType = {
toggle: 'boolean',
parent: '(null|element)',
};
const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_HIDE = `hide${EVENT_KEY}`;
@ -59,31 +44,36 @@ const HEIGHT = 'height';
const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="collapse"]';
const Default = {
parent: null,
toggle: true,
};
const DefaultType = {
parent: '(null|element)',
toggle: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Collapse extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._isTransitioning = false;
this._config = this._getConfig(config);
this._triggerArray = [];
const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE);
for (let i = 0, len = toggleList.length; i < len; i++) {
const elem = toggleList[i];
for (const elem of toggleList) {
const selector = getSelectorFromElement(elem);
const filterElement = SelectorEngine.find(selector).filter(
(foundElem) => foundElem === this._element
(foundElement) => foundElement === this._element
);
if (selector !== null && filterElement.length) {
this._selector = selector;
this._triggerArray.push(elem);
}
}
@ -100,17 +90,19 @@ class Collapse extends BaseComponent {
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
toggle() {
if (this._isShown()) {
this.hide();
@ -124,24 +116,17 @@ class Collapse extends BaseComponent {
return;
}
let actives = [];
let activesData;
let activeChildren = [];
// find active children
if (this._config.parent) {
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
actives = SelectorEngine.find(SELECTOR_ACTIVES, this._config.parent).filter(
(elem) => !children.includes(elem)
); // remove children if greater depth
activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES)
.filter((element) => element !== this._element)
.map((element) => Collapse.getOrCreateInstance(element, { toggle: false }));
}
const container = SelectorEngine.findOne(this._selector);
if (actives.length) {
const tempActiveData = actives.find((elem) => container !== elem);
activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
if (activesData && activesData._isTransitioning) {
return;
}
if (activeChildren.length && activeChildren[0]._isTransitioning) {
return;
}
const startEvent = EventHandler.trigger(this._element, EVENT_SHOW);
@ -149,15 +134,9 @@ class Collapse extends BaseComponent {
return;
}
actives.forEach((elemActive) => {
if (container !== elemActive) {
Collapse.getOrCreateInstance(elemActive, { toggle: false }).hide();
}
if (!activesData) {
Data.set(elemActive, DATA_KEY, null);
}
});
for (const activeInstance of activeChildren) {
activeInstance.hide();
}
const dimension = this._getDimension();
@ -206,12 +185,10 @@ class Collapse extends BaseComponent {
this._element.classList.add(CLASS_NAME_COLLAPSING);
this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW);
const triggerArrayLength = this._triggerArray.length;
for (let i = 0; i < triggerArrayLength; i++) {
const trigger = this._triggerArray[i];
const elem = getElementFromSelector(trigger);
for (const trigger of this._triggerArray) {
const element = getElementFromSelector(trigger);
if (elem && !this._isShown(elem)) {
if (element && !this._isShown(element)) {
this._addAriaAndCollapsedClass([trigger], false);
}
}
@ -235,16 +212,9 @@ class Collapse extends BaseComponent {
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...config,
};
_configAfterMerge(config) {
config.toggle = Boolean(config.toggle); // Coerce string values
config.parent = getElement(config.parent);
typeCheckConfig(NAME, config, DefaultType);
return config;
}
@ -257,16 +227,23 @@ class Collapse extends BaseComponent {
return;
}
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
SelectorEngine.find(SELECTOR_DATA_TOGGLE, this._config.parent)
.filter((elem) => !children.includes(elem))
.forEach((element) => {
const selected = getElementFromSelector(element);
const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE);
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
});
for (const element of children) {
const selected = getElementFromSelector(element);
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
}
}
_getFirstLevelChildren(selector) {
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
// remove children if greater depth
return SelectorEngine.find(selector, this._config.parent).filter(
(element) => !children.includes(element)
);
}
_addAriaAndCollapsedClass(triggerArray, isOpen) {
@ -274,26 +251,20 @@ class Collapse extends BaseComponent {
return;
}
triggerArray.forEach((elem) => {
if (isOpen) {
elem.classList.remove(CLASS_NAME_COLLAPSED);
} else {
elem.classList.add(CLASS_NAME_COLLAPSED);
}
elem.setAttribute('aria-expanded', isOpen);
});
for (const element of triggerArray) {
element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
element.setAttribute('aria-expanded', isOpen);
}
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
return this.each(function () {
const data = Collapse.getOrCreateInstance(this, _config);
if (typeof config === 'string') {
@ -308,9 +279,7 @@ class Collapse extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
@ -325,16 +294,13 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
const selector = getSelectorFromElement(this);
const selectorElements = SelectorEngine.find(selector);
selectorElements.forEach((element) => {
for (const element of selectorElements) {
Collapse.getOrCreateInstance(element, { toggle: false }).toggle();
});
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Collapse to jQuery only if jQuery is present
*/
defineJQueryPlugin(Collapse);

4
src/js/bootstrap/mdb-prefix/dom/data.js
View File

@ -1,14 +1,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/data.js
* Bootstrap (v5.2.2): dom/data.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const elementMap = new Map();

203
src/js/bootstrap/mdb-prefix/dom/event-handler.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/event-handler.js
* Bootstrap (v5.2.2): dom/event-handler.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,9 +8,7 @@
import { getjQuery } from '../util/index';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
@ -22,7 +20,7 @@ const customEvents = {
mouseenter: 'mouseover',
mouseleave: 'mouseout',
};
const customEventsRegex = /^(mouseenter|mouseleave)/i;
const nativeEvents = new Set([
'click',
'dblclick',
@ -73,17 +71,15 @@ const nativeEvents = new Set([
]);
/**
* ------------------------------------------------------------------------
* Private methods
* ------------------------------------------------------------------------
*/
function getUidEvent(element, uid) {
function makeEventUid(element, uid) {
return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++;
}
function getEvent(element) {
const uid = getUidEvent(element);
function getElementEvents(element) {
const uid = makeEventUid(element);
element.uidEvent = uid;
eventRegistry[uid] = eventRegistry[uid] || {};
@ -93,7 +89,7 @@ function getEvent(element) {
function bootstrapHandler(element, fn) {
return function handler(event) {
event.delegateTarget = element;
hydrateObj(event, { delegateTarget: element });
if (handler.oneOff) {
EventHandler.off(element, event.type, fn);
@ -108,66 +104,57 @@ function bootstrapDelegationHandler(element, selector, fn) {
const domElements = element.querySelectorAll(selector);
for (let { target } = event; target && target !== this; target = target.parentNode) {
for (let i = domElements.length; i--; ) {
if (domElements[i] === target) {
event.delegateTarget = target;
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
for (const domElement of domElements) {
if (domElement !== target) {
continue;
}
hydrateObj(event, { delegateTarget: target });
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
}
}
// To please ESLint
return null;
};
}
function findHandler(events, handler, delegationSelector = null) {
const uidEventList = Object.keys(events);
for (let i = 0, len = uidEventList.length; i < len; i++) {
const event = events[uidEventList[i]];
if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
return event;
}
}
return null;
function findHandler(events, callable, delegationSelector = null) {
return Object.values(events).find(
(event) => event.callable === callable && event.delegationSelector === delegationSelector
);
}
function normalizeParams(originalTypeEvent, handler, delegationFn) {
const delegation = typeof handler === 'string';
const originalHandler = delegation ? delegationFn : handler;
function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
const isDelegated = typeof handler === 'string';
// todo: tooltip passes `false` instead of selector, so we need to check
const callable = isDelegated ? delegationFunction : handler || delegationFunction;
let typeEvent = getTypeEvent(originalTypeEvent);
const isNative = nativeEvents.has(typeEvent);
if (!isNative) {
if (!nativeEvents.has(typeEvent)) {
typeEvent = originalTypeEvent;
}
return [delegation, originalHandler, typeEvent];
return [isDelegated, callable, typeEvent];
}
function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
if (!handler) {
handler = delegationFn;
delegationFn = null;
}
let [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFunction
);
// in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
// this prevents the handler from being dispatched the same way as mouseover or mouseout does
if (customEventsRegex.test(originalTypeEvent)) {
const wrapFn = (fn) => {
if (originalTypeEvent in customEvents) {
const wrapFunction = (fn) => {
return function (event) {
if (
!event.relatedTarget ||
@ -179,40 +166,31 @@ function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
};
};
if (delegationFn) {
delegationFn = wrapFn(delegationFn);
} else {
handler = wrapFn(handler);
}
callable = wrapFunction(callable);
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
originalTypeEvent,
handler,
delegationFn
);
const events = getEvent(element);
const events = getElementEvents(element);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
if (previousFn) {
previousFn.oneOff = previousFn.oneOff && oneOff;
if (previousFunction) {
previousFunction.oneOff = previousFunction.oneOff && oneOff;
return;
}
const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
const fn = delegation
? bootstrapDelegationHandler(element, handler, delegationFn)
: bootstrapHandler(element, handler);
const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
const fn = isDelegated
? bootstrapDelegationHandler(element, handler, callable)
: bootstrapHandler(element, callable);
fn.delegationSelector = delegation ? handler : null;
fn.originalHandler = originalHandler;
fn.delegationSelector = isDelegated ? handler : null;
fn.callable = callable;
fn.oneOff = oneOff;
fn.uidEvent = uid;
handlers[uid] = fn;
element.addEventListener(typeEvent, fn, delegation);
element.addEventListener(typeEvent, fn, isDelegated);
}
function removeHandler(element, events, typeEvent, handler, delegationSelector) {
@ -229,13 +207,12 @@ function removeHandler(element, events, typeEvent, handler, delegationSelector)
function removeNamespacedHandlers(element, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((handlerKey) => {
for (const handlerKey of Object.keys(storeElementEvent)) {
if (handlerKey.includes(namespace)) {
const event = storeElementEvent[handlerKey];
removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
}
function getTypeEvent(event) {
@ -245,54 +222,53 @@ function getTypeEvent(event) {
}
const EventHandler = {
on(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, false);
on(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, false);
},
one(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, true);
one(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, true);
},
off(element, originalTypeEvent, handler, delegationFn) {
off(element, originalTypeEvent, handler, delegationFunction) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
const [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFn
delegationFunction
);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getEvent(element);
const events = getElementEvents(element);
const storeElementEvent = events[typeEvent] || {};
const isNamespace = originalTypeEvent.startsWith('.');
if (typeof originalHandler !== 'undefined') {
if (typeof callable !== 'undefined') {
// Simplest case: handler is passed, remove that listener ONLY.
if (!events || !events[typeEvent]) {
if (!Object.keys(storeElementEvent).length) {
return;
}
removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
return;
}
if (isNamespace) {
Object.keys(events).forEach((elementEvent) => {
for (const elementEvent of Object.keys(events)) {
removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
});
}
}
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((keyHandlers) => {
for (const keyHandlers of Object.keys(storeElementEvent)) {
const handlerKey = keyHandlers.replace(stripUidRegex, '');
if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
const event = storeElementEvent[keyHandlers];
removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
},
trigger(element, event, args) {
@ -303,13 +279,11 @@ const EventHandler = {
const $ = getjQuery();
const typeEvent = getTypeEvent(event);
const inNamespace = event !== typeEvent;
const isNative = nativeEvents.has(typeEvent);
let jQueryEvent;
let jQueryEvent = null;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
let evt = null;
if (inNamespace && $) {
jQueryEvent = $.Event(event, args);
@ -320,26 +294,8 @@ const EventHandler = {
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
if (isNative) {
evt = document.createEvent('HTMLEvents');
evt.initEvent(typeEvent, bubbles, true);
} else {
evt = new CustomEvent(event, {
bubbles,
cancelable: true,
});
}
// merge custom information in our event
if (typeof args !== 'undefined') {
Object.keys(args).forEach((key) => {
Object.defineProperty(evt, key, {
get() {
return args[key];
},
});
});
}
let evt = new Event(event, { bubbles, cancelable: true });
evt = hydrateObj(evt, args);
if (defaultPrevented) {
evt.preventDefault();
@ -349,7 +305,7 @@ const EventHandler = {
element.dispatchEvent(evt);
}
if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
if (evt.defaultPrevented && jQueryEvent) {
jQueryEvent.preventDefault();
}
@ -357,4 +313,21 @@ const EventHandler = {
},
};
function hydrateObj(obj, meta) {
for (const [key, value] of Object.entries(meta || {})) {
try {
obj[key] = value;
} catch {
Object.defineProperty(obj, key, {
configurable: true,
get() {
return value;
},
});
}
}
return obj;
}
export default EventHandler;

55
src/js/bootstrap/mdb-prefix/dom/manipulator.js
View File

@ -1,28 +1,36 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/manipulator.js
* Bootstrap (v5.2.2): dom/manipulator.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
function normalizeData(val) {
if (val === 'true') {
function normalizeData(value) {
if (value === 'true') {
return true;
}
if (val === 'false') {
if (value === 'false') {
return false;
}
if (val === Number(val).toString()) {
return Number(val);
if (value === Number(value).toString()) {
return Number(value);
}
if (val === '' || val === 'null') {
if (value === '' || value === 'null') {
return null;
}
return val;
if (typeof value !== 'string') {
return value;
}
try {
return JSON.parse(decodeURIComponent(value));
} catch {
return value;
}
}
function normalizeDataKey(key) {
@ -44,14 +52,15 @@ const Manipulator = {
}
const attributes = {};
const mdbKeys = Object.keys(element.dataset).filter(
(key) => key.startsWith('mdb') && !key.startsWith('mdbConfig')
);
Object.keys(element.dataset)
.filter((key) => key.startsWith('mdb'))
.forEach((key) => {
let pureKey = key.replace(/^mdb/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
});
for (const key of mdbKeys) {
let pureKey = key.replace(/^mdb/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
}
return attributes;
},
@ -59,22 +68,6 @@ const Manipulator = {
getDataAttribute(element, key) {
return normalizeData(element.getAttribute(`data-mdb-${normalizeDataKey(key)}`));
},
offset(element) {
const rect = element.getBoundingClientRect();
return {
top: rect.top + window.pageYOffset,
left: rect.left + window.pageXOffset,
};
},
position(element) {
return {
top: element.offsetTop,
left: element.offsetLeft,
};
},
};
export default Manipulator;

28
src/js/bootstrap/mdb-prefix/dom/selector-engine.js
View File

@ -1,19 +1,15 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/selector-engine.js
* Bootstrap (v5.2.2): dom/selector-engine.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
import { isDisabled, isVisible } from '../util/index';
const NODE_TEXT = 3;
/**
* Constants
*/
const SelectorEngine = {
find(selector, element = document.documentElement) {
@ -30,15 +26,11 @@ const SelectorEngine = {
parents(element, selector) {
const parents = [];
let ancestor = element.parentNode.closest(selector);
let ancestor = element.parentNode;
while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
if (ancestor.matches(selector)) {
parents.push(ancestor);
}
ancestor = ancestor.parentNode;
while (ancestor) {
parents.push(ancestor);
ancestor = ancestor.parentNode.closest(selector);
}
return parents;
@ -57,7 +49,7 @@ const SelectorEngine = {
return [];
},
// TODO: this is now unused; remove later along with prev()
next(element, selector) {
let next = element.nextElementSibling;
@ -84,7 +76,7 @@ const SelectorEngine = {
'[contenteditable="true"]',
]
.map((selector) => `${selector}:not([tabindex^="-"])`)
.join(', ');
.join(',');
return this.find(focusables, element).filter((el) => !isDisabled(el) && isVisible(el));
},

258
src/js/bootstrap/mdb-prefix/dropdown.js
View File

@ -1,23 +1,20 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dropdown.js
* Bootstrap (v5.2.2): dropdown.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import * as Popper from '@popperjs/core';
import {
defineJQueryPlugin,
getElement,
getElementFromSelector,
getNextActiveElement,
isDisabled,
isElement,
isRTL,
isVisible,
noop,
typeCheckConfig,
} from './util/index';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
@ -25,9 +22,7 @@ import SelectorEngine from './dom/selector-engine';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'dropdown';
@ -36,14 +31,11 @@ const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const ESCAPE_KEY = 'Escape';
const SPACE_KEY = 'Space';
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 REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY}`);
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
const EVENT_SHOW = `show${EVENT_KEY}`;
@ -56,10 +48,13 @@ const CLASS_NAME_SHOW = 'show';
const CLASS_NAME_DROPUP = 'dropup';
const CLASS_NAME_DROPEND = 'dropend';
const CLASS_NAME_DROPSTART = 'dropstart';
const CLASS_NAME_NAVBAR = 'navbar';
const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="dropdown"]';
const SELECTOR_DATA_TOGGLE = '[data-mdb-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)';
@ -69,43 +64,46 @@ const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
const PLACEMENT_TOPCENTER = 'top';
const PLACEMENT_BOTTOMCENTER = 'bottom';
const Default = {
offset: [0, 2],
boundary: 'clippingParents',
reference: 'toggle',
display: 'dynamic',
popperConfig: null,
autoClose: true,
boundary: 'clippingParents',
display: 'dynamic',
offset: [0, 2],
popperConfig: null,
reference: 'toggle',
};
const DefaultType = {
offset: '(array|string|function)',
boundary: '(string|element)',
reference: '(string|element|object)',
display: 'string',
popperConfig: '(null|object|function)',
autoClose: '(boolean|string)',
boundary: '(string|element)',
display: 'string',
offset: '(array|string|function)',
popperConfig: '(null|object|function)',
reference: '(string|element|object)',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Dropdown extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._popper = null;
this._config = this._getConfig(config);
this._menu = this._getMenuElement();
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.next(this._element, SELECTOR_MENU)[0] ||
SelectorEngine.prev(this._element, SELECTOR_MENU)[0] ||
SelectorEngine.findOne(SELECTOR_MENU, this._parent);
this._inNavbar = this._detectNavbar();
}
// Getters
static get Default() {
return Default;
}
@ -119,13 +117,12 @@ class Dropdown extends BaseComponent {
}
// Public
toggle() {
return this._isShown() ? this.hide() : this.show();
}
show() {
if (isDisabled(this._element) || this._isShown(this._menu)) {
if (isDisabled(this._element) || this._isShown()) {
return;
}
@ -139,22 +136,16 @@ class Dropdown extends BaseComponent {
return;
}
const parent = Dropdown.getParentFromElement(this._element);
// Totally disable Popper for Dropdowns in Navbar
if (this._inNavbar) {
Manipulator.setDataAttribute(this._menu, 'popper', 'none');
} else {
this._createPopper(parent);
}
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 && !parent.closest(SELECTOR_NAVBAR_NAV)) {
[]
.concat(...document.body.children)
.forEach((elem) => EventHandler.on(elem, 'mouseover', noop));
if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
for (const element of [].concat(...document.body.children)) {
EventHandler.on(element, 'mouseover', noop);
}
}
this._element.focus();
@ -166,7 +157,7 @@ class Dropdown extends BaseComponent {
}
hide() {
if (isDisabled(this._element) || !this._isShown(this._menu)) {
if (isDisabled(this._element) || !this._isShown()) {
return;
}
@ -193,7 +184,6 @@ class Dropdown extends BaseComponent {
}
// Private
_completeHide(relatedTarget) {
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE, relatedTarget);
if (hideEvent.defaultPrevented) {
@ -203,9 +193,9 @@ class Dropdown extends BaseComponent {
// 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((elem) => EventHandler.off(elem, 'mouseover', noop));
for (const element of [].concat(...document.body.children)) {
EventHandler.off(element, 'mouseover', noop);
}
}
if (this._popper) {
@ -220,13 +210,7 @@ class Dropdown extends BaseComponent {
}
_getConfig(config) {
config = {
...this.constructor.Default,
...Manipulator.getDataAttributes(this._element),
...config,
};
typeCheckConfig(NAME, config, this.constructor.DefaultType);
config = super._getConfig(config);
if (
typeof config.reference === 'object' &&
@ -242,7 +226,7 @@ class Dropdown extends BaseComponent {
return config;
}
_createPopper(parent) {
_createPopper() {
if (typeof Popper === 'undefined') {
throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
}
@ -250,7 +234,7 @@ class Dropdown extends BaseComponent {
let referenceElement = this._element;
if (this._config.reference === 'parent') {
referenceElement = parent;
referenceElement = this._parent;
} else if (isElement(this._config.reference)) {
referenceElement = getElement(this._config.reference);
} else if (typeof this._config.reference === 'object') {
@ -258,27 +242,15 @@ class Dropdown extends BaseComponent {
}
const popperConfig = this._getPopperConfig();
const isDisplayStatic = popperConfig.modifiers.find(
(modifier) => modifier.name === 'applyStyles' && modifier.enabled === false
);
this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);
if (isDisplayStatic) {
Manipulator.setDataAttribute(this._menu, 'popper', 'static');
}
}
_isShown(element = this._element) {
return element.classList.contains(CLASS_NAME_SHOW);
}
_getMenuElement() {
return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
_isShown() {
return this._menu.classList.contains(CLASS_NAME_SHOW);
}
_getPlacement() {
const parentDropdown = this._element.parentNode;
const parentDropdown = this._parent;
if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
return PLACEMENT_RIGHT;
@ -288,6 +260,14 @@ class Dropdown extends BaseComponent {
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';
@ -299,14 +279,14 @@ class Dropdown extends BaseComponent {
}
_detectNavbar() {
return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
return this._element.closest(SELECTOR_NAVBAR) !== null;
}
_getOffset() {
const { offset } = this._config;
if (typeof offset === 'string') {
return offset.split(',').map((val) => Number.parseInt(val, 10));
return offset.split(',').map((value) => Number.parseInt(value, 10));
}
if (typeof offset === 'function') {
@ -335,8 +315,9 @@ class Dropdown extends BaseComponent {
],
};
// Disable Popper if we have a static display
if (this._config.display === 'static') {
// Disable Popper if we have a static display or Dropdown is in Navbar
if (this._inNavbar || this._config.display === 'static') {
Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // todo:v6 remove
defaultBsPopperConfig.modifiers = [
{
name: 'applyStyles',
@ -354,7 +335,9 @@ class Dropdown extends BaseComponent {
}
_selectMenuItem({ key, target }) {
const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter((element) =>
isVisible(element)
);
if (!items.length) {
return;
@ -366,7 +349,6 @@ class Dropdown extends BaseComponent {
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Dropdown.getOrCreateInstance(this, config);
@ -384,123 +366,92 @@ class Dropdown extends BaseComponent {
}
static clearMenus(event) {
if (
event &&
(event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY))
) {
if (event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY)) {
return;
}
const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE);
const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
for (let i = 0, len = toggles.length; i < len; i++) {
const context = Dropdown.getInstance(toggles[i]);
for (const toggle of openToggles) {
const context = Dropdown.getInstance(toggle);
if (!context || context._config.autoClose === false) {
continue;
}
if (!context._isShown()) {
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;
}
const relatedTarget = {
relatedTarget: context._element,
};
// 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;
}
if (event) {
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;
}
const relatedTarget = { relatedTarget: context._element };
// 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;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
context._completeHide(relatedTarget);
}
}
static getParentFromElement(element) {
return getElementFromSelector(element) || element.parentNode;
}
static dataApiKeydownHandler(event) {
// If not input/textarea:
// - And not a key in REGEXP_KEYDOWN => not a dropdown command
// If input/textarea:
// - If space key => not a dropdown command
// - If key is other than escape
// - If key is not up or down => not a dropdown command
// - If trigger inside the menu => not a dropdown command
if (
/input|textarea/i.test(event.target.tagName)
? event.key === SPACE_KEY ||
(event.key !== ESCAPE_KEY &&
((event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY) ||
event.target.closest(SELECTOR_MENU)))
: !REGEXP_KEYDOWN.test(event.key)
) {
// 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;
}
const isActive = this.classList.contains(CLASS_NAME_SHOW);
if (!isActive && event.key === ESCAPE_KEY) {
if (isInput && !isEscapeEvent) {
return;
}
event.preventDefault();
event.stopPropagation();
if (isDisabled(this)) {
return;
}
// todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/
const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE)
? this
: SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0];
: SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0] ||
SelectorEngine.next(this, SELECTOR_DATA_TOGGLE)[0] ||
SelectorEngine.findOne(SELECTOR_DATA_TOGGLE, event.delegateTarget.parentNode);
const instance = Dropdown.getOrCreateInstance(getToggleButton);
if (event.key === ESCAPE_KEY) {
instance.hide();
return;
}
if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
if (!isActive) {
instance.show();
}
if (isUpOrDownEvent) {
event.stopPropagation();
instance.show();
instance._selectMenuItem(event);
return;
}
if (!isActive || event.key === SPACE_KEY) {
Dropdown.clearMenus();
if (instance._isShown()) {
// else is escape and we check if it is shown
event.stopPropagation();
instance.hide();
getToggleButton.focus();
}
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(
@ -518,10 +469,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Dropdown to jQuery only if jQuery is present
*/
defineJQueryPlugin(Dropdown);

252
src/js/bootstrap/mdb-prefix/modal.js
View File

@ -1,20 +1,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): modal.js
* Bootstrap (v5.2.2): modal.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import {
defineJQueryPlugin,
getElementFromSelector,
isRTL,
isVisible,
reflow,
typeCheckConfig,
} from './util/index';
import { defineJQueryPlugin, getElementFromSelector, isRTL, isVisible, reflow } from './util/index';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
import SelectorEngine from './dom/selector-engine';
import ScrollBarHelper from './util/scrollbar';
import BaseComponent from './base-component';
@ -23,9 +15,7 @@ import FocusTrap from './util/focustrap';
import { enableDismissTrigger } from './util/component-functions';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'modal';
@ -34,18 +24,6 @@ const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const ESCAPE_KEY = 'Escape';
const Default = {
backdrop: true,
keyboard: true,
focus: true,
};
const DefaultType = {
backdrop: '(boolean|string)',
keyboard: 'boolean',
focus: 'boolean',
};
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
@ -53,9 +31,8 @@ const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_RESIZE = `resize${EVENT_KEY}`;
const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`;
const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`;
const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY}`;
const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY}`;
const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
const CLASS_NAME_OPEN = 'modal-open';
@ -68,38 +45,50 @@ const SELECTOR_DIALOG = '.modal-dialog';
const SELECTOR_MODAL_BODY = '.modal-body';
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="modal"]';
const Default = {
backdrop: true,
focus: true,
keyboard: true,
};
const DefaultType = {
backdrop: '(boolean|string)',
focus: 'boolean',
keyboard: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Modal extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._config = this._getConfig(config);
this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
this._backdrop = this._initializeBackDrop();
this._focustrap = this._initializeFocusTrap();
this._isShown = false;
this._ignoreBackdropClick = false;
this._isTransitioning = false;
this._scrollBar = new ScrollBarHelper();
this._addEventListeners();
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
toggle(relatedTarget) {
return this._isShown ? this.hide() : this.show(relatedTarget);
}
@ -118,10 +107,7 @@ class Modal extends BaseComponent {
}
this._isShown = true;
if (this._isAnimated()) {
this._isTransitioning = true;
}
this._isTransitioning = true;
this._scrollBar.hide();
@ -129,18 +115,7 @@ class Modal extends BaseComponent {
this._adjustDialog();
this._setEscapeEvent();
this._setResizeEvent();
EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => {
EventHandler.one(this._element, EVENT_MOUSEUP_DISMISS, (event) => {
if (event.target === this._element) {
this._ignoreBackdropClick = true;
}
});
});
this._showBackdrop(() => this._showElement(relatedTarget));
this._backdrop.show(() => this._showElement(relatedTarget));
}
hide() {
@ -155,27 +130,18 @@ class Modal extends BaseComponent {
}
this._isShown = false;
const isAnimated = this._isAnimated();
if (isAnimated) {
this._isTransitioning = true;
}
this._setEscapeEvent();
this._setResizeEvent();
this._isTransitioning = true;
this._focustrap.deactivate();
this._element.classList.remove(CLASS_NAME_SHOW);
EventHandler.off(this._element, EVENT_CLICK_DISMISS);
EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
this._queueCallback(() => this._hideModal(), this._element, isAnimated);
this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
}
dispose() {
[window, this._dialog].forEach((htmlElement) => EventHandler.off(htmlElement, EVENT_KEY));
for (const htmlElement of [window, this._dialog]) {
EventHandler.off(htmlElement, EVENT_KEY);
}
this._backdrop.dispose();
this._focustrap.deactivate();
@ -187,10 +153,9 @@ class Modal extends BaseComponent {
}
// Private
_initializeBackDrop() {
return new Backdrop({
isVisible: Boolean(this._config.backdrop), // 'static' option will be translated to true, and booleans will keep their value
isVisible: Boolean(this._config.backdrop) && Boolean(!this._config.modalNonInvasive), // 'static' option will be translated to true, and booleans will keep their value,
isAnimated: this._isAnimated(),
});
}
@ -201,22 +166,9 @@ class Modal extends BaseComponent {
});
}
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' ? config : {}),
};
typeCheckConfig(NAME, config, DefaultType);
return config;
}
_showElement(relatedTarget) {
const isAnimated = this._isAnimated();
const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
// Don't move modal's DOM position
// try to append dynamic modal
if (!document.body.contains(this._element)) {
document.body.append(this._element);
}
@ -226,13 +178,12 @@ class Modal extends BaseComponent {
this._element.setAttribute('role', 'dialog');
this._element.scrollTop = 0;
const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
if (modalBody) {
modalBody.scrollTop = 0;
}
if (isAnimated) {
reflow(this._element);
}
reflow(this._element);
this._element.classList.add(CLASS_NAME_SHOW);
@ -247,30 +198,47 @@ class Modal extends BaseComponent {
});
};
this._queueCallback(transitionComplete, this._dialog, isAnimated);
this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
}
_setEscapeEvent() {
if (this._isShown) {
EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
if (this._config.keyboard && event.key === ESCAPE_KEY) {
event.preventDefault();
this.hide();
} else if (!this._config.keyboard && event.key === ESCAPE_KEY) {
_addEventListeners() {
EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
if (event.key !== ESCAPE_KEY) {
return;
}
if (this._config.keyboard) {
event.preventDefault();
this.hide();
return;
}
this._triggerBackdropTransition();
});
EventHandler.on(window, EVENT_RESIZE, () => {
if (this._isShown && !this._isTransitioning) {
this._adjustDialog();
}
});
EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, (event) => {
// a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
EventHandler.one(this._element, EVENT_CLICK_DISMISS, (event2) => {
if (this._element !== event.target || this._element !== event2.target) {
return;
}
if (this._config.backdrop === 'static') {
this._triggerBackdropTransition();
return;
}
if (this._config.backdrop) {
this.hide();
}
});
} else {
EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS);
}
}
_setResizeEvent() {
if (this._isShown) {
EventHandler.on(window, EVENT_RESIZE, () => this._adjustDialog());
} else {
EventHandler.off(window, EVENT_RESIZE);
}
});
}
_hideModal() {
@ -279,6 +247,7 @@ class Modal extends BaseComponent {
this._element.removeAttribute('aria-modal');
this._element.removeAttribute('role');
this._isTransitioning = false;
this._backdrop.hide(() => {
document.body.classList.remove(CLASS_NAME_OPEN);
this._resetAdjustments();
@ -287,27 +256,6 @@ class Modal extends BaseComponent {
});
}
_showBackdrop(callback) {
EventHandler.on(this._element, EVENT_CLICK_DISMISS, (event) => {
if (this._ignoreBackdropClick) {
this._ignoreBackdropClick = false;
return;
}
if (event.target !== event.currentTarget) {
return;
}
if (this._config.backdrop === true) {
this.hide();
} else if (this._config.backdrop === 'static') {
this._triggerBackdropTransition();
}
});
this._backdrop.show(callback);
}
_isAnimated() {
return this._element.classList.contains(CLASS_NAME_FADE);
}
@ -318,55 +266,45 @@ class Modal extends BaseComponent {
return;
}
const { classList, scrollHeight, style } = this._element;
const isModalOverflowing = scrollHeight > document.documentElement.clientHeight;
const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
const initialOverflowY = this._element.style.overflowY;
// return if the following background transition hasn't yet completed
if (
(!isModalOverflowing && style.overflowY === 'hidden') ||
classList.contains(CLASS_NAME_STATIC)
) {
if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
return;
}
if (!isModalOverflowing) {
style.overflowY = 'hidden';
this._element.style.overflowY = 'hidden';
}
classList.add(CLASS_NAME_STATIC);
this._element.classList.add(CLASS_NAME_STATIC);
this._queueCallback(() => {
classList.remove(CLASS_NAME_STATIC);
if (!isModalOverflowing) {
this._queueCallback(() => {
style.overflowY = '';
}, this._dialog);
}
this._element.classList.remove(CLASS_NAME_STATIC);
this._queueCallback(() => {
this._element.style.overflowY = initialOverflowY;
}, this._dialog);
}, this._dialog);
this._element.focus();
}
// ----------------------------------------------------------------------
// the following methods are used to handle overflowing modals
// ----------------------------------------------------------------------
/**
* The following methods are used to handle overflowing modals
*/
_adjustDialog() {
const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
const scrollbarWidth = this._scrollBar.getWidth();
const isBodyOverflowing = scrollbarWidth > 0;
if (
(!isBodyOverflowing && isModalOverflowing && !isRTL()) ||
(isBodyOverflowing && !isModalOverflowing && isRTL())
) {
this._element.style.paddingLeft = `${scrollbarWidth}px`;
if (isBodyOverflowing && !isModalOverflowing) {
const property = isRTL() ? 'paddingLeft' : 'paddingRight';
this._element.style[property] = `${scrollbarWidth}px`;
}
if (
(isBodyOverflowing && !isModalOverflowing && !isRTL()) ||
(!isBodyOverflowing && isModalOverflowing && isRTL())
) {
this._element.style.paddingRight = `${scrollbarWidth}px`;
if (!isBodyOverflowing && isModalOverflowing) {
const property = isRTL() ? 'paddingRight' : 'paddingLeft';
this._element.style[property] = `${scrollbarWidth}px`;
}
}
@ -376,7 +314,6 @@ class Modal extends BaseComponent {
}
// Static
static jQueryInterface(config, relatedTarget) {
return this.each(function () {
const data = Modal.getOrCreateInstance(this, config);
@ -395,9 +332,7 @@ class Modal extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
@ -420,7 +355,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
});
});
// avoid conflict when clicking moddal toggler while another one is open
// avoid conflict when clicking modal toggler while another one is open
const allreadyOpenedModals = SelectorEngine.find(OPEN_SELECTOR);
allreadyOpenedModals.forEach((modal) => {
if (!modal.classList.contains('modal-non-invasive-show')) {
@ -436,10 +371,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
enableDismissTrigger(Modal);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Modal to jQuery only if jQuery is present
*/
defineJQueryPlugin(Modal);

146
src/js/bootstrap/mdb-prefix/offcanvas.js
View File

@ -1,30 +1,21 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): offcanvas.js
* Bootstrap (v5.2.2): offcanvas.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import {
defineJQueryPlugin,
getElementFromSelector,
isDisabled,
isVisible,
typeCheckConfig,
} from './util/index';
import { defineJQueryPlugin, getElementFromSelector, isDisabled, isVisible } from './util/index';
import ScrollBarHelper from './util/scrollbar';
import EventHandler from './dom/event-handler';
import BaseComponent from './base-component';
import SelectorEngine from './dom/selector-engine';
import Manipulator from './dom/manipulator';
import Backdrop from './util/backdrop';
import FocusTrap from './util/focustrap';
import { enableDismissTrigger } from './util/component-functions';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'offcanvas';
@ -34,6 +25,23 @@ const DATA_API_KEY = '.data-api';
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`;
const ESCAPE_KEY = 'Escape';
const CLASS_NAME_SHOW = 'show';
const CLASS_NAME_SHOWING = 'showing';
const CLASS_NAME_HIDING = 'hiding';
const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
const OPEN_SELECTOR = '.offcanvas.show';
const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
const EVENT_RESIZE = `resize${EVENT_KEY}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`;
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="offcanvas"]';
const Default = {
backdrop: true,
keyboard: true,
@ -41,35 +49,19 @@ const Default = {
};
const DefaultType = {
backdrop: 'boolean',
backdrop: '(boolean|string)',
keyboard: 'boolean',
scroll: 'boolean',
};
const CLASS_NAME_SHOW = 'show';
const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
const OPEN_SELECTOR = '.offcanvas.show';
const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`;
const SELECTOR_DATA_TOGGLE = '[data-mdb-toggle="offcanvas"]';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Offcanvas extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._config = this._getConfig(config);
this._isShown = false;
this._backdrop = this._initializeBackDrop();
this._focustrap = this._initializeFocusTrap();
@ -77,17 +69,19 @@ class Offcanvas extends BaseComponent {
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
static get Default() {
return Default;
}
// Public
toggle(relatedTarget) {
return this._isShown ? this.hide() : this.show(relatedTarget);
}
@ -104,24 +98,23 @@ class Offcanvas extends BaseComponent {
}
this._isShown = true;
this._element.style.visibility = 'visible';
this._backdrop.show();
if (!this._config.scroll) {
new ScrollBarHelper().hide();
}
this._element.removeAttribute('aria-hidden');
this._element.setAttribute('aria-modal', true);
this._element.setAttribute('role', 'dialog');
this._element.classList.add(CLASS_NAME_SHOW);
this._element.classList.add(CLASS_NAME_SHOWING);
const completeCallBack = () => {
if (!this._config.scroll) {
if (!this._config.scroll || this._config.backdrop) {
this._focustrap.activate();
}
this._element.classList.add(CLASS_NAME_SHOW);
this._element.classList.remove(CLASS_NAME_SHOWING);
EventHandler.trigger(this._element, EVENT_SHOWN, { relatedTarget });
};
@ -142,14 +135,13 @@ class Offcanvas extends BaseComponent {
this._focustrap.deactivate();
this._element.blur();
this._isShown = false;
this._element.classList.remove(CLASS_NAME_SHOW);
this._element.classList.add(CLASS_NAME_HIDING);
this._backdrop.hide();
const completeCallback = () => {
this._element.setAttribute('aria-hidden', true);
this._element.classList.remove(CLASS_NAME_SHOW, CLASS_NAME_HIDING);
this._element.removeAttribute('aria-modal');
this._element.removeAttribute('role');
this._element.style.visibility = 'hidden';
if (!this._config.scroll) {
new ScrollBarHelper().reset();
@ -168,24 +160,25 @@ class Offcanvas extends BaseComponent {
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' ? config : {}),
};
typeCheckConfig(NAME, config, DefaultType);
return config;
}
_initializeBackDrop() {
const clickCallback = () => {
if (this._config.backdrop === 'static') {
EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
return;
}
this.hide();
};
// 'static' option will be translated to true, and booleans will keep their value
const isVisible = Boolean(this._config.backdrop);
return new Backdrop({
className: CLASS_NAME_BACKDROP,
isVisible: this._config.backdrop,
isVisible,
isAnimated: true,
rootElement: this._element.parentNode,
clickCallback: () => this.hide(),
clickCallback: isVisible ? clickCallback : null,
});
}
@ -197,14 +190,20 @@ class Offcanvas extends BaseComponent {
_addEventListeners() {
EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
if (this._config.keyboard && event.key === ESCAPE_KEY) {
this.hide();
if (event.key !== ESCAPE_KEY) {
return;
}
if (!this._config.keyboard) {
EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
return;
}
this.hide();
});
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Offcanvas.getOrCreateInstance(this, config);
@ -223,9 +222,7 @@ class Offcanvas extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
@ -247,24 +244,33 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
});
// avoid conflict when clicking a toggler of an offcanvas, while another is open
const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
if (allReadyOpen && allReadyOpen !== target) {
Offcanvas.getInstance(allReadyOpen).hide();
const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
if (alreadyOpen && alreadyOpen !== target) {
Offcanvas.getInstance(alreadyOpen).hide();
}
const data = Offcanvas.getOrCreateInstance(target);
data.toggle(this);
});
EventHandler.on(window, EVENT_LOAD_DATA_API, () =>
SelectorEngine.find(OPEN_SELECTOR).forEach((el) => Offcanvas.getOrCreateInstance(el).show())
);
EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {
Offcanvas.getOrCreateInstance(selector).show();
}
});
EventHandler.on(window, EVENT_RESIZE, () => {
for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {
if (getComputedStyle(element).position !== 'fixed') {
Offcanvas.getOrCreateInstance(element).hide();
}
}
});
enableDismissTrigger(Offcanvas);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
*/
defineJQueryPlugin(Offcanvas);

87
src/js/bootstrap/mdb-prefix/popover.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): popover.js
* Bootstrap (v5.2.2): popover.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -9,119 +9,88 @@ import { defineJQueryPlugin } from './util/index';
import Tooltip from './tooltip';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'popover';
const DATA_KEY = 'bs.popover';
const EVENT_KEY = `.${DATA_KEY}`;
const CLASS_PREFIX = 'bs-popover';
const SELECTOR_TITLE = '.popover-header';
const SELECTOR_CONTENT = '.popover-body';
const Default = {
...Tooltip.Default,
placement: 'right',
offset: [0, 8],
trigger: 'click',
content: '',
offset: [0, 8],
placement: 'right',
template:
'<div class="popover" role="tooltip">' +
'<div class="popover-arrow"></div>' +
'<h3 class="popover-header"></h3>' +
'<div class="popover-body"></div>' +
'</div>',
trigger: 'click',
};
const DefaultType = {
...Tooltip.DefaultType,
content: '(string|element|function)',
content: '(null|string|element|function)',
};
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 SELECTOR_TITLE = '.popover-header';
const SELECTOR_CONTENT = '.popover-body';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Popover extends Tooltip {
// Getters
static get Default() {
return Default;
}
static get NAME() {
return NAME;
}
static get Event() {
return Event;
}
static get DefaultType() {
return DefaultType;
}
// Overrides
isWithContent() {
return this.getTitle() || this._getContent();
static get NAME() {
return NAME;
}
setContent(tip) {
this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE);
this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT);
// Overrides
_isWithContent() {
return this._getTitle() || this._getContent();
}
// Private
_getContentForTemplate() {
return {
[SELECTOR_TITLE]: this._getTitle(),
[SELECTOR_CONTENT]: this._getContent(),
};
}
_getContent() {
return this._resolvePossibleFunction(this._config.content);
}
_getBasicClassPrefix() {
return CLASS_PREFIX;
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Popover.getOrCreateInstance(this, config);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Popover to jQuery only if jQuery is present
*/
defineJQueryPlugin(Popover);

378
src/js/bootstrap/mdb-prefix/scrollspy.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): scrollspy.js
* Bootstrap (v5.2.2): scrollspy.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,18 +8,16 @@
import {
defineJQueryPlugin,
getElement,
isDisabled,
isVisible,
getSelectorFromElement,
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';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'scrollspy';
@ -27,234 +25,258 @@ const DATA_KEY = 'bs.scrollspy';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const Default = {
offset: 10,
method: 'auto',
target: '',
};
const DefaultType = {
offset: 'number',
method: 'string',
target: '(string|element)',
};
const EVENT_ACTIVATE = `activate${EVENT_KEY}`;
const EVENT_SCROLL = `scroll${EVENT_KEY}`;
const EVENT_CLICK = `click${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`;
const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
const CLASS_NAME_ACTIVE = 'active';
const SELECTOR_DATA_SPY = '[data-mdb-spy="scroll"]';
const SELECTOR_TARGET_LINKS = '[href]';
const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
const SELECTOR_NAV_LINKS = '.nav-link';
const SELECTOR_NAV_ITEMS = '.nav-item';
const SELECTOR_LIST_ITEMS = '.list-group-item';
const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}, .${CLASS_NAME_DROPDOWN_ITEM}`;
const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
const SELECTOR_DROPDOWN = '.dropdown';
const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
const METHOD_OFFSET = 'offset';
const METHOD_POSITION = 'position';
const Default = {
offset: null, // TODO: v6 @deprecated, keep it for backwards compatibility reasons
rootMargin: '0px 0px -25%',
smoothScroll: false,
target: null,
threshold: [0.1, 0.5, 1],
};
const DefaultType = {
offset: '(number|null)', // TODO v6 @deprecated, keep it for backwards compatibility reasons
rootMargin: 'string',
smoothScroll: 'boolean',
target: 'element',
threshold: 'array',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class ScrollSpy extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
if (!getSelectorFromElement(element)) {
return;
}
this._scrollElement = this._element.tagName === 'BODY' ? window : this._element;
this._config = this._getConfig(config);
this._offsets = [];
this._targets = [];
// this._element is the observablesContainer and config.target the menu links wrapper
this._targetLinks = new Map();
this._observableSections = new Map();
this._rootElement =
getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;
this._activeTarget = null;
this._scrollHeight = 0;
EventHandler.on(this._scrollElement, EVENT_SCROLL, () => this._process());
this.refresh();
this._process();
this._observer = null;
this._previousScrollData = {
visibleEntryTop: 0,
parentScrollTop: 0,
};
this.refresh(); // initialize
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
refresh() {
const autoMethod =
this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
this._initializeTargetsAndObservables();
this._maybeEnableSmoothScroll();
const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
if (this._observer) {
this._observer.disconnect();
} else {
this._observer = this._getNewObserver();
}
const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
this._offsets = [];
this._targets = [];
this._scrollHeight = this._getScrollHeight();
const targets = SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target);
targets
.map((element) => {
const targetSelector = getSelectorFromElement(element);
const target = targetSelector ? SelectorEngine.findOne(targetSelector) : null;
if (target) {
const targetBCR = target.getBoundingClientRect();
if (targetBCR.width || targetBCR.height) {
return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector];
}
}
return null;
})
.filter((item) => item)
.sort((a, b) => a[0] - b[0])
.forEach((item) => {
this._offsets.push(item[0]);
this._targets.push(item[1]);
});
for (const section of this._observableSections.values()) {
this._observer.observe(section);
}
}
dispose() {
EventHandler.off(this._scrollElement, EVENT_KEY);
if (this._observer) {
this._observer.disconnect();
}
super.dispose();
}
// Private
_configAfterMerge(config) {
// TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
config.target = getElement(config.target) || document.body;
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' && config ? config : {}),
};
// TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;
config.target = getElement(config.target) || document.documentElement;
typeCheckConfig(NAME, config, DefaultType);
if (typeof config.threshold === 'string') {
config.threshold = config.threshold.split(',').map((value) => Number.parseFloat(value));
}
return config;
}
_getScrollTop() {
return this._scrollElement === window
? this._scrollElement.pageYOffset
: this._scrollElement.scrollTop;
}
_getScrollHeight() {
return (
this._scrollElement.scrollHeight ||
Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)
);
}
_getOffsetHeight() {
return this._scrollElement === window
? window.innerHeight
: this._scrollElement.getBoundingClientRect().height;
}
_process() {
const scrollTop = this._getScrollTop() + this._config.offset;
const scrollHeight = this._getScrollHeight();
const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
if (this._scrollHeight !== scrollHeight) {
this.refresh();
}
if (scrollTop >= maxScroll) {
const target = this._targets[this._targets.length - 1];
if (this._activeTarget !== target) {
this._activate(target);
}
_maybeEnableSmoothScroll() {
if (!this._config.smoothScroll) {
return;
}
if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
this._activeTarget = null;
this._clear();
return;
}
// unregister any previous listeners
EventHandler.off(this._config.target, EVENT_CLICK);
for (let i = this._offsets.length; i--; ) {
const isActiveTarget =
this._activeTarget !== this._targets[i] &&
scrollTop >= this._offsets[i] &&
(typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, (event) => {
const observableSection = this._observableSections.get(event.target.hash);
if (observableSection) {
event.preventDefault();
const root = this._rootElement || window;
const height = observableSection.offsetTop - this._element.offsetTop;
if (root.scrollTo) {
root.scrollTo({ top: height, behavior: 'smooth' });
return;
}
if (isActiveTarget) {
this._activate(this._targets[i]);
// Chrome 60 doesn't support `scrollTo`
root.scrollTop = height;
}
}
}
_activate(target) {
this._activeTarget = target;
this._clear();
const queries = SELECTOR_LINK_ITEMS.split(',').map(
(selector) => `${selector}[data-mdb-target="${target}"],${selector}[href="${target}"]`
);
const link = SelectorEngine.findOne(queries.join(','), this._config.target);
link.classList.add(CLASS_NAME_ACTIVE);
if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
SelectorEngine.findOne(
SELECTOR_DROPDOWN_TOGGLE,
link.closest(SELECTOR_DROPDOWN)
).classList.add(CLASS_NAME_ACTIVE);
} else {
SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP).forEach((listGroup) => {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
SelectorEngine.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`).forEach(
(item) => item.classList.add(CLASS_NAME_ACTIVE)
);
// Handle special case when .nav-link is inside .nav-item
SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach((navItem) => {
SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach((item) =>
item.classList.add(CLASS_NAME_ACTIVE)
);
});
});
}
EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, {
relatedTarget: target,
});
}
_clear() {
SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target)
.filter((node) => node.classList.contains(CLASS_NAME_ACTIVE))
.forEach((node) => node.classList.remove(CLASS_NAME_ACTIVE));
_getNewObserver() {
const options = {
root: this._rootElement,
threshold: this._config.threshold,
rootMargin: this._config.rootMargin,
};
return new IntersectionObserver((entries) => this._observerCallback(entries), options);
}
// The logic of selection
_observerCallback(entries) {
const targetElement = (entry) => this._targetLinks.get(`#${entry.target.id}`);
const activate = (entry) => {
this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
this._process(targetElement(entry));
};
const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
this._previousScrollData.parentScrollTop = parentScrollTop;
for (const entry of entries) {
if (!entry.isIntersecting) {
this._activeTarget = null;
this._clearActiveClass(targetElement(entry));
continue;
}
const entryIsLowerThanPrevious =
entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;
// if we are scrolling down, pick the bigger offsetTop
if (userScrollsDown && entryIsLowerThanPrevious) {
activate(entry);
// if parent isn't scrolled, let's keep the first visible item, breaking the iteration
if (!parentScrollTop) {
return;
}
continue;
}
// if we are scrolling up, pick the smallest offsetTop
if (!userScrollsDown && !entryIsLowerThanPrevious) {
activate(entry);
}
}
}
_initializeTargetsAndObservables() {
this._targetLinks = new Map();
this._observableSections = new Map();
const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);
for (const anchor of targetLinks) {
// ensure that the anchor has an id and is not disabled
if (!anchor.hash || isDisabled(anchor)) {
continue;
}
const observableSection = SelectorEngine.findOne(anchor.hash, this._element);
// ensure that the observableSection exists & is visible
if (isVisible(observableSection)) {
this._targetLinks.set(anchor.hash, anchor);
this._observableSections.set(anchor.hash, observableSection);
}
}
}
_process(target) {
if (this._activeTarget === target) {
return;
}
this._clearActiveClass(this._config.target);
this._activeTarget = target;
target.classList.add(CLASS_NAME_ACTIVE);
this._activateParents(target);
EventHandler.trigger(this._element, EVENT_ACTIVATE, { relatedTarget: target });
}
_activateParents(target) {
// Activate dropdown parents
if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
SelectorEngine.findOne(
SELECTOR_DROPDOWN_TOGGLE,
target.closest(SELECTOR_DROPDOWN)
).classList.add(CLASS_NAME_ACTIVE);
return;
}
for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
// Set triggered links parents as active
// With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
item.classList.add(CLASS_NAME_ACTIVE);
}
}
}
_clearActiveClass(parent) {
parent.classList.remove(CLASS_NAME_ACTIVE);
const activeNodes = SelectorEngine.find(
`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE}`,
parent
);
for (const node of activeNodes) {
node.classList.remove(CLASS_NAME_ACTIVE);
}
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = ScrollSpy.getOrCreateInstance(this, config);
@ -263,7 +285,7 @@ class ScrollSpy extends BaseComponent {
return;
}
if (typeof data[config] === 'undefined') {
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
@ -273,21 +295,17 @@ class ScrollSpy extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
// EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
// SelectorEngine.find(SELECTOR_DATA_SPY)
// .forEach(spy => new ScrollSpy(spy))
// })
EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
ScrollSpy.getOrCreateInstance(spy);
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .ScrollSpy to jQuery only if jQuery is present
*/
defineJQueryPlugin(ScrollSpy);

358
src/js/bootstrap/mdb-prefix/tab.js
View File

@ -1,208 +1,294 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): tab.js
* Bootstrap (v5.2.2): tab.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import { defineJQueryPlugin, getElementFromSelector, isDisabled, reflow } from './util/index';
import {
defineJQueryPlugin,
getElementFromSelector,
getNextActiveElement,
isDisabled,
} from './util/index';
import EventHandler from './dom/event-handler';
import SelectorEngine from './dom/selector-engine';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'tab';
const DATA_KEY = 'bs.tab';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
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_CLICK_DATA_API = `click${EVENT_KEY}`;
const EVENT_KEYDOWN = `keydown${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}`;
const ARROW_LEFT_KEY = 'ArrowLeft';
const ARROW_RIGHT_KEY = 'ArrowRight';
const ARROW_UP_KEY = 'ArrowUp';
const ARROW_DOWN_KEY = 'ArrowDown';
const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
const CLASS_NAME_ACTIVE = 'active';
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
const CLASS_DROPDOWN = 'dropdown';
const SELECTOR_DROPDOWN = '.dropdown';
const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
const SELECTOR_ACTIVE = '.active';
const SELECTOR_ACTIVE_UL = ':scope > li > .active';
const SELECTOR_DATA_TOGGLE =
'[data-mdb-toggle="tab"], [data-mdb-toggle="pill"], [data-mdb-toggle="list"]';
const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
const NOT_SELECTOR_DROPDOWN_TOGGLE = ':not(.dropdown-toggle)';
const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
const SELECTOR_OUTER = '.nav-item, .list-group-item';
const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
const SELECTOR_DATA_TOGGLE =
'[data-mdb-toggle="tab"], [data-mdb-toggle="pill"], [data-mdb-toggle="list"]'; // todo:v6: could be only `tab`
const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-mdb-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-mdb-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-mdb-toggle="list"]`;
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Tab extends BaseComponent {
// Getters
constructor(element) {
super(element);
this._parent = this._element.closest(SELECTOR_TAB_PANEL);
if (!this._parent) {
return;
// todo: should Throw exception on v6
// throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
}
// Set up initial aria attributes
this._setInitialAttributes(this._parent, this._getChildren());
EventHandler.on(this._element, EVENT_KEYDOWN, (event) => this._keydown(event));
}
// Getters
static get NAME() {
return NAME;
}
// Public
show() {
if (
this._element.parentNode &&
this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
this._element.classList.contains(CLASS_NAME_ACTIVE)
) {
// Shows this elem and deactivate the active sibling if exists
const innerElem = this._element;
if (this._elemIsActive(innerElem)) {
return;
}
let previous;
const target = getElementFromSelector(this._element);
const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);
// Search for active tab on same parent to deactivate it
const active = this._getActiveElem();
if (listElement) {
const itemSelector =
listElement.nodeName === 'UL' || listElement.nodeName === 'OL'
? SELECTOR_ACTIVE_UL
: SELECTOR_ACTIVE;
previous = SelectorEngine.find(itemSelector, listElement);
previous = previous[previous.length - 1];
}
const hideEvent = previous
? EventHandler.trigger(previous, EVENT_HIDE, {
relatedTarget: this._element,
})
const hideEvent = active
? EventHandler.trigger(active, EVENT_HIDE, { relatedTarget: innerElem })
: null;
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, {
relatedTarget: previous,
});
const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW, { relatedTarget: active });
if (showEvent.defaultPrevented || (hideEvent !== null && hideEvent.defaultPrevented)) {
if (showEvent.defaultPrevented || (hideEvent && hideEvent.defaultPrevented)) {
return;
}
this._activate(this._element, listElement);
const complete = () => {
EventHandler.trigger(previous, EVENT_HIDDEN, {
relatedTarget: this._element,
});
EventHandler.trigger(this._element, EVENT_SHOWN, {
relatedTarget: previous,
});
};
if (target) {
this._activate(target, target.parentNode, complete);
} else {
complete();
}
this._deactivate(active, innerElem);
this._activate(innerElem, active);
}
// Private
_activate(element, container, callback) {
const activeElements =
container && (container.nodeName === 'UL' || container.nodeName === 'OL')
? SelectorEngine.find(SELECTOR_ACTIVE_UL, container)
: SelectorEngine.children(container, SELECTOR_ACTIVE);
const active = activeElements[0];
const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE);
const complete = () => this._transitionComplete(element, active, callback);
if (active && isTransitioning) {
active.classList.remove(CLASS_NAME_SHOW);
this._queueCallback(complete, element, true);
} else {
complete();
}
}
_transitionComplete(element, active, callback) {
if (active) {
active.classList.remove(CLASS_NAME_ACTIVE);
const dropdownChild = SelectorEngine.findOne(
SELECTOR_DROPDOWN_ACTIVE_CHILD,
active.parentNode
);
if (dropdownChild) {
dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
}
if (active.getAttribute('role') === 'tab') {
active.setAttribute('aria-selected', false);
}
_activate(element, relatedElem) {
if (!element) {
return;
}
element.classList.add(CLASS_NAME_ACTIVE);
if (element.getAttribute('role') === 'tab') {
element.setAttribute('aria-selected', true);
}
reflow(element);
this._activate(getElementFromSelector(element)); // Search and activate/show the proper section
if (element.classList.contains(CLASS_NAME_FADE)) {
element.classList.add(CLASS_NAME_SHOW);
}
let parent = element.parentNode;
if (parent && parent.nodeName === 'LI') {
parent = parent.parentNode;
}
if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
const dropdownElement = element.closest(SELECTOR_DROPDOWN);
if (dropdownElement) {
SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach((dropdown) =>
dropdown.classList.add(CLASS_NAME_ACTIVE)
);
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.add(CLASS_NAME_SHOW);
return;
}
element.setAttribute('aria-expanded', true);
element.removeAttribute('tabindex');
element.setAttribute('aria-selected', true);
this._toggleDropDown(element, true);
EventHandler.trigger(element, EVENT_SHOWN, {
relatedTarget: relatedElem,
});
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE));
}
_deactivate(element, relatedElem) {
if (!element) {
return;
}
if (callback) {
callback();
element.classList.remove(CLASS_NAME_ACTIVE);
element.blur();
this._deactivate(getElementFromSelector(element)); // Search and deactivate the shown section too
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.remove(CLASS_NAME_SHOW);
return;
}
element.setAttribute('aria-selected', false);
element.setAttribute('tabindex', '-1');
this._toggleDropDown(element, false);
EventHandler.trigger(element, EVENT_HIDDEN, { relatedTarget: relatedElem });
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE));
}
_keydown(event) {
if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key)) {
return;
}
event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
event.preventDefault();
const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
const nextActiveElement = getNextActiveElement(
this._getChildren().filter((element) => !isDisabled(element)),
event.target,
isNext,
true
);
if (nextActiveElement) {
nextActiveElement.focus({ preventScroll: true });
Tab.getOrCreateInstance(nextActiveElement).show();
}
}
// Static
_getChildren() {
// collection of inner elements
return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent);
}
_getActiveElem() {
return this._getChildren().find((child) => this._elemIsActive(child)) || null;
}
_setInitialAttributes(parent, children) {
this._setAttributeIfNotExists(parent, 'role', 'tablist');
for (const child of children) {
this._setInitialAttributesOnChild(child);
}
}
_setInitialAttributesOnChild(child) {
child = this._getInnerElement(child);
const isActive = this._elemIsActive(child);
const outerElem = this._getOuterElement(child);
child.setAttribute('aria-selected', isActive);
if (outerElem !== child) {
this._setAttributeIfNotExists(outerElem, 'role', 'presentation');
}
if (!isActive) {
child.setAttribute('tabindex', '-1');
}
this._setAttributeIfNotExists(child, 'role', 'tab');
// set attributes to the related panel too
this._setInitialAttributesOnTargetPanel(child);
}
_setInitialAttributesOnTargetPanel(child) {
const target = getElementFromSelector(child);
if (!target) {
return;
}
this._setAttributeIfNotExists(target, 'role', 'tabpanel');
if (child.id) {
this._setAttributeIfNotExists(target, 'aria-labelledby', `#${child.id}`);
}
}
_toggleDropDown(element, open) {
const outerElem = this._getOuterElement(element);
if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
return;
}
const toggle = (selector, className) => {
const element = SelectorEngine.findOne(selector, outerElem);
if (element) {
element.classList.toggle(className, open);
}
};
toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW);
outerElem.setAttribute('aria-expanded', open);
}
_setAttributeIfNotExists(element, attribute, value) {
if (!element.hasAttribute(attribute)) {
element.setAttribute(attribute, value);
}
}
_elemIsActive(elem) {
return elem.classList.contains(CLASS_NAME_ACTIVE);
}
// Try to get the inner element (usually the .nav-link)
_getInnerElement(elem) {
return elem.matches(SELECTOR_INNER_ELEM)
? elem
: SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem);
}
// Try to get the outer element (usually the .nav-item)
_getOuterElement(elem) {
return elem.closest(SELECTOR_OUTER) || elem;
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Tab.getOrCreateInstance(this);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
if (typeof config !== 'string') {
return;
}
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
@ -214,15 +300,19 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
return;
}
const data = Tab.getOrCreateInstance(this);
data.show();
Tab.getOrCreateInstance(this).show();
});
/**
* ------------------------------------------------------------------------
* Initialize on focus
*/
EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
Tab.getOrCreateInstance(element);
}
});
/**
* jQuery
* ------------------------------------------------------------------------
* add .Tab to jQuery only if jQuery is present
*/
defineJQueryPlugin(Tab);

67
src/js/bootstrap/mdb-prefix/toast.js
View File

@ -1,20 +1,17 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): toast.js
* Bootstrap (v5.2.2): toast.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import { defineJQueryPlugin, reflow, typeCheckConfig } from './util/index';
import { defineJQueryPlugin, reflow } from './util/index';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
import BaseComponent from './base-component';
import { enableDismissTrigger } from './util/component-functions';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'toast';
@ -48,16 +45,13 @@ const Default = {
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Toast extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._config = this._getConfig(config);
this._timeout = null;
this._hasMouseInteraction = false;
this._hasKeyboardInteraction = false;
@ -65,21 +59,19 @@ class Toast extends BaseComponent {
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get Default() {
return Default;
}
static get NAME() {
return NAME;
}
// Public
show() {
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
@ -102,14 +94,13 @@ class Toast extends BaseComponent {
this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
reflow(this._element);
this._element.classList.add(CLASS_NAME_SHOW);
this._element.classList.add(CLASS_NAME_SHOWING);
this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
this._queueCallback(complete, this._element, this._config.animation);
}
hide() {
if (!this._element.classList.contains(CLASS_NAME_SHOW)) {
if (!this.isShown()) {
return;
}
@ -121,8 +112,7 @@ class Toast extends BaseComponent {
const complete = () => {
this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
this._element.classList.remove(CLASS_NAME_SHOWING);
this._element.classList.remove(CLASS_NAME_SHOW);
this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
EventHandler.trigger(this._element, EVENT_HIDDEN);
};
@ -133,27 +123,19 @@ class Toast extends BaseComponent {
dispose() {
this._clearTimeout();
if (this._element.classList.contains(CLASS_NAME_SHOW)) {
if (this.isShown()) {
this._element.classList.remove(CLASS_NAME_SHOW);
}
super.dispose();
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' && config ? config : {}),
};
typeCheckConfig(NAME, config, this.constructor.DefaultType);
return config;
isShown() {
return this._element.classList.contains(CLASS_NAME_SHOW);
}
// Private
_maybeScheduleHide() {
if (!this._config.autohide) {
return;
@ -171,15 +153,20 @@ class Toast extends BaseComponent {
_onInteraction(event, isInteracting) {
switch (event.type) {
case 'mouseover':
case 'mouseout':
case 'mouseout': {
this._hasMouseInteraction = isInteracting;
break;
}
case 'focusin':
case 'focusout':
case 'focusout': {
this._hasKeyboardInteraction = isInteracting;
break;
default:
}
default: {
break;
}
}
if (isInteracting) {
@ -208,7 +195,6 @@ class Toast extends BaseComponent {
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Toast.getOrCreateInstance(this, config);
@ -224,13 +210,14 @@ class Toast extends BaseComponent {
}
}
/**
* Data API implementation
*/
enableDismissTrigger(Toast);
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Toast to jQuery only if jQuery is present
*/
defineJQueryPlugin(Toast);

709
src/js/bootstrap/mdb-prefix/tooltip.js
View File

File diff suppressed because it is too large Load Diff

91
src/js/bootstrap/mdb-prefix/util/backdrop.js
View File

@ -1,41 +1,65 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/backdrop.js
* Bootstrap (v5.2.2): util/backdrop.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import EventHandler from '../dom/event-handler';
import { execute, executeAfterTransition, getElement, reflow, typeCheckConfig } from './index';
import { execute, executeAfterTransition, getElement, reflow } from './index';
import Config from './config';
/**
* Constants
*/
const NAME = 'backdrop';
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`;
const Default = {
className: 'modal-backdrop',
isVisible: true, // if false, we use the backdrop helper without adding any element to the dom
isAnimated: false,
rootElement: 'body', // give the choice to place backdrop under different elements
clickCallback: null,
isAnimated: false,
isVisible: true, // if false, we use the backdrop helper without adding any element to the dom
rootElement: 'body', // give the choice to place backdrop under different elements
};
const DefaultType = {
className: 'string',
isVisible: 'boolean',
isAnimated: 'boolean',
rootElement: '(element|string)',
clickCallback: '(function|null)',
isAnimated: 'boolean',
isVisible: 'boolean',
rootElement: '(element|string)',
};
const NAME = 'backdrop';
const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`;
/**
* Class definition
*/
class Backdrop {
class Backdrop extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isAppended = false;
this._element = null;
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
show(callback) {
if (!this._config.isVisible) {
execute(callback);
@ -44,11 +68,12 @@ class Backdrop {
this._append();
const element = this._getElement();
if (this._config.isAnimated) {
reflow(this._getElement());
reflow(element);
}
this._getElement().classList.add(CLASS_NAME_SHOW);
element.classList.add(CLASS_NAME_SHOW);
this._emulateAnimation(() => {
execute(callback);
@ -69,8 +94,18 @@ class Backdrop {
});
}
// Private
dispose() {
if (!this._isAppended) {
return;
}
EventHandler.off(this._element, EVENT_MOUSEDOWN);
this._element.remove();
this._isAppended = false;
}
// Private
_getElement() {
if (!this._element) {
const backdrop = document.createElement('div');
@ -85,15 +120,9 @@ class Backdrop {
return this._element;
}
_getConfig(config) {
config = {
...Default,
...(typeof config === 'object' ? config : {}),
};
_configAfterMerge(config) {
// use getElement() with the default "body" to get a fresh Element on each instantiation
config.rootElement = getElement(config.rootElement);
typeCheckConfig(NAME, config, DefaultType);
return config;
}
@ -102,26 +131,16 @@ class Backdrop {
return;
}
this._config.rootElement.append(this._getElement());
const element = this._getElement();
this._config.rootElement.append(element);
EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, () => {
EventHandler.on(element, EVENT_MOUSEDOWN, () => {
execute(this._config.clickCallback);
});
this._isAppended = true;
}
dispose() {
if (!this._isAppended) {
return;
}
EventHandler.off(this._element, EVENT_MOUSEDOWN);
this._element.remove();
this._isAppended = false;
}
_emulateAnimation(callback) {
executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
}

2
src/js/bootstrap/mdb-prefix/util/component-functions.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/component-functions.js
* Bootstrap (v5.2.2): util/component-functions.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/

66
src/js/bootstrap/mdb-prefix/util/config.js Normal file
View File

@ -0,0 +1,66 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/config.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import { isElement, toType } from './index';
import Manipulator from '../dom/manipulator';
/**
* Class definition
*/
class Config {
// Getters
static get Default() {
return {};
}
static get DefaultType() {
return {};
}
static get NAME() {
throw new Error('You have to implement the static method "NAME", for each component!');
}
_getConfig(config) {
config = this._mergeConfigObj(config);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
_configAfterMerge(config) {
return config;
}
_mergeConfigObj(config, element) {
const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
return {
...this.constructor.Default,
...(typeof jsonConfig === 'object' ? jsonConfig : {}),
...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),
...(typeof config === 'object' ? config : {}),
};
}
_typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
for (const property of Object.keys(configTypes)) {
const expectedTypes = configTypes[property];
const value = config[property];
const valueType = isElement(value) ? 'element' : toType(value);
if (!new RegExp(expectedTypes).test(valueType)) {
throw new TypeError(
`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
);
}
}
}
}
export default Config;

70
src/js/bootstrap/mdb-prefix/util/focustrap.js
View File

@ -1,23 +1,17 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/focustrap.js
* Bootstrap (v5.2.2): util/focustrap.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import EventHandler from '../dom/event-handler';
import SelectorEngine from '../dom/selector-engine';
import { typeCheckConfig } from './index';
import Config from './config';
const Default = {
trapElement: null, // The element to trap focus inside of
autofocus: true,
};
const DefaultType = {
trapElement: 'element',
autofocus: 'boolean',
};
/**
* Constants
*/
const NAME = 'focustrap';
const DATA_KEY = 'bs.focustrap';
@ -29,22 +23,49 @@ const TAB_KEY = 'Tab';
const TAB_NAV_FORWARD = 'forward';
const TAB_NAV_BACKWARD = 'backward';
class FocusTrap {
const Default = {
autofocus: true,
trapElement: null, // The element to trap focus inside of
};
const DefaultType = {
autofocus: 'boolean',
trapElement: 'element',
};
/**
* Class definition
*/
class FocusTrap extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isActive = false;
this._lastTabNavDirection = null;
}
activate() {
const { trapElement, autofocus } = this._config;
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
activate() {
if (this._isActive) {
return;
}
if (autofocus) {
trapElement.focus();
if (this._config.autofocus) {
this._config.trapElement.focus();
}
EventHandler.off(document, EVENT_KEY); // guard against infinite focus loop
@ -64,12 +85,14 @@ class FocusTrap {
}
// Private
_handleFocusin(event) {
const { target } = event;
const { trapElement } = this._config;
if (target === document || target === trapElement || trapElement.contains(target)) {
if (
event.target === document ||
event.target === trapElement ||
trapElement.contains(event.target)
) {
return;
}
@ -91,15 +114,6 @@ class FocusTrap {
this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
}
_getConfig(config) {
config = {
...Default,
...(typeof config === 'object' ? config : {}),
};
typeCheckConfig(NAME, config, DefaultType);
return config;
}
}
export default FocusTrap;

142
src/js/bootstrap/mdb-prefix/util/index.js
View File

@ -1,30 +1,28 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/index.js
* Bootstrap (v5.2.2): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const MAX_UID = 1000000;
const MAX_UID = 1_000_000;
const MILLISECONDS_MULTIPLIER = 1000;
const TRANSITION_END = 'transitionend';
// Shoutout AngusCroll (https://goo.gl/pxwQGp)
const toType = (obj) => {
if (obj === null || obj === undefined) {
return `${obj}`;
// Shout-out Angus Croll (https://goo.gl/pxwQGp)
const toType = (object) => {
if (object === null || object === undefined) {
return `${object}`;
}
return {}.toString
.call(obj)
return Object.prototype.toString
.call(object)
.match(/\s([a-z]+)/i)[1]
.toLowerCase();
};
/**
* --------------------------------------------------------------------------
* Public Util Api
* --------------------------------------------------------------------------
* Public Util API
*/
const getUID = (prefix) => {
@ -39,22 +37,22 @@ const getSelector = (element) => {
let selector = element.getAttribute('data-mdb-target');
if (!selector || selector === '#') {
let hrefAttr = element.getAttribute('href');
let hrefAttribute = element.getAttribute('href');
// The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
if (!hrefAttribute || (!hrefAttribute.includes('#') && !hrefAttribute.startsWith('.'))) {
return null;
}
// Just in case some CMS puts out a full URL with the anchor appended
if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
hrefAttr = `#${hrefAttr.split('#')[1]}`;
if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
}
selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
}
return selector;
@ -106,51 +104,56 @@ const triggerTransitionEnd = (element) => {
element.dispatchEvent(new Event(TRANSITION_END));
};
const isElement = (obj) => {
if (!obj || typeof obj !== 'object') {
const isElement = (object) => {
if (!object || typeof object !== 'object') {
return false;
}
if (typeof obj.jquery !== 'undefined') {
obj = obj[0];
if (typeof object.jquery !== 'undefined') {
object = object[0];
}
return typeof obj.nodeType !== 'undefined';
return typeof object.nodeType !== 'undefined';
};
const getElement = (obj) => {
if (isElement(obj)) {
// it's a jQuery object or a node element
return obj.jquery ? obj[0] : obj;
const getElement = (object) => {
// it's a jQuery object or a node element
if (isElement(object)) {
return object.jquery ? object[0] : object;
}
if (typeof obj === 'string' && obj.length > 0) {
return document.querySelector(obj);
if (typeof object === 'string' && object.length > 0) {
return document.querySelector(object);
}
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 isVisible = (element) => {
if (!isElement(element) || element.getClientRects().length === 0) {
return false;
}
return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';
// Handle `details` element as its content may falsie appear visible when it is closed
const closedDetails = element.closest('details:not([open])');
if (!closedDetails) {
return elementIsVisible;
}
if (closedDetails !== element) {
const summary = element.closest('summary');
if (summary && summary.parentNode !== closedDetails) {
return false;
}
if (summary === null) {
return false;
}
}
return elementIsVisible;
};
const isDisabled = (element) => {
@ -203,15 +206,12 @@ const noop = () => {};
* @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
*/
const reflow = (element) => {
// eslint-disable-next-line no-unused-expressions
element.offsetHeight;
element.offsetHeight; // eslint-disable-line no-unused-expressions
};
const getjQuery = () => {
const { jQuery } = window;
if (jQuery && !document.body.hasAttribute('data-mdb-no-jquery')) {
return jQuery;
if (window.jQuery && !document.body.hasAttribute('data-mdb-no-jquery')) {
return window.jQuery;
}
return null;
@ -224,7 +224,9 @@ const onDOMContentLoaded = (callback) => {
// add listener on the first call when the document is in loading state
if (!DOMContentLoadedCallbacks.length) {
document.addEventListener('DOMContentLoaded', () => {
DOMContentLoadedCallbacks.forEach((callback) => callback());
for (const callback of DOMContentLoadedCallbacks) {
callback();
}
});
}
@ -298,15 +300,15 @@ const executeAfterTransition = (callback, transitionElement, waitForTransition =
* @return {Element|elem} The proper element
*/
const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
const listLength = list.length;
let index = list.indexOf(activeElement);
// if the element does not exist in the list return an element depending on the direction and if cycle is allowed
// if the element does not exist in the list return an element
// depending on the direction and if cycle is allowed
if (index === -1) {
return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0];
return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
}
const listLength = list.length;
index += shouldGetNext ? 1 : -1;
if (isCycleAllowed) {
@ -317,24 +319,24 @@ const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed
};
export {
getElement,
getUID,
getSelectorFromElement,
getElementFromSelector,
getTransitionDurationFromElement,
triggerTransitionEnd,
isElement,
typeCheckConfig,
isVisible,
isDisabled,
findShadowRoot,
noop,
getNextActiveElement,
reflow,
getjQuery,
onDOMContentLoaded,
isRTL,
defineJQueryPlugin,
execute,
executeAfterTransition,
findShadowRoot,
getElement,
getElementFromSelector,
getjQuery,
getNextActiveElement,
getSelectorFromElement,
getTransitionDurationFromElement,
getUID,
isDisabled,
isElement,
isRTL,
isVisible,
noop,
onDOMContentLoaded,
reflow,
triggerTransitionEnd,
toType,
};

31
src/js/bootstrap/mdb-prefix/util/sanitizer.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/sanitizer.js
* Bootstrap (v5.2.2): util/sanitizer.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -21,14 +21,14 @@ 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
* Shout-out 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
* Shout-out 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;
@ -46,16 +46,10 @@ const allowedAttribute = (attribute, allowedAttributeList) => {
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;
return allowedAttributeList
.filter((attributeRegex) => attributeRegex instanceof RegExp)
.some((regex) => regex.test(attributeName));
};
export const DefaultAllowlist = {
@ -92,21 +86,20 @@ export const DefaultAllowlist = {
ul: [],
};
export function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
export function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
if (!unsafeHtml.length) {
return unsafeHtml;
}
if (sanitizeFn && typeof sanitizeFn === 'function') {
return sanitizeFn(unsafeHtml);
if (sanitizeFunction && typeof sanitizeFunction === 'function') {
return sanitizeFunction(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];
for (const element of elements) {
const elementName = element.nodeName.toLowerCase();
if (!Object.keys(allowList).includes(elementName)) {
@ -118,11 +111,11 @@ export function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
const attributeList = [].concat(...element.attributes);
const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
attributeList.forEach((attribute) => {
for (const attribute of attributeList) {
if (!allowedAttribute(attribute, allowedAttributes)) {
element.removeAttribute(attribute.nodeName);
}
});
}
}
return createdDocument.body.innerHTML;

77
src/js/bootstrap/mdb-prefix/util/scrollbar.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): util/scrollBar.js
* Bootstrap (v5.2.2): util/scrollBar.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -9,14 +9,25 @@ import SelectorEngine from '../dom/selector-engine';
import Manipulator from '../dom/manipulator';
import { isElement } from './index';
/**
* Constants
*/
const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
const SELECTOR_STICKY_CONTENT = '.sticky-top';
const PROPERTY_PADDING = 'padding-right';
const PROPERTY_MARGIN = 'margin-right';
/**
* Class definition
*/
class ScrollBarHelper {
constructor() {
this._element = document.body;
}
// Public
getWidth() {
// https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
const documentWidth = document.documentElement.clientWidth;
@ -29,65 +40,72 @@ class ScrollBarHelper {
// give padding to element to balance the hidden scrollbar width
this._setElementAttributes(
this._element,
'paddingRight',
PROPERTY_PADDING,
(calculatedValue) => calculatedValue + width
);
// trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
this._setElementAttributes(
SELECTOR_FIXED_CONTENT,
'paddingRight',
PROPERTY_PADDING,
(calculatedValue) => calculatedValue + width
);
this._setElementAttributes(
SELECTOR_STICKY_CONTENT,
'marginRight',
PROPERTY_MARGIN,
(calculatedValue) => calculatedValue - width
);
}
reset() {
this._resetElementAttributes(this._element, 'overflow');
this._resetElementAttributes(this._element, PROPERTY_PADDING);
this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
}
isOverflowing() {
return this.getWidth() > 0;
}
// Private
_disableOverFlow() {
this._saveInitialAttribute(this._element, 'overflow');
this._element.style.overflow = 'hidden';
}
_setElementAttributes(selector, styleProp, callback) {
_setElementAttributes(selector, styleProperty, callback) {
const scrollbarWidth = this.getWidth();
const manipulationCallBack = (element) => {
if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
return;
}
this._saveInitialAttribute(element, styleProp);
const calculatedValue = window.getComputedStyle(element)[styleProp];
element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
this._saveInitialAttribute(element, styleProperty);
const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);
};
this._applyManipulationCallback(selector, manipulationCallBack);
}
reset() {
this._resetElementAttributes(this._element, 'overflow');
this._resetElementAttributes(this._element, 'paddingRight');
this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
}
_saveInitialAttribute(element, styleProp) {
const actualValue = element.style[styleProp];
_saveInitialAttribute(element, styleProperty) {
const actualValue = element.style.getPropertyValue(styleProperty);
if (actualValue) {
Manipulator.setDataAttribute(element, styleProp, actualValue);
Manipulator.setDataAttribute(element, styleProperty, actualValue);
}
}
_resetElementAttributes(selector, styleProp) {
_resetElementAttributes(selector, styleProperty) {
const manipulationCallBack = (element) => {
const value = Manipulator.getDataAttribute(element, styleProp);
if (typeof value === 'undefined') {
element.style.removeProperty(styleProp);
} else {
Manipulator.removeDataAttribute(element, styleProp);
element.style[styleProp] = value;
const value = Manipulator.getDataAttribute(element, styleProperty);
// We only want to remove the property if the value is `null`; the value can also be zero
if (value === null) {
element.style.removeProperty(styleProperty);
return;
}
Manipulator.removeDataAttribute(element, styleProperty);
element.style.setProperty(styleProperty, value);
};
this._applyManipulationCallback(selector, manipulationCallBack);
@ -96,13 +114,12 @@ class ScrollBarHelper {
_applyManipulationCallback(selector, callBack) {
if (isElement(selector)) {
callBack(selector);
} else {
SelectorEngine.find(selector, this._element).forEach(callBack);
return;
}
}
isOverflowing() {
return this.getWidth() > 0;
for (const sel of SelectorEngine.find(selector, this._element)) {
callBack(sel);
}
}
}

148
src/js/bootstrap/mdb-prefix/util/swipe.js Normal file
View File

@ -0,0 +1,148 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/swipe.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import Config from './config';
import EventHandler from '../dom/event-handler';
import { execute } from './index';
/**
* Constants
*/
const NAME = 'swipe';
const EVENT_KEY = '.bs.swipe';
const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`;
const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`;
const EVENT_TOUCHEND = `touchend${EVENT_KEY}`;
const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`;
const EVENT_POINTERUP = `pointerup${EVENT_KEY}`;
const POINTER_TYPE_TOUCH = 'touch';
const POINTER_TYPE_PEN = 'pen';
const CLASS_NAME_POINTER_EVENT = 'pointer-event';
const SWIPE_THRESHOLD = 40;
const Default = {
endCallback: null,
leftCallback: null,
rightCallback: null,
};
const DefaultType = {
endCallback: '(function|null)',
leftCallback: '(function|null)',
rightCallback: '(function|null)',
};
/**
* Class definition
*/
class Swipe extends Config {
constructor(element, config) {
super();
this._element = element;
if (!element || !Swipe.isSupported()) {
return;
}
this._config = this._getConfig(config);
this._deltaX = 0;
this._supportPointerEvents = Boolean(window.PointerEvent);
this._initEvents();
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
dispose() {
EventHandler.off(this._element, EVENT_KEY);
}
// Private
_start(event) {
if (!this._supportPointerEvents) {
this._deltaX = event.touches[0].clientX;
return;
}
if (this._eventIsPointerPenTouch(event)) {
this._deltaX = event.clientX;
}
}
_end(event) {
if (this._eventIsPointerPenTouch(event)) {
this._deltaX = event.clientX - this._deltaX;
}
this._handleSwipe();
execute(this._config.endCallback);
}
_move(event) {
this._deltaX =
event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
}
_handleSwipe() {
const absDeltaX = Math.abs(this._deltaX);
if (absDeltaX <= SWIPE_THRESHOLD) {
return;
}
const direction = absDeltaX / this._deltaX;
this._deltaX = 0;
if (!direction) {
return;
}
execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
}
_initEvents() {
if (this._supportPointerEvents) {
EventHandler.on(this._element, EVENT_POINTERDOWN, (event) => this._start(event));
EventHandler.on(this._element, EVENT_POINTERUP, (event) => this._end(event));
this._element.classList.add(CLASS_NAME_POINTER_EVENT);
} else {
EventHandler.on(this._element, EVENT_TOUCHSTART, (event) => this._start(event));
EventHandler.on(this._element, EVENT_TOUCHMOVE, (event) => this._move(event));
EventHandler.on(this._element, EVENT_TOUCHEND, (event) => this._end(event));
}
}
_eventIsPointerPenTouch(event) {
return (
this._supportPointerEvents &&
(event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
);
}
// Static
static isSupported() {
return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
}
}
export default Swipe;

162
src/js/bootstrap/mdb-prefix/util/template-factory.js Normal file
View File

@ -0,0 +1,162 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.2.2): util/template-factory.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import { DefaultAllowlist, sanitizeHtml } from './sanitizer';
import { getElement, isElement } from '../util/index';
import SelectorEngine from '../dom/selector-engine';
import Config from './config';
/**
* Constants
*/
const NAME = 'TemplateFactory';
const Default = {
allowList: DefaultAllowlist,
content: {}, // { selector : text , selector2 : text2 , }
extraClass: '',
html: false,
sanitize: true,
sanitizeFn: null,
template: '<div></div>',
};
const DefaultType = {
allowList: 'object',
content: 'object',
extraClass: '(string|function)',
html: 'boolean',
sanitize: 'boolean',
sanitizeFn: '(null|function)',
template: 'string',
};
const DefaultContentType = {
entry: '(string|element|function|null)',
selector: '(string|element)',
};
/**
* Class definition
*/
class TemplateFactory extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
getContent() {
return Object.values(this._config.content)
.map((config) => this._resolvePossibleFunction(config))
.filter(Boolean);
}
hasContent() {
return this.getContent().length > 0;
}
changeContent(content) {
this._checkContent(content);
this._config.content = { ...this._config.content, ...content };
return this;
}
toHtml() {
const templateWrapper = document.createElement('div');
templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
for (const [selector, text] of Object.entries(this._config.content)) {
this._setContent(templateWrapper, text, selector);
}
const template = templateWrapper.children[0];
const extraClass = this._resolvePossibleFunction(this._config.extraClass);
if (extraClass) {
template.classList.add(...extraClass.split(' '));
}
return template;
}
// Private
_typeCheckConfig(config) {
super._typeCheckConfig(config);
this._checkContent(config.content);
}
_checkContent(arg) {
for (const [selector, content] of Object.entries(arg)) {
super._typeCheckConfig({ selector, entry: content }, DefaultContentType);
}
}
_setContent(template, content, selector) {
const templateElement = SelectorEngine.findOne(selector, template);
if (!templateElement) {
return;
}
content = this._resolvePossibleFunction(content);
if (!content) {
templateElement.remove();
return;
}
if (isElement(content)) {
this._putElementInTemplate(getElement(content), templateElement);
return;
}
if (this._config.html) {
templateElement.innerHTML = this._maybeSanitize(content);
return;
}
templateElement.textContent = content;
}
_maybeSanitize(arg) {
return this._config.sanitize
? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn)
: arg;
}
_resolvePossibleFunction(arg) {
return typeof arg === 'function' ? arg(this) : arg;
}
_putElementInTemplate(element, templateElement) {
if (this._config.html) {
templateElement.innerHTML = '';
templateElement.append(element);
return;
}
templateElement.textContent = element.textContent;
}
}
export default TemplateFactory;

18
src/js/bootstrap/src/alert.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): alert.js
* Bootstrap (v5.2.2): alert.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -11,9 +11,7 @@ import BaseComponent from './base-component';
import { enableDismissTrigger } from './util/component-functions';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'alert';
@ -26,20 +24,16 @@ const CLASS_NAME_FADE = 'fade';
const CLASS_NAME_SHOW = 'show';
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Alert extends BaseComponent {
// Getters
static get NAME() {
return NAME;
}
// Public
close() {
const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
@ -61,7 +55,6 @@ class Alert extends BaseComponent {
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Alert.getOrCreateInstance(this);
@ -80,18 +73,13 @@ class Alert extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
enableDismissTrigger(Alert, 'close');
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Alert to jQuery only if jQuery is present
*/
defineJQueryPlugin(Alert);

41
src/js/bootstrap/src/base-component.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): base-component.js
* Bootstrap (v5.2.2): base-component.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,42 +8,55 @@
import Data from './dom/data';
import { executeAfterTransition, getElement } from './util/index';
import EventHandler from './dom/event-handler';
import Config from './util/config';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const VERSION = '5.1.3';
const VERSION = '5.2.2';
/**
* Class definition
*/
class BaseComponent extends Config {
constructor(element, config) {
super();
class BaseComponent {
constructor(element) {
element = getElement(element);
if (!element) {
return;
}
this._element = element;
this._config = this._getConfig(config);
Data.set(this._element, this.constructor.DATA_KEY, this);
}
// Public
dispose() {
Data.remove(this._element, this.constructor.DATA_KEY);
EventHandler.off(this._element, this.constructor.EVENT_KEY);
Object.getOwnPropertyNames(this).forEach((propertyName) => {
for (const propertyName of Object.getOwnPropertyNames(this)) {
this[propertyName] = null;
});
}
}
_queueCallback(callback, element, isAnimated = true) {
executeAfterTransition(callback, element, isAnimated);
}
/** Static */
_getConfig(config) {
config = this._mergeConfigObj(config, this._element);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
// Static
static getInstance(element) {
return Data.get(getElement(element), this.DATA_KEY);
}
@ -58,10 +71,6 @@ class BaseComponent {
return VERSION;
}
static get NAME() {
throw new Error('You have to implement the static method "NAME", for each component!');
}
static get DATA_KEY() {
return `bs.${this.NAME}`;
}
@ -69,6 +78,10 @@ class BaseComponent {
static get EVENT_KEY() {
return `.${this.DATA_KEY}`;
}
static eventName(name) {
return `${name}${this.EVENT_KEY}`;
}
}
export default BaseComponent;

20
src/js/bootstrap/src/button.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): button.js
* Bootstrap (v5.2.2): button.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -10,9 +10,7 @@ import EventHandler from './dom/event-handler';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'button';
@ -21,33 +19,26 @@ const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const CLASS_NAME_ACTIVE = 'active';
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]';
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Button extends BaseComponent {
// Getters
static get NAME() {
return NAME;
}
// Public
toggle() {
// Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE));
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Button.getOrCreateInstance(this);
@ -60,9 +51,7 @@ class Button extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, (event) => {
@ -75,10 +64,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, (event) =>
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Button to jQuery only if jQuery is present
*/
defineJQueryPlugin(Button);

573
src/js/bootstrap/src/carousel.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): carousel.js
* Bootstrap (v5.2.2): carousel.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,22 +8,20 @@
import {
defineJQueryPlugin,
getElementFromSelector,
getNextActiveElement,
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 Swipe from './util/swipe';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'carousel';
@ -34,46 +32,17 @@ const DATA_API_KEY = '.data-api';
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;
const Default = {
interval: 5000,
keyboard: true,
slide: false,
pause: 'hover',
wrap: true,
touch: true,
};
const DefaultType = {
interval: '(number|boolean)',
keyboard: 'boolean',
slide: '(boolean|string)',
pause: '(string|boolean)',
wrap: 'boolean',
touch: 'boolean',
};
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}`;
const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY}`;
const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY}`;
const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`;
const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`;
const EVENT_TOUCHEND = `touchend${EVENT_KEY}`;
const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`;
const EVENT_POINTERUP = `pointerup${EVENT_KEY}`;
const EVENT_DRAG_START = `dragstart${EVENT_KEY}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;
@ -85,65 +54,80 @@ 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';
const SELECTOR_ACTIVE = '.active';
const SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
const SELECTOR_ITEM = '.carousel-item';
const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_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_INDICATOR = '[data-bs-target]';
const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
const POINTER_TYPE_TOUCH = 'touch';
const POINTER_TYPE_PEN = 'pen';
const KEY_TO_DIRECTION = {
[ARROW_LEFT_KEY]: DIRECTION_RIGHT,
[ARROW_RIGHT_KEY]: DIRECTION_LEFT,
};
const Default = {
interval: 5000,
keyboard: true,
pause: 'hover',
ride: false,
touch: true,
wrap: true,
};
const DefaultType = {
interval: '(number|boolean)', // TODO:v6 remove boolean support
keyboard: 'boolean',
pause: '(string|boolean)',
ride: '(boolean|string)',
touch: 'boolean',
wrap: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Carousel extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._items = null;
this._interval = null;
this._activeElement = null;
this._isPaused = false;
this._isSliding = false;
this.touchTimeout = null;
this.touchStartX = 0;
this.touchDeltaX = 0;
this._swipeHelper = null;
this._config = this._getConfig(config);
this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
this._touchSupported =
'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
this._pointerEvent = Boolean(window.PointerEvent);
this._addEventListeners();
if (this._config.ride === CLASS_NAME_CAROUSEL) {
this.cycle();
}
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
next() {
this._slide(ORDER_NEXT);
}
nextWhenVisible() {
// FIXME TODO use `document.visibilityState`
// Don't call next when the page isn't visible
// or the carousel or its parent isn't visible
if (!document.hidden && isVisible(this._element)) {
@ -155,45 +139,37 @@ class Carousel extends BaseComponent {
this._slide(ORDER_PREV);
}
pause(event) {
if (!event) {
this._isPaused = true;
}
if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
pause() {
if (this._isSliding) {
triggerTransitionEnd(this._element);
this.cycle(true);
}
clearInterval(this._interval);
this._interval = null;
this._clearInterval();
}
cycle(event) {
if (!event) {
this._isPaused = false;
cycle() {
this._clearInterval();
this._updateInterval();
this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
}
_maybeEnableCycle() {
if (!this._config.ride) {
return;
}
if (this._interval) {
clearInterval(this._interval);
this._interval = null;
if (this._isSliding) {
EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
return;
}
if (this._config && this._config.interval && !this._isPaused) {
this._updateInterval();
this._interval = setInterval(
(document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
this._config.interval
);
}
this.cycle();
}
to(index) {
this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
const activeIndex = this._getItemIndex(this._activeElement);
if (index > this._items.length - 1 || index < 0) {
const items = this._getItems();
if (index > items.length - 1 || index < 0) {
return;
}
@ -202,125 +178,81 @@ class Carousel extends BaseComponent {
return;
}
const activeIndex = this._getItemIndex(this._getActive());
if (activeIndex === index) {
this.pause();
this.cycle();
return;
}
const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
this._slide(order, this._items[index]);
this._slide(order, items[index]);
}
dispose() {
if (this._swipeHelper) {
this._swipeHelper.dispose();
}
super.dispose();
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...(typeof config === 'object' ? config : {}),
};
typeCheckConfig(NAME, config, DefaultType);
_configAfterMerge(config) {
config.defaultInterval = config.interval;
return config;
}
_handleSwipe() {
const absDeltax = Math.abs(this.touchDeltaX);
if (absDeltax <= SWIPE_THRESHOLD) {
return;
}
const direction = absDeltax / this.touchDeltaX;
this.touchDeltaX = 0;
if (!direction) {
return;
}
this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
}
_addEventListeners() {
if (this._config.keyboard) {
EventHandler.on(this._element, EVENT_KEYDOWN, (event) => this._keydown(event));
}
if (this._config.pause === 'hover') {
EventHandler.on(this._element, EVENT_MOUSEENTER, (event) => this.pause(event));
EventHandler.on(this._element, EVENT_MOUSELEAVE, (event) => this.cycle(event));
EventHandler.on(this._element, EVENT_MOUSEENTER, () => this.pause());
EventHandler.on(this._element, EVENT_MOUSELEAVE, () => this._maybeEnableCycle());
}
if (this._config.touch && this._touchSupported) {
if (this._config.touch && Swipe.isSupported()) {
this._addTouchEventListeners();
}
}
_addTouchEventListeners() {
const hasPointerPenTouch = (event) => {
return (
this._pointerEvent &&
(event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
EventHandler.on(img, EVENT_DRAG_START, (event) => event.preventDefault());
}
const endCallBack = () => {
if (this._config.pause !== 'hover') {
return;
}
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// 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
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
this.pause();
if (this.touchTimeout) {
clearTimeout(this.touchTimeout);
}
this.touchTimeout = setTimeout(
() => this._maybeEnableCycle(),
TOUCHEVENT_COMPAT_WAIT + this._config.interval
);
};
const start = (event) => {
if (hasPointerPenTouch(event)) {
this.touchStartX = event.clientX;
} else if (!this._pointerEvent) {
this.touchStartX = event.touches[0].clientX;
}
const swipeConfig = {
leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
endCallback: endCallBack,
};
const move = (event) => {
// ensure swiping with one touch and not pinching
this.touchDeltaX =
event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX;
};
const end = (event) => {
if (hasPointerPenTouch(event)) {
this.touchDeltaX = event.clientX - this.touchStartX;
}
this._handleSwipe();
if (this._config.pause === 'hover') {
// If it's a touch-enabled device, mouseenter/leave are fired as
// part of the mouse compatibility events on first tap - the carousel
// 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
// is NOT fired) and after a timeout (to allow for mouse compatibility
// events to fire) we explicitly restart cycling
this.pause();
if (this.touchTimeout) {
clearTimeout(this.touchTimeout);
}
this.touchTimeout = setTimeout(
(event) => this.cycle(event),
TOUCHEVENT_COMPAT_WAIT + this._config.interval
);
}
};
SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach((itemImg) => {
EventHandler.on(itemImg, EVENT_DRAG_START, (event) => event.preventDefault());
});
if (this._pointerEvent) {
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 {
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));
}
this._swipeHelper = new Swipe(this._element, swipeConfig);
}
_keydown(event) {
@ -331,61 +263,37 @@ class Carousel extends BaseComponent {
const direction = KEY_TO_DIRECTION[event.key];
if (direction) {
event.preventDefault();
this._slide(direction);
this._slide(this._directionToOrder(direction));
}
}
_getItemIndex(element) {
this._items =
element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
return this._items.indexOf(element);
return this._getItems().indexOf(element);
}
_getItemByOrder(order, activeElement) {
const isNext = order === ORDER_NEXT;
return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap);
}
_setActiveIndicatorElement(index) {
if (!this._indicatorsElement) {
return;
}
_triggerSlideEvent(relatedTarget, eventDirectionName) {
const targetIndex = this._getItemIndex(relatedTarget);
const fromIndex = this._getItemIndex(
SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
activeIndicator.removeAttribute('aria-current');
const newActiveIndicator = SelectorEngine.findOne(
`[data-bs-slide-to="${index}"]`,
this._indicatorsElement
);
return EventHandler.trigger(this._element, EVENT_SLIDE, {
relatedTarget,
direction: eventDirectionName,
from: fromIndex,
to: targetIndex,
});
}
_setActiveIndicatorElement(element) {
if (this._indicatorsElement) {
const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
activeIndicator.removeAttribute('aria-current');
const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
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;
}
}
if (newActiveIndicator) {
newActiveIndicator.classList.add(CLASS_NAME_ACTIVE);
newActiveIndicator.setAttribute('aria-current', 'true');
}
}
_updateInterval() {
const element =
this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
const element = this._activeElement || this._getActive();
if (!element) {
return;
@ -393,103 +301,102 @@ class Carousel extends BaseComponent {
const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
if (elementInterval) {
this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
this._config.interval = elementInterval;
} else {
this._config.interval = this._config.defaultInterval || this._config.interval;
}
this._config.interval = elementInterval || this._config.defaultInterval;
}
_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 || this._getItemByOrder(order, activeElement);
const nextElementIndex = this._getItemIndex(nextElement);
const isCycling = Boolean(this._interval);
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 (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) {
this._isSliding = false;
return;
}
_slide(order, element = null) {
if (this._isSliding) {
return;
}
const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
const activeElement = this._getActive();
const isNext = order === ORDER_NEXT;
const nextElement =
element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
if (nextElement === activeElement) {
return;
}
const nextElementIndex = this._getItemIndex(nextElement);
const triggerEvent = (eventName) => {
return EventHandler.trigger(this._element, eventName, {
relatedTarget: nextElement,
direction: this._orderToDirection(order),
from: this._getItemIndex(activeElement),
to: nextElementIndex,
});
};
const slideEvent = triggerEvent(EVENT_SLIDE);
if (slideEvent.defaultPrevented) {
return;
}
if (!activeElement || !nextElement) {
// Some weirdness is happening, so we bail
// todo: change tests that use empty divs to avoid this check
return;
}
const isCycling = Boolean(this._interval);
this.pause();
this._isSliding = true;
if (isCycling) {
this.pause();
}
this._setActiveIndicatorElement(nextElement);
this._setActiveIndicatorElement(nextElementIndex);
this._activeElement = nextElement;
const triggerSlidEvent = () => {
EventHandler.trigger(this._element, EVENT_SLID, {
relatedTarget: nextElement,
direction: eventDirectionName,
from: activeElementIndex,
to: nextElementIndex,
});
};
const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
nextElement.classList.add(orderClassName);
nextElement.classList.add(orderClassName);
reflow(nextElement);
reflow(nextElement);
activeElement.classList.add(directionalClassName);
nextElement.classList.add(directionalClassName);
activeElement.classList.add(directionalClassName);
nextElement.classList.add(directionalClassName);
const completeCallBack = () => {
nextElement.classList.remove(directionalClassName, orderClassName);
nextElement.classList.add(CLASS_NAME_ACTIVE);
activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName);
this._isSliding = false;
setTimeout(triggerSlidEvent, 0);
};
this._queueCallback(completeCallBack, activeElement, true);
} else {
activeElement.classList.remove(CLASS_NAME_ACTIVE);
const completeCallBack = () => {
nextElement.classList.remove(directionalClassName, orderClassName);
nextElement.classList.add(CLASS_NAME_ACTIVE);
activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName);
this._isSliding = false;
triggerSlidEvent();
}
triggerEvent(EVENT_SLID);
};
this._queueCallback(completeCallBack, activeElement, this._isAnimated());
if (isCycling) {
this.cycle();
}
}
_directionToOrder(direction) {
if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
return direction;
}
_isAnimated() {
return this._element.classList.contains(CLASS_NAME_SLIDE);
}
_getActive() {
return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
}
_getItems() {
return SelectorEngine.find(SELECTOR_ITEM, this._element);
}
_clearInterval() {
if (this._interval) {
clearInterval(this._interval);
this._interval = null;
}
}
_directionToOrder(direction) {
if (isRTL()) {
return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
}
@ -498,10 +405,6 @@ class Carousel extends BaseComponent {
}
_orderToDirection(order) {
if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
return order;
}
if (isRTL()) {
return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
}
@ -510,88 +413,68 @@ class Carousel extends BaseComponent {
}
// Static
static carouselInterface(element, config) {
const data = Carousel.getOrCreateInstance(element, config);
let { _config } = data;
if (typeof config === 'object') {
_config = {
..._config,
...config,
};
}
const action = typeof config === 'string' ? config : _config.slide;
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();
}
}
static jQueryInterface(config) {
return this.each(function () {
Carousel.carouselInterface(this, config);
const data = Carousel.getOrCreateInstance(this, config);
if (typeof config === 'number') {
data.to(config);
return;
}
if (typeof config === 'string') {
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
}
});
}
static dataApiClickHandler(event) {
const target = getElementFromSelector(this);
if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
return;
}
const config = {
...Manipulator.getDataAttributes(target),
...Manipulator.getDataAttributes(this),
};
const slideIndex = this.getAttribute('data-bs-slide-to');
if (slideIndex) {
config.interval = false;
}
Carousel.carouselInterface(target, config);
if (slideIndex) {
Carousel.getInstance(target).to(slideIndex);
}
event.preventDefault();
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (event) {
const target = getElementFromSelector(this);
if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
return;
}
event.preventDefault();
const carousel = Carousel.getOrCreateInstance(target);
const slideIndex = this.getAttribute('data-bs-slide-to');
if (slideIndex) {
carousel.to(slideIndex);
carousel._maybeEnableCycle();
return;
}
if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
carousel.next();
carousel._maybeEnableCycle();
return;
}
carousel.prev();
carousel._maybeEnableCycle();
});
EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
for (let i = 0, len = carousels.length; i < len; i++) {
Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]));
for (const carousel of carousels) {
Carousel.getOrCreateInstance(carousel);
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Carousel to jQuery only if jQuery is present
*/
defineJQueryPlugin(Carousel);

158
src/js/bootstrap/src/collapse.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): collapse.js
* Bootstrap (v5.2.2): collapse.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,21 +8,16 @@
import {
defineJQueryPlugin,
getElement,
getSelectorFromElement,
getElementFromSelector,
getSelectorFromElement,
reflow,
typeCheckConfig,
} from './util/index';
import Data from './dom/data';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
import SelectorEngine from './dom/selector-engine';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'collapse';
@ -30,16 +25,6 @@ const DATA_KEY = 'bs.collapse';
const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const Default = {
toggle: true,
parent: null,
};
const DefaultType = {
toggle: 'boolean',
parent: '(null|element)',
};
const EVENT_SHOW = `show${EVENT_KEY}`;
const EVENT_SHOWN = `shown${EVENT_KEY}`;
const EVENT_HIDE = `hide${EVENT_KEY}`;
@ -59,31 +44,36 @@ const HEIGHT = 'height';
const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="collapse"]';
const Default = {
parent: null,
toggle: true,
};
const DefaultType = {
parent: '(null|element)',
toggle: 'boolean',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Collapse extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._isTransitioning = false;
this._config = this._getConfig(config);
this._triggerArray = [];
const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE);
for (let i = 0, len = toggleList.length; i < len; i++) {
const elem = toggleList[i];
for (const elem of toggleList) {
const selector = getSelectorFromElement(elem);
const filterElement = SelectorEngine.find(selector).filter(
(foundElem) => foundElem === this._element
(foundElement) => foundElement === this._element
);
if (selector !== null && filterElement.length) {
this._selector = selector;
this._triggerArray.push(elem);
}
}
@ -100,17 +90,19 @@ class Collapse extends BaseComponent {
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
toggle() {
if (this._isShown()) {
this.hide();
@ -124,24 +116,17 @@ class Collapse extends BaseComponent {
return;
}
let actives = [];
let activesData;
let activeChildren = [];
// find active children
if (this._config.parent) {
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
actives = SelectorEngine.find(SELECTOR_ACTIVES, this._config.parent).filter(
(elem) => !children.includes(elem)
); // remove children if greater depth
activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES)
.filter((element) => element !== this._element)
.map((element) => Collapse.getOrCreateInstance(element, { toggle: false }));
}
const container = SelectorEngine.findOne(this._selector);
if (actives.length) {
const tempActiveData = actives.find((elem) => container !== elem);
activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
if (activesData && activesData._isTransitioning) {
return;
}
if (activeChildren.length && activeChildren[0]._isTransitioning) {
return;
}
const startEvent = EventHandler.trigger(this._element, EVENT_SHOW);
@ -149,15 +134,9 @@ class Collapse extends BaseComponent {
return;
}
actives.forEach((elemActive) => {
if (container !== elemActive) {
Collapse.getOrCreateInstance(elemActive, { toggle: false }).hide();
}
if (!activesData) {
Data.set(elemActive, DATA_KEY, null);
}
});
for (const activeInstance of activeChildren) {
activeInstance.hide();
}
const dimension = this._getDimension();
@ -206,12 +185,10 @@ class Collapse extends BaseComponent {
this._element.classList.add(CLASS_NAME_COLLAPSING);
this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW);
const triggerArrayLength = this._triggerArray.length;
for (let i = 0; i < triggerArrayLength; i++) {
const trigger = this._triggerArray[i];
const elem = getElementFromSelector(trigger);
for (const trigger of this._triggerArray) {
const element = getElementFromSelector(trigger);
if (elem && !this._isShown(elem)) {
if (element && !this._isShown(element)) {
this._addAriaAndCollapsedClass([trigger], false);
}
}
@ -235,16 +212,9 @@ class Collapse extends BaseComponent {
}
// Private
_getConfig(config) {
config = {
...Default,
...Manipulator.getDataAttributes(this._element),
...config,
};
_configAfterMerge(config) {
config.toggle = Boolean(config.toggle); // Coerce string values
config.parent = getElement(config.parent);
typeCheckConfig(NAME, config, DefaultType);
return config;
}
@ -257,16 +227,23 @@ class Collapse extends BaseComponent {
return;
}
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
SelectorEngine.find(SELECTOR_DATA_TOGGLE, this._config.parent)
.filter((elem) => !children.includes(elem))
.forEach((element) => {
const selected = getElementFromSelector(element);
const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE);
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
});
for (const element of children) {
const selected = getElementFromSelector(element);
if (selected) {
this._addAriaAndCollapsedClass([element], this._isShown(selected));
}
}
}
_getFirstLevelChildren(selector) {
const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
// remove children if greater depth
return SelectorEngine.find(selector, this._config.parent).filter(
(element) => !children.includes(element)
);
}
_addAriaAndCollapsedClass(triggerArray, isOpen) {
@ -274,26 +251,20 @@ class Collapse extends BaseComponent {
return;
}
triggerArray.forEach((elem) => {
if (isOpen) {
elem.classList.remove(CLASS_NAME_COLLAPSED);
} else {
elem.classList.add(CLASS_NAME_COLLAPSED);
}
elem.setAttribute('aria-expanded', isOpen);
});
for (const element of triggerArray) {
element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
element.setAttribute('aria-expanded', isOpen);
}
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
const _config = {};
if (typeof config === 'string' && /show|hide/.test(config)) {
_config.toggle = false;
}
return this.each(function () {
const data = Collapse.getOrCreateInstance(this, _config);
if (typeof config === 'string') {
@ -308,9 +279,7 @@ class Collapse extends BaseComponent {
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
@ -325,16 +294,13 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
const selector = getSelectorFromElement(this);
const selectorElements = SelectorEngine.find(selector);
selectorElements.forEach((element) => {
for (const element of selectorElements) {
Collapse.getOrCreateInstance(element, { toggle: false }).toggle();
});
}
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Collapse to jQuery only if jQuery is present
*/
defineJQueryPlugin(Collapse);

4
src/js/bootstrap/src/dom/data.js
View File

@ -1,14 +1,12 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/data.js
* Bootstrap (v5.2.2): dom/data.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const elementMap = new Map();

203
src/js/bootstrap/src/dom/event-handler.js
View File

@ -1,6 +1,6 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/event-handler.js
* Bootstrap (v5.2.2): dom/event-handler.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
@ -8,9 +8,7 @@
import { getjQuery } from '../util/index';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
@ -22,7 +20,7 @@ const customEvents = {
mouseenter: 'mouseover',
mouseleave: 'mouseout',
};
const customEventsRegex = /^(mouseenter|mouseleave)/i;
const nativeEvents = new Set([
'click',
'dblclick',
@ -73,17 +71,15 @@ const nativeEvents = new Set([
]);
/**
* ------------------------------------------------------------------------
* Private methods
* ------------------------------------------------------------------------
*/
function getUidEvent(element, uid) {
function makeEventUid(element, uid) {
return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++;
}
function getEvent(element) {
const uid = getUidEvent(element);
function getElementEvents(element) {
const uid = makeEventUid(element);
element.uidEvent = uid;
eventRegistry[uid] = eventRegistry[uid] || {};
@ -93,7 +89,7 @@ function getEvent(element) {
function bootstrapHandler(element, fn) {
return function handler(event) {
event.delegateTarget = element;
hydrateObj(event, { delegateTarget: element });
if (handler.oneOff) {
EventHandler.off(element, event.type, fn);
@ -108,66 +104,57 @@ function bootstrapDelegationHandler(element, selector, fn) {
const domElements = element.querySelectorAll(selector);
for (let { target } = event; target && target !== this; target = target.parentNode) {
for (let i = domElements.length; i--; ) {
if (domElements[i] === target) {
event.delegateTarget = target;
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
for (const domElement of domElements) {
if (domElement !== target) {
continue;
}
hydrateObj(event, { delegateTarget: target });
if (handler.oneOff) {
EventHandler.off(element, event.type, selector, fn);
}
return fn.apply(target, [event]);
}
}
// To please ESLint
return null;
};
}
function findHandler(events, handler, delegationSelector = null) {
const uidEventList = Object.keys(events);
for (let i = 0, len = uidEventList.length; i < len; i++) {
const event = events[uidEventList[i]];
if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
return event;
}
}
return null;
function findHandler(events, callable, delegationSelector = null) {
return Object.values(events).find(
(event) => event.callable === callable && event.delegationSelector === delegationSelector
);
}
function normalizeParams(originalTypeEvent, handler, delegationFn) {
const delegation = typeof handler === 'string';
const originalHandler = delegation ? delegationFn : handler;
function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
const isDelegated = typeof handler === 'string';
// todo: tooltip passes `false` instead of selector, so we need to check
const callable = isDelegated ? delegationFunction : handler || delegationFunction;
let typeEvent = getTypeEvent(originalTypeEvent);
const isNative = nativeEvents.has(typeEvent);
if (!isNative) {
if (!nativeEvents.has(typeEvent)) {
typeEvent = originalTypeEvent;
}
return [delegation, originalHandler, typeEvent];
return [isDelegated, callable, typeEvent];
}
function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
if (!handler) {
handler = delegationFn;
delegationFn = null;
}
let [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFunction
);
// in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
// this prevents the handler from being dispatched the same way as mouseover or mouseout does
if (customEventsRegex.test(originalTypeEvent)) {
const wrapFn = (fn) => {
if (originalTypeEvent in customEvents) {
const wrapFunction = (fn) => {
return function (event) {
if (
!event.relatedTarget ||
@ -179,40 +166,31 @@ function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
};
};
if (delegationFn) {
delegationFn = wrapFn(delegationFn);
} else {
handler = wrapFn(handler);
}
callable = wrapFunction(callable);
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
originalTypeEvent,
handler,
delegationFn
);
const events = getEvent(element);
const events = getElementEvents(element);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
if (previousFn) {
previousFn.oneOff = previousFn.oneOff && oneOff;
if (previousFunction) {
previousFunction.oneOff = previousFunction.oneOff && oneOff;
return;
}
const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
const fn = delegation
? bootstrapDelegationHandler(element, handler, delegationFn)
: bootstrapHandler(element, handler);
const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
const fn = isDelegated
? bootstrapDelegationHandler(element, handler, callable)
: bootstrapHandler(element, callable);
fn.delegationSelector = delegation ? handler : null;
fn.originalHandler = originalHandler;
fn.delegationSelector = isDelegated ? handler : null;
fn.callable = callable;
fn.oneOff = oneOff;
fn.uidEvent = uid;
handlers[uid] = fn;
element.addEventListener(typeEvent, fn, delegation);
element.addEventListener(typeEvent, fn, isDelegated);
}
function removeHandler(element, events, typeEvent, handler, delegationSelector) {
@ -229,13 +207,12 @@ function removeHandler(element, events, typeEvent, handler, delegationSelector)
function removeNamespacedHandlers(element, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((handlerKey) => {
for (const handlerKey of Object.keys(storeElementEvent)) {
if (handlerKey.includes(namespace)) {
const event = storeElementEvent[handlerKey];
removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
}
function getTypeEvent(event) {
@ -245,54 +222,53 @@ function getTypeEvent(event) {
}
const EventHandler = {
on(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, false);
on(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, false);
},
one(element, event, handler, delegationFn) {
addHandler(element, event, handler, delegationFn, true);
one(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, true);
},
off(element, originalTypeEvent, handler, delegationFn) {
off(element, originalTypeEvent, handler, delegationFunction) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
const [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFn
delegationFunction
);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getEvent(element);
const events = getElementEvents(element);
const storeElementEvent = events[typeEvent] || {};
const isNamespace = originalTypeEvent.startsWith('.');
if (typeof originalHandler !== 'undefined') {
if (typeof callable !== 'undefined') {
// Simplest case: handler is passed, remove that listener ONLY.
if (!events || !events[typeEvent]) {
if (!Object.keys(storeElementEvent).length) {
return;
}
removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
return;
}
if (isNamespace) {
Object.keys(events).forEach((elementEvent) => {
for (const elementEvent of Object.keys(events)) {
removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
});
}
}
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((keyHandlers) => {
for (const keyHandlers of Object.keys(storeElementEvent)) {
const handlerKey = keyHandlers.replace(stripUidRegex, '');
if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
const event = storeElementEvent[keyHandlers];
removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
});
}
},
trigger(element, event, args) {
@ -303,13 +279,11 @@ const EventHandler = {
const $ = getjQuery();
const typeEvent = getTypeEvent(event);
const inNamespace = event !== typeEvent;
const isNative = nativeEvents.has(typeEvent);
let jQueryEvent;
let jQueryEvent = null;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
let evt = null;
if (inNamespace && $) {
jQueryEvent = $.Event(event, args);
@ -320,26 +294,8 @@ const EventHandler = {
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
if (isNative) {
evt = document.createEvent('HTMLEvents');
evt.initEvent(typeEvent, bubbles, true);
} else {
evt = new CustomEvent(event, {
bubbles,
cancelable: true,
});
}
// merge custom information in our event
if (typeof args !== 'undefined') {
Object.keys(args).forEach((key) => {
Object.defineProperty(evt, key, {
get() {
return args[key];
},
});
});
}
let evt = new Event(event, { bubbles, cancelable: true });
evt = hydrateObj(evt, args);
if (defaultPrevented) {
evt.preventDefault();
@ -349,7 +305,7 @@ const EventHandler = {
element.dispatchEvent(evt);
}
if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
if (evt.defaultPrevented && jQueryEvent) {
jQueryEvent.preventDefault();
}
@ -357,4 +313,21 @@ const EventHandler = {
},
};
function hydrateObj(obj, meta) {
for (const [key, value] of Object.entries(meta || {})) {
try {
obj[key] = value;
} catch {
Object.defineProperty(obj, key, {
configurable: true,
get() {
return value;
},
});
}
}
return obj;
}
export default EventHandler;

55
src/js/bootstrap/src/dom/manipulator.js
View File

@ -1,28 +1,36 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/manipulator.js
* Bootstrap (v5.2.2): dom/manipulator.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
function normalizeData(val) {
if (val === 'true') {
function normalizeData(value) {
if (value === 'true') {
return true;
}
if (val === 'false') {
if (value === 'false') {
return false;
}
if (val === Number(val).toString()) {
return Number(val);
if (value === Number(value).toString()) {
return Number(value);
}
if (val === '' || val === 'null') {
if (value === '' || value === 'null') {
return null;
}
return val;
if (typeof value !== 'string') {
return value;
}
try {
return JSON.parse(decodeURIComponent(value));
} catch {
return value;
}
}
function normalizeDataKey(key) {
@ -44,14 +52,15 @@ const Manipulator = {
}
const attributes = {};
const bsKeys = Object.keys(element.dataset).filter(
(key) => key.startsWith('bs') && !key.startsWith('bsConfig')
);
Object.keys(element.dataset)
.filter((key) => key.startsWith('bs'))
.forEach((key) => {
let pureKey = key.replace(/^bs/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
});
for (const key of bsKeys) {
let pureKey = key.replace(/^bs/, '');
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element.dataset[key]);
}
return attributes;
},
@ -59,22 +68,6 @@ const Manipulator = {
getDataAttribute(element, key) {
return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
},
offset(element) {
const rect = element.getBoundingClientRect();
return {
top: rect.top + window.pageYOffset,
left: rect.left + window.pageXOffset,
};
},
position(element) {
return {
top: element.offsetTop,
left: element.offsetLeft,
};
},
};
export default Manipulator;

28
src/js/bootstrap/src/dom/selector-engine.js
View File

@ -1,19 +1,15 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dom/selector-engine.js
* Bootstrap (v5.2.2): dom/selector-engine.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
import { isDisabled, isVisible } from '../util/index';
const NODE_TEXT = 3;
/**
* Constants
*/
const SelectorEngine = {
find(selector, element = document.documentElement) {
@ -30,15 +26,11 @@ const SelectorEngine = {
parents(element, selector) {
const parents = [];
let ancestor = element.parentNode.closest(selector);
let ancestor = element.parentNode;
while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
if (ancestor.matches(selector)) {
parents.push(ancestor);
}
ancestor = ancestor.parentNode;
while (ancestor) {
parents.push(ancestor);
ancestor = ancestor.parentNode.closest(selector);
}
return parents;
@ -57,7 +49,7 @@ const SelectorEngine = {
return [];
},
// TODO: this is now unused; remove later along with prev()
next(element, selector) {
let next = element.nextElementSibling;
@ -84,7 +76,7 @@ const SelectorEngine = {
'[contenteditable="true"]',
]
.map((selector) => `${selector}:not([tabindex^="-"])`)
.join(', ');
.join(',');
return this.find(focusables, element).filter((el) => !isDisabled(el) && isVisible(el));
},

258
src/js/bootstrap/src/dropdown.js
View File

@ -1,23 +1,20 @@
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.1.3): dropdown.js
* Bootstrap (v5.2.2): dropdown.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
import * as Popper from '@popperjs/core';
import {
defineJQueryPlugin,
getElement,
getElementFromSelector,
getNextActiveElement,
isDisabled,
isElement,
isRTL,
isVisible,
noop,
typeCheckConfig,
} from './util/index';
import EventHandler from './dom/event-handler';
import Manipulator from './dom/manipulator';
@ -25,9 +22,7 @@ import SelectorEngine from './dom/selector-engine';
import BaseComponent from './base-component';
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const NAME = 'dropdown';
@ -36,14 +31,11 @@ const EVENT_KEY = `.${DATA_KEY}`;
const DATA_API_KEY = '.data-api';
const ESCAPE_KEY = 'Escape';
const SPACE_KEY = 'Space';
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 REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY}`);
const EVENT_HIDE = `hide${EVENT_KEY}`;
const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
const EVENT_SHOW = `show${EVENT_KEY}`;
@ -56,10 +48,13 @@ const CLASS_NAME_SHOW = 'show';
const CLASS_NAME_DROPUP = 'dropup';
const CLASS_NAME_DROPEND = 'dropend';
const CLASS_NAME_DROPSTART = 'dropstart';
const CLASS_NAME_NAVBAR = 'navbar';
const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]';
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)';
@ -69,43 +64,46 @@ const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
const PLACEMENT_TOPCENTER = 'top';
const PLACEMENT_BOTTOMCENTER = 'bottom';
const Default = {
offset: [0, 2],
boundary: 'clippingParents',
reference: 'toggle',
display: 'dynamic',
popperConfig: null,
autoClose: true,
boundary: 'clippingParents',
display: 'dynamic',
offset: [0, 2],
popperConfig: null,
reference: 'toggle',
};
const DefaultType = {
offset: '(array|string|function)',
boundary: '(string|element)',
reference: '(string|element|object)',
display: 'string',
popperConfig: '(null|object|function)',
autoClose: '(boolean|string)',
boundary: '(string|element)',
display: 'string',
offset: '(array|string|function)',
popperConfig: '(null|object|function)',
reference: '(string|element|object)',
};
/**
* ------------------------------------------------------------------------
* Class Definition
* ------------------------------------------------------------------------
* Class definition
*/
class Dropdown extends BaseComponent {
constructor(element, config) {
super(element);
super(element, config);
this._popper = null;
this._config = this._getConfig(config);
this._menu = this._getMenuElement();
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.next(this._element, SELECTOR_MENU)[0] ||
SelectorEngine.prev(this._element, SELECTOR_MENU)[0] ||
SelectorEngine.findOne(SELECTOR_MENU, this._parent);
this._inNavbar = this._detectNavbar();
}
// Getters
static get Default() {
return Default;
}
@ -119,13 +117,12 @@ class Dropdown extends BaseComponent {
}
// Public
toggle() {
return this._isShown() ? this.hide() : this.show();
}
show() {
if (isDisabled(this._element) || this._isShown(this._menu)) {
if (isDisabled(this._element) || this._isShown()) {
return;
}
@ -139,22 +136,16 @@ class Dropdown extends BaseComponent {
return;
}
const parent = Dropdown.getParentFromElement(this._element);
// Totally disable Popper for Dropdowns in Navbar
if (this._inNavbar) {
Manipulator.setDataAttribute(this._menu, 'popper', 'none');
} else {
this._createPopper(parent);
}
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 && !parent.closest(SELECTOR_NAVBAR_NAV)) {
[]
.concat(...document.body.children)
.forEach((elem) => EventHandler.on(elem, 'mouseover', noop));
if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
for (const element of [].concat(...document.body.children)) {
EventHandler.on(element, 'mouseover', noop);
}
}
this._element.focus();
@ -166,7 +157,7 @@ class Dropdown extends BaseComponent {
}
hide() {
if (isDisabled(this._element) || !this._isShown(this._menu)) {
if (isDisabled(this._element) || !this._isShown()) {
return;
}
@ -193,7 +184,6 @@ class Dropdown extends BaseComponent {
}
// Private
_completeHide(relatedTarget) {
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE, relatedTarget);
if (hideEvent.defaultPrevented) {
@ -203,9 +193,9 @@ class Dropdown extends BaseComponent {
// 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((elem) => EventHandler.off(elem, 'mouseover', noop));
for (const element of [].concat(...document.body.children)) {
EventHandler.off(element, 'mouseover', noop);
}
}
if (this._popper) {
@ -220,13 +210,7 @@ class Dropdown extends BaseComponent {
}
_getConfig(config) {
config = {
...this.constructor.Default,
...Manipulator.getDataAttributes(this._element),
...config,
};
typeCheckConfig(NAME, config, this.constructor.DefaultType);
config = super._getConfig(config);
if (
typeof config.reference === 'object' &&
@ -242,7 +226,7 @@ class Dropdown extends BaseComponent {
return config;
}
_createPopper(parent) {
_createPopper() {
if (typeof Popper === 'undefined') {
throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
}
@ -250,7 +234,7 @@ class Dropdown extends BaseComponent {
let referenceElement = this._element;
if (this._config.reference === 'parent') {
referenceElement = parent;
referenceElement = this._parent;
} else if (isElement(this._config.reference)) {
referenceElement = getElement(this._config.reference);
} else if (typeof this._config.reference === 'object') {
@ -258,27 +242,15 @@ class Dropdown extends BaseComponent {
}
const popperConfig = this._getPopperConfig();
const isDisplayStatic = popperConfig.modifiers.find(
(modifier) => modifier.name === 'applyStyles' && modifier.enabled === false
);
this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);
if (isDisplayStatic) {
Manipulator.setDataAttribute(this._menu, 'popper', 'static');
}
}
_isShown(element = this._element) {
return element.classList.contains(CLASS_NAME_SHOW);
}
_getMenuElement() {
return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
_isShown() {
return this._menu.classList.contains(CLASS_NAME_SHOW);
}
_getPlacement() {
const parentDropdown = this._element.parentNode;
const parentDropdown = this._parent;
if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
return PLACEMENT_RIGHT;
@ -288,6 +260,14 @@ class Dropdown extends BaseComponent {
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';
@ -299,14 +279,14 @@ class Dropdown extends BaseComponent {
}
_detectNavbar() {
return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
return this._element.closest(SELECTOR_NAVBAR) !== null;
}
_getOffset() {
const { offset } = this._config;
if (typeof offset === 'string') {
return offset.split(',').map((val) => Number.parseInt(val, 10));
return offset.split(',').map((value) => Number.parseInt(value, 10));
}
if (typeof offset === 'function') {
@ -335,8 +315,9 @@ class Dropdown extends BaseComponent {
],
};
// Disable Popper if we have a static display
if (this._config.display === 'static') {
// Disable Popper if we have a static display or Dropdown is in Navbar
if (this._inNavbar || this._config.display === 'static') {
Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // todo:v6 remove
defaultBsPopperConfig.modifiers = [
{
name: 'applyStyles',
@ -354,7 +335,9 @@ class Dropdown extends BaseComponent {
}
_selectMenuItem({ key, target }) {
const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter((element) =>
isVisible(element)
);
if (!items.length) {
return;
@ -366,7 +349,6 @@ class Dropdown extends BaseComponent {
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Dropdown.getOrCreateInstance(this, config);
@ -384,123 +366,92 @@ class Dropdown extends BaseComponent {
}
static clearMenus(event) {
if (
event &&
(event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY))
) {
if (event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY)) {
return;
}
const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE);
const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
for (let i = 0, len = toggles.length; i < len; i++) {
const context = Dropdown.getInstance(toggles[i]);
for (const toggle of openToggles) {
const context = Dropdown.getInstance(toggle);
if (!context || context._config.autoClose === false) {
continue;
}
if (!context._isShown()) {
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;
}
const relatedTarget = {
relatedTarget: context._element,
};
// 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;
}
if (event) {
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;
}
const relatedTarget = { relatedTarget: context._element };
// 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;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
context._completeHide(relatedTarget);
}
}
static getParentFromElement(element) {
return getElementFromSelector(element) || element.parentNode;
}
static dataApiKeydownHandler(event) {
// If not input/textarea:
// - And not a key in REGEXP_KEYDOWN => not a dropdown command
// If input/textarea:
// - If space key => not a dropdown command
// - If key is other than escape
// - If key is not up or down => not a dropdown command
// - If trigger inside the menu => not a dropdown command
if (
/input|textarea/i.test(event.target.tagName)
? event.key === SPACE_KEY ||
(event.key !== ESCAPE_KEY &&
((event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY) ||
event.target.closest(SELECTOR_MENU)))
: !REGEXP_KEYDOWN.test(event.key)
) {
// 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;
}
const isActive = this.classList.contains(CLASS_NAME_SHOW);
if (!isActive && event.key === ESCAPE_KEY) {
if (isInput && !isEscapeEvent) {
return;
}
event.preventDefault();
event.stopPropagation();
if (isDisabled(this)) {
return;
}
// todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/
const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE)
? this
: SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0];
: SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0] ||
SelectorEngine.next(this, SELECTOR_DATA_TOGGLE)[0] ||
SelectorEngine.findOne(SELECTOR_DATA_TOGGLE, event.delegateTarget.parentNode);
const instance = Dropdown.getOrCreateInstance(getToggleButton);
if (event.key === ESCAPE_KEY) {
instance.hide();
return;
}
if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
if (!isActive) {
instance.show();
}
if (isUpOrDownEvent) {
event.stopPropagation();
instance.show();
instance._selectMenuItem(event);
return;
}
if (!isActive || event.key === SPACE_KEY) {
Dropdown.clearMenus();
if (instance._isShown()) {
// else is escape and we check if it is shown
event.stopPropagation();
instance.hide();
getToggleButton.focus();
}
}
}
/**
* ------------------------------------------------------------------------
* Data Api implementation
* ------------------------------------------------------------------------
* Data API implementation
*/
EventHandler.on(
@ -518,10 +469,7 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
});
/**
* ------------------------------------------------------------------------
* jQuery
* ------------------------------------------------------------------------
* add .Dropdown to jQuery only if jQuery is present
*/
defineJQueryPlugin(Dropdown);

Some files were not shown because too many files have changed in this diff Show More