code
stringlengths 10
343k
| docstring
stringlengths 36
21.9k
| func_name
stringlengths 1
3.35k
| language
stringclasses 1
value | repo
stringlengths 7
58
| path
stringlengths 4
131
| url
stringlengths 44
195
| license
stringclasses 5
values |
|---|---|---|---|---|---|---|---|
SparkMD5.ArrayBuffer.prototype.reset = function () {
this._buff = new Uint8Array(0);
this._length = 0;
this._state = [1732584193, -271733879, -1732584194, 271733878];
return this;
}; | Resets the internal state of the computation.
@return {SparkMD5.ArrayBuffer} The instance itself | SparkMD5.ArrayBuffer.prototype.reset ( ) | javascript | fex-team/webuploader | dist/webuploader.fis.js | https://github.com/fex-team/webuploader/blob/master/dist/webuploader.fis.js | BSD-3-Clause |
SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
var firstLength = first.length,
result = new Uint8Array(firstLength + second.byteLength);
result.set(first);
result.set(new Uint8Array(second), firstLength);
return result;
}; | Concats two array buffers, returning a new one.
@param {ArrayBuffer} first The first array buffer
@param {ArrayBuffer} second The second array buffer
@return {ArrayBuffer} The new array buffer | SparkMD5.ArrayBuffer.prototype._concatArrayBuffer ( first , second ) | javascript | fex-team/webuploader | dist/webuploader.fis.js | https://github.com/fex-team/webuploader/blob/master/dist/webuploader.fis.js | BSD-3-Clause |
SparkMD5.ArrayBuffer.hash = function (arr, raw) {
var hash = md51_array(new Uint8Array(arr));
return !!raw ? hash : hex(hash);
}; | Performs the md5 hash on an array buffer.
@param {ArrayBuffer} arr The array buffer
@param {Boolean} raw True to get the raw result, false to get the hex result
@return {String|Array} The result | SparkMD5.ArrayBuffer.hash ( arr , raw ) | javascript | fex-team/webuploader | dist/webuploader.fis.js | https://github.com/fex-team/webuploader/blob/master/dist/webuploader.fis.js | BSD-3-Clause |
SparkMD5.prototype._finish = function (tail, length) {
var i = length,
tmp,
lo,
hi;
tail[i >> 2] |= 0x80 << ((i % 4) << 3);
if (i > 55) {
md5cycle(this._state, tail);
for (i = 0; i < 16; i += 1) {
tail[i] = 0;
}
}
// Do the final computation based on the tail and length
// Beware that the final length may not fit in 32 bits so we take care of that
tmp = this._length * 8;
tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
lo = parseInt(tmp[2], 16);
hi = parseInt(tmp[1], 16) || 0;
tail[14] = lo;
tail[15] = hi;
md5cycle(this._state, tail);
};
/**
* Resets the internal state of the computation.
*
* @return {SparkMD5} The instance itself
*/
SparkMD5.prototype.reset = function () {
this._buff = "";
this._length = 0;
this._state = [1732584193, -271733879, -1732584194, 271733878];
return this;
};
/**
* Releases memory used by the incremental buffer and other aditional
* resources. If you plan to use the instance again, use reset instead.
*/
SparkMD5.prototype.destroy = function () {
delete this._state;
delete this._buff;
delete this._length;
};
/**
* Performs the md5 hash on a string.
* A conversion will be applied if utf8 string is detected.
*
* @param {String} str The string
* @param {Boolean} raw True to get the raw result, false to get the hex result
*
* @return {String|Array} The result
*/
SparkMD5.hash = function (str, raw) {
// converts the string to utf8 bytes if necessary
if (/[\u0080-\uFFFF]/.test(str)) {
str = unescape(encodeURIComponent(str));
}
var hash = md51(str);
return !!raw ? hash : hex(hash);
};
/**
* Performs the md5 hash on a binary string.
*
* @param {String} content The binary string
* @param {Boolean} raw True to get the raw result, false to get the hex result
*
* @return {String|Array} The result
*/
SparkMD5.hashBinary = function (content, raw) {
var hash = md51(content);
return !!raw ? hash : hex(hash);
};
/**
* SparkMD5 OOP implementation for array buffers.
*
* Use this class to perform an incremental md5 ONLY for array buffers.
*/
SparkMD5.ArrayBuffer = function () {
// call reset to init the instance
this.reset();
};
////////////////////////////////////////////////////////////////////////////
/**
* Appends an array buffer.
*
* @param {ArrayBuffer} arr The array to be appended
*
* @return {SparkMD5.ArrayBuffer} The instance itself
*/
SparkMD5.ArrayBuffer.prototype.append = function (arr) {
// TODO: we could avoid the concatenation here but the algorithm would be more complex
// if you find yourself needing extra performance, please make a PR.
var buff = this._concatArrayBuffer(this._buff, arr),
length = buff.length,
i;
this._length += arr.byteLength;
for (i = 64; i <= length; i += 64) {
md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
}
// Avoids IE10 weirdness (documented above)
this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
return this;
};
/**
* Finishes the incremental computation, reseting the internal state and
* returning the result.
* Use the raw parameter to obtain the raw result instead of the hex one.
*
* @param {Boolean} raw True to get the raw result, false to get the hex result
*
* @return {String|Array} The result
*/
SparkMD5.ArrayBuffer.prototype.end = function (raw) {
var buff = this._buff,
length = buff.length,
tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
i,
ret;
for (i = 0; i < length; i += 1) {
tail[i >> 2] |= buff[i] << ((i % 4) << 3);
}
this._finish(tail, length);
ret = !!raw ? this._state : hex(this._state);
this.reset();
return ret;
};
SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
/**
* Resets the internal state of the computation.
*
* @return {SparkMD5.ArrayBuffer} The instance itself
*/
SparkMD5.ArrayBuffer.prototype.reset = function () {
this._buff = new Uint8Array(0);
this._length = 0;
this._state = [1732584193, -271733879, -1732584194, 271733878];
return this;
};
/**
* Releases memory used by the incremental buffer and other aditional
* resources. If you plan to use the instance again, use reset instead.
*/
SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
/**
* Concats two array buffers, returning a new one.
*
* @param {ArrayBuffer} first The first array buffer
* @param {ArrayBuffer} second The second array buffer
*
* @return {ArrayBuffer} The new array buffer
*/
SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
var firstLength = first.length,
result = new Uint8Array(firstLength + second.byteLength);
result.set(first);
result.set(new Uint8Array(second), firstLength);
return result;
};
/**
* Performs the md5 hash on an array buffer.
*
* @param {ArrayBuffer} arr The array buffer
* @param {Boolean} raw True to get the raw result, false to get the hex result
*
* @return {String|Array} The result
*/
SparkMD5.ArrayBuffer.hash = function (arr, raw) {
var hash = md51_array(new Uint8Array(arr));
return !!raw ? hash : hex(hash);
};
return FlashRuntime.register( 'Md5', {
init: function() {
// do nothing.
},
loadFromBlob: function( file ) {
var blob = file.getSource(),
chunkSize = 2 * 1024 * 1024,
chunks = Math.ceil( blob.size / chunkSize ),
chunk = 0,
owner = this.owner,
spark = new SparkMD5.ArrayBuffer(),
me = this,
blobSlice = blob.mozSlice || blob.webkitSlice || blob.slice,
loadNext, fr;
fr = new FileReader();
loadNext = function() {
var start, end;
start = chunk * chunkSize;
end = Math.min( start + chunkSize, blob.size );
fr.onload = function( e ) {
spark.append( e.target.result );
owner.trigger( 'progress', {
total: file.size,
loaded: end
});
};
fr.onloadend = function() {
fr.onloadend = fr.onload = null;
if ( ++chunk < chunks ) {
setTimeout( loadNext, 1 );
} else {
setTimeout(function(){
owner.trigger('load');
me.result = spark.end();
loadNext = file = blob = spark = null;
owner.trigger('complete');
}, 50 );
}
};
fr.readAsArrayBuffer( blobSlice.call( blob, start, end ) );
};
loadNext();
},
getResult: function() {
return this.result;
}
});
}); | Finish the final calculation based on the tail.
@param {Array} tail The tail (will be modified)
@param {Number} length The length of the remaining buffer | SparkMD5.prototype._finish ( tail , length ) | javascript | fex-team/webuploader | dist/webuploader.fis.js | https://github.com/fex-team/webuploader/blob/master/dist/webuploader.fis.js | BSD-3-Clause |
addButton: function( pick ) {
var me = this,
opts = me.options,
accept = opts.accept,
options, picker, deferred;
if ( !pick ) {
return;
}
deferred = Base.Deferred();
if ( typeof pick === 'string' ) {
pick = {
id: pick
};
}
options = $.extend({}, pick, {
accept: $.isPlainObject( accept ) ? [ accept ] : accept,
swf: opts.swf,
runtimeOrder: opts.runtimeOrder
});
picker = new FilePicker( options );
picker.once( 'ready', deferred.resolve );
picker.on( 'select', function( files ) {
me.owner.request( 'add-file', [ files ]);
});
picker.init();
this.pickers.push( picker );
return deferred.promise();
}
});
}); | @method addButton
@for Uploader
@grammar addButton( pick ) => Promise
@description
添加文件选择按钮，如果一个按钮不够，需要调用此方法来添加。参数跟[options.pick](#WebUploader:Uploader:options)一致。
@example
uploader.addButton({
id: '#btnContainer',
label: '选择文件'
}); | addButton ( pick ) | javascript | fex-team/webuploader | _draft/music/webuploader.js | https://github.com/fex-team/webuploader/blob/master/_draft/music/webuploader.js | BSD-3-Clause |
define( 'runtime/html5/util', function() {
var urlAPI = window.createObjectURL && window ||
window.URL && URL.revokeObjectURL && URL ||
window.webkitURL;
return {
createObjectURL: urlAPI && urlAPI.createObjectURL,
revokeObjectURL: urlAPI && urlAPI.revokeObjectURL,
dataURL2Blob: function( dataURI ) {
var byteStr, intArray, ab, i, mimetype, parts;
parts = dataURI.split(',');
if ( ~parts[ 0 ].indexOf('base64') ) {
byteStr = atob( parts[ 1 ] );
} else {
byteStr = decodeURIComponent( parts[ 1 ] );
}
ab = new ArrayBuffer( byteStr.length );
intArray = new Uint8Array( ab );
for ( i = 0; i < byteStr.length; i++ ) {
intArray[ i ] = byteStr.charCodeAt( i );
}
mimetype = parts[ 0 ].split(':')[ 1 ].split(';')[ 0 ];
return new Blob([ ab ], {
type: mimetype
});
},
dataURL2ArrayBuffer: function( dataURI ) {
var byteStr, intArray, i, parts;
parts = dataURI.split(',');
if ( ~parts[ 0 ].indexOf('base64') ) {
byteStr = atob( parts[ 1 ] );
} else {
byteStr = decodeURIComponent( parts[ 1 ] );
}
intArray = new Uint8Array( byteStr.length );
for ( i = 0; i < byteStr.length; i++ ) {
intArray[ i ] = byteStr.charCodeAt( i );
}
return intArray.buffer;
},
arrayBufferToBlob: function( buffer, type ) {
return new Blob([ buffer ], type ? { type: type } : {} );
}
};
}); | Terms:
Uint8Array, FileReader, BlobBuilder, atob, ArrayBuffer
@fileOverview Image控件 | (anonymous) ( ) | javascript | fex-team/webuploader | _draft/music/webuploader.js | https://github.com/fex-team/webuploader/blob/master/_draft/music/webuploader.js | BSD-3-Clause |
(function( modules ) {
var
// 让首写字母大写。
ucFirst = function( str ) {
return str && (str.charAt( 0 ).toUpperCase() + str.substr( 1 ));
},
// 暴露出去的key
exportName = 'WebUploader',
exports = modules.base,
key, host, parts, part, last, origin;
for ( key in modules ) {
host = exports;
if ( !modules.hasOwnProperty( key ) ) {
continue;
}
parts = key.split('/');
last = ucFirst( parts.pop() );
while( (part = ucFirst( parts.shift() )) ) {
host[ part ] = host[ part ] || {};
host = host[ part ];
}
host[ last ] = modules[ key ];
}
if ( typeof module === 'object' && typeof module.exports === 'object' ) {
module.exports = exports;
} else if ( window.define && window.define.amd ) {
window.define( function() { return exports; } );
} else {
origin = window[ exportName ];
window[ exportName ] = exports;
window[ exportName ].noConflict = function() {
window[ exportName ] = origin;
};
}
})( internalAmd.modules ); | @file 暴露变量给外部使用。
此文件也只有在把webupload合并成一个文件使用的时候才会引入。
将所有modules，将路径ids装换成对象。 | (anonymous) ( modules ) | javascript | fex-team/webuploader | _draft/music/webuploader.js | https://github.com/fex-team/webuploader/blob/master/_draft/music/webuploader.js | BSD-3-Clause |
log: (function() {
if ( window.console ) {
return bindFn( console.log, console );
}
return noop;
})(), | 引用Console.log如果存在的话，否则引用一个[空函数noop](#WebUploader:Base.noop)。
@grammar Base.log( args... ) => undefined
@method log | log ( function ( ) | javascript | fex-team/webuploader | src/base.js | https://github.com/fex-team/webuploader/blob/master/src/base.js | BSD-3-Clause |
option: function( key, val ) {
var opts = this.options;
// setter
if ( arguments.length > 1 ) {
if ( $.isPlainObject( val ) &&
$.isPlainObject( opts[ key ] ) ) {
$.extend( opts[ key ], val );
} else {
opts[ key ] = val;
}
} else { // getter
return key ? opts[ key ] : opts;
}
}, | 获取或者设置Uploader配置项。
@method option
@grammar option( key ) => *
@grammar option( key, val ) => self
@example
// 初始状态图片上传前不会压缩
var uploader = new WebUploader.Uploader({
compress: null;
});
// 修改后图片上传前，尝试将图片压缩到1600 * 1600
uploader.option( 'compress', {
width: 1600,
height: 1600
}); | option ( key , val ) | javascript | fex-team/webuploader | src/uploader.js | https://github.com/fex-team/webuploader/blob/master/src/uploader.js | BSD-3-Clause |
async function gracefulClusterShutdown () {
console.log('Starting graceful cluster shutdown')
shuttingDownServer = true
await shutdownWorkers('SIGTERM')
console.log('Successfully finished graceful cluster shutdown')
process.exit(0)
} | Shutdown the cluster workers properly | gracefulClusterShutdown ( ) | javascript | godaddy/terminus | example/express.cluster.js | https://github.com/godaddy/terminus/blob/master/example/express.cluster.js | MIT |
getCommit: function getCommit(ref) {
var commitData = this.commitData,
headMatcher = /HEAD(\^+)/.exec(ref),
matchedCommit = null;
if (ref === 'initial') {
return this.initialCommit;
}
if (headMatcher) {
ref = 'HEAD';
}
for (var i = 0; i < commitData.length; i++) {
var commit = commitData[i];
if (commit === ref) {
matchedCommit = commit;
break;
}
if (commit.id === ref) {
matchedCommit = commit;
break;
}
var matchedTag = function() {
for (var j = 0; j < commit.tags.length; j++) {
var tag = commit.tags[j];
if (tag === ref) {
matchedCommit = commit;
return true;
}
if (tag.indexOf('[') === 0 && tag.indexOf(']') === tag.length - 1) {
tag = tag.substring(1, tag.length - 1);
}
if (tag === ref) {
matchedCommit = commit;
return true;
}
}
}();
if (matchedTag === true) {
break;
}
}
if (headMatcher && matchedCommit) {
for (var h = 0; h < headMatcher[1].length; h++) {
matchedCommit = getCommit.call(this, matchedCommit.parent);
}
}
return matchedCommit;
}, | @method getCommit
@param ref {String} the id or a tag name that refers to the commit
@return {Object} the commit datum object | getCommit ( ref ) | javascript | onlywei/explain-git-with-d3 | js/historyview.js | https://github.com/onlywei/explain-git-with-d3/blob/master/js/historyview.js | MIT |
getCircle: function (ref) {
var circle = this.svg.select('#' + this.name + '-' + ref),
commit;
if (circle && !circle.empty()) {
return circle;
}
commit = this.getCommit(ref);
if (!commit) {
return null;
}
return this.svg.select('#' + this.name + '-' + commit.id);
}, | @method getCircle
@param ref {String} the id or a tag name that refers to the commit
@return {d3 Selection} the d3 selected SVG circle | getCircle ( ref ) | javascript | onlywei/explain-git-with-d3 | js/historyview.js | https://github.com/onlywei/explain-git-with-d3/blob/master/js/historyview.js | MIT |
render: function (container) {
var svgContainer, svg;
svgContainer = container.append('div')
.classed('svg-container', true)
.classed('remote-container', this.isRemote);
svg = svgContainer.append('svg:svg');
svg.attr('id', this.name)
.attr('width', this.width)
.attr('height', this.height);
if (this.isRemote) {
svg.append('svg:text')
.classed('remote-name-display', true)
.text(this.remoteName)
.attr('x', 10)
.attr('y', 25);
} else {
svg.append('svg:text')
.classed('remote-name-display', true)
.text('Local Repository')
.attr('x', 10)
.attr('y', 25);
svg.append('svg:text')
.classed('current-branch-display', true)
.attr('x', 10)
.attr('y', 45);
}
this.svgContainer = svgContainer;
this.svg = svg;
this.arrowBox = svg.append('svg:g').classed('pointers', true);
this.commitBox = svg.append('svg:g').classed('commits', true);
this.tagBox = svg.append('svg:g').classed('tags', true);
this.renderCommits();
this._setCurrentBranch(this.currentBranch);
}, | @method render
@param container {String} selector for the container to render the SVG into | render ( container ) | javascript | onlywei/explain-git-with-d3 | js/historyview.js | https://github.com/onlywei/explain-git-with-d3/blob/master/js/historyview.js | MIT |
isAncestor: function isAncestor(ref1, ref2) {
var currentCommit = this.getCommit(ref1),
targetTree = this.getCommit(ref2),
inTree = false,
additionalTrees = [];
if (!currentCommit) {
return false;
}
while (targetTree) {
if (targetTree.id === currentCommit.id) {
inTree = true;
targetTree = null;
} else {
if (targetTree.parent2) {
additionalTrees.push(targetTree.parent2);
}
targetTree = this.getCommit(targetTree.parent);
}
}
if (inTree) {
return true;
}
for (var i = 0; i < additionalTrees.length; i++) {
inTree = isAncestor.call(this, currentCommit, additionalTrees[i]);
if (inTree) break;
}
return inTree;
}, | @method isAncestor
@param ref1
@param ref2
@return {Boolean} whether or not ref1 is an ancestor of ref2 | isAncestor ( ref1 , ref2 ) | javascript | onlywei/explain-git-with-d3 | js/historyview.js | https://github.com/onlywei/explain-git-with-d3/blob/master/js/historyview.js | MIT |
pushVal: function() {
var self = this,
val = $.map(self.items(), function(item) {
return self.options.itemValue(item).toString();
});
self.$element.val(val, true).trigger('change');
}, | Assembly value by retrieving the value of each item, and set it on the
element. | pushVal ( ) | javascript | hargata/lubelog | wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | https://github.com/hargata/lubelog/blob/master/wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | MIT |
function makeOptionItemFunction(options, key) {
if (typeof options[key] !== 'function') {
var propertyName = options[key];
options[key] = function(item) { return item[propertyName]; };
}
} | Most options support both a string or number as well as a function as
option value. This function makes sure that the option with the given
key in the given options is wrapped in a function | makeOptionItemFunction ( options , key ) | javascript | hargata/lubelog | wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | https://github.com/hargata/lubelog/blob/master/wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | MIT |
function doGetCaretPosition(oField) {
var iCaretPos = 0;
if (document.selection) {
oField.focus ();
var oSel = document.selection.createRange();
oSel.moveStart ('character', -oField.value.length);
iCaretPos = oSel.text.length;
} else if (oField.selectionStart || oField.selectionStart == '0') {
iCaretPos = oField.selectionStart;
}
return (iCaretPos);
} | Returns the position of the caret in the given input field
http://flightschool.acylt.com/devnotes/caret-position-woes/ | doGetCaretPosition ( oField ) | javascript | hargata/lubelog | wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | https://github.com/hargata/lubelog/blob/master/wwwroot/lib/bootstrap-tagsinput/bootstrap-tagsinput.js | MIT |
const parseSelector = selector => {
if (selector && window.CSS && window.CSS.escape) {
// document.querySelector needs escaping to handle IDs (html5+) containing for instance /
selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
}
return selector;
};
// 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 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(parseSelector(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 = (possibleCallback, args = [], defaultValue = possibleCallback) => {
return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue;
};
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))];
};
/**
* --------------------------------------------------------------------------
* Bootstrap dom/event-handler.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
const stripNameRegex = /\..*/;
const stripUidRegex = /::\d+$/;
const eventRegistry = {}; // Events storage
let uidEvent = 1;
const customEvents = {
mouseenter: 'mouseover',
mouseleave: 'mouseout'
};
const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
/**
* Private methods
*/
function makeEventUid(element, uid) {
return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
}
function getElementEvents(element) {
const uid = makeEventUid(element);
element.uidEvent = uid;
eventRegistry[uid] = eventRegistry[uid] || {};
return eventRegistry[uid];
}
function bootstrapHandler(element, fn) {
return function handler(event) {
hydrateObj(event, {
delegateTarget: element
});
if (handler.oneOff) {
EventHandler.off(element, event.type, fn);
}
return fn.apply(element, [event]);
};
}
function bootstrapDelegationHandler(element, selector, fn) {
return function handler(event) {
const domElements = element.querySelectorAll(selector);
for (let {
target
} = event; target && target !== this; target = target.parentNode) {
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]);
}
}
};
}
function findHandler(events, callable, delegationSelector = null) {
return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
}
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);
if (!nativeEvents.has(typeEvent)) {
typeEvent = originalTypeEvent;
}
return [isDelegated, callable, typeEvent];
}
function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
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 (originalTypeEvent in customEvents) {
const wrapFunction = fn => {
return function (event) {
if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
return fn.call(this, event);
}
};
};
callable = wrapFunction(callable);
}
const events = getElementEvents(element);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
if (previousFunction) {
previousFunction.oneOff = previousFunction.oneOff && oneOff;
return;
}
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, isDelegated);
}
function removeHandler(element, events, typeEvent, handler, delegationSelector) {
const fn = findHandler(events[typeEvent], handler, delegationSelector);
if (!fn) {
return;
}
element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
delete events[typeEvent][fn.uidEvent];
}
function removeNamespacedHandlers(element, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
if (handlerKey.includes(namespace)) {
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
}
}
function getTypeEvent(event) {
// allow to get the native events from namespaced events ('click.bs.button' --> 'click')
event = event.replace(stripNameRegex, '');
return customEvents[event] || event;
}
const EventHandler = {
on(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, false);
},
one(element, event, handler, delegationFunction) {
addHandler(element, event, handler, delegationFunction, true);
},
off(element, originalTypeEvent, handler, delegationFunction) {
if (typeof originalTypeEvent !== 'string' || !element) {
return;
}
const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getElementEvents(element);
const storeElementEvent = events[typeEvent] || {};
const isNamespace = originalTypeEvent.startsWith('.');
if (typeof callable !== 'undefined') {
// Simplest case: handler is passed, remove that listener ONLY.
if (!Object.keys(storeElementEvent).length) {
return;
}
removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
return;
}
if (isNamespace) {
for (const elementEvent of Object.keys(events)) {
removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
}
}
for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
const handlerKey = keyHandlers.replace(stripUidRegex, '');
if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
}
}
},
trigger(element, event, args) {
if (typeof event !== 'string' || !element) {
return null;
}
const $ = getjQuery();
const typeEvent = getTypeEvent(event);
const inNamespace = event !== typeEvent;
let jQueryEvent = null;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
if (inNamespace && $) {
jQueryEvent = $.Event(event, args);
$(element).trigger(jQueryEvent);
bubbles = !jQueryEvent.isPropagationStopped();
nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
const evt = hydrateObj(new Event(event, {
bubbles,
cancelable: true
}), args);
if (defaultPrevented) {
evt.preventDefault();
}
if (nativeDispatch) {
element.dispatchEvent(evt);
}
if (evt.defaultPrevented && jQueryEvent) {
jQueryEvent.preventDefault();
}
return evt;
}
};
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;
}
/**
* --------------------------------------------------------------------------
* Bootstrap dom/manipulator.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
function normalizeData(value) {
if (value === 'true') {
return true;
}
if (value === 'false') {
return false;
}
if (value === Number(value).toString()) {
return Number(value);
}
if (value === '' || value === 'null') {
return null;
}
if (typeof value !== 'string') {
return value;
}
try {
return JSON.parse(decodeURIComponent(value));
} catch (_unused) {
return value;
}
}
function normalizeDataKey(key) {
return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
}
const Manipulator = {
setDataAttribute(element, key, value) {
element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
},
removeDataAttribute(element, key) {
element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
},
getDataAttributes(element) {
if (!element) {
return {};
}
const attributes = {};
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)}`));
}
};
/**
* --------------------------------------------------------------------------
* Bootstrap 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 = 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, expectedTypes] of Object.entries(configTypes)) {
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}".`);
}
}
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap base-component.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const VERSION = '5.3.2';
/**
* Class definition
*/
class BaseComponent extends Config {
constructor(element, config) {
super();
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);
for (const propertyName of Object.getOwnPropertyNames(this)) {
this[propertyName] = null;
}
}
_queueCallback(callback, element, isAnimated = true) {
executeAfterTransition(callback, element, isAnimated);
}
_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);
}
static getOrCreateInstance(element, config = {}) {
return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
}
static get VERSION() {
return VERSION;
}
static get DATA_KEY() {
return `bs.${this.NAME}`;
}
static get EVENT_KEY() {
return `.${this.DATA_KEY}`;
}
static eventName(name) {
return `${name}${this.EVENT_KEY}`;
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap dom/selector-engine.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 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 !== '#' ? parseSelector(hrefAttribute.trim()) : null;
}
return selector;
};
const SelectorEngine = {
find(selector, element = document.documentElement) {
return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
},
findOne(selector, element = document.documentElement) {
return Element.prototype.querySelector.call(element, selector);
},
children(element, selector) {
return [].concat(...element.children).filter(child => child.matches(selector));
},
parents(element, selector) {
const parents = [];
let ancestor = element.parentNode.closest(selector);
while (ancestor) {
parents.push(ancestor);
ancestor = ancestor.parentNode.closest(selector);
}
return parents;
},
prev(element, selector) {
let previous = element.previousElementSibling;
while (previous) {
if (previous.matches(selector)) {
return [previous];
}
previous = previous.previousElementSibling;
}
return [];
},
// TODO: this is now unused; remove later along with prev()
next(element, selector) {
let next = element.nextElementSibling;
while (next) {
if (next.matches(selector)) {
return [next];
}
next = next.nextElementSibling;
}
return [];
},
focusableChildren(element) {
const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(',');
return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
},
getSelectorFromElement(element) {
const selector = getSelector(element);
if (selector) {
return SelectorEngine.findOne(selector) ? selector : null;
}
return null;
},
getElementFromSelector(element) {
const selector = getSelector(element);
return selector ? SelectorEngine.findOne(selector) : null;
},
getMultipleElementsFromSelector(element) {
const selector = getSelector(element);
return selector ? SelectorEngine.find(selector) : [];
}
};
/**
* --------------------------------------------------------------------------
* Bootstrap 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.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
const target = SelectorEngine.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 alert.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$f = 'alert';
const DATA_KEY$a = 'bs.alert';
const EVENT_KEY$b = `.${DATA_KEY$a}`;
const EVENT_CLOSE = `close${EVENT_KEY$b}`;
const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
const CLASS_NAME_FADE$5 = 'fade';
const CLASS_NAME_SHOW$8 = 'show';
/**
* Class definition
*/
class Alert extends BaseComponent {
// Getters
static get NAME() {
return NAME$f;
}
// Public
close() {
const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
if (closeEvent.defaultPrevented) {
return;
}
this._element.classList.remove(CLASS_NAME_SHOW$8);
const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
}
// Private
_destroyElement() {
this._element.remove();
EventHandler.trigger(this._element, EVENT_CLOSED);
this.dispose();
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Alert.getOrCreateInstance(this);
if (typeof config !== 'string') {
return;
}
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config](this);
});
}
}
/**
* Data API implementation
*/
enableDismissTrigger(Alert, 'close');
/**
* jQuery
*/
defineJQueryPlugin(Alert);
/**
* --------------------------------------------------------------------------
* Bootstrap button.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$e = 'button';
const DATA_KEY$9 = 'bs.button';
const EVENT_KEY$a = `.${DATA_KEY$9}`;
const DATA_API_KEY$6 = '.data-api';
const CLASS_NAME_ACTIVE$3 = 'active';
const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
/**
* Class definition
*/
class Button extends BaseComponent {
// Getters
static get NAME() {
return NAME$e;
}
// 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$3));
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Button.getOrCreateInstance(this);
if (config === 'toggle') {
data[config]();
}
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
event.preventDefault();
const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
const data = Button.getOrCreateInstance(button);
data.toggle();
});
/**
* jQuery
*/
defineJQueryPlugin(Button);
/**
* --------------------------------------------------------------------------
* Bootstrap util/swipe.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$d = 'swipe';
const EVENT_KEY$9 = '.bs.swipe';
const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
const POINTER_TYPE_TOUCH = 'touch';
const POINTER_TYPE_PEN = 'pen';
const CLASS_NAME_POINTER_EVENT = 'pointer-event';
const SWIPE_THRESHOLD = 40;
const Default$c = {
endCallback: null,
leftCallback: null,
rightCallback: null
};
const DefaultType$c = {
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$c;
}
static get DefaultType() {
return DefaultType$c;
}
static get NAME() {
return NAME$d;
}
// Public
dispose() {
EventHandler.off(this._element, EVENT_KEY$9);
}
// 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;
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap carousel.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$c = 'carousel';
const DATA_KEY$8 = 'bs.carousel';
const EVENT_KEY$8 = `.${DATA_KEY$8}`;
const DATA_API_KEY$5 = '.data-api';
const ARROW_LEFT_KEY$1 = 'ArrowLeft';
const ARROW_RIGHT_KEY$1 = 'ArrowRight';
const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
const ORDER_NEXT = 'next';
const ORDER_PREV = 'prev';
const DIRECTION_LEFT = 'left';
const DIRECTION_RIGHT = 'right';
const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
const EVENT_SLID = `slid${EVENT_KEY$8}`;
const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
const CLASS_NAME_CAROUSEL = 'carousel';
const CLASS_NAME_ACTIVE$2 = 'active';
const CLASS_NAME_SLIDE = 'slide';
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 SELECTOR_ACTIVE = '.active';
const SELECTOR_ITEM = '.carousel-item';
const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
const SELECTOR_ITEM_IMG = '.carousel-item img';
const SELECTOR_INDICATORS = '.carousel-indicators';
const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
const KEY_TO_DIRECTION = {
[ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
[ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
};
const Default$b = {
interval: 5000,
keyboard: true,
pause: 'hover',
ride: false,
touch: true,
wrap: true
};
const DefaultType$b = {
interval: '(number|boolean)',
// TODO:v6 remove boolean support
keyboard: 'boolean',
pause: '(string|boolean)',
ride: '(boolean|string)',
touch: 'boolean',
wrap: 'boolean'
};
/**
* Class definition
*/
class Carousel extends BaseComponent {
constructor(element, config) {
super(element, config);
this._interval = null;
this._activeElement = null;
this._isSliding = false;
this.touchTimeout = null;
this._swipeHelper = null;
this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
this._addEventListeners();
if (this._config.ride === CLASS_NAME_CAROUSEL) {
this.cycle();
}
}
// Getters
static get Default() {
return Default$b;
}
static get DefaultType() {
return DefaultType$b;
}
static get NAME() {
return NAME$c;
}
// 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)) {
this.next();
}
}
prev() {
this._slide(ORDER_PREV);
}
pause() {
if (this._isSliding) {
triggerTransitionEnd(this._element);
}
this._clearInterval();
}
cycle() {
this._clearInterval();
this._updateInterval();
this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
}
_maybeEnableCycle() {
if (!this._config.ride) {
return;
}
if (this._isSliding) {
EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
return;
}
this.cycle();
}
to(index) {
const items = this._getItems();
if (index > items.length - 1 || index < 0) {
return;
}
if (this._isSliding) {
EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
return;
}
const activeIndex = this._getItemIndex(this._getActive());
if (activeIndex === index) {
return;
}
const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
this._slide(order, items[index]);
}
dispose() {
if (this._swipeHelper) {
this._swipeHelper.dispose();
}
super.dispose();
}
// Private
_configAfterMerge(config) {
config.defaultInterval = config.interval;
return config;
}
_addEventListeners() {
if (this._config.keyboard) {
EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
}
if (this._config.pause === 'hover') {
EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
}
if (this._config.touch && Swipe.isSupported()) {
this._addTouchEventListeners();
}
}
_addTouchEventListeners() {
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 swipeConfig = {
leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
endCallback: endCallBack
};
this._swipeHelper = new Swipe(this._element, swipeConfig);
}
_keydown(event) {
if (/input|textarea/i.test(event.target.tagName)) {
return;
}
const direction = KEY_TO_DIRECTION[event.key];
if (direction) {
event.preventDefault();
this._slide(this._directionToOrder(direction));
}
}
_getItemIndex(element) {
return this._getItems().indexOf(element);
}
_setActiveIndicatorElement(index) {
if (!this._indicatorsElement) {
return;
}
const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
activeIndicator.removeAttribute('aria-current');
const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
if (newActiveIndicator) {
newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
newActiveIndicator.setAttribute('aria-current', 'true');
}
}
_updateInterval() {
const element = this._activeElement || this._getActive();
if (!element) {
return;
}
const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
this._config.interval = elementInterval || this._config.defaultInterval;
}
_slide(order, element = null) {
if (this._isSliding) {
return;
}
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;
this._setActiveIndicatorElement(nextElementIndex);
this._activeElement = nextElement;
const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
nextElement.classList.add(orderClassName);
reflow(nextElement);
activeElement.classList.add(directionalClassName);
nextElement.classList.add(directionalClassName);
const completeCallBack = () => {
nextElement.classList.remove(directionalClassName, orderClassName);
nextElement.classList.add(CLASS_NAME_ACTIVE$2);
activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
this._isSliding = false;
triggerEvent(EVENT_SLID);
};
this._queueCallback(completeCallBack, activeElement, this._isAnimated());
if (isCycling) {
this.cycle();
}
}
_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;
}
return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
}
_orderToDirection(order) {
if (isRTL()) {
return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
}
return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
}
// Static
static jQueryInterface(config) {
return this.each(function () {
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]();
}
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
const target = SelectorEngine.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$3, () => {
const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
for (const carousel of carousels) {
Carousel.getOrCreateInstance(carousel);
}
});
/**
* jQuery
*/
defineJQueryPlugin(Carousel);
/**
* --------------------------------------------------------------------------
* Bootstrap collapse.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$b = 'collapse';
const DATA_KEY$7 = 'bs.collapse';
const EVENT_KEY$7 = `.${DATA_KEY$7}`;
const DATA_API_KEY$4 = '.data-api';
const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
const CLASS_NAME_SHOW$7 = 'show';
const CLASS_NAME_COLLAPSE = 'collapse';
const CLASS_NAME_COLLAPSING = 'collapsing';
const CLASS_NAME_COLLAPSED = 'collapsed';
const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
const WIDTH = 'width';
const HEIGHT = 'height';
const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
const Default$a = {
parent: null,
toggle: true
};
const DefaultType$a = {
parent: '(null|element)',
toggle: 'boolean'
};
/**
* Class definition
*/
class Collapse extends BaseComponent {
constructor(element, config) {
super(element, config);
this._isTransitioning = false;
this._triggerArray = [];
const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
for (const elem of toggleList) {
const selector = SelectorEngine.getSelectorFromElement(elem);
const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
if (selector !== null && filterElement.length) {
this._triggerArray.push(elem);
}
}
this._initializeChildren();
if (!this._config.parent) {
this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
}
if (this._config.toggle) {
this.toggle();
}
}
// Getters
static get Default() {
return Default$a;
}
static get DefaultType() {
return DefaultType$a;
}
static get NAME() {
return NAME$b;
}
// Public
toggle() {
if (this._isShown()) {
this.hide();
} else {
this.show();
}
}
show() {
if (this._isTransitioning || this._isShown()) {
return;
}
let activeChildren = [];
// find active children
if (this._config.parent) {
activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
toggle: false
}));
}
if (activeChildren.length && activeChildren[0]._isTransitioning) {
return;
}
const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
if (startEvent.defaultPrevented) {
return;
}
for (const activeInstance of activeChildren) {
activeInstance.hide();
}
const dimension = this._getDimension();
this._element.classList.remove(CLASS_NAME_COLLAPSE);
this._element.classList.add(CLASS_NAME_COLLAPSING);
this._element.style[dimension] = 0;
this._addAriaAndCollapsedClass(this._triggerArray, true);
this._isTransitioning = true;
const complete = () => {
this._isTransitioning = false;
this._element.classList.remove(CLASS_NAME_COLLAPSING);
this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
this._element.style[dimension] = '';
EventHandler.trigger(this._element, EVENT_SHOWN$6);
};
const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
const scrollSize = `scroll${capitalizedDimension}`;
this._queueCallback(complete, this._element, true);
this._element.style[dimension] = `${this._element[scrollSize]}px`;
}
hide() {
if (this._isTransitioning || !this._isShown()) {
return;
}
const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
if (startEvent.defaultPrevented) {
return;
}
const dimension = this._getDimension();
this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
reflow(this._element);
this._element.classList.add(CLASS_NAME_COLLAPSING);
this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
for (const trigger of this._triggerArray) {
const element = SelectorEngine.getElementFromSelector(trigger);
if (element && !this._isShown(element)) {
this._addAriaAndCollapsedClass([trigger], false);
}
}
this._isTransitioning = true;
const complete = () => {
this._isTransitioning = false;
this._element.classList.remove(CLASS_NAME_COLLAPSING);
this._element.classList.add(CLASS_NAME_COLLAPSE);
EventHandler.trigger(this._element, EVENT_HIDDEN$6);
};
this._element.style[dimension] = '';
this._queueCallback(complete, this._element, true);
}
_isShown(element = this._element) {
return element.classList.contains(CLASS_NAME_SHOW$7);
}
// Private
_configAfterMerge(config) {
config.toggle = Boolean(config.toggle); // Coerce string values
config.parent = getElement(config.parent);
return config;
}
_getDimension() {
return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
}
_initializeChildren() {
if (!this._config.parent) {
return;
}
const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
for (const element of children) {
const selected = SelectorEngine.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) {
if (!triggerArray.length) {
return;
}
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 data = Collapse.getOrCreateInstance(this, _config);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
}
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
// preventDefault only for <a> elements (which change the URL) not inside the collapsible element
if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
event.preventDefault();
}
for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
Collapse.getOrCreateInstance(element, {
toggle: false
}).toggle();
}
});
/**
* jQuery
*/
defineJQueryPlugin(Collapse);
/**
* --------------------------------------------------------------------------
* Bootstrap dropdown.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$a = 'dropdown';
const DATA_KEY$6 = 'bs.dropdown';
const EVENT_KEY$6 = `.${DATA_KEY$6}`;
const DATA_API_KEY$3 = '.data-api';
const ESCAPE_KEY$2 = 'Escape';
const TAB_KEY$1 = 'Tab';
const ARROW_UP_KEY$1 = 'ArrowUp';
const ARROW_DOWN_KEY$1 = 'ArrowDown';
const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;
const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;
const EVENT_SHOW$5 = `show${EVENT_KEY$6}`;
const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;
const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;
const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;
const CLASS_NAME_SHOW$6 = 'show';
const CLASS_NAME_DROPUP = 'dropup';
const CLASS_NAME_DROPEND = 'dropend';
const CLASS_NAME_DROPSTART = 'dropstart';
const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)';
const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;
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_TOPCENTER = 'top';
const PLACEMENT_BOTTOMCENTER = 'bottom';
const Default$9 = {
autoClose: true,
boundary: 'clippingParents',
display: 'dynamic',
offset: [0, 2],
popperConfig: null,
reference: 'toggle'
};
const DefaultType$9 = {
autoClose: '(boolean|string)',
boundary: '(string|element)',
display: 'string',
offset: '(array|string|function)',
popperConfig: '(null|object|function)',
reference: '(string|element|object)'
};
/**
* Class definition
*/
class Dropdown extends BaseComponent {
constructor(element, config) {
super(element, config);
this._popper = null;
this._parent = this._element.parentNode; // dropdown wrapper
// TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/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$9;
}
static get DefaultType() {
return DefaultType$9;
}
static get NAME() {
return NAME$a;
}
// Public
toggle() {
return this._isShown() ? this.hide() : this.show();
}
show() {
if (isDisabled(this._element) || this._isShown()) {
return;
}
const relatedTarget = {
relatedTarget: this._element
};
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);
if (showEvent.defaultPrevented) {
return;
}
this._createPopper();
// If this is a touch-enabled device we add extra
// empty mouseover listeners to the body's immediate children;
// only needed because of broken event delegation on iOS
// https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
for (const element of [].concat(...document.body.children)) {
EventHandler.on(element, 'mouseover', noop);
}
}
this._element.focus();
this._element.setAttribute('aria-expanded', true);
this._menu.classList.add(CLASS_NAME_SHOW$6);
this._element.classList.add(CLASS_NAME_SHOW$6);
EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);
}
hide() {
if (isDisabled(this._element) || !this._isShown()) {
return;
}
const relatedTarget = {
relatedTarget: this._element
};
this._completeHide(relatedTarget);
}
dispose() {
if (this._popper) {
this._popper.destroy();
}
super.dispose();
}
update() {
this._inNavbar = this._detectNavbar();
if (this._popper) {
this._popper.update();
}
}
// Private
_completeHide(relatedTarget) {
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);
if (hideEvent.defaultPrevented) {
return;
}
// If this is a touch-enabled device we remove the extra
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
for (const element of [].concat(...document.body.children)) {
EventHandler.off(element, 'mouseover', noop);
}
}
if (this._popper) {
this._popper.destroy();
}
this._menu.classList.remove(CLASS_NAME_SHOW$6);
this._element.classList.remove(CLASS_NAME_SHOW$6);
this._element.setAttribute('aria-expanded', 'false');
Manipulator.removeDataAttribute(this._menu, 'popper');
EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);
}
_getConfig(config) {
config = super._getConfig(config);
if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
// Popper virtual elements require a getBoundingClientRect method
throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
}
return config;
}
_createPopper() {
if (typeof Popper === 'undefined') {
throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
}
let referenceElement = this._element;
if (this._config.reference === 'parent') {
referenceElement = this._parent;
} else if (isElement(this._config.reference)) {
referenceElement = getElement(this._config.reference);
} else if (typeof this._config.reference === 'object') {
referenceElement = this._config.reference;
}
const popperConfig = this._getPopperConfig();
this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);
}
_isShown() {
return this._menu.classList.contains(CLASS_NAME_SHOW$6);
}
_getPlacement() {
const parentDropdown = this._parent;
if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
return PLACEMENT_RIGHT;
}
if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
return PLACEMENT_LEFT;
}
if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
return PLACEMENT_TOPCENTER;
}
if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
return PLACEMENT_BOTTOMCENTER;
}
// We need to trim the value because custom properties can also include spaces
const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
}
return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
}
_detectNavbar() {
return this._element.closest(SELECTOR_NAVBAR) !== null;
}
_getOffset() {
const {
offset
} = this._config;
if (typeof offset === 'string') {
return offset.split(',').map(value => Number.parseInt(value, 10));
}
if (typeof offset === 'function') {
return popperData => offset(popperData, this._element);
}
return offset;
}
_getPopperConfig() {
const defaultBsPopperConfig = {
placement: this._getPlacement(),
modifiers: [{
name: 'preventOverflow',
options: {
boundary: this._config.boundary
}
}, {
name: 'offset',
options: {
offset: this._getOffset()
}
}]
};
// Disable Popper if we have a static display or Dropdown is in Navbar
if (this._inNavbar || this._config.display === 'static') {
Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove
defaultBsPopperConfig.modifiers = [{
name: 'applyStyles',
enabled: false
}];
}
return {
...defaultBsPopperConfig,
...execute(this._config.popperConfig, [defaultBsPopperConfig])
};
}
_selectMenuItem({
key,
target
}) {
const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => 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$1, !items.includes(target)).focus();
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Dropdown.getOrCreateInstance(this, config);
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
static clearMenus(event) {
if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {
return;
}
const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
for (const toggle of openToggles) {
const context = Dropdown.getInstance(toggle);
if (!context || context._config.autoClose === false) {
continue;
}
const composedPath = event.composedPath();
const isMenuTarget = composedPath.includes(context._menu);
if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
continue;
}
// Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
continue;
}
const relatedTarget = {
relatedTarget: context._element
};
if (event.type === 'click') {
relatedTarget.clickEvent = event;
}
context._completeHide(relatedTarget);
}
}
static dataApiKeydownHandler(event) {
// If not an UP | DOWN | ESCAPE key => not a dropdown command
// If input/textarea && if key is other than ESCAPE => not a dropdown command
const isInput = /input|textarea/i.test(event.target.tagName);
const isEscapeEvent = event.key === ESCAPE_KEY$2;
const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);
if (!isUpOrDownEvent && !isEscapeEvent) {
return;
}
if (isInput && !isEscapeEvent) {
return;
}
event.preventDefault();
// TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);
const instance = Dropdown.getOrCreateInstance(getToggleButton);
if (isUpOrDownEvent) {
event.stopPropagation();
instance.show();
instance._selectMenuItem(event);
return;
}
if (instance._isShown()) {
// else is escape and we check if it is shown
event.stopPropagation();
instance.hide();
getToggleButton.focus();
}
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
event.preventDefault();
Dropdown.getOrCreateInstance(this).toggle();
});
/**
* jQuery
*/
defineJQueryPlugin(Dropdown);
/**
* --------------------------------------------------------------------------
* Bootstrap util/backdrop.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$9 = 'backdrop';
const CLASS_NAME_FADE$4 = 'fade';
const CLASS_NAME_SHOW$5 = 'show';
const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;
const Default$8 = {
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$8 = {
className: 'string',
clickCallback: '(function|null)',
isAnimated: 'boolean',
isVisible: 'boolean',
rootElement: '(element|string)'
};
/**
* Class definition
*/
class Backdrop extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isAppended = false;
this._element = null;
}
// Getters
static get Default() {
return Default$8;
}
static get DefaultType() {
return DefaultType$8;
}
static get NAME() {
return NAME$9;
}
// Public
show(callback) {
if (!this._config.isVisible) {
execute(callback);
return;
}
this._append();
const element = this._getElement();
if (this._config.isAnimated) {
reflow(element);
}
element.classList.add(CLASS_NAME_SHOW$5);
this._emulateAnimation(() => {
execute(callback);
});
}
hide(callback) {
if (!this._config.isVisible) {
execute(callback);
return;
}
this._getElement().classList.remove(CLASS_NAME_SHOW$5);
this._emulateAnimation(() => {
this.dispose();
execute(callback);
});
}
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');
backdrop.className = this._config.className;
if (this._config.isAnimated) {
backdrop.classList.add(CLASS_NAME_FADE$4);
}
this._element = backdrop;
}
return this._element;
}
_configAfterMerge(config) {
// use getElement() with the default "body" to get a fresh Element on each instantiation
config.rootElement = getElement(config.rootElement);
return config;
}
_append() {
if (this._isAppended) {
return;
}
const element = this._getElement();
this._config.rootElement.append(element);
EventHandler.on(element, EVENT_MOUSEDOWN, () => {
execute(this._config.clickCallback);
});
this._isAppended = true;
}
_emulateAnimation(callback) {
executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap util/focustrap.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$8 = 'focustrap';
const DATA_KEY$5 = 'bs.focustrap';
const EVENT_KEY$5 = `.${DATA_KEY$5}`;
const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;
const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;
const TAB_KEY = 'Tab';
const TAB_NAV_FORWARD = 'forward';
const TAB_NAV_BACKWARD = 'backward';
const Default$7 = {
autofocus: true,
trapElement: null // The element to trap focus inside of
};
const DefaultType$7 = {
autofocus: 'boolean',
trapElement: 'element'
};
/**
* Class definition
*/
class FocusTrap extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isActive = false;
this._lastTabNavDirection = null;
}
// Getters
static get Default() {
return Default$7;
}
static get DefaultType() {
return DefaultType$7;
}
static get NAME() {
return NAME$8;
}
// Public
activate() {
if (this._isActive) {
return;
}
if (this._config.autofocus) {
this._config.trapElement.focus();
}
EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop
EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));
EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
this._isActive = true;
}
deactivate() {
if (!this._isActive) {
return;
}
this._isActive = false;
EventHandler.off(document, EVENT_KEY$5);
}
// Private
_handleFocusin(event) {
const {
trapElement
} = this._config;
if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
return;
}
const elements = SelectorEngine.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;
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap 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.setDataAttribute(element, styleProperty, actualValue);
}
}
_resetElementAttributes(selector, styleProperty) {
const manipulationCallBack = element => {
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);
}
_applyManipulationCallback(selector, callBack) {
if (isElement(selector)) {
callBack(selector);
return;
}
for (const sel of SelectorEngine.find(selector, this._element)) {
callBack(sel);
}
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap modal.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$7 = 'modal';
const DATA_KEY$4 = 'bs.modal';
const EVENT_KEY$4 = `.${DATA_KEY$4}`;
const DATA_API_KEY$2 = '.data-api';
const ESCAPE_KEY$1 = 'Escape';
const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;
const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;
const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;
const EVENT_SHOW$4 = `show${EVENT_KEY$4}`;
const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;
const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;
const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;
const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;
const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;
const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;
const CLASS_NAME_OPEN = 'modal-open';
const CLASS_NAME_FADE$3 = 'fade';
const CLASS_NAME_SHOW$4 = 'show';
const CLASS_NAME_STATIC = 'modal-static';
const OPEN_SELECTOR$1 = '.modal.show';
const SELECTOR_DIALOG = '.modal-dialog';
const SELECTOR_MODAL_BODY = '.modal-body';
const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
const Default$6 = {
backdrop: true,
focus: true,
keyboard: true
};
const DefaultType$6 = {
backdrop: '(boolean|string)',
focus: 'boolean',
keyboard: 'boolean'
};
/**
* Class definition
*/
class Modal extends BaseComponent {
constructor(element, config) {
super(element, config);
this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
this._backdrop = this._initializeBackDrop();
this._focustrap = this._initializeFocusTrap();
this._isShown = false;
this._isTransitioning = false;
this._scrollBar = new ScrollBarHelper();
this._addEventListeners();
}
// Getters
static get Default() {
return Default$6;
}
static get DefaultType() {
return DefaultType$6;
}
static get NAME() {
return NAME$7;
}
// Public
toggle(relatedTarget) {
return this._isShown ? this.hide() : this.show(relatedTarget);
}
show(relatedTarget) {
if (this._isShown || this._isTransitioning) {
return;
}
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {
relatedTarget
});
if (showEvent.defaultPrevented) {
return;
}
this._isShown = true;
this._isTransitioning = true;
this._scrollBar.hide();
document.body.classList.add(CLASS_NAME_OPEN);
this._adjustDialog();
this._backdrop.show(() => this._showElement(relatedTarget));
}
hide() {
if (!this._isShown || this._isTransitioning) {
return;
}
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
if (hideEvent.defaultPrevented) {
return;
}
this._isShown = false;
this._isTransitioning = true;
this._focustrap.deactivate();
this._element.classList.remove(CLASS_NAME_SHOW$4);
this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
}
dispose() {
EventHandler.off(window, EVENT_KEY$4);
EventHandler.off(this._dialog, EVENT_KEY$4);
this._backdrop.dispose();
this._focustrap.deactivate();
super.dispose();
}
handleUpdate() {
this._adjustDialog();
}
// Private
_initializeBackDrop() {
return new Backdrop({
isVisible: Boolean(this._config.backdrop),
// 'static' option will be translated to true, and booleans will keep their value,
isAnimated: this._isAnimated()
});
}
_initializeFocusTrap() {
return new FocusTrap({
trapElement: this._element
});
}
_showElement(relatedTarget) {
// try to append dynamic modal
if (!document.body.contains(this._element)) {
document.body.append(this._element);
}
this._element.style.display = 'block';
this._element.removeAttribute('aria-hidden');
this._element.setAttribute('aria-modal', true);
this._element.setAttribute('role', 'dialog');
this._element.scrollTop = 0;
const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
if (modalBody) {
modalBody.scrollTop = 0;
}
reflow(this._element);
this._element.classList.add(CLASS_NAME_SHOW$4);
const transitionComplete = () => {
if (this._config.focus) {
this._focustrap.activate();
}
this._isTransitioning = false;
EventHandler.trigger(this._element, EVENT_SHOWN$4, {
relatedTarget
});
};
this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
}
_addEventListeners() {
EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
if (event.key !== ESCAPE_KEY$1) {
return;
}
if (this._config.keyboard) {
this.hide();
return;
}
this._triggerBackdropTransition();
});
EventHandler.on(window, EVENT_RESIZE$1, () => {
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();
}
});
});
}
_hideModal() {
this._element.style.display = 'none';
this._element.setAttribute('aria-hidden', true);
this._element.removeAttribute('aria-modal');
this._element.removeAttribute('role');
this._isTransitioning = false;
this._backdrop.hide(() => {
document.body.classList.remove(CLASS_NAME_OPEN);
this._resetAdjustments();
this._scrollBar.reset();
EventHandler.trigger(this._element, EVENT_HIDDEN$4);
});
}
_isAnimated() {
return this._element.classList.contains(CLASS_NAME_FADE$3);
}
_triggerBackdropTransition() {
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);
if (hideEvent.defaultPrevented) {
return;
}
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 (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
return;
}
if (!isModalOverflowing) {
this._element.style.overflowY = 'hidden';
}
this._element.classList.add(CLASS_NAME_STATIC);
this._queueCallback(() => {
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
*/
_adjustDialog() {
const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
const scrollbarWidth = this._scrollBar.getWidth();
const isBodyOverflowing = scrollbarWidth > 0;
if (isBodyOverflowing && !isModalOverflowing) {
const property = isRTL() ? 'paddingLeft' : 'paddingRight';
this._element.style[property] = `${scrollbarWidth}px`;
}
if (!isBodyOverflowing && isModalOverflowing) {
const property = isRTL() ? 'paddingRight' : 'paddingLeft';
this._element.style[property] = `${scrollbarWidth}px`;
}
}
_resetAdjustments() {
this._element.style.paddingLeft = '';
this._element.style.paddingRight = '';
}
// Static
static jQueryInterface(config, relatedTarget) {
return this.each(function () {
const data = Modal.getOrCreateInstance(this, config);
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config](relatedTarget);
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
const target = SelectorEngine.getElementFromSelector(this);
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
EventHandler.one(target, EVENT_SHOW$4, showEvent => {
if (showEvent.defaultPrevented) {
// only register focus restorer if modal will actually get shown
return;
}
EventHandler.one(target, EVENT_HIDDEN$4, () => {
if (isVisible(this)) {
this.focus();
}
});
});
// avoid conflict when clicking modal toggler while another one is open
const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
if (alreadyOpen) {
Modal.getInstance(alreadyOpen).hide();
}
const data = Modal.getOrCreateInstance(target);
data.toggle(this);
});
enableDismissTrigger(Modal);
/**
* jQuery
*/
defineJQueryPlugin(Modal);
/**
* --------------------------------------------------------------------------
* Bootstrap offcanvas.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$6 = 'offcanvas';
const DATA_KEY$3 = 'bs.offcanvas';
const EVENT_KEY$3 = `.${DATA_KEY$3}`;
const DATA_API_KEY$1 = '.data-api';
const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;
const ESCAPE_KEY = 'Escape';
const CLASS_NAME_SHOW$3 = 'show';
const CLASS_NAME_SHOWING$1 = 'showing';
const CLASS_NAME_HIDING = 'hiding';
const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
const OPEN_SELECTOR = '.offcanvas.show';
const EVENT_SHOW$3 = `show${EVENT_KEY$3}`;
const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;
const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;
const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;
const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;
const EVENT_RESIZE = `resize${EVENT_KEY$3}`;
const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;
const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;
const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
const Default$5 = {
backdrop: true,
keyboard: true,
scroll: false
};
const DefaultType$5 = {
backdrop: '(boolean|string)',
keyboard: 'boolean',
scroll: 'boolean'
};
/**
* Class definition
*/
class Offcanvas extends BaseComponent {
constructor(element, config) {
super(element, config);
this._isShown = false;
this._backdrop = this._initializeBackDrop();
this._focustrap = this._initializeFocusTrap();
this._addEventListeners();
}
// Getters
static get Default() {
return Default$5;
}
static get DefaultType() {
return DefaultType$5;
}
static get NAME() {
return NAME$6;
}
// Public
toggle(relatedTarget) {
return this._isShown ? this.hide() : this.show(relatedTarget);
}
show(relatedTarget) {
if (this._isShown) {
return;
}
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
relatedTarget
});
if (showEvent.defaultPrevented) {
return;
}
this._isShown = true;
this._backdrop.show();
if (!this._config.scroll) {
new ScrollBarHelper().hide();
}
this._element.setAttribute('aria-modal', true);
this._element.setAttribute('role', 'dialog');
this._element.classList.add(CLASS_NAME_SHOWING$1);
const completeCallBack = () => {
if (!this._config.scroll || this._config.backdrop) {
this._focustrap.activate();
}
this._element.classList.add(CLASS_NAME_SHOW$3);
this._element.classList.remove(CLASS_NAME_SHOWING$1);
EventHandler.trigger(this._element, EVENT_SHOWN$3, {
relatedTarget
});
};
this._queueCallback(completeCallBack, this._element, true);
}
hide() {
if (!this._isShown) {
return;
}
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
if (hideEvent.defaultPrevented) {
return;
}
this._focustrap.deactivate();
this._element.blur();
this._isShown = false;
this._element.classList.add(CLASS_NAME_HIDING);
this._backdrop.hide();
const completeCallback = () => {
this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);
this._element.removeAttribute('aria-modal');
this._element.removeAttribute('role');
if (!this._config.scroll) {
new ScrollBarHelper().reset();
}
EventHandler.trigger(this._element, EVENT_HIDDEN$3);
};
this._queueCallback(completeCallback, this._element, true);
}
dispose() {
this._backdrop.dispose();
this._focustrap.deactivate();
super.dispose();
}
// Private
_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,
isAnimated: true,
rootElement: this._element.parentNode,
clickCallback: isVisible ? clickCallback : null
});
}
_initializeFocusTrap() {
return new FocusTrap({
trapElement: this._element
});
}
_addEventListeners() {
EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
if (event.key !== ESCAPE_KEY) {
return;
}
if (this._config.keyboard) {
this.hide();
return;
}
EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
});
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Offcanvas.getOrCreateInstance(this, config);
if (typeof config !== 'string') {
return;
}
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config](this);
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
const target = SelectorEngine.getElementFromSelector(this);
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
EventHandler.one(target, EVENT_HIDDEN$3, () => {
// focus on trigger when it is closed
if (isVisible(this)) {
this.focus();
}
});
// avoid conflict when clicking a toggler of an offcanvas, while another is open
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$2, () => {
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);
/**
* --------------------------------------------------------------------------
* Bootstrap util/sanitizer.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
// js-docs-start allow-list
const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
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: []
};
// js-docs-end allow-list
const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
/**
* A pattern that recognizes URLs that are safe wrt. XSS in URL navigation
* contexts.
*
* Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38
*/
// eslint-disable-next-line unicorn/better-regex
const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/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));
}
return true;
}
// Check if a regular expression validates the attribute.
return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));
};
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;
}
/**
* --------------------------------------------------------------------------
* Bootstrap util/template-factory.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$5 = 'TemplateFactory';
const Default$4 = {
allowList: DefaultAllowlist,
content: {},
// { selector : text , selector2 : text2 , }
extraClass: '',
html: false,
sanitize: true,
sanitizeFn: null,
template: '<div></div>'
};
const DefaultType$4 = {
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$4;
}
static get DefaultType() {
return DefaultType$4;
}
static get NAME() {
return NAME$5;
}
// 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 execute(arg, [this]);
}
_putElementInTemplate(element, templateElement) {
if (this._config.html) {
templateElement.innerHTML = '';
templateElement.append(element);
return;
}
templateElement.textContent = element.textContent;
}
}
/**
* --------------------------------------------------------------------------
* Bootstrap tooltip.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$4 = 'tooltip';
const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
const CLASS_NAME_FADE$2 = 'fade';
const CLASS_NAME_MODAL = 'modal';
const CLASS_NAME_SHOW$2 = 'show';
const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
const EVENT_MODAL_HIDE = 'hide.bs.modal';
const TRIGGER_HOVER = 'hover';
const TRIGGER_FOCUS = 'focus';
const TRIGGER_CLICK = 'click';
const TRIGGER_MANUAL = 'manual';
const EVENT_HIDE$2 = 'hide';
const EVENT_HIDDEN$2 = 'hidden';
const EVENT_SHOW$2 = 'show';
const EVENT_SHOWN$2 = 'shown';
const EVENT_INSERTED = 'inserted';
const EVENT_CLICK$1 = 'click';
const EVENT_FOCUSIN$1 = 'focusin';
const EVENT_FOCUSOUT$1 = 'focusout';
const EVENT_MOUSEENTER = 'mouseenter';
const EVENT_MOUSELEAVE = 'mouseleave';
const AttachmentMap = {
AUTO: 'auto',
TOP: 'top',
RIGHT: isRTL() ? 'left' : 'right',
BOTTOM: 'bottom',
LEFT: isRTL() ? 'right' : 'left'
};
const Default$3 = {
allowList: DefaultAllowlist,
animation: true,
boundary: 'clippingParents',
container: false,
customClass: '',
delay: 0,
fallbackPlacements: ['top', 'right', 'bottom', 'left'],
html: false,
offset: [0, 6],
placement: 'top',
popperConfig: null,
sanitize: true,
sanitizeFn: null,
selector: false,
template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
title: '',
trigger: 'hover focus'
};
const DefaultType$3 = {
allowList: 'object',
animation: 'boolean',
boundary: '(string|element)',
container: '(string|element|boolean)',
customClass: '(string|function)',
delay: '(number|object)',
fallbackPlacements: 'array',
html: 'boolean',
offset: '(array|string|function)',
placement: '(string|function)',
popperConfig: '(null|object|function)',
sanitize: 'boolean',
sanitizeFn: '(null|function)',
selector: '(string|boolean)',
template: 'string',
title: '(string|element|function)',
trigger: 'string'
};
/**
* Class definition
*/
class Tooltip extends BaseComponent {
constructor(element, config) {
if (typeof Popper === 'undefined') {
throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
}
super(element, config);
// Private
this._isEnabled = true;
this._timeout = 0;
this._isHovered = null;
this._activeTrigger = {};
this._popper = null;
this._templateFactory = null;
this._newContent = null;
// Protected
this.tip = null;
this._setListeners();
if (!this._config.selector) {
this._fixTitle();
}
}
// Getters
static get Default() {
return Default$3;
}
static get DefaultType() {
return DefaultType$3;
}
static get NAME() {
return NAME$4;
}
// Public
enable() {
this._isEnabled = true;
}
disable() {
this._isEnabled = false;
}
toggleEnabled() {
this._isEnabled = !this._isEnabled;
}
toggle() {
if (!this._isEnabled) {
return;
}
this._activeTrigger.click = !this._activeTrigger.click;
if (this._isShown()) {
this._leave();
return;
}
this._enter();
}
dispose() {
clearTimeout(this._timeout);
EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
if (this._element.getAttribute('data-bs-original-title')) {
this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));
}
this._disposePopper();
super.dispose();
}
show() {
if (this._element.style.display === 'none') {
throw new Error('Please use show on visible elements');
}
if (!(this._isWithContent() && this._isEnabled)) {
return;
}
const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));
const shadowRoot = findShadowRoot(this._element);
const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);
if (showEvent.defaultPrevented || !isInTheDom) {
return;
}
// TODO: v6 remove this or make it optional
this._disposePopper();
const tip = this._getTipElement();
this._element.setAttribute('aria-describedby', tip.getAttribute('id'));
const {
container
} = this._config;
if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
container.append(tip);
EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));
}
this._popper = this._createPopper(tip);
tip.classList.add(CLASS_NAME_SHOW$2);
// 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) {
for (const element of [].concat(...document.body.children)) {
EventHandler.on(element, 'mouseover', noop);
}
}
const complete = () => {
EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));
if (this._isHovered === false) {
this._leave();
}
this._isHovered = false;
};
this._queueCallback(complete, this.tip, this._isAnimated());
}
hide() {
if (!this._isShown()) {
return;
}
const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));
if (hideEvent.defaultPrevented) {
return;
}
const tip = this._getTipElement();
tip.classList.remove(CLASS_NAME_SHOW$2);
// If this is a touch-enabled device we remove the extra
// empty mouseover listeners we added for iOS support
if ('ontouchstart' in document.documentElement) {
for (const element of [].concat(...document.body.children)) {
EventHandler.off(element, 'mouseover', noop);
}
}
this._activeTrigger[TRIGGER_CLICK] = false;
this._activeTrigger[TRIGGER_FOCUS] = false;
this._activeTrigger[TRIGGER_HOVER] = false;
this._isHovered = null; // it is a trick to support manual triggering
const complete = () => {
if (this._isWithActiveTrigger()) {
return;
}
if (!this._isHovered) {
this._disposePopper();
}
this._element.removeAttribute('aria-describedby');
EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));
};
this._queueCallback(complete, this.tip, this._isAnimated());
}
update() {
if (this._popper) {
this._popper.update();
}
}
// Protected
_isWithContent() {
return Boolean(this._getTitle());
}
_getTipElement() {
if (!this.tip) {
this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());
}
return this.tip;
}
_createTipElement(content) {
const tip = this._getTemplateFactory(content).toHtml();
// TODO: remove this check in v6
if (!tip) {
return null;
}
tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
// TODO: v6 the following can be achieved with CSS only
tip.classList.add(`bs-${this.constructor.NAME}-auto`);
const tipId = getUID(this.constructor.NAME).toString();
tip.setAttribute('id', tipId);
if (this._isAnimated()) {
tip.classList.add(CLASS_NAME_FADE$2);
}
return tip;
}
setContent(content) {
this._newContent = content;
if (this._isShown()) {
this._disposePopper();
this.show();
}
}
_getTemplateFactory(content) {
if (this._templateFactory) {
this._templateFactory.changeContent(content);
} else {
this._templateFactory = new TemplateFactory({
...this._config,
// the `content` var has to be after `this._config`
// to override config.content in case of popover
content,
extraClass: this._resolvePossibleFunction(this._config.customClass)
});
}
return this._templateFactory;
}
_getContentForTemplate() {
return {
[SELECTOR_TOOLTIP_INNER]: this._getTitle()
};
}
_getTitle() {
return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');
}
// Private
_initializeOnDelegatedTarget(event) {
return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
}
_isAnimated() {
return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);
}
_isShown() {
return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);
}
_createPopper(tip) {
const placement = execute(this._config.placement, [this, tip, this._element]);
const attachment = AttachmentMap[placement.toUpperCase()];
return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment));
}
_getOffset() {
const {
offset
} = this._config;
if (typeof offset === 'string') {
return offset.split(',').map(value => Number.parseInt(value, 10));
}
if (typeof offset === 'function') {
return popperData => offset(popperData, this._element);
}
return offset;
}
_resolvePossibleFunction(arg) {
return execute(arg, [this._element]);
}
_getPopperConfig(attachment) {
const defaultBsPopperConfig = {
placement: attachment,
modifiers: [{
name: 'flip',
options: {
fallbackPlacements: this._config.fallbackPlacements
}
}, {
name: 'offset',
options: {
offset: this._getOffset()
}
}, {
name: 'preventOverflow',
options: {
boundary: this._config.boundary
}
}, {
name: 'arrow',
options: {
element: `.${this.constructor.NAME}-arrow`
}
}, {
name: 'preSetPlacement',
enabled: true,
phase: 'beforeMain',
fn: data => {
// Pre-set Popper's placement attribute in order to read the arrow sizes properly.
// Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement
this._getTipElement().setAttribute('data-popper-placement', data.state.placement);
}
}]
};
return {
...defaultBsPopperConfig,
...execute(this._config.popperConfig, [defaultBsPopperConfig])
};
}
_setListeners() {
const triggers = this._config.trigger.split(' ');
for (const trigger of triggers) {
if (trigger === 'click') {
EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {
const context = this._initializeOnDelegatedTarget(event);
context.toggle();
});
} else if (trigger !== TRIGGER_MANUAL) {
const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);
const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);
EventHandler.on(this._element, eventIn, this._config.selector, event => {
const context = this._initializeOnDelegatedTarget(event);
context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
context._enter();
});
EventHandler.on(this._element, eventOut, this._config.selector, event => {
const context = this._initializeOnDelegatedTarget(event);
context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
context._leave();
});
}
}
this._hideModalHandler = () => {
if (this._element) {
this.hide();
}
};
EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
}
_fixTitle() {
const title = this._element.getAttribute('title');
if (!title) {
return;
}
if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {
this._element.setAttribute('aria-label', title);
}
this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility
this._element.removeAttribute('title');
}
_enter() {
if (this._isShown() || this._isHovered) {
this._isHovered = true;
return;
}
this._isHovered = true;
this._setTimeout(() => {
if (this._isHovered) {
this.show();
}
}, this._config.delay.show);
}
_leave() {
if (this._isWithActiveTrigger()) {
return;
}
this._isHovered = false;
this._setTimeout(() => {
if (!this._isHovered) {
this.hide();
}
}, this._config.delay.hide);
}
_setTimeout(handler, timeout) {
clearTimeout(this._timeout);
this._timeout = setTimeout(handler, timeout);
}
_isWithActiveTrigger() {
return Object.values(this._activeTrigger).includes(true);
}
_getConfig(config) {
const dataAttributes = Manipulator.getDataAttributes(this._element);
for (const dataAttribute of Object.keys(dataAttributes)) {
if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
delete dataAttributes[dataAttribute];
}
}
config = {
...dataAttributes,
...(typeof config === 'object' && config ? config : {})
};
config = this._mergeConfigObj(config);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
_configAfterMerge(config) {
config.container = config.container === false ? document.body : getElement(config.container);
if (typeof config.delay === 'number') {
config.delay = {
show: config.delay,
hide: config.delay
};
}
if (typeof config.title === 'number') {
config.title = config.title.toString();
}
if (typeof config.content === 'number') {
config.content = config.content.toString();
}
return config;
}
_getDelegateConfig() {
const config = {};
for (const [key, value] of Object.entries(this._config)) {
if (this.constructor.Default[key] !== value) {
config[key] = value;
}
}
config.selector = false;
config.trigger = 'manual';
// In the future can be replaced with:
// const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
// `Object.fromEntries(keysWithDifferentValues)`
return config;
}
_disposePopper() {
if (this._popper) {
this._popper.destroy();
this._popper = null;
}
if (this.tip) {
this.tip.remove();
this.tip = null;
}
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Tooltip.getOrCreateInstance(this, config);
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* jQuery
*/
defineJQueryPlugin(Tooltip);
/**
* --------------------------------------------------------------------------
* Bootstrap popover.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$3 = 'popover';
const SELECTOR_TITLE = '.popover-header';
const SELECTOR_CONTENT = '.popover-body';
const Default$2 = {
...Tooltip.Default,
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$2 = {
...Tooltip.DefaultType,
content: '(null|string|element|function)'
};
/**
* Class definition
*/
class Popover extends Tooltip {
// Getters
static get Default() {
return Default$2;
}
static get DefaultType() {
return DefaultType$2;
}
static get NAME() {
return NAME$3;
}
// 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);
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Popover.getOrCreateInstance(this, config);
if (typeof config !== 'string') {
return;
}
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* jQuery
*/
defineJQueryPlugin(Popover);
/**
* --------------------------------------------------------------------------
* Bootstrap scrollspy.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$2 = 'scrollspy';
const DATA_KEY$2 = 'bs.scrollspy';
const EVENT_KEY$2 = `.${DATA_KEY$2}`;
const DATA_API_KEY = '.data-api';
const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
const EVENT_CLICK = `click${EVENT_KEY$2}`;
const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;
const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
const CLASS_NAME_ACTIVE$1 = '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_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
const SELECTOR_DROPDOWN = '.dropdown';
const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
const Default$1 = {
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$1 = {
offset: '(number|null)',
// TODO v6 @deprecated, keep it for backwards compatibility reasons
rootMargin: 'string',
smoothScroll: 'boolean',
target: 'element',
threshold: 'array'
};
/**
* Class definition
*/
class ScrollSpy extends BaseComponent {
constructor(element, config) {
super(element, config);
// 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._observer = null;
this._previousScrollData = {
visibleEntryTop: 0,
parentScrollTop: 0
};
this.refresh(); // initialize
}
// Getters
static get Default() {
return Default$1;
}
static get DefaultType() {
return DefaultType$1;
}
static get NAME() {
return NAME$2;
}
// Public
refresh() {
this._initializeTargetsAndObservables();
this._maybeEnableSmoothScroll();
if (this._observer) {
this._observer.disconnect();
} else {
this._observer = this._getNewObserver();
}
for (const section of this._observableSections.values()) {
this._observer.observe(section);
}
}
dispose() {
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;
// 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;
}
_maybeEnableSmoothScroll() {
if (!this._config.smoothScroll) {
return;
}
// unregister any previous listeners
EventHandler.off(this._config.target, EVENT_CLICK);
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;
}
// 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.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(decodeURI(anchor.hash), this._element);
// ensure that the observableSection exists & is visible
if (isVisible(observableSection)) {
this._targetLinks.set(decodeURI(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$1);
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$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);
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$1);
}
}
}
_clearActiveClass(parent) {
parent.classList.remove(CLASS_NAME_ACTIVE$1);
const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent);
for (const node of activeNodes) {
node.classList.remove(CLASS_NAME_ACTIVE$1);
}
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = ScrollSpy.getOrCreateInstance(this, 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
*/
EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
ScrollSpy.getOrCreateInstance(spy);
}
});
/**
* jQuery
*/
defineJQueryPlugin(ScrollSpy);
/**
* --------------------------------------------------------------------------
* Bootstrap tab.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME$1 = 'tab';
const DATA_KEY$1 = 'bs.tab';
const EVENT_KEY$1 = `.${DATA_KEY$1}`;
const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`;
const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`;
const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`;
const ARROW_LEFT_KEY = 'ArrowLeft';
const ARROW_RIGHT_KEY = 'ArrowRight';
const ARROW_UP_KEY = 'ArrowUp';
const ARROW_DOWN_KEY = 'ArrowDown';
const HOME_KEY = 'Home';
const END_KEY = 'End';
const CLASS_NAME_ACTIVE = 'active';
const CLASS_NAME_FADE$1 = 'fade';
const CLASS_NAME_SHOW$1 = 'show';
const CLASS_DROPDOWN = 'dropdown';
const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_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: could only be `tab` in v6
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 Tab extends BaseComponent {
constructor(element) {
super(element);
this._parent = this._element.closest(SELECTOR_TAB_PANEL);
if (!this._parent) {
return;
// TODO: should throw exception in 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$1;
}
// Public
show() {
// 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
const active = this._getActiveElem();
const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, {
relatedTarget: innerElem
}) : null;
const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, {
relatedTarget: active
});
if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) {
return;
}
this._deactivate(active, innerElem);
this._activate(innerElem, active);
}
// Private
_activate(element, relatedElem) {
if (!element) {
return;
}
element.classList.add(CLASS_NAME_ACTIVE);
this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.add(CLASS_NAME_SHOW$1);
return;
}
element.removeAttribute('tabindex');
element.setAttribute('aria-selected', true);
this._toggleDropDown(element, true);
EventHandler.trigger(element, EVENT_SHOWN$1, {
relatedTarget: relatedElem
});
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
}
_deactivate(element, relatedElem) {
if (!element) {
return;
}
element.classList.remove(CLASS_NAME_ACTIVE);
element.blur();
this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too
const complete = () => {
if (element.getAttribute('role') !== 'tab') {
element.classList.remove(CLASS_NAME_SHOW$1);
return;
}
element.setAttribute('aria-selected', false);
element.setAttribute('tabindex', '-1');
this._toggleDropDown(element, false);
EventHandler.trigger(element, EVENT_HIDDEN$1, {
relatedTarget: relatedElem
});
};
this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
}
_keydown(event) {
if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) {
return;
}
event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
event.preventDefault();
const children = this._getChildren().filter(element => !isDisabled(element));
let nextActiveElement;
if ([HOME_KEY, END_KEY].includes(event.key)) {
nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1];
} else {
const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
nextActiveElement = getNextActiveElement(children, event.target, isNext, true);
}
if (nextActiveElement) {
nextActiveElement.focus({
preventScroll: true
});
Tab.getOrCreateInstance(nextActiveElement).show();
}
}
_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 = SelectorEngine.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$1);
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') {
return;
}
if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
throw new TypeError(`No method named "${config}"`);
}
data[config]();
});
}
}
/**
* Data API implementation
*/
EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
if (['A', 'AREA'].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
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
*/
defineJQueryPlugin(Tab);
/**
* --------------------------------------------------------------------------
* Bootstrap toast.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* Constants
*/
const NAME = 'toast';
const DATA_KEY = 'bs.toast';
const EVENT_KEY = `.${DATA_KEY}`;
const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
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 CLASS_NAME_FADE = 'fade';
const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
const CLASS_NAME_SHOW = 'show';
const CLASS_NAME_SHOWING = 'showing';
const DefaultType = {
animation: 'boolean',
autohide: 'boolean',
delay: 'number'
};
const Default = {
animation: true,
autohide: true,
delay: 5000
};
/**
* Class definition
*/
class Toast extends BaseComponent {
constructor(element, config) {
super(element, config);
this._timeout = null;
this._hasMouseInteraction = false;
this._hasKeyboardInteraction = false;
this._setListeners();
}
// Getters
static get Default() {
return Default;
}
static get DefaultType() {
return DefaultType;
}
static get NAME() {
return NAME;
}
// Public
show() {
const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
if (showEvent.defaultPrevented) {
return;
}
this._clearTimeout();
if (this._config.animation) {
this._element.classList.add(CLASS_NAME_FADE);
}
const complete = () => {
this._element.classList.remove(CLASS_NAME_SHOWING);
EventHandler.trigger(this._element, EVENT_SHOWN);
this._maybeScheduleHide();
};
this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
reflow(this._element);
this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
this._queueCallback(complete, this._element, this._config.animation);
}
hide() {
if (!this.isShown()) {
return;
}
const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
if (hideEvent.defaultPrevented) {
return;
}
const complete = () => {
this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
EventHandler.trigger(this._element, EVENT_HIDDEN);
};
this._element.classList.add(CLASS_NAME_SHOWING);
this._queueCallback(complete, this._element, this._config.animation);
}
dispose() {
this._clearTimeout();
if (this.isShown()) {
this._element.classList.remove(CLASS_NAME_SHOW);
}
super.dispose();
}
isShown() {
return this._element.classList.contains(CLASS_NAME_SHOW);
}
// Private
_maybeScheduleHide() {
if (!this._config.autohide) {
return;
}
if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
return;
}
this._timeout = setTimeout(() => {
this.hide();
}, this._config.delay);
}
_onInteraction(event, isInteracting) {
switch (event.type) {
case 'mouseover':
case 'mouseout':
{
this._hasMouseInteraction = isInteracting;
break;
}
case 'focusin':
case 'focusout':
{
this._hasKeyboardInteraction = isInteracting;
break;
}
}
if (isInteracting) {
this._clearTimeout();
return;
}
const nextElement = event.relatedTarget;
if (this._element === nextElement || this._element.contains(nextElement)) {
return;
}
this._maybeScheduleHide();
}
_setListeners() {
EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
}
_clearTimeout() {
clearTimeout(this._timeout);
this._timeout = null;
}
// Static
static jQueryInterface(config) {
return this.each(function () {
const data = Toast.getOrCreateInstance(this, config);
if (typeof config === 'string') {
if (typeof data[config] === 'undefined') {
throw new TypeError(`No method named "${config}"`);
}
data[config](this);
}
});
}
}
/**
* Data API implementation
*/
enableDismissTrigger(Toast);
/**
* jQuery
*/
defineJQueryPlugin(Toast);
| Properly escape IDs selectors to handle weird IDs
@param {string} selector
@returns {string} | parseSelector | javascript | hargata/lubelog | wwwroot/lib/bootstrap/dist/js/bootstrap.esm.js | https://github.com/hargata/lubelog/blob/master/wwwroot/lib/bootstrap/dist/js/bootstrap.esm.js | MIT |
export default function createObservableMethod (methodName, passContext) {
const vm = this
if (vm[methodName] !== undefined) {
warn(
'Potential bug: ' +
`Method ${methodName} already defined on vm and has been overwritten by $createObservableMethod.` +
String(vm[methodName]),
vm
)
}
const creator = function (observer) {
vm[methodName] = function () {
const args = Array.from(arguments)
if (passContext) {
args.push(this)
observer.next(args)
} else {
if (args.length <= 1) {
observer.next(args[0])
} else {
observer.next(args)
}
}
}
return function () {
delete vm[methodName]
}
}
// Must be a hot stream otherwise function context may overwrite over and over again
return new Observable(creator).pipe(share())
} | @name Vue.prototype.$createObservableMethod
@description Creates an observable from a given function name.
@param {String} methodName Function name
@param {Boolean} [passContext] Append the call context at the end of emit data?
@return {Observable} Hot stream | createObservableMethod ( methodName , passContext ) | javascript | vuejs/vue-rx | src/methods/createObservableMethod.js | https://github.com/vuejs/vue-rx/blob/master/src/methods/createObservableMethod.js | MIT |
function TypeChecker() {
this.checks = [];
} | Function to store type checks
@private | TypeChecker ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function getGlobalType(obj) {
return main.getType(obj);
} | Get type information of anything
@param {any} obj Anything that could require type information
@return {Type} type info
@private | getGlobalType ( obj ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function AssertionError(options) {
merge(this, options);
if (!options.message) {
Object.defineProperty(this, "message", {
get: function() {
if (!this._message) {
this._message = this.generateMessage();
this.generatedMessage = true;
}
return this._message;
},
configurable: true,
enumerable: false
});
}
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.stackStartFunction);
} else {
// non v8 browsers so we can have a stacktrace
var err = new Error();
if (err.stack) {
var out = err.stack;
if (this.stackStartFunction) {
// try to strip useless frames
var fn_name = functionName$1(this.stackStartFunction);
var idx = out.indexOf("\n" + fn_name);
if (idx >= 0) {
// once we have located the function frame
// we need to strip out everything before it (and its line)
var next_line = out.indexOf("\n", idx + 1);
out = out.substring(next_line + 1);
}
}
this.stack = out;
}
}
} | should AssertionError
@param {Object} options
@constructor
@memberOf should
@static | AssertionError ( options ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function Assertion(obj) {
this.obj = obj;
this.anyOne = false;
this.negate = false;
this.params = { actual: obj };
} | should Assertion
@param {*} obj Given object for assertion
@constructor
@memberOf should
@static | Assertion ( obj ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert: function(expr) {
if (expr) {
return this;
}
var params = this.params;
if ("obj" in params && !("actual" in params)) {
params.actual = params.obj;
} else if (!("obj" in params) && !("actual" in params)) {
params.actual = this.obj;
}
params.stackStartFunction = params.stackStartFunction || this.assert;
params.negate = this.negate;
params.assertion = this;
if (this.light) {
throw new LightAssertionError(params);
} else {
throw new AssertionError(params);
}
}, | Base method for assertions.
Before calling this method need to fill Assertion#params object. This method usually called from other assertion methods.
`Assertion#params` can contain such properties:
* `operator` - required string containing description of this assertion
* `obj` - optional replacement for this.obj, it is useful if you prepare more clear object then given
* `message` - if this property filled with string any others will be ignored and this one used as assertion message
* `expected` - any object used when you need to assert relation between given object and expected. Like given == expected (== is a relation)
* `details` - additional string with details to generated message
@memberOf Assertion
@category assertion
@param {*} expr Any expression that will be used as a condition for asserting.
@example
var a = new should.Assertion(42);
a.params = {
operator: 'to be magic number',
}
a.assert(false);
//throws AssertionError: expected 42 to be magic number | assert ( expr ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
fail: function() {
return this.assert(false);
}, | Shortcut for `Assertion#assert(false)`.
@memberOf Assertion
@category assertion
@example
var a = new should.Assertion(42);
a.params = {
operator: 'to be magic number',
}
a.fail();
//throws AssertionError: expected 42 to be magic number | fail ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function PromisedAssertion(/* obj */) {
Assertion.apply(this, arguments);
} | Assertion used to delegate calls of Assertion methods inside of Promise.
It has almost all methods of Assertion.prototype
@param {Promise} obj | PromisedAssertion ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
PromisedAssertion.prototype.then = function(resolve, reject) {
return this.obj.then(resolve, reject);
}; | Make PromisedAssertion to look like promise. Delegate resolve and reject to given promise.
@private
@returns {Promise} | PromisedAssertion.prototype.then ( resolve , reject ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add = function(name, func) {
Object.defineProperty(Assertion.prototype, name, {
enumerable: true,
configurable: true,
value: function() {
var context = new Assertion(this.obj, this, name);
context.anyOne = this.anyOne;
context.onlyThis = this.onlyThis;
// hack
context.light = true;
try {
func.apply(context, arguments);
} catch (e) {
// check for fail
if (e instanceof AssertionError || e instanceof LightAssertionError) {
// negative fail
if (this.negate) {
this.obj = context.obj;
this.negate = false;
return this;
}
if (context !== e.assertion) {
context.params.previous = e;
}
// positive fail
context.negate = false;
// hack
context.light = false;
context.fail();
}
// throw if it is another exception
throw e;
}
// negative pass
if (this.negate) {
context.negate = true; // because .fail will set negate
context.params.details = "false negative fail";
// hack
context.light = false;
context.fail();
}
// positive pass
if (!this.params.operator) {
this.params = context.params; // shortcut
}
this.obj = context.obj;
this.negate = false;
return this;
}
});
Object.defineProperty(PromisedAssertion.prototype, name, {
enumerable: true,
configurable: true,
value: function() {
var args = arguments;
this.obj = this.obj.then(function(a) {
return a[name].apply(a, args);
});
return this;
}
});
}; | Way to extend Assertion function. It uses some logic
to define only positive assertions and itself rule with negative assertion.
All actions happen in subcontext and this method take care about negation.
Potentially we can add some more modifiers that does not depends from state of assertion.
@memberOf Assertion
@static
@param {String} name Name of assertion. It will be used for defining method or getter on Assertion.prototype
@param {Function} func Function that will be called on executing assertion
@example
Assertion.add('asset', function() {
this.params = { operator: 'to be asset' }
this.obj.should.have.property('id').which.is.a.Number()
this.obj.should.have.property('path')
}) | Assertion.add ( name , func ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.addChain = function(name, onCall) {
onCall = onCall || function() {};
Object.defineProperty(Assertion.prototype, name, {
get: function() {
onCall.call(this);
return this;
},
enumerable: true
});
Object.defineProperty(PromisedAssertion.prototype, name, {
enumerable: true,
configurable: true,
get: function() {
this.obj = this.obj.then(function(a) {
return a[name];
});
return this;
}
});
}; | Add chaining getter to Assertion like .a, .which etc
@memberOf Assertion
@static
@param {string} name name of getter
@param {function} [onCall] optional function to call | Assertion.addChain ( name , onCall ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.alias = function(from, to) {
var desc = Object.getOwnPropertyDescriptor(Assertion.prototype, from);
if (!desc) {
throw new Error("Alias " + from + " -> " + to + " could not be created as " + from + " not defined");
}
Object.defineProperty(Assertion.prototype, to, desc);
var desc2 = Object.getOwnPropertyDescriptor(PromisedAssertion.prototype, from);
if (desc2) {
Object.defineProperty(PromisedAssertion.prototype, to, desc2);
}
}; | Create alias for some `Assertion` property
@memberOf Assertion
@static
@param {String} from Name of to map
@param {String} to Name of alias
@example
Assertion.alias('true', 'True') | Assertion.alias ( from , to ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.addChain("not", function() {
this.negate = !this.negate;
}); | Negation modifier. Current assertion chain become negated. Each call invert negation on current assertion.
@name not
@property
@memberOf Assertion
@category assertion | Assertion.addChain ( "not" , function ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.addChain("any", function() {
this.anyOne = true;
}); | Any modifier - it affect on execution of sequenced assertion to do not `check all`, but `check any of`.
@name any
@property
@memberOf Assertion
@category assertion | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.addChain("only", function() {
this.onlyThis = true;
}); | Only modifier - currently used with .keys to check if object contains only exactly this .keys
@name only
@property
@memberOf Assertion
@category assertion | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function fail(actual, expected, message, operator, stackStartFunction) {
var a = new Assertion(actual);
a.params = {
operator: operator,
expected: expected,
message: message,
stackStartFunction: stackStartFunction || fail
};
a.fail();
} | Node.js standard [`assert.fail`](http://nodejs.org/api/assert.html#assert_assert_fail_actual_expected_message_operator).
@static
@memberOf should
@category assertion assert
@param {*} actual Actual object
@param {*} expected Expected object
@param {string} message Message for assertion
@param {string} operator Operator text | fail ( actual , expected , message , operator , stackStartFunction ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function ok(value, message) {
if (!value) {
fail(value, true, message, "==", assert.ok);
}
} | Node.js standard [`assert.ok`](http://nodejs.org/api/assert.html#assert_assert_value_message_assert_ok_value_message).
@static
@memberOf should
@category assertion assert
@param {*} value
@param {string} [message] | ok ( value , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.equal = function equal(actual, expected, message) {
if (actual != expected) {
fail(actual, expected, message, "==", assert.equal);
}
}; | Node.js standard [`assert.equal`](http://nodejs.org/api/assert.html#assert_assert_equal_actual_expected_message).
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | equal ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.notEqual = function notEqual(actual, expected, message) {
if (actual == expected) {
fail(actual, expected, message, "!=", assert.notEqual);
}
}; | Node.js standard [`assert.notEqual`](http://nodejs.org/api/assert.html#assert_assert_notequal_actual_expected_message).
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | notEqual ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.deepEqual = function deepEqual(actual, expected, message) {
if (eq(actual, expected).length !== 0) {
fail(actual, expected, message, "deepEqual", assert.deepEqual);
}
}; | Node.js standard [`assert.deepEqual`](http://nodejs.org/api/assert.html#assert_assert_deepequal_actual_expected_message).
But uses should.js .eql implementation instead of Node.js own deepEqual.
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | deepEqual ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (eq(actual, expected).result) {
fail(actual, expected, message, "notDeepEqual", assert.notDeepEqual);
}
}; | Node.js standard [`assert.notDeepEqual`](http://nodejs.org/api/assert.html#assert_assert_notdeepequal_actual_expected_message).
But uses should.js .eql implementation instead of Node.js own deepEqual.
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | notDeepEqual ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.strictEqual = function strictEqual(actual, expected, message) {
if (actual !== expected) {
fail(actual, expected, message, "===", assert.strictEqual);
}
}; | Node.js standard [`assert.strictEqual`](http://nodejs.org/api/assert.html#assert_assert_strictequal_actual_expected_message).
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | strictEqual ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (actual === expected) {
fail(actual, expected, message, "!==", assert.notStrictEqual);
}
}; | Node.js standard [`assert.notStrictEqual`](http://nodejs.org/api/assert.html#assert_assert_notstrictequal_actual_expected_message).
@static
@memberOf should
@category assertion assert
@param {*} actual
@param {*} expected
@param {string} [message] | notStrictEqual ( actual , expected , message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.throws = function(/*block, error, message*/) {
_throws.apply(this, [true].concat(pSlice.call(arguments)));
}; | Node.js standard [`assert.throws`](http://nodejs.org/api/assert.html#assert_assert_throws_block_error_message).
@static
@memberOf should
@category assertion assert
@param {Function} block
@param {Function} [error]
@param {String} [message] | assert.throws ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.doesNotThrow = function(/*block, message*/) {
_throws.apply(this, [false].concat(pSlice.call(arguments)));
}; | Node.js standard [`assert.doesNotThrow`](http://nodejs.org/api/assert.html#assert_assert_doesnotthrow_block_message).
@static
@memberOf should
@category assertion assert
@param {Function} block
@param {String} [message] | assert.doesNotThrow ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
assert.ifError = function(err) {
if (err) {
throw err;
}
}; | Node.js standard [`assert.ifError`](http://nodejs.org/api/assert.html#assert_assert_iferror_value).
@static
@memberOf should
@category assertion assert
@param {Error} err | assert.ifError ( err ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
should.not.exist = should.not.exists = function(obj, msg) {
if (null != obj) {
throw new AssertionError({
message: msg || "expected " + i(obj) + " to not exist",
stackStartFunction: should.not.exist
});
}
};
} | Asserts _obj_ does not exist, with optional message.
@name not.exist
@static
@memberOf should
@category assertion assert
@alias should.not.exists
@param {*} obj
@param {String} [msg]
@example
should.not.exist(null);
should.not.exist(void 0); | should.not.exists ( obj , msg ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("true", function(message) {
this.is.exactly(true, message);
}); | Assert given object is exactly `true`.
@name true
@memberOf Assertion
@category assertion bool
@alias Assertion#True
@param {string} [message] Optional message
@example
(true).should.be.true();
false.should.not.be.true();
({ a: 10}).should.not.be.true(); | (anonymous) ( message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("false", function(message) {
this.is.exactly(false, message);
}); | Assert given object is exactly `false`.
@name false
@memberOf Assertion
@category assertion bool
@alias Assertion#False
@param {string} [message] Optional message
@example
(true).should.not.be.false();
false.should.be.false(); | (anonymous) ( message ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("ok", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be truthy" };
this.assert(this.obj);
}); | Assert given object is truthy according javascript type conversions.
@name ok
@memberOf Assertion
@category assertion bool
@example
(true).should.be.ok();
''.should.not.be.ok();
should(null).not.be.ok();
should(void 0).not.be.ok();
(10).should.be.ok();
(0).should.not.be.ok(); | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("NaN", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be NaN" };
this.assert(this.obj !== this.obj);
}); | Assert given object is NaN
@name NaN
@memberOf Assertion
@category assertion numbers
@example
(10).should.not.be.NaN();
NaN.should.be.NaN(); | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Infinity", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be Infinity" };
this.is.a
.Number()
.and.not.a.NaN()
.and.assert(!isFinite(this.obj));
}); | Assert given object is not finite (positive or negative)
@name Infinity
@memberOf Assertion
@category assertion numbers
@example
(10).should.not.be.Infinity();
NaN.should.not.be.Infinity(); | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("within", function(start, finish, description) {
this.params = {
operator: "to be within " + start + ".." + finish,
message: description
};
this.assert(this.obj >= start && this.obj <= finish);
}); | Assert given number between `start` and `finish` or equal one of them.
@name within
@memberOf Assertion
@category assertion numbers
@param {number} start Start number
@param {number} finish Finish number
@param {string} [description] Optional message
@example
(10).should.be.within(0, 20); | (anonymous) ( start , finish , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("approximately", function(value, delta, description) {
this.params = {
operator: "to be approximately " + value + " ±" + delta,
message: description
};
this.assert(Math.abs(this.obj - value) <= delta);
}); | Assert given number near some other `value` within `delta`
@name approximately
@memberOf Assertion
@category assertion numbers
@param {number} value Center number
@param {number} delta Radius
@param {string} [description] Optional message
@example
(9.99).should.be.approximately(10, 0.1); | (anonymous) ( value , delta , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("above", function(n, description) {
this.params = { operator: "to be above " + n, message: description };
this.assert(this.obj > n);
}); | Assert given number above `n`.
@name above
@alias Assertion#greaterThan
@memberOf Assertion
@category assertion numbers
@param {number} n Margin number
@param {string} [description] Optional message
@example
(10).should.be.above(0); | (anonymous) ( n , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("below", function(n, description) {
this.params = { operator: "to be below " + n, message: description };
this.assert(this.obj < n);
}); | Assert given number below `n`.
@name below
@alias Assertion#lessThan
@memberOf Assertion
@category assertion numbers
@param {number} n Margin number
@param {string} [description] Optional message
@example
(0).should.be.below(10); | (anonymous) ( n , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("aboveOrEqual", function(n, description) {
this.params = {
operator: "to be above or equal " + n,
message: description
};
this.assert(this.obj >= n);
}); | Assert given number above `n`.
@name aboveOrEqual
@alias Assertion#greaterThanOrEqual
@memberOf Assertion
@category assertion numbers
@param {number} n Margin number
@param {string} [description] Optional message
@example
(10).should.be.aboveOrEqual(0);
(10).should.be.aboveOrEqual(10); | (anonymous) ( n , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("belowOrEqual", function(n, description) {
this.params = {
operator: "to be below or equal " + n,
message: description
};
this.assert(this.obj <= n);
}); | Assert given number below `n`.
@name belowOrEqual
@alias Assertion#lessThanOrEqual
@memberOf Assertion
@category assertion numbers
@param {number} n Margin number
@param {string} [description] Optional message
@example
(0).should.be.belowOrEqual(10);
(0).should.be.belowOrEqual(0); | (anonymous) ( n , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Number", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a number" };
this.have.type("number");
}); | Assert given object is number
@name Number
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("arguments", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be arguments" };
this.have.class("Arguments");
}); | Assert given object is arguments
@name arguments
@alias Assertion#Arguments
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("type", function(type, description) {
this.params = { operator: "to have type " + type, message: description };
should(typeof this.obj).be.exactly(type);
}); | Assert given object has some type using `typeof`
@name type
@memberOf Assertion
@param {string} type Type name
@param {string} [description] Optional message
@category assertion types | (anonymous) ( type , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Function", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a function" };
this.have.type("function");
}); | Assert given object is function
@name Function
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Object", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an object" };
this.is.not.null().and.have.type("object");
}); | Assert given object is object
@name Object
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("String", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a string" };
this.have.type("string");
}); | Assert given object is string
@name String
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Array", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an array" };
this.have.class("Array");
}); | Assert given object is array
@name Array
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Boolean", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a boolean" };
this.have.type("boolean");
}); | Assert given object is boolean
@name Boolean
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Error", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an error" };
this.have.instanceOf(Error);
}); | Assert given object is error
@name Error
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("Date", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a date" };
this.have.instanceOf(Date);
}); | Assert given object is a date
@name Date
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("null", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be null" };
this.assert(this.obj === null);
}); | Assert given object is null
@name null
@alias Assertion#Null
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("class", function(cls) {
this.params = { operator: "to have [[Class]] " + cls };
this.assert(Object.prototype.toString.call(this.obj) === "[object " + cls + "]");
}); | Assert given object has some internal [[Class]], via Object.prototype.toString call
@name class
@alias Assertion#Class
@memberOf Assertion
@category assertion types | (anonymous) ( cls ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("undefined", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be undefined" };
this.assert(this.obj === void 0);
}); | Assert given object is undefined
@name undefined
@alias Assertion#Undefined
@memberOf Assertion
@category assertion types | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("iterable", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be iterable" };
should(this.obj)
.have.property(Symbol.iterator)
.which.is.a.Function();
}); | Assert given object supports es6 iterable protocol (just check
that object has property Symbol.iterator, which is a function)
@name iterable
@memberOf Assertion
@category assertion es6 | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("iterator", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be iterator" };
should(this.obj)
.have.property("next")
.which.is.a.Function();
}); | Assert given object supports es6 iterator protocol (just check
that object has property next, which is a function)
@name iterator
@memberOf Assertion
@category assertion es6 | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("generator", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be generator" };
should(this.obj).be.iterable.and.iterator.and.it.is.equal(this.obj[Symbol.iterator]());
}); | Assert given object is a generator object
@name generator
@memberOf Assertion
@category assertion es6 | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("instanceof", function(constructor, description) {
this.params = {
operator: "to be an instance of " + functionName$1(constructor),
message: description
};
this.assert(Object(this.obj) instanceof constructor);
});
Assertion.alias("instanceof", "instanceOf");
/**
* Assert given object is function
* @name Function
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Function", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a function" };
this.have.type("function");
});
/**
* Assert given object is object
* @name Object
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Object", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an object" };
this.is.not.null().and.have.type("object");
});
/**
* Assert given object is string
* @name String
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("String", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a string" };
this.have.type("string");
});
/**
* Assert given object is array
* @name Array
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Array", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an array" };
this.have.class("Array");
});
/**
* Assert given object is boolean
* @name Boolean
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Boolean", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a boolean" };
this.have.type("boolean");
});
/**
* Assert given object is error
* @name Error
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Error", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be an error" };
this.have.instanceOf(Error);
});
/**
* Assert given object is a date
* @name Date
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("Date", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be a date" };
this.have.instanceOf(Date);
});
/**
* Assert given object is null
* @name null
* @alias Assertion#Null
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("null", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be null" };
this.assert(this.obj === null);
});
Assertion.alias("null", "Null");
/**
* Assert given object has some internal [[Class]], via Object.prototype.toString call
* @name class
* @alias Assertion#Class
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("class", function(cls) {
this.params = { operator: "to have [[Class]] " + cls };
this.assert(Object.prototype.toString.call(this.obj) === "[object " + cls + "]");
});
Assertion.alias("class", "Class");
/**
* Assert given object is undefined
* @name undefined
* @alias Assertion#Undefined
* @memberOf Assertion
* @category assertion types
*/
Assertion.add("undefined", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be undefined" };
this.assert(this.obj === void 0);
});
Assertion.alias("undefined", "Undefined");
/**
* Assert given object supports es6 iterable protocol (just check
* that object has property Symbol.iterator, which is a function)
* @name iterable
* @memberOf Assertion
* @category assertion es6
*/
Assertion.add("iterable", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be iterable" };
should(this.obj)
.have.property(Symbol.iterator)
.which.is.a.Function();
});
/**
* Assert given object supports es6 iterator protocol (just check
* that object has property next, which is a function)
* @name iterator
* @memberOf Assertion
* @category assertion es6
*/
Assertion.add("iterator", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be iterator" };
should(this.obj)
.have.property("next")
.which.is.a.Function();
});
/**
* Assert given object is a generator object
* @name generator
* @memberOf Assertion
* @category assertion es6
*/
Assertion.add("generator", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be generator" };
should(this.obj).be.iterable.and.iterator.and.it.is.equal(this.obj[Symbol.iterator]());
});
} | Assert given object is instance of `constructor`
@name instanceof
@alias Assertion#instanceOf
@memberOf Assertion
@param {Function} constructor Constructor function
@param {string} [description] Optional message
@category assertion types | (anonymous) ( constructor , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("eql", function(val, description) {
this.params = { operator: "to equal", expected: val, message: description };
var obj = this.obj;
var fails = eq(this.obj, val, should.config);
this.params.details = fails
.map(function(fail) {
return formatEqlResult(fail, obj, val);
})
.join(", ");
this.params.showDiff = eq(getGlobalType(obj), getGlobalType(val)).length === 0;
this.assert(fails.length === 0);
}); | Deep object equality comparison. For full spec see [`should-equal tests`](https://github.com/shouldjs/equal/blob/master/test.js).
@name eql
@memberOf Assertion
@category assertion equality
@alias Assertion#eqls
@alias Assertion#deepEqual
@param {*} val Expected value
@param {string} [description] Optional message
@example
(10).should.be.eql(10);
('10').should.not.be.eql(10);
(-0).should.not.be.eql(+0);
NaN.should.be.eql(NaN);
({ a: 10}).should.be.eql({ a: 10 });
[ 'a' ].should.not.be.eql({ '0': 'a' }); | (anonymous) ( val , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("equal", function(val, description) {
this.params = { operator: "to be", expected: val, message: description };
this.params.showDiff = eq(getGlobalType(this.obj), getGlobalType(val)).length === 0;
this.assert(val === this.obj);
}); | Exact comparison using ===.
@name equal
@memberOf Assertion
@category assertion equality
@alias Assertion#equals
@alias Assertion#exactly
@param {*} val Expected value
@param {string} [description] Optional message
@example
10.should.be.equal(10);
'a'.should.be.exactly('a');
should(null).be.exactly(null); | (anonymous) ( val , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion$$1.add("Promise", function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be promise" };
var obj = this.obj;
should(obj)
.have.property("then")
.which.is.a.Function();
}); | Assert given object is a Promise
@name Promise
@memberOf Assertion
@category assertion promises
@example
promise.should.be.Promise()
(new Promise(function(resolve, reject) { resolve(10); })).should.be.a.Promise()
(10).should.not.be.a.Promise() | (anonymous) ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion$$1.prototype.fulfilled = function Assertion$fulfilled() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be fulfilled" };
should(this.obj).be.a.Promise();
var that = this;
return this.obj.then(
function next$onResolve(value) {
if (that.negate) {
that.fail();
}
return value;
},
function next$onReject(err) {
if (!that.negate) {
that.params.operator += ", but it was rejected with " + should.format(err);
that.fail();
}
return err;
}
);
}; | Assert given promise will be fulfilled. Result of assertion is still .thenable and should be handled accordingly.
@name fulfilled
@memberOf Assertion
@alias Assertion#resolved
@returns {Promise}
@category assertion promises
@example
// don't forget to handle async nature
(new Promise(function(resolve, reject) { resolve(10); })).should.be.fulfilled();
// test example with mocha it is possible to return promise
it('is async', () => {
return new Promise(resolve => resolve(10))
.should.be.fulfilled();
}); | $fulfilled ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion$$1.prototype.rejected = function() {
this.assertZeroArguments(arguments);
this.params = { operator: "to be rejected" };
should(this.obj).be.a.Promise();
var that = this;
return this.obj.then(
function(value) {
if (!that.negate) {
that.params.operator += ", but it was fulfilled";
if (arguments.length != 0) {
that.params.operator += " with " + should.format(value);
}
that.fail();
}
return value;
},
function next$onError(err) {
if (that.negate) {
that.fail();
}
return err;
}
);
}; | Assert given promise will be rejected. Result of assertion is still .thenable and should be handled accordingly.
@name rejected
@memberOf Assertion
@category assertion promises
@returns {Promise}
@example
// don't forget to handle async nature
(new Promise(function(resolve, reject) { resolve(10); }))
.should.not.be.rejected();
// test example with mocha it is possible to return promise
it('is async', () => {
return new Promise((resolve, reject) => reject(new Error('boom')))
.should.be.rejected();
}); | $1.prototype.rejected ( ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion$$1.prototype.rejectedWith = function(message, properties) {
this.params = { operator: "to be rejected" };
should(this.obj).be.a.Promise();
var that = this;
return this.obj.then(
function(value) {
if (!that.negate) {
that.fail();
}
return value;
},
function next$onError(err) {
if (that.negate) {
that.fail();
}
var errorMatched = true;
var errorInfo = "";
if ("string" === typeof message) {
errorMatched = message === err.message;
} else if (message instanceof RegExp) {
errorMatched = message.test(err.message);
} else if ("function" === typeof message) {
errorMatched = err instanceof message;
} else if (message !== null && typeof message === "object") {
try {
should(err).match(message);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
if (!errorMatched) {
if (typeof message === "string" || message instanceof RegExp) {
errorInfo = " with a message matching " + should.format(message) + ", but got '" + err.message + "'";
} else if ("function" === typeof message) {
errorInfo = " of type " + functionName$1(message) + ", but got " + functionName$1(err.constructor);
}
} else if ("function" === typeof message && properties) {
try {
should(err).match(properties);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
that.params.operator += errorInfo;
that.assert(errorMatched);
return err;
}
);
}; | Assert given promise will be rejected with some sort of error. Arguments is the same for Assertion#throw.
Result of assertion is still .thenable and should be handled accordingly.
@name rejectedWith
@memberOf Assertion
@category assertion promises
@returns {Promise}
@example
function failedPromise() {
return new Promise(function(resolve, reject) {
reject(new Error('boom'))
})
}
failedPromise().should.be.rejectedWith(Error);
failedPromise().should.be.rejectedWith('boom');
failedPromise().should.be.rejectedWith(/boom/);
failedPromise().should.be.rejectedWith(Error, { message: 'boom' });
failedPromise().should.be.rejectedWith({ message: 'boom' });
// test example with mocha it is possible to return promise
it('is async', () => {
return failedPromise().should.be.rejectedWith({ message: 'boom' });
}); | $1.prototype.rejectedWith ( message , properties ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion$$1.prototype.fulfilledWith = function(expectedValue) {
this.params = {
operator: "to be fulfilled with " + should.format(expectedValue)
};
should(this.obj).be.a.Promise();
var that = this;
return this.obj.then(
function(value) {
if (that.negate) {
that.fail();
}
should(value).eql(expectedValue);
return value;
},
function next$onError(err) {
if (!that.negate) {
that.params.operator += ", but it was rejected with " + should.format(err);
that.fail();
}
return err;
}
);
};
Assertion$$1.prototype.resolvedWith = Assertion$$1.prototype.fulfilledWith;
/**
* Assert given promise will be rejected with some sort of error. Arguments is the same for Assertion#throw.
* Result of assertion is still .thenable and should be handled accordingly.
*
* @name rejectedWith
* @memberOf Assertion
* @category assertion promises
* @returns {Promise}
* @example
*
* function failedPromise() {
* return new Promise(function(resolve, reject) {
* reject(new Error('boom'))
* })
* }
* failedPromise().should.be.rejectedWith(Error);
* failedPromise().should.be.rejectedWith('boom');
* failedPromise().should.be.rejectedWith(/boom/);
* failedPromise().should.be.rejectedWith(Error, { message: 'boom' });
* failedPromise().should.be.rejectedWith({ message: 'boom' });
*
* // test example with mocha it is possible to return promise
* it('is async', () => {
* return failedPromise().should.be.rejectedWith({ message: 'boom' });
* });
*/
Assertion$$1.prototype.rejectedWith = function(message, properties) {
this.params = { operator: "to be rejected" };
should(this.obj).be.a.Promise();
var that = this;
return this.obj.then(
function(value) {
if (!that.negate) {
that.fail();
}
return value;
},
function next$onError(err) {
if (that.negate) {
that.fail();
}
var errorMatched = true;
var errorInfo = "";
if ("string" === typeof message) {
errorMatched = message === err.message;
} else if (message instanceof RegExp) {
errorMatched = message.test(err.message);
} else if ("function" === typeof message) {
errorMatched = err instanceof message;
} else if (message !== null && typeof message === "object") {
try {
should(err).match(message);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
if (!errorMatched) {
if (typeof message === "string" || message instanceof RegExp) {
errorInfo = " with a message matching " + should.format(message) + ", but got '" + err.message + "'";
} else if ("function" === typeof message) {
errorInfo = " of type " + functionName$1(message) + ", but got " + functionName$1(err.constructor);
}
} else if ("function" === typeof message && properties) {
try {
should(err).match(properties);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
that.params.operator += errorInfo;
that.assert(errorMatched);
return err;
}
);
};
/**
* Assert given object is promise and wrap it in PromisedAssertion, which has all properties of Assertion.
* That means you can chain as with usual Assertion.
* Result of assertion is still .thenable and should be handled accordingly.
*
* @name finally
* @memberOf Assertion
* @alias Assertion#eventually
* @category assertion promises
* @returns {PromisedAssertion} Like Assertion, but .then this.obj in Assertion
* @example
*
* (new Promise(function(resolve, reject) { resolve(10); }))
* .should.be.eventually.equal(10);
*
* // test example with mocha it is possible to return promise
* it('is async', () => {
* return new Promise(resolve => resolve(10))
* .should.be.finally.equal(10);
* });
*/
Object.defineProperty(Assertion$$1.prototype, "finally", {
get: function() {
should(this.obj).be.a.Promise();
var that = this;
return new PromisedAssertion(
this.obj.then(function(obj) {
var a = should(obj);
a.negate = that.negate;
a.anyOne = that.anyOne;
return a;
})
);
}
});
Assertion$$1.alias("finally", "eventually");
} | Assert given promise will be fulfilled with some expected value (value compared using .eql).
Result of assertion is still .thenable and should be handled accordingly.
@name fulfilledWith
@memberOf Assertion
@alias Assertion#resolvedWith
@category assertion promises
@returns {Promise}
@example
// don't forget to handle async nature
(new Promise(function(resolve, reject) { resolve(10); }))
.should.be.fulfilledWith(10);
// test example with mocha it is possible to return promise
it('is async', () => {
return new Promise((resolve, reject) => resolve(10))
.should.be.fulfilledWith(10);
}); | $1.prototype.fulfilledWith ( expectedValue ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("endWith", function(str, description) {
this.params = {
operator: "to end with " + should.format(str),
message: description
};
this.assert(this.obj.indexOf(str, this.obj.length - str.length) >= 0);
});
} | Assert given string ends with prefix
@name endWith
@memberOf Assertion
@category assertion strings
@param {string} str Prefix
@param {string} [description] Optional message
@example
'abca'.should.endWith('a'); | (anonymous) ( str , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("containDeep", function(other) {
this.params = { operator: "to contain " + i(other) };
var obj = this.obj;
if (typeof obj === "string" && typeof other === "string") {
// expect other to be string
this.is.equal(String(other));
} else if (isIterable(obj) && isIterable(other)) {
var usedKeys = {};
forEach(
other,
function(otherItem) {
this.assert(
some(obj, function(item, index) {
if (index in usedKeys) {
return false;
}
try {
should(item).containDeep(otherItem);
usedKeys[index] = true;
return true;
} catch (e) {
if (e instanceof should.AssertionError) {
return false;
}
throw e;
}
})
);
},
this
);
} else if (obj != null && other != null && typeof obj == "object" && typeof other == "object") {
// object contains object case
forEach(other, function(value, key) {
should(obj[key]).containDeep(value);
});
// if both objects is empty means we finish traversing - and we need to compare for hidden values
if (isEmpty(other)) {
this.eql(other);
}
} else {
this.eql(other);
}
});
} | The same like `Assertion#containDeepOrdered` but all checks on arrays without order.
@name containDeep
@memberOf Assertion
@category assertion contain
@param {*} other Nested object
@example
[ 1, 2, 3].should.containDeep([2, 1]);
[ 1, 2, [ 1, 2, 3 ]].should.containDeep([ 1, [ 3, 1 ]]); | (anonymous) ( other ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("property", function(name, val) {
name = convertPropertyName(name);
if (arguments.length > 1) {
var p = {};
p[name] = val;
this.have.properties(p);
} else {
this.have.properties(name);
}
this.obj = this.obj[name];
}); | Asserts given object has property with optionally value. **On success it change given object to be value of property**.
@name property
@memberOf Assertion
@category assertion property
@param {string} name Name of property
@param {*} [val] Optional property value to check
@example
({ a: 10 }).should.have.property('a'); | (anonymous) ( name , val ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("properties", function(names) {
var values = {};
if (arguments.length > 1) {
names = aSlice.call(arguments);
} else if (!Array.isArray(names)) {
if (typeof names == "string" || typeof names == "symbol") {
names = [names];
} else {
values = names;
names = Object.keys(names);
}
}
var obj = Object(this.obj),
missingProperties = [];
//just enumerate properties and check if they all present
names.forEach(function(name) {
if (!(name in obj)) {
missingProperties.push(formatProp(name));
}
});
var props = missingProperties;
if (props.length === 0) {
props = names.map(formatProp);
} else if (this.anyOne) {
props = names
.filter(function(name) {
return missingProperties.indexOf(formatProp(name)) < 0;
})
.map(formatProp);
}
var operator =
(props.length === 1
? "to have property "
: "to have " + (this.anyOne ? "any of " : "") + "properties ") + props.join(", ");
this.params = { obj: this.obj, operator: operator };
//check that all properties presented
//or if we request one of them that at least one them presented
this.assert(
missingProperties.length === 0 || (this.anyOne && missingProperties.length != names.length)
);
// check if values in object matched expected
var valueCheckNames = Object.keys(values);
if (valueCheckNames.length) {
var wrongValues = [];
props = [];
// now check values, as there we have all properties
valueCheckNames.forEach(function(name) {
var value = values[name];
if (eq(obj[name], value).length !== 0) {
wrongValues.push(formatProp(name) + " of " + i(value) + " (got " + i(obj[name]) + ")");
} else {
props.push(formatProp(name) + " of " + i(value));
}
});
if ((wrongValues.length !== 0 && !this.anyOne) || (this.anyOne && props.length === 0)) {
props = wrongValues;
}
operator =
(props.length === 1
? "to have property "
: "to have " + (this.anyOne ? "any of " : "") + "properties ") + props.join(", ");
this.params = { obj: this.obj, operator: operator };
//if there is no not matched values
//or there is at least one matched
this.assert(
wrongValues.length === 0 || (this.anyOne && wrongValues.length != valueCheckNames.length)
);
}
}); | Asserts given object has properties. On this method affect .any modifier, which allow to check not all properties.
@name properties
@memberOf Assertion
@category assertion property
@param {Array|...string|Object} names Names of property
@example
({ a: 10 }).should.have.properties('a');
({ a: 10, b: 20 }).should.have.properties([ 'a' ]);
({ a: 10, b: 20 }).should.have.properties({ b: 20 }); | (anonymous) ( names ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("length", function(n, description) {
this.have.property("length", n, description);
}); | Asserts given object has property `length` with given value `n`
@name length
@alias Assertion#lengthOf
@memberOf Assertion
@category assertion property
@param {number} n Expected length
@param {string} [description] Optional message
@example
[1, 2].should.have.length(2); | (anonymous) ( n , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("value", function(key, value) {
this.have.key(key).which.is.eql(value);
}); | Asserts given object has such value for given key
@name value
@memberOf Assertion
@category assertion property
@param {*} key Key to check
@param {*} value Value to check
@example
({ a: 10 }).should.have.value('a', 10);
(new Map([[1, 2]])).should.have.value(1, 2); | (anonymous) ( key , value ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("size", function(s) {
this.params = { operator: "to have size " + s };
should(size(this.obj)).be.exactly(s);
}); | Asserts given object has such size.
@name size
@memberOf Assertion
@category assertion property
@param {number} s Size to check
@example
({ a: 10 }).should.have.size(1);
(new Map([[1, 2]])).should.have.size(1); | (anonymous) ( s ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("throw", function(message, properties) {
var fn = this.obj;
var err = {};
var errorInfo = "";
var thrown = false;
if (isGeneratorFunction(fn)) {
return should(fn()).throw(message, properties);
} else if (isIterator(fn)) {
return should(fn.next.bind(fn)).throw(message, properties);
}
this.is.a.Function();
var errorMatched = true;
try {
fn();
} catch (e) {
thrown = true;
err = e;
}
if (thrown) {
if (message) {
if ("string" == typeof message) {
errorMatched = message == err.message;
} else if (message instanceof RegExp) {
errorMatched = message.test(err.message);
} else if ("function" == typeof message) {
errorMatched = err instanceof message;
} else if (null != message) {
try {
should(err).match(message);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
if (!errorMatched) {
if ("string" == typeof message || message instanceof RegExp) {
errorInfo =
" with a message matching " +
i(message) +
", but got '" +
err.message +
"'";
} else if ("function" == typeof message) {
errorInfo =
" of type " +
functionName$1(message) +
", but got " +
functionName$1(err.constructor);
}
} else if ("function" == typeof message && properties) {
try {
should(err).match(properties);
} catch (e) {
if (e instanceof should.AssertionError) {
errorInfo = ": " + e.message;
errorMatched = false;
} else {
throw e;
}
}
}
} else {
errorInfo = " (got " + i(err) + ")";
}
}
this.params = { operator: "to throw exception" + errorInfo };
this.assert(thrown);
this.assert(errorMatched);
}); | Assert given function throws error with such message.
@name throw
@memberOf Assertion
@category assertion errors
@alias Assertion#throwError
@param {string|RegExp|Function|Object|GeneratorFunction|GeneratorObject} [message] Message to match or properties
@param {Object} [properties] Optional properties that will be matched to thrown error
@example
(function(){ throw new Error('fail') }).should.throw();
(function(){ throw new Error('fail') }).should.throw('fail');
(function(){ throw new Error('fail') }).should.throw(/fail/);
(function(){ throw new Error('fail') }).should.throw(Error);
var error = new Error();
error.a = 10;
(function(){ throw error; }).should.throw(Error, { a: 10 });
(function(){ throw error; }).should.throw({ a: 10 });
(function*() {
yield throwError();
}).should.throw(); | (anonymous) ( message , properties ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
Assertion.add("matchAny", function(other, description) {
this.params = {
operator: "to match any " + i(other),
message: description
};
this.assert(
some(this.obj, function(value) {
try {
should(value).match(other);
return true;
} catch (e) {
if (e instanceof should.AssertionError) {
// Caught an AssertionError, return false to the iterator
return false;
}
throw e;
}
})
);
});
Assertion.alias("matchAny", "matchSome");
Assertion.alias("matchEach", "matchEvery");
} | Asserts if any of given object values or array elements match `other` object, using some assumptions:
First object matched if they are equal,
If `other` is a regexp - matching with regexp
If `other` is a function check if this function throws AssertionError on given object or return false - it will be assumed as not matched
All other cases check if this `other` equal to each element
@name matchAny
@memberOf Assertion
@category assertion matching
@param {*} other Object to match
@alias Assertion#matchSome
@param {string} [description] Optional message
@example
[ 'a', 'b', 'c'].should.matchAny(/\w+/);
[ 'a', 'b', 'c'].should.matchAny('a');
[ 'a', 'b', 'c'].should.matchAny(function(value) { value.should.be.eql('a') });
{ a: 'a', b: 'b', c: 'c' }.should.matchAny(function(value) { value.should.be.eql('a') }); | (anonymous) ( other , description ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
function should$1(obj) {
return new Assertion(obj);
} | Our function should
@param {*} obj Object to assert
@returns {should.Assertion} Returns new Assertion for beginning assertion chain
@example
var should = require('should');
should('abc').be.a.String(); | $1 ( obj ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
should$1.noConflict = function(desc) {
desc = desc || should$1._prevShould;
if (desc) {
delete desc.proto[desc.name];
if (desc.descriptor) {
Object.defineProperty(desc.proto, desc.name, desc.descriptor);
}
}
return should$1;
}; | Delete previous extension. If `desc` missing it will remove default extension.
@param {{ name: string, descriptor: Object, proto: Object }} [desc] Returned from `should.extend` object
@memberOf should
@returns {Function} Returns should function
@static
@example
var should = require('should').noConflict();
should(Object.prototype).not.have.property('should');
var prev = should.extend('must', Object.prototype);
'abc'.must.startWith('a');
should.noConflict(prev);
should(Object.prototype).not.have.property('must'); | $1.noConflict ( desc ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
should$1.use = function(f) {
f(should$1, should$1.Assertion);
return this;
}; | Simple utility function for a bit more easier should assertion extension
@param {Function} f So called plugin function. It should accept 2 arguments: `should` function and `Assertion` constructor
@memberOf should
@returns {Function} Returns `should` function
@static
@example
should.use(function(should, Assertion) {
Assertion.add('asset', function() {
this.params = { operator: 'to be asset' };
this.obj.should.have.property('id').which.is.a.Number();
this.obj.should.have.property('path');
})
}) | $1.use ( f ) | javascript | shouldjs/should.js | should.js | https://github.com/shouldjs/should.js/blob/master/should.js | MIT |
ref() {
this.debug('Grabbing reference to network');
this.references++;
this.updateSocket();
let released = false;
let self = this;
return {
release() {
if(released) return;
self.debug('Releasing reference to network');
released = true;
self.references--;
self.updateSocket();
}
};
} | Get a reference to the network. Helps with locking of a socket. | ref ( ) | javascript | aholstenson/miio | lib/network.js | https://github.com/aholstenson/miio/blob/master/lib/network.js | MIT |
updateSocket() {
if(this.references === 0) {
// No more references, kill the socket
if(this._socket) {
this.debug('Network no longer active, destroying socket');
this._socket.close();
this._socket = null;
}
} else if(this.references === 1 && ! this._socket) {
// This is the first reference, create the socket
this.debug('Making network active, creating socket');
this.createSocket();
}
} | Update wether the socket is available or not. Instead of always keeping
a socket we track if it is available to allow Node to exit if no
discovery or device is being used. | updateSocket ( ) | javascript | aholstenson/miio | lib/network.js | https://github.com/aholstenson/miio/blob/master/lib/network.js | MIT |
enrich() {
if(! this.id) {
throw new Error('Device has no identifier yet, handshake needed');
}
if(this.model && ! this.tokenChanged && this.packet.token) {
// This device has model info and a valid token
return Promise.resolve();
}
if(this.enrichPromise) {
// If enrichment is already happening
return this.enrichPromise;
}
// Check if there is a token available, otherwise try to resolve it
let promise;
if(! this.packet.token) {
// No automatic token found - see if we have a stored one
this.debug('Loading token from storage, device hides token and no token set via options');
this.autoToken = false;
promise = tokens.get(this.id)
.then(token => {
this.debug('Using stored token:', token);
this.packet.token = Buffer.from(token, 'hex');
this.tokenChanged = true;
});
} else {
if(this.tokenChanged) {
this.autoToken = false;
} else {
this.autoToken = true;
this.debug('Using automatic token:', this.packet.token.toString('hex'));
}
promise = Promise.resolve();
}
return this.enrichPromise = promise
.then(() => this.call('miIO.info'))
.then(data => {
this.enriched = true;
this.model = data.model;
this.tokenChanged = false;
this.enrichPromise = null;
})
.catch(err => {
this.enrichPromise = null;
this.enriched = true;
if(err.code === 'missing-token') {
// Rethrow some errors
err.device = this;
throw err;
}
if(this.packet.token) {
// Could not call the info method, this might be either a timeout or a token problem
const e = new Error('Could not connect to device, token might be wrong');
e.code = 'connection-failure';
e.device = this;
throw e;
} else {
const e = new Error('Could not connect to device, token needs to be specified');
e.code = 'missing-token';
e.device = this;
throw e;
}
});
} | Enrich this device with detailed information about the model. This will
simply call miIO.info. | enrich ( ) | javascript | aholstenson/miio | lib/network.js | https://github.com/aholstenson/miio/blob/master/lib/network.js | MIT |
info() {
return this.api.call('miIO.info');
} | Get information about this device. Includes model info, token and
connection information. | info ( ) | javascript | aholstenson/miio | lib/management.js | https://github.com/aholstenson/miio/blob/master/lib/management.js | MIT |
updateWireless(options) {
if(typeof options.ssid !== 'string') {
throw new Error('options.ssid must be a string');
}
if(typeof options.passwd !== 'string') {
throw new Error('options.passwd must be a string');
}
return this.api.call('miIO.config_router', options)
.then(result => {
if(result !== 0 && result !== 'OK' && result !== 'ok') {
throw new Error('Failed updating wireless');
}
return true;
});
} | Update the wireless settings of this device. Needs `ssid` and `passwd`
to be set in the options object.
`uid` can be set to associate the device with a Mi Home user id. | updateWireless ( options ) | javascript | aholstenson/miio | lib/management.js | https://github.com/aholstenson/miio/blob/master/lib/management.js | MIT |
wirelessState() {
return this.api.call('miIO.wifi_assoc_state');
} | Get the wireless state of this device. Includes if the device is
online and counters for things such as authentication failures and
connection success and failures. | wirelessState ( ) | javascript | aholstenson/miio | lib/management.js | https://github.com/aholstenson/miio/blob/master/lib/management.js | MIT |
updateToken(token) {
if(token instanceof Buffer) {
token = token.toString('hex');
} else if(typeof token !== 'string') {
return Promise.reject(new Error('Token must be a hex-string or a Buffer'));
}
// Lazily imported to solve recursive dependencies
const connectToDevice = require('./connectToDevice');
return connectToDevice({
address: this.address,
port: this.port,
token: token
}).then(device => {
// Connection to device could be performed
return tokens.update(this.api.id, token)
.then(() => device.destroy())
.then(() => true);
}).catch(err => {
// Connection to device failed with the token
return false;
});
} | Update the token used to connect to this device.
@param {string|Buffer} token | updateToken ( token ) | javascript | aholstenson/miio | lib/management.js | https://github.com/aholstenson/miio/blob/master/lib/management.js | MIT |
module.exports.browse = function(options) {
return new discovery.Browser(options || {});
}; | Browse for devices available on the network. Will not automatically
connect to them. | module.exports.browse ( options ) | javascript | aholstenson/miio | lib/index.js | https://github.com/aholstenson/miio/blob/master/lib/index.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.