sweetalert2
Version:
A beautiful, responsive, customizable and accessible (WAI-ARIA) replacement for JavaScript's popup boxes, supported fork of sweetalert
1,532 lines (1,413 loc) • 150 kB
JavaScript
/*!
* sweetalert2 v11.10.2
* Released under the MIT License.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sweetalert2 = factory());
})(this, (function () { 'use strict';
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = !0,
o = !1;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = !1;
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
} catch (r) {
o = !0, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : String(i);
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
return typeof o;
} : function (o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _construct(Parent, args, Class) {
if (_isNativeReflectConstruct()) {
_construct = Reflect.construct.bind();
} else {
_construct = function _construct(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _setPrototypeOf(instance, Class.prototype);
return instance;
};
}
return _construct.apply(null, arguments);
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _possibleConstructorReturn(self, call) {
if (call && (typeof call === "object" || typeof call === "function")) {
return call;
} else if (call !== void 0) {
throw new TypeError("Derived constructors may only return object or undefined");
}
return _assertThisInitialized(self);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = _getPrototypeOf(object);
if (object === null) break;
}
return object;
}
function _get() {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get.bind();
} else {
_get = function _get(target, property, receiver) {
var base = _superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(arguments.length < 3 ? target : receiver);
}
return desc.value;
};
}
return _get.apply(this, arguments);
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _classPrivateFieldGet(receiver, privateMap) {
var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
return _classApplyDescriptorGet(receiver, descriptor);
}
function _classPrivateFieldSet(receiver, privateMap, value) {
var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
_classApplyDescriptorSet(receiver, descriptor, value);
return value;
}
function _classExtractFieldDescriptor(receiver, privateMap, action) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to " + action + " private field on non-instance");
}
return privateMap.get(receiver);
}
function _classApplyDescriptorGet(receiver, descriptor) {
if (descriptor.get) {
return descriptor.get.call(receiver);
}
return descriptor.value;
}
function _classApplyDescriptorSet(receiver, descriptor, value) {
if (descriptor.set) {
descriptor.set.call(receiver, value);
} else {
if (!descriptor.writable) {
throw new TypeError("attempted to set read only private field");
}
descriptor.value = value;
}
}
function _checkPrivateRedeclaration(obj, privateCollection) {
if (privateCollection.has(obj)) {
throw new TypeError("Cannot initialize the same private elements twice on an object");
}
}
function _classPrivateFieldInitSpec(obj, privateMap, value) {
_checkPrivateRedeclaration(obj, privateMap);
privateMap.set(obj, value);
}
var RESTORE_FOCUS_TIMEOUT = 100;
/** @type {GlobalState} */
var globalState = {};
var focusPreviousActiveElement = function focusPreviousActiveElement() {
if (globalState.previousActiveElement instanceof HTMLElement) {
globalState.previousActiveElement.focus();
globalState.previousActiveElement = null;
} else if (document.body) {
document.body.focus();
}
};
/**
* Restore previous active (focused) element
*
* @param {boolean} returnFocus
* @returns {Promise<void>}
*/
var restoreActiveElement = function restoreActiveElement(returnFocus) {
return new Promise(function (resolve) {
if (!returnFocus) {
return resolve();
}
var x = window.scrollX;
var y = window.scrollY;
globalState.restoreFocusTimeout = setTimeout(function () {
focusPreviousActiveElement();
resolve();
}, RESTORE_FOCUS_TIMEOUT); // issues/900
window.scrollTo(x, y);
});
};
var swalPrefix = 'swal2-';
/**
* @typedef
* { | 'container'
* | 'shown'
* | 'height-auto'
* | 'iosfix'
* | 'popup'
* | 'modal'
* | 'no-backdrop'
* | 'no-transition'
* | 'toast'
* | 'toast-shown'
* | 'show'
* | 'hide'
* | 'close'
* | 'title'
* | 'html-container'
* | 'actions'
* | 'confirm'
* | 'deny'
* | 'cancel'
* | 'default-outline'
* | 'footer'
* | 'icon'
* | 'icon-content'
* | 'image'
* | 'input'
* | 'file'
* | 'range'
* | 'select'
* | 'radio'
* | 'checkbox'
* | 'label'
* | 'textarea'
* | 'inputerror'
* | 'input-label'
* | 'validation-message'
* | 'progress-steps'
* | 'active-progress-step'
* | 'progress-step'
* | 'progress-step-line'
* | 'loader'
* | 'loading'
* | 'styled'
* | 'top'
* | 'top-start'
* | 'top-end'
* | 'top-left'
* | 'top-right'
* | 'center'
* | 'center-start'
* | 'center-end'
* | 'center-left'
* | 'center-right'
* | 'bottom'
* | 'bottom-start'
* | 'bottom-end'
* | 'bottom-left'
* | 'bottom-right'
* | 'grow-row'
* | 'grow-column'
* | 'grow-fullscreen'
* | 'rtl'
* | 'timer-progress-bar'
* | 'timer-progress-bar-container'
* | 'scrollbar-measure'
* | 'icon-success'
* | 'icon-warning'
* | 'icon-info'
* | 'icon-question'
* | 'icon-error'
* } SwalClass
* @typedef {Record<SwalClass, string>} SwalClasses
*/
/**
* @typedef {'success' | 'warning' | 'info' | 'question' | 'error'} SwalIcon
* @typedef {Record<SwalIcon, string>} SwalIcons
*/
/** @type {SwalClass[]} */
var classNames = ['container', 'shown', 'height-auto', 'iosfix', 'popup', 'modal', 'no-backdrop', 'no-transition', 'toast', 'toast-shown', 'show', 'hide', 'close', 'title', 'html-container', 'actions', 'confirm', 'deny', 'cancel', 'default-outline', 'footer', 'icon', 'icon-content', 'image', 'input', 'file', 'range', 'select', 'radio', 'checkbox', 'label', 'textarea', 'inputerror', 'input-label', 'validation-message', 'progress-steps', 'active-progress-step', 'progress-step', 'progress-step-line', 'loader', 'loading', 'styled', 'top', 'top-start', 'top-end', 'top-left', 'top-right', 'center', 'center-start', 'center-end', 'center-left', 'center-right', 'bottom', 'bottom-start', 'bottom-end', 'bottom-left', 'bottom-right', 'grow-row', 'grow-column', 'grow-fullscreen', 'rtl', 'timer-progress-bar', 'timer-progress-bar-container', 'scrollbar-measure', 'icon-success', 'icon-warning', 'icon-info', 'icon-question', 'icon-error'];
var swalClasses = classNames.reduce(function (acc, className) {
acc[className] = swalPrefix + className;
return acc;
}, /** @type {SwalClasses} */{});
/** @type {SwalIcon[]} */
var icons = ['success', 'warning', 'info', 'question', 'error'];
var iconTypes = icons.reduce(function (acc, icon) {
acc[icon] = swalPrefix + icon;
return acc;
}, /** @type {SwalIcons} */{});
var consolePrefix = 'SweetAlert2:';
/**
* Capitalize the first letter of a string
*
* @param {string} str
* @returns {string}
*/
var capitalizeFirstLetter = function capitalizeFirstLetter(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
};
/**
* Standardize console warnings
*
* @param {string | string[]} message
*/
var warn = function warn(message) {
console.warn("".concat(consolePrefix, " ").concat(_typeof(message) === 'object' ? message.join(' ') : message));
};
/**
* Standardize console errors
*
* @param {string} message
*/
var error = function error(message) {
console.error("".concat(consolePrefix, " ").concat(message));
};
/**
* Private global state for `warnOnce`
*
* @type {string[]}
* @private
*/
var previousWarnOnceMessages = [];
/**
* Show a console warning, but only if it hasn't already been shown
*
* @param {string} message
*/
var warnOnce = function warnOnce(message) {
if (!previousWarnOnceMessages.includes(message)) {
previousWarnOnceMessages.push(message);
warn(message);
}
};
/**
* Show a one-time console warning about deprecated params/methods
*
* @param {string} deprecatedParam
* @param {string} useInstead
*/
var warnAboutDeprecation = function warnAboutDeprecation(deprecatedParam, useInstead) {
warnOnce("\"".concat(deprecatedParam, "\" is deprecated and will be removed in the next major release. Please use \"").concat(useInstead, "\" instead."));
};
/**
* If `arg` is a function, call it (with no arguments or context) and return the result.
* Otherwise, just pass the value through
*
* @param {Function | any} arg
* @returns {any}
*/
var callIfFunction = function callIfFunction(arg) {
return typeof arg === 'function' ? arg() : arg;
};
/**
* @param {any} arg
* @returns {boolean}
*/
var hasToPromiseFn = function hasToPromiseFn(arg) {
return arg && typeof arg.toPromise === 'function';
};
/**
* @param {any} arg
* @returns {Promise<any>}
*/
var asPromise = function asPromise(arg) {
return hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
};
/**
* @param {any} arg
* @returns {boolean}
*/
var isPromise = function isPromise(arg) {
return arg && Promise.resolve(arg) === arg;
};
/**
* Gets the popup container which contains the backdrop and the popup itself.
*
* @returns {HTMLElement | null}
*/
var getContainer = function getContainer() {
return document.body.querySelector(".".concat(swalClasses.container));
};
/**
* @param {string} selectorString
* @returns {HTMLElement | null}
*/
var elementBySelector = function elementBySelector(selectorString) {
var container = getContainer();
return container ? container.querySelector(selectorString) : null;
};
/**
* @param {string} className
* @returns {HTMLElement | null}
*/
var elementByClass = function elementByClass(className) {
return elementBySelector(".".concat(className));
};
/**
* @returns {HTMLElement | null}
*/
var getPopup = function getPopup() {
return elementByClass(swalClasses.popup);
};
/**
* @returns {HTMLElement | null}
*/
var getIcon = function getIcon() {
return elementByClass(swalClasses.icon);
};
/**
* @returns {HTMLElement | null}
*/
var getIconContent = function getIconContent() {
return elementByClass(swalClasses['icon-content']);
};
/**
* @returns {HTMLElement | null}
*/
var getTitle = function getTitle() {
return elementByClass(swalClasses.title);
};
/**
* @returns {HTMLElement | null}
*/
var getHtmlContainer = function getHtmlContainer() {
return elementByClass(swalClasses['html-container']);
};
/**
* @returns {HTMLElement | null}
*/
var getImage = function getImage() {
return elementByClass(swalClasses.image);
};
/**
* @returns {HTMLElement | null}
*/
var getProgressSteps = function getProgressSteps() {
return elementByClass(swalClasses['progress-steps']);
};
/**
* @returns {HTMLElement | null}
*/
var getValidationMessage = function getValidationMessage() {
return elementByClass(swalClasses['validation-message']);
};
/**
* @returns {HTMLButtonElement | null}
*/
var getConfirmButton = function getConfirmButton() {
return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.confirm));
};
/**
* @returns {HTMLButtonElement | null}
*/
var getCancelButton = function getCancelButton() {
return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.cancel));
};
/**
* @returns {HTMLButtonElement | null}
*/
var getDenyButton = function getDenyButton() {
return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.deny));
};
/**
* @returns {HTMLElement | null}
*/
var getInputLabel = function getInputLabel() {
return elementByClass(swalClasses['input-label']);
};
/**
* @returns {HTMLElement | null}
*/
var getLoader = function getLoader() {
return elementBySelector(".".concat(swalClasses.loader));
};
/**
* @returns {HTMLElement | null}
*/
var getActions = function getActions() {
return elementByClass(swalClasses.actions);
};
/**
* @returns {HTMLElement | null}
*/
var getFooter = function getFooter() {
return elementByClass(swalClasses.footer);
};
/**
* @returns {HTMLElement | null}
*/
var getTimerProgressBar = function getTimerProgressBar() {
return elementByClass(swalClasses['timer-progress-bar']);
};
/**
* @returns {HTMLElement | null}
*/
var getCloseButton = function getCloseButton() {
return elementByClass(swalClasses.close);
};
// https://github.com/jkup/focusable/blob/master/index.js
var focusable = "\n a[href],\n area[href],\n input:not([disabled]),\n select:not([disabled]),\n textarea:not([disabled]),\n button:not([disabled]),\n iframe,\n object,\n embed,\n [tabindex=\"0\"],\n [contenteditable],\n audio[controls],\n video[controls],\n summary\n";
/**
* @returns {HTMLElement[]}
*/
var getFocusableElements = function getFocusableElements() {
var popup = getPopup();
if (!popup) {
return [];
}
/** @type {NodeListOf<HTMLElement>} */
var focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])');
var focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)
// sort according to tabindex
.sort(function (a, b) {
var tabindexA = parseInt(a.getAttribute('tabindex') || '0');
var tabindexB = parseInt(b.getAttribute('tabindex') || '0');
if (tabindexA > tabindexB) {
return 1;
} else if (tabindexA < tabindexB) {
return -1;
}
return 0;
});
/** @type {NodeListOf<HTMLElement>} */
var otherFocusableElements = popup.querySelectorAll(focusable);
var otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(function (el) {
return el.getAttribute('tabindex') !== '-1';
});
return _toConsumableArray(new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))).filter(function (el) {
return isVisible$1(el);
});
};
/**
* @returns {boolean}
*/
var isModal = function isModal() {
return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
};
/**
* @returns {boolean}
*/
var isToast = function isToast() {
var popup = getPopup();
if (!popup) {
return false;
}
return hasClass(popup, swalClasses.toast);
};
/**
* @returns {boolean}
*/
var isLoading = function isLoading() {
var popup = getPopup();
if (!popup) {
return false;
}
return popup.hasAttribute('data-loading');
};
/**
* Securely set innerHTML of an element
* https://github.com/sweetalert2/sweetalert2/issues/1926
*
* @param {HTMLElement} elem
* @param {string} html
*/
var setInnerHtml = function setInnerHtml(elem, html) {
elem.textContent = '';
if (html) {
var parser = new DOMParser();
var parsed = parser.parseFromString(html, "text/html");
var head = parsed.querySelector('head');
head && Array.from(head.childNodes).forEach(function (child) {
elem.appendChild(child);
});
var body = parsed.querySelector('body');
body && Array.from(body.childNodes).forEach(function (child) {
if (child instanceof HTMLVideoElement || child instanceof HTMLAudioElement) {
elem.appendChild(child.cloneNode(true)); // https://github.com/sweetalert2/sweetalert2/issues/2507
} else {
elem.appendChild(child);
}
});
}
};
/**
* @param {HTMLElement} elem
* @param {string} className
* @returns {boolean}
*/
var hasClass = function hasClass(elem, className) {
if (!className) {
return false;
}
var classList = className.split(/\s+/);
for (var i = 0; i < classList.length; i++) {
if (!elem.classList.contains(classList[i])) {
return false;
}
}
return true;
};
/**
* @param {HTMLElement} elem
* @param {SweetAlertOptions} params
*/
var removeCustomClasses = function removeCustomClasses(elem, params) {
Array.from(elem.classList).forEach(function (className) {
if (!Object.values(swalClasses).includes(className) && !Object.values(iconTypes).includes(className) && !Object.values(params.showClass || {}).includes(className)) {
elem.classList.remove(className);
}
});
};
/**
* @param {HTMLElement} elem
* @param {SweetAlertOptions} params
* @param {string} className
*/
var applyCustomClass = function applyCustomClass(elem, params, className) {
removeCustomClasses(elem, params);
if (params.customClass && params.customClass[className]) {
if (typeof params.customClass[className] !== 'string' && !params.customClass[className].forEach) {
warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(_typeof(params.customClass[className]), "\""));
return;
}
addClass(elem, params.customClass[className]);
}
};
/**
* @param {HTMLElement} popup
* @param {import('./renderers/renderInput').InputClass | SweetAlertInput} inputClass
* @returns {HTMLInputElement | null}
*/
var getInput$1 = function getInput(popup, inputClass) {
if (!inputClass) {
return null;
}
switch (inputClass) {
case 'select':
case 'textarea':
case 'file':
return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses[inputClass]));
case 'checkbox':
return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.checkbox, " input"));
case 'radio':
return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:checked")) || popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:first-child"));
case 'range':
return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.range, " input"));
default:
return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.input));
}
};
/**
* @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
*/
var focusInput = function focusInput(input) {
input.focus();
// place cursor at end of text in text input
if (input.type !== 'file') {
// http://stackoverflow.com/a/2345915
var val = input.value;
input.value = '';
input.value = val;
}
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
* @param {boolean} condition
*/
var toggleClass = function toggleClass(target, classList, condition) {
if (!target || !classList) {
return;
}
if (typeof classList === 'string') {
classList = classList.split(/\s+/).filter(Boolean);
}
classList.forEach(function (className) {
if (Array.isArray(target)) {
target.forEach(function (elem) {
condition ? elem.classList.add(className) : elem.classList.remove(className);
});
} else {
condition ? target.classList.add(className) : target.classList.remove(className);
}
});
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
*/
var addClass = function addClass(target, classList) {
toggleClass(target, classList, true);
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
*/
var removeClass = function removeClass(target, classList) {
toggleClass(target, classList, false);
};
/**
* Get direct child of an element by class name
*
* @param {HTMLElement} elem
* @param {string} className
* @returns {HTMLElement | undefined}
*/
var getDirectChildByClass = function getDirectChildByClass(elem, className) {
var children = Array.from(elem.children);
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (child instanceof HTMLElement && hasClass(child, className)) {
return child;
}
}
};
/**
* @param {HTMLElement} elem
* @param {string} property
* @param {*} value
*/
var applyNumericalStyle = function applyNumericalStyle(elem, property, value) {
if (value === "".concat(parseInt(value))) {
value = parseInt(value);
}
if (value || parseInt(value) === 0) {
elem.style.setProperty(property, typeof value === 'number' ? "".concat(value, "px") : value);
} else {
elem.style.removeProperty(property);
}
};
/**
* @param {HTMLElement | null} elem
* @param {string} display
*/
var show = function show(elem) {
var display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
elem && (elem.style.display = display);
};
/**
* @param {HTMLElement | null} elem
*/
var hide = function hide(elem) {
elem && (elem.style.display = 'none');
};
/**
* @param {HTMLElement | null} elem
* @param {string} display
*/
var showWhenInnerHtmlPresent = function showWhenInnerHtmlPresent(elem) {
var display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'block';
if (!elem) {
return;
}
new MutationObserver(function () {
toggle(elem, elem.innerHTML, display);
}).observe(elem, {
childList: true,
subtree: true
});
};
/**
* @param {HTMLElement} parent
* @param {string} selector
* @param {string} property
* @param {string} value
*/
var setStyle = function setStyle(parent, selector, property, value) {
/** @type {HTMLElement | null} */
var el = parent.querySelector(selector);
if (el) {
el.style.setProperty(property, value);
}
};
/**
* @param {HTMLElement} elem
* @param {any} condition
* @param {string} display
*/
var toggle = function toggle(elem, condition) {
var display = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex';
condition ? show(elem, display) : hide(elem);
};
/**
* borrowed from jquery $(elem).is(':visible') implementation
*
* @param {HTMLElement | null} elem
* @returns {boolean}
*/
var isVisible$1 = function isVisible(elem) {
return !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
};
/**
* @returns {boolean}
*/
var allButtonsAreHidden = function allButtonsAreHidden() {
return !isVisible$1(getConfirmButton()) && !isVisible$1(getDenyButton()) && !isVisible$1(getCancelButton());
};
/**
* @param {HTMLElement} elem
* @returns {boolean}
*/
var isScrollable = function isScrollable(elem) {
return !!(elem.scrollHeight > elem.clientHeight);
};
/**
* borrowed from https://stackoverflow.com/a/46352119
*
* @param {HTMLElement} elem
* @returns {boolean}
*/
var hasCssAnimation = function hasCssAnimation(elem) {
var style = window.getComputedStyle(elem);
var animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
var transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
return animDuration > 0 || transDuration > 0;
};
/**
* @param {number} timer
* @param {boolean} reset
*/
var animateTimerProgressBar = function animateTimerProgressBar(timer) {
var reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var timerProgressBar = getTimerProgressBar();
if (!timerProgressBar) {
return;
}
if (isVisible$1(timerProgressBar)) {
if (reset) {
timerProgressBar.style.transition = 'none';
timerProgressBar.style.width = '100%';
}
setTimeout(function () {
timerProgressBar.style.transition = "width ".concat(timer / 1000, "s linear");
timerProgressBar.style.width = '0%';
}, 10);
}
};
var stopTimerProgressBar = function stopTimerProgressBar() {
var timerProgressBar = getTimerProgressBar();
if (!timerProgressBar) {
return;
}
var timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
timerProgressBar.style.removeProperty('transition');
timerProgressBar.style.width = '100%';
var timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
var timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
timerProgressBar.style.width = "".concat(timerProgressBarPercent, "%");
};
/**
* Detect Node env
*
* @returns {boolean}
*/
var isNodeEnv = function isNodeEnv() {
return typeof window === 'undefined' || typeof document === 'undefined';
};
var sweetHTML = "\n <div aria-labelledby=\"".concat(swalClasses.title, "\" aria-describedby=\"").concat(swalClasses['html-container'], "\" class=\"").concat(swalClasses.popup, "\" tabindex=\"-1\">\n <button type=\"button\" class=\"").concat(swalClasses.close, "\"></button>\n <ul class=\"").concat(swalClasses['progress-steps'], "\"></ul>\n <div class=\"").concat(swalClasses.icon, "\"></div>\n <img class=\"").concat(swalClasses.image, "\" />\n <h2 class=\"").concat(swalClasses.title, "\" id=\"").concat(swalClasses.title, "\"></h2>\n <div class=\"").concat(swalClasses['html-container'], "\" id=\"").concat(swalClasses['html-container'], "\"></div>\n <input class=\"").concat(swalClasses.input, "\" id=\"").concat(swalClasses.input, "\" />\n <input type=\"file\" class=\"").concat(swalClasses.file, "\" />\n <div class=\"").concat(swalClasses.range, "\">\n <input type=\"range\" />\n <output></output>\n </div>\n <select class=\"").concat(swalClasses.select, "\" id=\"").concat(swalClasses.select, "\"></select>\n <div class=\"").concat(swalClasses.radio, "\"></div>\n <label class=\"").concat(swalClasses.checkbox, "\">\n <input type=\"checkbox\" id=\"").concat(swalClasses.checkbox, "\" />\n <span class=\"").concat(swalClasses.label, "\"></span>\n </label>\n <textarea class=\"").concat(swalClasses.textarea, "\" id=\"").concat(swalClasses.textarea, "\"></textarea>\n <div class=\"").concat(swalClasses['validation-message'], "\" id=\"").concat(swalClasses['validation-message'], "\"></div>\n <div class=\"").concat(swalClasses.actions, "\">\n <div class=\"").concat(swalClasses.loader, "\"></div>\n <button type=\"button\" class=\"").concat(swalClasses.confirm, "\"></button>\n <button type=\"button\" class=\"").concat(swalClasses.deny, "\"></button>\n <button type=\"button\" class=\"").concat(swalClasses.cancel, "\"></button>\n </div>\n <div class=\"").concat(swalClasses.footer, "\"></div>\n <div class=\"").concat(swalClasses['timer-progress-bar-container'], "\">\n <div class=\"").concat(swalClasses['timer-progress-bar'], "\"></div>\n </div>\n </div>\n").replace(/(^|\n)\s*/g, '');
/**
* @returns {boolean}
*/
var resetOldContainer = function resetOldContainer() {
var oldContainer = getContainer();
if (!oldContainer) {
return false;
}
oldContainer.remove();
removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
return true;
};
var resetValidationMessage$1 = function resetValidationMessage() {
globalState.currentInstance.resetValidationMessage();
};
var addInputChangeListeners = function addInputChangeListeners() {
var popup = getPopup();
var input = getDirectChildByClass(popup, swalClasses.input);
var file = getDirectChildByClass(popup, swalClasses.file);
/** @type {HTMLInputElement} */
var range = popup.querySelector(".".concat(swalClasses.range, " input"));
/** @type {HTMLOutputElement} */
var rangeOutput = popup.querySelector(".".concat(swalClasses.range, " output"));
var select = getDirectChildByClass(popup, swalClasses.select);
/** @type {HTMLInputElement} */
var checkbox = popup.querySelector(".".concat(swalClasses.checkbox, " input"));
var textarea = getDirectChildByClass(popup, swalClasses.textarea);
input.oninput = resetValidationMessage$1;
file.onchange = resetValidationMessage$1;
select.onchange = resetValidationMessage$1;
checkbox.onchange = resetValidationMessage$1;
textarea.oninput = resetValidationMessage$1;
range.oninput = function () {
resetValidationMessage$1();
rangeOutput.value = range.value;
};
range.onchange = function () {
resetValidationMessage$1();
rangeOutput.value = range.value;
};
};
/**
* @param {string | HTMLElement} target
* @returns {HTMLElement}
*/
var getTarget = function getTarget(target) {
return typeof target === 'string' ? document.querySelector(target) : target;
};
/**
* @param {SweetAlertOptions} params
*/
var setupAccessibility = function setupAccessibility(params) {
var popup = getPopup();
popup.setAttribute('role', params.toast ? 'alert' : 'dialog');
popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');
if (!params.toast) {
popup.setAttribute('aria-modal', 'true');
}
};
/**
* @param {HTMLElement} targetElement
*/
var setupRTL = function setupRTL(targetElement) {
if (window.getComputedStyle(targetElement).direction === 'rtl') {
addClass(getContainer(), swalClasses.rtl);
}
};
/**
* Add modal + backdrop + no-war message for Russians to DOM
*
* @param {SweetAlertOptions} params
*/
var init = function init(params) {
// Clean up the old popup container if it exists
var oldContainerExisted = resetOldContainer();
if (isNodeEnv()) {
error('SweetAlert2 requires document to initialize');
return;
}
var container = document.createElement('div');
container.className = swalClasses.container;
if (oldContainerExisted) {
addClass(container, swalClasses['no-transition']);
}
setInnerHtml(container, sweetHTML);
var targetElement = getTarget(params.target);
targetElement.appendChild(container);
setupAccessibility(params);
setupRTL(targetElement);
addInputChangeListeners();
};
/**
* @param {HTMLElement | object | string} param
* @param {HTMLElement} target
*/
var parseHtmlToContainer = function parseHtmlToContainer(param, target) {
// DOM element
if (param instanceof HTMLElement) {
target.appendChild(param);
}
// Object
else if (_typeof(param) === 'object') {
handleObject(param, target);
}
// Plain string
else if (param) {
setInnerHtml(target, param);
}
};
/**
* @param {any} param
* @param {HTMLElement} target
*/
var handleObject = function handleObject(param, target) {
// JQuery element(s)
if (param.jquery) {
handleJqueryElem(target, param);
}
// For other objects use their string representation
else {
setInnerHtml(target, param.toString());
}
};
/**
* @param {HTMLElement} target
* @param {any} elem
*/
var handleJqueryElem = function handleJqueryElem(target, elem) {
target.textContent = '';
if (0 in elem) {
for (var i = 0; (i in elem); i++) {
target.appendChild(elem[i].cloneNode(true));
}
} else {
target.appendChild(elem.cloneNode(true));
}
};
/**
* @returns {'webkitAnimationEnd' | 'animationend' | false}
*/
var animationEndEvent = function () {
// Prevent run in Node env
if (isNodeEnv()) {
return false;
}
var testEl = document.createElement('div');
// Chrome, Safari and Opera
if (typeof testEl.style.webkitAnimation !== 'undefined') {
return 'webkitAnimationEnd';
}
// Standard syntax
if (typeof testEl.style.animation !== 'undefined') {
return 'animationend';
}
return false;
}();
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
var renderActions = function renderActions(instance, params) {
var actions = getActions();
var loader = getLoader();
if (!actions || !loader) {
return;
}
// Actions (buttons) wrapper
if (!params.showConfirmButton && !params.showDenyButton && !params.showCancelButton) {
hide(actions);
} else {
show(actions);
}
// Custom class
applyCustomClass(actions, params, 'actions');
// Render all the buttons
renderButtons(actions, loader, params);
// Loader
setInnerHtml(loader, params.loaderHtml || '');
applyCustomClass(loader, params, 'loader');
};
/**
* @param {HTMLElement} actions
* @param {HTMLElement} loader
* @param {SweetAlertOptions} params
*/
function renderButtons(actions, loader, params) {
var confirmButton = getConfirmButton();
var denyButton = getDenyButton();
var cancelButton = getCancelButton();
if (!confirmButton || !denyButton || !cancelButton) {
return;
}
// Render buttons
renderButton(confirmButton, 'confirm', params);
renderButton(denyButton, 'deny', params);
renderButton(cancelButton, 'cancel', params);
handleButtonsStyling(confirmButton, denyButton, cancelButton, params);
if (params.reverseButtons) {
if (params.toast) {
actions.insertBefore(cancelButton, confirmButton);
actions.insertBefore(denyButton, confirmButton);
} else {
actions.insertBefore(cancelButton, loader);
actions.insertBefore(denyButton, loader);
actions.insertBefore(confirmButton, loader);
}
}
}
/**
* @param {HTMLElement} confirmButton
* @param {HTMLElement} denyButton
* @param {HTMLElement} cancelButton
* @param {SweetAlertOptions} params
*/
function handleButtonsStyling(confirmButton, denyButton, cancelButton, params) {
if (!params.buttonsStyling) {
removeClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
return;
}
addClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
// Buttons background colors
if (params.confirmButtonColor) {
confirmButton.style.backgroundColor = params.confirmButtonColor;
addClass(confirmButton, swalClasses['default-outline']);
}
if (params.denyButtonColor) {
denyButton.style.backgroundColor = params.denyButtonColor;
addClass(denyButton, swalClasses['default-outline']);
}
if (params.cancelButtonColor) {
cancelButton.style.backgroundColor = params.cancelButtonColor;
addClass(cancelButton, swalClasses['default-outline']);
}
}
/**
* @param {HTMLElement} button
* @param {'confirm' | 'deny' | 'cancel'} buttonType
* @param {SweetAlertOptions} params
*/
function renderButton(button, buttonType, params) {
var buttonName = /** @type {'Confirm' | 'Deny' | 'Cancel'} */capitalizeFirstLetter(buttonType);
toggle(button, params["show".concat(buttonName, "Button")], 'inline-block');
setInnerHtml(button, params["".concat(buttonType, "ButtonText")] || ''); // Set caption text
button.setAttribute('aria-label', params["".concat(buttonType, "ButtonAriaLabel")] || ''); // ARIA label
// Add buttons custom classes
button.className = swalClasses[buttonType];
applyCustomClass(button, params, "".concat(buttonType, "Button"));
}
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
var renderCloseButton = function renderCloseButton(instance, params) {
var closeButton = getCloseButton();
if (!closeButton) {
return;
}
setInnerHtml(closeButton, params.closeButtonHtml || '');
// Custom class
applyCustomClass(closeButton, params, 'closeButton');
toggle(closeButton, params.showCloseButton);
closeButton.setAttribute('aria-label', params.closeButtonAriaLabel || '');
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
var renderContainer = function renderContainer(instance, params) {
var container = getContainer();
if (!container) {
return;
}
handleBackdropParam(container, params.backdrop);
handlePositionParam(container, params.position);
handleGrowParam(container, params.grow);
// Custom class
applyCustomClass(container, params, 'container');
};
/**
* @param {HTMLElement} container
* @param {SweetAlertOptions['backdrop']} backdrop
*/
function handleBackdropParam(container, backdrop) {
if (typeof backdrop === 'string') {
container.style.background = backdrop;
} else if (!backdrop) {
addClass([document.documentElement, document.body], swalClasses['no-backdrop']);
}
}
/**
* @param {HTMLElement} container
* @param {SweetAlertOptions['position']} position
*/
function handlePositionParam(container, position) {
if (!position) {
return;
}
if (position in swalClasses) {
addClass(container, swalClasses[position]);
} else {
warn('The "position" parameter is not valid, defaulting to "center"');
addClass(container, swalClasses.center);
}
}
/**
* @param {HTMLElement} container
* @param {SweetAlertOptions['grow']} grow
*/
function handleGrowParam(container, grow) {
if (!grow) {
return;
}
addClass(container, swalClasses["grow-".concat(grow)]);
}
/**
* This module contains `WeakMap`s for each effectively-"private property" that a `Swal` has.
* For example, to set the private property "foo" of `this` to "bar", you can `privateProps.foo.set(this, 'bar')`
* This is the approach that Babel will probably take to implement private methods/fields
* https://github.com/tc39/proposal-private-methods
* https://github.com/babel/babel/pull/7555
* Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*
* then we can use that language feature.
*/
var privateProps = {
innerParams: new WeakMap(),
domCache: new WeakMap()
};
/** @type {InputClass[]} */
var inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
var renderInput = function renderInput(instance, params) {
var popup = getPopup();
if (!popup) {
return;
}
var innerParams = privateProps.innerParams.get(instance);
var rerender = !innerParams || params.input !== innerParams.input;
inputClasses.forEach(function (inputClass) {
var inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]);
if (!inputContainer) {
return;
}
// set attributes
setAttributes(inputClass, params.inputAttributes);
// set class
inputContainer.className = swalClasses[inputClass];
if (rerender) {
hide(inputContainer);
}
});
if (params.input) {
if (rerender) {
showInput(params);
}
// set custom class
setCustomClass(params);
}
};
/**
* @param {SweetAlertOptions} params
*/
var showInput = function showInput(params) {
if (!params.input) {
return;
}
if (!renderInputType[params.input]) {
error("Unexpected type of input! Expected ".concat(Object.keys(renderInputType).join(' | '), ", got \"").concat(params.input, "\""));
return;
}
var inputContainer = getInputContainer(params.input);
var input = renderInputType[params.input](inputContainer, params);
show(inputContainer);
// input autofocus
if (params.inputAutoFocus) {
setTimeout(function () {
focusInput(input);
});
}
};
/**
* @param {HTMLInputElement} input
*/
var removeAttributes = function removeAttributes(input) {
for (var i = 0; i < input.attributes.length; i++) {
var attrName = input.attributes[i].name;
if (!['id', 'type', 'value', 'style'].includes(attrName)) {
input.removeAttribute(attrName);
}
}
};
/**
* @param {InputClass} inputClass
* @param {SweetAlertOptions['inputAttributes']} inputAttributes
*/
var setAttributes = function setAttributes(inputClass, inputAttributes) {
var input = getInput$1(getPopup(), inputClass);
if (!input) {
return;
}
removeAttributes(input);
for (var attr in inputAttributes) {
input.setAttribute(attr, inputAttributes[attr]);
}
};
/**
* @param {SweetAlertOptions} params
*/
var setCustomClass = function setCustomClass(params) {
var inputContainer = getInputContainer(params.input);
if (_typeof(params.customClass) === 'object') {
addClass(inputContainer, params.customClass.input);
}
};
/**
* @param {HTMLInputElement | HTMLTextAreaElement} input
* @param {SweetAlertOptions} params
*/
var setInputPlaceholder = function setInputPlaceholder(input, params) {
if (!input.placeholder || params.inputPlaceholder) {
input.placeholder = params.inputPlaceholder;
}
};
/**
* @param {Input} input
* @param {Input} prependTo
* @param {SweetAlertOptions} params
*/
var setInputLabel = function setInputLabel(input, prependTo, params) {
if (params.inputLabel) {
var label = document.createElement('label');
var labelClass = swalClasses['input-label'];
label.setAttribute('for', input.id);
label.className = labelClass;
if (_typeof(params.customClass) === 'object') {
addClass(label, params.customClass.inputLabel);
}
label.innerText = params.inputLabel;
prependTo.insertAdjacentElement('beforebegin', label);
}
};
/**
* @param {SweetAlertOptions['input']} inputType
* @returns {HTMLElement}
*/
var getInputContainer = function getInputContainer(inputType) {
return getDirectChildByClass(getPopup(), swalClasses[inputType] || swalClasses.input);
};
/**
* @param {HTMLInputElement | HTMLOutputElement | HTMLTextAreaElement} input
* @param {SweetAlertOptions['inputValue']} inputValue
*/
var checkAndSetInputValue = function checkAndSetInputValue(input, inputValue) {
if (['string', 'number'].includes(_typeof(inputValue))) {
input.value = "".concat(inputValue);
} else if (!isPromise(inputValue)) {
warn("Unexpected type of inputValue! Expected \"string\", \"number\" or \"Promise\", got \"".concat(_typeof(inputValue), "\""));
}
};
/** @type {Record<SweetAlertInput, (inpu