/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "./assets/src/js/admin/order/add-courses-to-order.js"
/*!***********************************************************!*\
!*** ./assets/src/js/admin/order/add-courses-to-order.js ***!
\***********************************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _utils_admin_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils-admin.js */ "./assets/src/js/admin/utils-admin.js");
/* harmony import */ var lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lpAssetsJsPath/utils.js */ "./assets/src/js/utils.js");
const addCoursesToOrder = () => {
let elModalSearchCourses;
let elSearchCoursesResult;
let elOrderDetails, modalSearchItemsTemplate, modalContainer;
let elOrderModalFooter, elOrderModalBtnAdd;
let elListOrderItems;
let timeOutSearch;
const idModalSearchItems = '#modal-search-items';
const idOrderDetails = '#learn-press-order';
let dataSend = {
search: '',
id_not_in: '',
paged: 1
};
const courseIdsNewSelected = [];
let courseIdsAdded = [];
const getAllElements = () => {
elOrderDetails = document.querySelector('#learn-press-order');
modalSearchItemsTemplate = document.querySelector('#learn-press-modal-search-items');
modalContainer = document.querySelector('#container-modal-search-items');
};
/**
* Fetch courses from API.
*
* @param keySearch
* @param course_ids_exclude
* @param paged
*/
const fetchCoursesAPI = (keySearch = '', course_ids_exclude = [], paged = 1) => {
let id_not_in = '';
if (course_ids_exclude.length > 0) {
id_not_in = course_ids_exclude.join(',');
}
dataSend = {
search: keySearch,
id_not_in,
paged
};
_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.AdminUtilsFunctions.fetchCourses(keySearch, dataSend, {
before() {
elModalSearchCourses.classList.add('loading');
},
success(response) {
const {
data,
status,
message
} = response;
const {
courses,
total_pages
} = data;
if ('success' !== status) {
console.error(message);
} else {
if (!courses.length) {
elSearchCoursesResult.innerHTML = 'No courses found';
return;
}
elSearchCoursesResult.innerHTML = renderSearchResult(courses);
const paginationHtml = renderPagination(paged, total_pages);
const searchNav = elModalSearchCourses.querySelector('.search-nav');
searchNav.innerHTML = paginationHtml;
}
},
error(err) {
console.error(err);
},
completed() {
elModalSearchCourses.classList.remove('loading');
}
});
};
/**
* Get list course ids added.
*/
const getCoursesAdded = () => {
courseIdsAdded = [];
const orderItems = document.querySelectorAll('#learn-press-order .list-order-items tbody .order-item-row');
orderItems.forEach(orderItem => {
const orderItemId = parseInt(orderItem.getAttribute('data-id'));
courseIdsAdded.push(orderItemId);
});
};
/**
* Add courses to order.
* @param e
* @param target
*/
const addCourses = (e, target) => {
if (!target.classList.contains('add')) {
return;
}
if (!target.closest(idModalSearchItems)) {
return;
}
elListOrderItems = elOrderDetails.querySelector('.list-order-items');
e.preventDefault();
target.disabled = true;
const dataSend = {
'lp-ajax': 'add_items_to_order',
order_id: document.querySelector('#post_ID').value,
items: courseIdsNewSelected,
nonce: lpDataAdmin.nonce
};
const callBack = {
success(response) {
const {
data,
messages,
status
} = response;
if ('error' === status) {
console.error(messages);
return;
}
const {
item_html,
order_data
} = data;
const elNoItem = elListOrderItems.querySelector('.no-order-items');
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_1__.lpShowHideEl(elNoItem, 0);
elNoItem.insertAdjacentHTML('beforebegin', item_html);
elOrderDetails.querySelector('.order-subtotal').innerHTML = order_data.subtotal_html;
elOrderDetails.querySelector('.order-total').innerHTML = order_data.total_html;
//courseIdsAdded.push( ...courseIdsNewSelected );
courseIdsNewSelected.splice(0, courseIdsNewSelected.length);
},
error(err) {
console.error(err);
},
completed() {
target.disabled = false;
modalContainer.style.display = 'none';
}
};
_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpFetchAPI(_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpAddQueryArgs(_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpGetCurrentURLNoParam(), dataSend), {}, callBack);
};
/**
* Remove course from order.
*
* @param e
* @param target
*/
const removeCourse = (e, target) => {
if (target.tagName !== 'SPAN') {
return;
}
if (!target.closest('.remove-order-item')) {
return;
}
e.preventDefault();
if (!confirm('Are you sure you want to remove this item?')) {
return;
}
target.disabled = true;
target.classList.add('dashicons-update');
const elItemRow = target.closest('.order-item-row');
const elListOrderItems = target.closest('.list-order-items');
const orderItemId = parseInt(elItemRow.getAttribute('data-item_id'));
const courseId = parseInt(elItemRow.getAttribute('data-id'));
const dataSend = {
'lp-ajax': 'remove_items_from_order',
order_id: document.querySelector('#post_ID').value,
items: orderItemId,
nonce: lpDataAdmin.nonce
};
const callBack = {
success(response) {
const {
data,
messages,
status
} = response;
if ('error' === status) {
console.error(messages);
return;
}
const {
item_html,
order_data
} = data;
const elNoItem = elListOrderItems.querySelector('.no-order-items');
const orderItems = elListOrderItems.querySelectorAll('.order-item-row');
orderItems.forEach(orderItem => {
orderItem.remove();
});
if (item_html.length) {
elNoItem.insertAdjacentHTML('beforebegin', item_html);
} else {
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_1__.lpShowHideEl(elNoItem, 1);
}
courseIdsNewSelected.splice(courseIdsNewSelected.indexOf(courseId), 1);
//courseIdsAdded.splice( courseIdsNewSelected.indexOf( courseId ), 1 );
elOrderDetails.querySelector('.order-subtotal').innerHTML = order_data.subtotal_html;
elOrderDetails.querySelector('.order-total').innerHTML = order_data.total_html;
},
error(err) {
console.error(err);
},
completed() {}
};
_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpFetchAPI(_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpAddQueryArgs(_utils_admin_js__WEBPACK_IMPORTED_MODULE_0__.Utils.lpGetCurrentURLNoParam(), dataSend), {}, callBack);
};
/**
* Search courses before add Order.
*
* @param e
* @param target
*/
const searchCourse = (e, target) => {
if ('search' !== target.name) {
return;
}
const elLPTarget = target.closest(idModalSearchItems);
if (!elLPTarget) {
return;
}
e.preventDefault();
const keyword = target.value;
if (!keyword || keyword && keyword.length > 2) {
if (undefined !== timeOutSearch) {
clearTimeout(timeOutSearch);
}
timeOutSearch = setTimeout(function () {
fetchCoursesAPI(keyword, courseIdsAdded, 1);
}, 800);
}
};
/**
* Display list courses when search done.
*
* @param courses
*/
const renderSearchResult = courses => {
let html = '';
courses.forEach(course => {
const courseId = parseInt(course.ID);
const checked = courseIdsNewSelected.includes(courseId) ? 'checked' : '';
html += `
`;
});
return html;
};
/**
* Render pagination.
*
* @param currentPage
* @param maxPage
*/
const renderPagination = (currentPage, maxPage) => {
currentPage = parseInt(currentPage);
maxPage = parseInt(maxPage);
let html = '';
if (maxPage <= 1) {
return html;
}
const nextPage = currentPage + 1;
const prevPage = currentPage - 1;
let pages = [];
if (maxPage <= 9) {
for (let i = 1; i <= maxPage; i++) {
pages.push(i);
}
} else if (currentPage <= 3) {
// x is ...
pages = [1, 2, 3, 4, 5, 'x', maxPage];
} else if (currentPage <= 5) {
for (let i = 1; i <= currentPage; i++) {
pages.push(i);
}
for (let j = 1; j <= 2; j++) {
const tempPage = currentPage + j;
pages.push(tempPage);
}
pages.push('x');
pages.push(maxPage);
} else {
pages = [1, 'x'];
for (let k = 2; k >= 0; k--) {
const tempPage = currentPage - k;
pages.push(tempPage);
}
const currentToLast = maxPage - currentPage;
if (currentToLast <= 5) {
for (let m = currentPage + 1; m <= maxPage; m++) {
pages.push(m);
}
} else {
for (let n = 1; n <= 2; n++) {
const tempPage = currentPage + n;
pages.push(tempPage);
}
pages.push('x');
pages.push(maxPage);
}
}
const maximum = pages.length;
if (currentPage !== 1) {
html += `<`;
}
for (let i = 0; i < maximum; i++) {
if (currentPage === parseInt(pages[i])) {
html += `
${pages[i]}
`;
} else if (pages[i] === 'x') {
html += `...`;
} else {
html += `${pages[i]} `;
}
}
if (currentPage !== maxPage) {
html += `>`;
}
return html;
};
const showPopupSearchCourses = () => {
getCoursesAdded();
modalContainer.style.display = 'block';
elOrderModalBtnAdd.style.display = 'none';
elSearchCoursesResult.innerHTML = '';
fetchCoursesAPI(dataSend.search, courseIdsAdded, dataSend.paged);
};
// Events.
document.addEventListener('click', e => {
const target = e.target;
//console.dir( target );
if (target.id === 'learn-press-add-order-item') {
e.preventDefault();
showPopupSearchCourses();
}
if (target.classList.contains('close') && target.closest(idModalSearchItems)) {
e.preventDefault();
elModalSearchCourses.querySelector('input[name="search"]').value = '';
dataSend.search = '';
dataSend.paged = 1;
modalContainer.style.display = 'none';
}
if (target.classList.contains('page-numbers')) {
if (target.closest(idModalSearchItems)) {
e.preventDefault();
const paged = target.getAttribute('data-page');
fetchCoursesAPI(dataSend.search, dataSend.id_not_in, paged);
}
}
if (target.name === 'selectedItems[]') {
if (target.closest(idModalSearchItems)) {
const courseId = parseInt(target.value);
if (target.checked) {
courseIdsNewSelected.push(courseId);
} else {
const index = courseIdsNewSelected.indexOf(courseId);
if (index > -1) {
courseIdsNewSelected.splice(index, 1);
}
}
elOrderModalBtnAdd.style.display = courseIdsNewSelected.length > 0 ? 'block' : 'none';
}
}
addCourses(e, target);
removeCourse(e, target);
});
document.addEventListener('keyup', function (e) {
const target = e.target;
searchCourse(e, target);
});
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_1__.lpOnElementReady('.lp-order-detail-items', el => {
getAllElements();
if (!elOrderDetails) {
return;
}
modalContainer.innerHTML = modalSearchItemsTemplate.innerHTML;
elModalSearchCourses = modalContainer.querySelector(idModalSearchItems);
elSearchCoursesResult = elModalSearchCourses.querySelector('.search-results');
elOrderModalFooter = elModalSearchCourses.querySelector('footer');
elOrderModalBtnAdd = elOrderModalFooter.querySelector('.add');
modalContainer.style.display = 'none';
});
};
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (addCoursesToOrder);
/***/ },
/***/ "./assets/src/js/admin/order/export_invoice.js"
/*!*****************************************************!*\
!*** ./assets/src/js/admin/order/export_invoice.js ***!
\*****************************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ export_invoice)
/* harmony export */ });
/**
* Export invoice to PDF
*/
function export_invoice() {
let html2pdf_obj, modal;
document.addEventListener('click', e => {
const target = e.target;
if (target.id === 'lp-invoice__export') {
html2pdf_obj.save();
} else if (target.id === 'lp-invoice__update') {
const elOption = document.querySelector('.export-options__content');
const fields = elOption.querySelectorAll('input');
const fieldNameUnChecked = [];
fields.forEach(field => {
if (!field.checked) {
fieldNameUnChecked.push(field.name);
}
});
window.localStorage.setItem('lp_invoice_un_fields', JSON.stringify(fieldNameUnChecked));
window.localStorage.setItem('lp_invoice_show', 1);
window.location.reload();
}
});
const exportPDF = () => {
const pdfOptions = {
margin: [0, 0, 0, 5],
filename: document.title,
image: {
type: 'webp'
},
html2canvas: {
scale: 2.5
},
jsPDF: {
format: 'a4',
orientation: 'p'
}
};
const html = document.querySelector('#lp-invoice__content');
html2pdf_obj = html2pdf().set(pdfOptions).from(html);
};
const showInfoFields = () => {
// Get fields name checked
const fieldsChecked = window.localStorage.getItem('lp_invoice_un_fields');
const elOptions = document.querySelector('.export-options__content');
const elInvoiceFields = document.querySelectorAll('.invoice-field');
elInvoiceFields.forEach(field => {
const nameClass = field.classList[1];
if (fieldsChecked && fieldsChecked.includes(nameClass)) {
field.remove();
const elOption = elOptions.querySelector(`[name=${nameClass}]`);
if (elOption) {
elOption.checked = false;
}
}
});
const showInvoice = parseInt(window.localStorage.getItem('lp_invoice_show'));
if (showInvoice === 1) {
modal.style.display = 'block';
}
};
document.addEventListener('DOMContentLoaded', () => {
const elExportSection = document.querySelector('#order-export__section');
if (!elExportSection.length) {
const tabs = document.querySelectorAll('.tabs');
const tab = document.querySelectorAll('.tab');
const panel = document.querySelectorAll('.panel');
function onTabClick(event) {
// deactivate existing active tabs and panel
for (let i = 0; i < tab.length; i++) {
tab[i].classList.remove('active');
}
for (let i = 0; i < panel.length; i++) {
panel[i].classList.remove('active');
}
// activate new tabs and panel
event.target.classList.add('active');
const classString = event.target.getAttribute('data-target');
document.getElementById('panels').getElementsByClassName(classString)[0].classList.add('active');
}
for (let i = 0; i < tab.length; i++) {
tab[i].addEventListener('click', onTabClick, false);
}
// Get the modal
modal = document.getElementById('myModal');
// Get the button that opens the modal
const btn = document.getElementById('order-export__button');
// Get the element that closes the modal
const span = document.getElementsByClassName('close')[0];
// When the user clicks on the button, open the modal
btn.onclick = function () {
modal.style.display = 'block';
};
// When the user clicks on (x), close the modal
span.onclick = function () {
modal.style.display = 'none';
window.localStorage.setItem('lp_invoice_show', 0);
};
// When the user clicks anywhere outside the modal, close it
window.onclick = function (event) {
if (event.target === modal) {
modal.style.display = 'none';
window.localStorage.setItem('lp_invoice_show', 0);
}
};
showInfoFields();
exportPDF();
}
});
}
/***/ },
/***/ "./assets/src/js/admin/order/refund-order.js"
/*!***************************************************!*\
!*** ./assets/src/js/admin/order/refund-order.js ***!
\***************************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ RefundOrder: () => (/* binding */ RefundOrder),
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var sweetalert2__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! sweetalert2 */ "./node_modules/sweetalert2/dist/sweetalert2.all.js");
/* harmony import */ var sweetalert2__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(sweetalert2__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var lpAssetsJsPath_lpToastify__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lpAssetsJsPath/lpToastify */ "./assets/src/js/lpToastify.js");
/* harmony import */ var lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! lpAssetsJsPath/utils.js */ "./assets/src/js/utils.js");
/**
* Handle admin approve/deny refund actions.
*
* @since 4.3.9
* @version 1.0.0
*/
class RefundOrder {
constructor() {
this.isRequesting = false;
this.isReloading = false;
}
static selectors = {
panel: '.order-data-refund-request',
action: '.lp-admin-refund-order-action'
};
init() {
this.events();
}
events() {
if (RefundOrder._loadedEvents) {
return;
}
RefundOrder._loadedEvents = this;
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_2__.eventHandlers('click', [{
selector: RefundOrder.selectors.action,
class: this,
callBack: this.handleAction.name
}]);
}
getPanelData(panel) {
const orderTotal = parseFloat(panel.dataset.orderTotal || '0');
return {
orderId: parseInt(panel.dataset.orderId || '0', 10),
orderTotal: Number.isNaN(orderTotal) ? 0 : orderTotal,
orderTotalFormatted: panel.dataset.orderTotalFormatted || '',
confirmTitle: panel.dataset.confirmTitle || 'Approve refund?',
confirmText: panel.dataset.confirmText || '',
messageLabel: panel.dataset.messageLabel || 'Message to payer',
messagePlaceholder: panel.dataset.messagePlaceholder || '',
amountLabel: panel.dataset.amountLabel || 'Refund amount',
amountInvalid: panel.dataset.amountInvalid || 'Invalid refund amount.',
confirmButton: panel.dataset.confirmButton || 'Approve Refund',
cancelButton: panel.dataset.cancelButton || 'Cancel'
};
}
setLoadingState(panel, isLoading) {
panel.querySelectorAll(RefundOrder.selectors.action).forEach(button => {
button.disabled = isLoading;
});
}
openApproveModal(data) {
const content = document.createElement('div');
const messageLabel = document.createElement('label');
const message = document.createElement('textarea');
const amountLabel = document.createElement('label');
const amount = document.createElement('input');
content.className = 'lp-admin-refund-modal__form';
if (data.confirmText) {
const confirmText = document.createElement('p');
confirmText.className = 'lp-admin-refund-modal__description';
confirmText.textContent = data.confirmText;
content.append(confirmText);
}
messageLabel.textContent = data.messageLabel;
messageLabel.htmlFor = 'lp-admin-refund-message';
messageLabel.className = 'swal2-input-label';
message.id = 'lp-admin-refund-message';
message.className = 'swal2-textarea';
message.placeholder = data.messagePlaceholder;
amountLabel.textContent = `${data.amountLabel} (${data.orderTotalFormatted})`;
amountLabel.htmlFor = 'lp-admin-refund-amount';
amountLabel.className = 'swal2-input-label';
amount.id = 'lp-admin-refund-amount';
amount.className = 'swal2-input';
amount.type = 'number';
amount.min = '0.01';
amount.max = data.orderTotal.toString();
amount.step = '0.01';
amount.value = data.orderTotal.toFixed(2);
content.append(messageLabel, message, amountLabel, amount);
return sweetalert2__WEBPACK_IMPORTED_MODULE_0___default().fire({
icon: 'warning',
title: data.confirmTitle,
html: content,
showCancelButton: true,
confirmButtonText: data.confirmButton,
cancelButtonText: data.cancelButton,
focusConfirm: false,
customClass: {
popup: 'lp-admin-refund-modal',
htmlContainer: 'lp-admin-refund-modal__content',
actions: 'lp-admin-refund-modal__actions'
},
preConfirm: () => {
const refundAmount = parseFloat(amount.value);
if (Number.isNaN(refundAmount) || refundAmount <= 0 || refundAmount > data.orderTotal) {
sweetalert2__WEBPACK_IMPORTED_MODULE_0___default().showValidationMessage(data.amountInvalid);
return false;
}
return {
note: message.value.trim(),
refundAmount
};
}
});
}
sendAction(actionButton, panel, refundAction, refundAmount = 0, note = '') {
const data = this.getPanelData(panel);
if (!data.orderId) {
lpAssetsJsPath_lpToastify__WEBPACK_IMPORTED_MODULE_1__.show('Invalid order.', 'error');
return;
}
this.isRequesting = true;
this.setLoadingState(panel, true);
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_2__.lpSetLoadingEl(actionButton, 1);
window.lpAJAXG.fetchAJAX({
action: 'admin_handle_request_refund',
order_id: data.orderId,
refund_action: refundAction,
refund_amount: refundAmount,
note
}, {
success: response => {
const {
status,
message,
data
} = response;
if (status !== 'success') {
throw new Error(message);
}
lpAssetsJsPath_lpToastify__WEBPACK_IMPORTED_MODULE_1__.show(message, 'success');
this.isReloading = true;
window.setTimeout(() => window.location.reload(), 1200);
},
error: error => {
const messageResponse = error?.message || error || 'Refund action failed.';
lpAssetsJsPath_lpToastify__WEBPACK_IMPORTED_MODULE_1__.show(messageResponse, 'error');
},
completed: () => {
if (this.isReloading) {
return;
}
this.isRequesting = false;
this.setLoadingState(panel, false);
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_2__.lpSetLoadingEl(actionButton, 0);
}
});
}
async handleAction(args) {
const {
e,
target
} = args;
e.preventDefault();
const actionButton = target.closest(RefundOrder.selectors.action);
const panel = actionButton?.closest(RefundOrder.selectors.panel);
if (!actionButton || !panel || this.isRequesting) {
return;
}
const refundAction = actionButton.dataset.refundAction || '';
let amount = '';
let note = '';
if ('reject' === refundAction) {
return this.sendAction(actionButton, panel, refundAction);
}
const result = await this.openApproveModal(this.getPanelData(panel));
if (result.isConfirmed && result.value) {
amount = result.value.refundAmount;
note = result.value.note;
this.sendAction(actionButton, panel, refundAction, amount, note);
}
}
}
const refundOrder = () => {
const refundOrderHandle = new RefundOrder();
lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_2__.lpOnElementReady(RefundOrder.selectors.action, () => {
refundOrderHandle.init();
});
};
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (refundOrder);
/***/ },
/***/ "./assets/src/js/admin/utils-admin.js"
/*!********************************************!*\
!*** ./assets/src/js/admin/utils-admin.js ***!
\********************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ AdminUtilsFunctions: () => (/* binding */ AdminUtilsFunctions),
/* harmony export */ Api: () => (/* reexport safe */ _api_js__WEBPACK_IMPORTED_MODULE_2__["default"]),
/* harmony export */ Utils: () => (/* reexport module object */ _utils_js__WEBPACK_IMPORTED_MODULE_0__)
/* harmony export */ });
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./assets/src/js/utils.js");
/* harmony import */ var tom_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tom-select */ "./node_modules/tom-select/dist/esm/tom-select.complete.js");
/* harmony import */ var _api_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../api.js */ "./assets/src/js/api.js");
/**
* Library run on Admin
*
* @since 4.2.6.9
* @version 1.0.1
*/
const AdminUtilsFunctions = {
buildTomSelect(elTomSelect, options, fetchAPI, dataSend, callBackHandleData) {
if (!elTomSelect) {
return;
}
const optionDefault = {
plugins: {
remove_button: {
title: 'Remove this item'
},
dropdown_input: {}
},
onInitialize() {},
onItemAdd(e) {
// Get list without current item.
if (fetchAPI) {
const selectedOptions = Array.from(elTomSelect.selectedOptions);
const selectedValues = selectedOptions.map(option => option.value);
selectedValues.push(e);
dataSend.id_not_in = selectedValues.join(',');
fetchAPI('', dataSend, callBackHandleData);
}
}
};
if (fetchAPI) {
optionDefault.load = (keySearch, callbackTom) => {
const selectedOptions = Array.from(elTomSelect.selectedOptions);
const selectedValues = selectedOptions.map(option => option.value);
dataSend.id_not_in = selectedValues.join(',');
fetchAPI(keySearch, dataSend, AdminUtilsFunctions.callBackTomSelectSearchAPI(callbackTom, callBackHandleData));
};
}
options = {
...optionDefault,
...options
};
const items_selected = options.options;
/*if ( options?.options?.length > 20 ) {
const chunkSize = 20;
const length = options.options.length;
let i = 0;
const chunkedOptions = { ...options };
chunkedOptions.options = items_selected.slice( i, chunkSize );
const tomSelect = new TomSelect( elTomSelect, chunkedOptions );
i += chunkSize;
const interval = setInterval( () => {
if ( i > ( length - 1 ) ) {
clearInterval( interval );
}
const optionsSlice = items_selected.slice( i, i + chunkSize );
i += chunkSize;
tomSelect.addOptions( optionsSlice );
tomSelect.setValue( options.items );
}, 200 );
return tomSelect;
}*/
return new tom_select__WEBPACK_IMPORTED_MODULE_1__["default"](elTomSelect, options);
},
callBackTomSelectSearchAPI(callbackTom, callBackHandleData) {
return {
success: response => {
const options = callBackHandleData.success(response);
callbackTom(options);
}
};
},
fetchCourses(keySearch = '', dataSend = {}, callback) {
const url = _api_js__WEBPACK_IMPORTED_MODULE_2__["default"].admin.apiSearchCourses;
dataSend.search = keySearch;
const params = {
headers: {
'Content-Type': 'application/json',
'X-WP-Nonce': lpDataAdmin.nonce
},
method: 'POST',
body: JSON.stringify(dataSend)
};
_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI(url, params, callback);
},
fetchUsers(keySearch = '', dataSend = {}, callback) {
const url = _api_js__WEBPACK_IMPORTED_MODULE_2__["default"].admin.apiSearchUsers;
dataSend.search = keySearch;
const params = {
headers: {
'Content-Type': 'application/json',
'X-WP-Nonce': lpDataAdmin.nonce
},
method: 'POST',
body: JSON.stringify(dataSend)
};
_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI(url, params, callback);
}
};
/***/ },
/***/ "./assets/src/js/api.js"
/*!******************************!*\
!*** ./assets/src/js/api.js ***!
\******************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/**
* List API on backend
*
* @since 4.2.6
* @version 1.0.2
*/
const lplistAPI = {};
let lp_rest_url;
if ('undefined' !== typeof lpDataAdmin) {
lp_rest_url = lpDataAdmin.lp_rest_url;
lplistAPI.admin = {
apiAdminNotice: lp_rest_url + 'lp/v1/admin/tools/admin-notices',
apiAddons: lp_rest_url + 'lp/v1/addon/all',
apiAddonAction: lp_rest_url + 'lp/v1/addon/action-n',
apiAddonsPurchase: lp_rest_url + 'lp/v1/addon/info-addons-purchase',
apiSearchCourses: lp_rest_url + 'lp/v1/admin/tools/search-course',
apiSearchUsers: lp_rest_url + 'lp/v1/admin/tools/search-user',
apiAssignUserCourse: lp_rest_url + 'lp/v1/admin/tools/assign-user-course',
apiUnAssignUserCourse: lp_rest_url + 'lp/v1/admin/tools/unassign-user-course'
};
}
if ('undefined' !== typeof lpData) {
lp_rest_url = lpData.lp_rest_url;
lplistAPI.frontend = {
apiWidgets: lp_rest_url + 'lp/v1/widgets/api',
apiCourses: lp_rest_url + 'lp/v1/courses/archive-course',
// Deprecated API, don't load from v4.3.7
apiAJAX: lp_rest_url + 'lp/v1/load_content_via_ajax/',
// Deprecated since 4.3.0
apiProfileCoverImage: lp_rest_url + 'lp/v1/profile/cover-image'
};
}
if (lp_rest_url) {
lplistAPI.apiCourses = lp_rest_url + 'lp/v1/courses/';
lplistAPI.apiEditCoursesArchiveBlock = lp_rest_url + 'lp/v1/courses/edit-archive-block';
lplistAPI.apiCoursesSuggest = lp_rest_url + 'lp/v1/courses/courses-suggest';
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (lplistAPI);
/***/ },
/***/ "./assets/src/js/lpToastify.js"
/*!*************************************!*\
!*** ./assets/src/js/lpToastify.js ***!
\*************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ show: () => (/* binding */ show)
/* harmony export */ });
/* harmony import */ var toastify_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! toastify-js */ "./node_modules/toastify-js/src/toastify.js");
/* harmony import */ var toastify_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(toastify_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var toastify_js_src_toastify_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! toastify-js/src/toastify.css */ "./node_modules/toastify-js/src/toastify.css");
/**
* Utils functions
*
* @param url
* @param data
* @param functions
* @since 4.3.0
* @version 1.0.0
*/
const argsToastify = {
text: '',
gravity: lpData.toast.gravity,
// `top` or `bottom`
position: lpData.toast.position,
// `left`, `center` or `right`
className: `${lpData.toast.classPrefix}`,
close: lpData.toast.close == 1,
stopOnFocus: lpData.toast.stopOnFocus == 1,
duration: lpData.toast.duration
};
const show = (message, status = 'success', argsCustom) => {
let args = argsToastify;
if (argsCustom) {
args = {
...args,
...argsCustom
};
}
const toastify = new (toastify_js__WEBPACK_IMPORTED_MODULE_0___default())({
...args,
text: message,
className: `${lpData.toast.classPrefix} ${status}`
});
toastify.showToast();
};
/***/ },
/***/ "./assets/src/js/utils.js"
/*!********************************!*\
!*** ./assets/src/js/utils.js ***!
\********************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ debounce: () => (/* binding */ debounce),
/* harmony export */ eventHandlers: () => (/* binding */ eventHandlers),
/* harmony export */ fullScreenView: () => (/* binding */ fullScreenView),
/* harmony export */ getDataOfForm: () => (/* binding */ getDataOfForm),
/* harmony export */ getFieldKeysOfForm: () => (/* binding */ getFieldKeysOfForm),
/* harmony export */ listenElementCreated: () => (/* binding */ listenElementCreated),
/* harmony export */ listenElementViewed: () => (/* binding */ listenElementViewed),
/* harmony export */ lpAddQueryArgs: () => (/* binding */ lpAddQueryArgs),
/* harmony export */ lpAjaxParseJsonOld: () => (/* binding */ lpAjaxParseJsonOld),
/* harmony export */ lpClassName: () => (/* binding */ lpClassName),
/* harmony export */ lpFetchAPI: () => (/* binding */ lpFetchAPI),
/* harmony export */ lpGetCurrentURLNoParam: () => (/* binding */ lpGetCurrentURLNoParam),
/* harmony export */ lpOnElementReady: () => (/* binding */ lpOnElementReady),
/* harmony export */ lpSetLoadingEl: () => (/* binding */ lpSetLoadingEl),
/* harmony export */ lpShowHideEl: () => (/* binding */ lpShowHideEl),
/* harmony export */ mergeDataWithDatForm: () => (/* binding */ mergeDataWithDatForm),
/* harmony export */ toggleCollapse: () => (/* binding */ toggleCollapse),
/* harmony export */ toggleEnable: () => (/* binding */ toggleEnable)
/* harmony export */ });
/**
* Utils functions
*
* @param url
* @param data
* @param functions
* @since 4.2.5.1
* @version 1.0.7
*/
const lpClassName = {
hidden: 'lp-hidden',
loading: 'loading',
elCollapse: 'lp-collapse',
elSectionToggle: '.lp-section-toggle',
elTriggerToggle: '.lp-trigger-toggle',
elBtnFullScreen: '.lp-btn-full-screen-view',
elFullScreen: 'lp-full-screen-view',
elBtnFullScreenClose: 'lp-full-screen-view__close'
};
const lpFetchAPI = (url, data = {}, functions = {}) => {
if ('function' === typeof functions.before) {
functions.before();
}
fetch(url, {
method: 'GET',
...data
}).then(response => response.json()).then(response => {
if ('function' === typeof functions.success) {
functions.success(response);
}
}).catch(err => {
if ('function' === typeof functions.error) {
functions.error(err);
}
}).finally(() => {
if ('function' === typeof functions.completed) {
functions.completed();
}
});
};
/**
* Get current URL without params.
*
* @since 4.2.5.1
*/
const lpGetCurrentURLNoParam = () => {
let currentUrl = window.location.href;
const hasParams = currentUrl.includes('?');
if (hasParams) {
currentUrl = currentUrl.split('?')[0];
}
return currentUrl;
};
const lpAddQueryArgs = (endpoint, args) => {
const url = new URL(endpoint);
Object.keys(args).forEach(arg => {
url.searchParams.set(arg, args[arg]);
});
return url;
};
/**
* Listen element viewed.
*
* @param el
* @param callback
* @since 4.2.5.8
*/
const listenElementViewed = (el, callback) => {
const observerSeeItem = new IntersectionObserver(function (entries) {
for (const entry of entries) {
if (entry.isIntersecting) {
callback(entry);
}
}
});
observerSeeItem.observe(el);
};
/**
* Listen element created.
*
* @param callback
* @since 4.2.5.8
*/
const listenElementCreated = callback => {
const observerCreateItem = new MutationObserver(function (mutations) {
mutations.forEach(function (mutation) {
if (mutation.addedNodes) {
mutation.addedNodes.forEach(function (node) {
if (node.nodeType === 1) {
callback(node);
}
});
}
});
});
observerCreateItem.observe(document, {
childList: true,
subtree: true
});
// End.
};
/**
* Listen element created.
*
* @param selector
* @param callback
* @since 4.2.7.1
*/
const lpOnElementReady = (selector, callback) => {
const element = document.querySelector(selector);
if (element) {
callback(element);
return;
}
const observer = new MutationObserver((mutations, obs) => {
const element = document.querySelector(selector);
if (element) {
obs.disconnect();
callback(element);
}
});
observer.observe(document.documentElement, {
childList: true,
subtree: true
});
};
// Parse JSON from string with content include LP_AJAX_START.
const lpAjaxParseJsonOld = data => {
if (typeof data !== 'string') {
return data;
}
const m = String.raw({
raw: data
}).match(/<-- LP_AJAX_START -->(.*)<-- LP_AJAX_END -->/s);
try {
if (m) {
data = JSON.parse(m[1].replace(/(?:\r\n|\r|\n)/g, ''));
} else {
data = JSON.parse(data);
}
} catch (e) {
data = {};
}
return data;
};
// status 0: hide, 1: show
const lpShowHideEl = (el, status = 0) => {
if (!el) {
return;
}
if (!status) {
el.classList.add(lpClassName.hidden);
} else {
el.classList.remove(lpClassName.hidden);
}
};
// status 0: hide, 1: show
const lpSetLoadingEl = (el, status) => {
if (!el) {
return;
}
if (!status) {
el.classList.remove(lpClassName.loading);
} else {
el.classList.add(lpClassName.loading);
}
};
// Toggle collapse section
const toggleCollapse = (e, target, elTriggerClassName = '', elsExclude = [], callback) => {
if (!elTriggerClassName) {
elTriggerClassName = lpClassName.elTriggerToggle;
}
// Exclude elements, which should not trigger the collapse toggle
if (elsExclude && elsExclude.length > 0) {
for (const elExclude of elsExclude) {
if (target.closest(elExclude)) {
return;
}
}
}
const elTrigger = target.closest(elTriggerClassName);
if (!elTrigger) {
return;
}
//console.log( 'elTrigger', elTrigger );
const elSectionToggle = elTrigger.closest(`${lpClassName.elSectionToggle}`);
if (!elSectionToggle) {
return;
}
elSectionToggle.classList.toggle(`${lpClassName.elCollapse}`);
if ('function' === typeof callback) {
callback(elSectionToggle);
}
};
// Get data of form
const getDataOfForm = form => {
const dataSend = {};
const formData = new FormData(form);
for (const pair of formData.entries()) {
const key = pair[0];
const value = formData.getAll(key);
if (!dataSend.hasOwnProperty(key)) {
// Convert value array to string.
dataSend[key] = value.join(',');
}
}
return dataSend;
};
// Get field keys of form
const getFieldKeysOfForm = form => {
const keys = [];
const elements = form.elements;
for (let i = 0; i < elements.length; i++) {
const name = elements[i].name;
if (name && !keys.includes(name)) {
keys.push(name);
}
}
return keys;
};
// Merge data handle with data form.
const mergeDataWithDatForm = (elForm, dataHandle) => {
const dataForm = getDataOfForm(elForm);
const keys = getFieldKeysOfForm(elForm);
keys.forEach(key => {
if (!dataForm.hasOwnProperty(key)) {
delete dataHandle[key];
} else if (dataForm[key][0] === '') {
delete dataForm[key];
delete dataHandle[key];
}
});
dataHandle = {
...dataHandle,
...dataForm
};
return dataHandle;
};
/**
* Event trigger
* For each list of event handlers, listen event on document.
*
* eventName: 'click', 'change', ...
* eventHandlers = [ { selector: '.lp-button', callBack: function(){}, class: object } ]
*
* @param eventName
* @param eventHandlers
*/
const eventHandlers = (eventName, eventHandlers) => {
document.addEventListener(eventName, e => {
const target = e.target;
let args = {
e,
target
};
eventHandlers.forEach(eventHandler => {
args = {
...args,
...eventHandler
};
//console.log( args );
// Check condition before call back
if (eventHandler.conditionBeforeCallBack) {
if (eventHandler.conditionBeforeCallBack(args) !== true) {
return;
}
}
// Special check for keydown event with checkIsEventEnter = true
if (eventName === 'keydown' && eventHandler.checkIsEventEnter) {
if (e.key !== 'Enter') {
return;
}
}
if (target.closest(eventHandler.selector)) {
if (eventHandler.class) {
// Call method of class, function callBack will understand exactly {this} is class object.
eventHandler.class[eventHandler.callBack](args);
} else {
// For send args is objected, {this} is eventHandler object, not class object.
eventHandler.callBack(args);
}
}
});
});
};
/**
* Debounce - delays function execution until after `wait` ms of inactivity.
*
* Each call resets the timer. Only the last call in a burst executes.
*
* USE CASES:
* - Search inputs, form validation, window resize
* - Multiple elements need independent timers
* - When you need to call with different arguments
*
* EXAMPLES:
* const debouncedSearch = debounce( (query) => fetchResults(query), 300 );
* searchInput.addEventListener('input', (e) => debouncedSearch(e.target.value));
*
* const debouncedResize = debounce( recalculateLayout, 250 );
* window.addEventListener('resize', debouncedResize);
*
* ⚠️ Create ONCE outside event handlers, not inside.
*
* @param {Function} func - Function to debounce (can be anonymous)
* @param {number} wait - Milliseconds to wait (default: 500)
* @return {Function} Debounced wrapper function
* @since 4.3.7
* @version 1.0.0
*/
const debounce = (func, wait = 500) => {
let timer;
return args => {
clearTimeout(timer);
timer = setTimeout(() => func(args), wait);
};
};
/**
* Initialize lp-toggle-enable components.
*
* Finds all `.lp-toggle-enable` elements and wires up toggle behavior.
* Reads initial state from `data-enabled` attribute ("true"/"false").
* Calls `data-on-toggle` callback (if provided via options) on state change.
*
* HTML structure:
*
*
* @param {string} selector CSS selector for toggle elements (default: '.lp-toggle-enable')
* @param {Function} onToggle Optional callback( el, isEnabled ) called on state change
* @since 4.4.5
* @version 1.0.0
*/
window.lpToggleEnableInit = 0;
const toggleEnable = (onToggle = null) => {
if (window.lpToggleEnableInit) {
return;
}
window.lpToggleEnableInit = 1;
const selector = '.lp-toggle-enable';
const updateUI = (toggle, isEnabled) => {
toggle.classList.toggle('is-enabled', isEnabled);
const input = toggle.querySelector('.lp-toggle-enable__input');
if (input) {
input.checked = isEnabled;
input.value = isEnabled ? '1' : '0';
}
};
// Delegate click handling via eventHandlers.
eventHandlers('click', [{
selector,
callBack: args => {
const {
e,
target
} = args;
const toggle = target.closest(selector);
if (!toggle || toggle.classList.contains('is-disabled')) {
return;
}
e.preventDefault();
const isEnabled = !toggle.classList.contains('is-enabled');
updateUI(toggle, isEnabled);
if ('function' === typeof onToggle) {
onToggle(toggle, isEnabled);
}
}
}]);
};
/**
* Initialize custom fullscreen view buttons.
*
* Delegates clicks on `.lp-btn-full-screen-view` buttons to
* `lpToggleFullscreenView`. Reads the `data-target` attribute to find the
* target element. Falls back to the button's parent element when
* `data-target` is not provided.
*
* @since 4.4.5
* @version 1.0.0
*/
window.lpFullScreenViewInit = 0;
const fullScreenView = () => {
if (window.lpFullScreenViewInit) {
return;
}
window.lpFullScreenViewInit = 1;
let lastScrollY = 0;
const lpToggleFullscreenView = (elTarget, elBtnFullScreen = null) => {
const isFullscreen = elTarget.classList.contains(lpClassName.elFullScreen);
if (isFullscreen) {
elTarget.classList.remove(lpClassName.elFullScreen);
document.documentElement.classList.remove('lp-full-screen-active');
window.scrollTo(0, lastScrollY);
} else {
lastScrollY = window.scrollY;
elTarget.classList.add(lpClassName.elFullScreen);
document.documentElement.classList.add('lp-full-screen-active');
}
if (!isFullscreen) {
if (!elTarget.querySelector(`.${lpClassName.elBtnFullScreenClose}`)) {
const closeButton = document.createElement('button');
closeButton.type = 'button';
closeButton.className = lpClassName.elBtnFullScreenClose;
closeButton.setAttribute('aria-label', 'Close');
closeButton.innerHTML = lpData.i18n.closeButtonFullScreen || 'Close ×';
closeButton.addEventListener('click', e => {
e.preventDefault();
lpToggleFullscreenView(elTarget);
});
elTarget.appendChild(closeButton);
}
} else {
const closeButton = elTarget.querySelector(`.${lpClassName.elBtnFullScreenClose}`);
if (closeButton) {
closeButton.remove();
}
}
};
eventHandlers('click', [{
selector: lpClassName.elBtnFullScreen,
callBack: args => {
const {
e,
target
} = args;
const elBtnFullScreen = target.closest(lpClassName.elBtnFullScreen);
if (!elBtnFullScreen) {
console.log('No full screen button found');
return;
}
e.preventDefault();
let elTarget = null;
const targetSelector = elBtnFullScreen.dataset.targetFullscreen;
console.log(targetSelector);
if (targetSelector) {
elTarget = document.querySelector(targetSelector);
}
if (!elTarget) {
console.log('No target element found');
return;
}
lpToggleFullscreenView(elTarget, elBtnFullScreen);
}
}]);
};
/***/ },
/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/toastify-js/src/toastify.css"
/*!*****************************************************************************************!*\
!*** ./node_modules/css-loader/dist/cjs.js!./node_modules/toastify-js/src/toastify.css ***!
\*****************************************************************************************/
(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../css-loader/dist/runtime/sourceMaps.js */ "./node_modules/css-loader/dist/runtime/sourceMaps.js");
/* harmony import */ var _css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js");
/* harmony import */ var _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, `/*!
* Toastify js 1.12.0
* https://github.com/apvarun/toastify-js
* @license MIT licensed
*
* Copyright (C) 2018 Varun A P
*/
.toastify {
padding: 12px 20px;
color: #ffffff;
display: inline-block;
box-shadow: 0 3px 6px -1px rgba(0, 0, 0, 0.12), 0 10px 36px -4px rgba(77, 96, 232, 0.3);
background: -webkit-linear-gradient(315deg, #73a5ff, #5477f5);
background: linear-gradient(135deg, #73a5ff, #5477f5);
position: fixed;
opacity: 0;
transition: all 0.4s cubic-bezier(0.215, 0.61, 0.355, 1);
border-radius: 2px;
cursor: pointer;
text-decoration: none;
max-width: calc(50% - 20px);
z-index: 2147483647;
}
.toastify.on {
opacity: 1;
}
.toast-close {
background: transparent;
border: 0;
color: white;
cursor: pointer;
font-family: inherit;
font-size: 1em;
opacity: 0.4;
padding: 0 5px;
}
.toastify-right {
right: 15px;
}
.toastify-left {
left: 15px;
}
.toastify-top {
top: -150px;
}
.toastify-bottom {
bottom: -150px;
}
.toastify-rounded {
border-radius: 25px;
}
.toastify-avatar {
width: 1.5em;
height: 1.5em;
margin: -7px 5px;
border-radius: 2px;
}
.toastify-center {
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
max-width: fit-content;
max-width: -moz-fit-content;
}
@media only screen and (max-width: 360px) {
.toastify-right, .toastify-left {
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
max-width: fit-content;
}
}
`, "",{"version":3,"sources":["webpack://./node_modules/toastify-js/src/toastify.css"],"names":[],"mappings":"AAAA;;;;;;EAME;;AAEF;IACI,kBAAkB;IAClB,cAAc;IACd,qBAAqB;IACrB,uFAAuF;IACvF,6DAA6D;IAC7D,qDAAqD;IACrD,eAAe;IACf,UAAU;IACV,wDAAwD;IACxD,kBAAkB;IAClB,eAAe;IACf,qBAAqB;IACrB,2BAA2B;IAC3B,mBAAmB;AACvB;;AAEA;IACI,UAAU;AACd;;AAEA;IACI,uBAAuB;IACvB,SAAS;IACT,YAAY;IACZ,eAAe;IACf,oBAAoB;IACpB,cAAc;IACd,YAAY;IACZ,cAAc;AAClB;;AAEA;IACI,WAAW;AACf;;AAEA;IACI,UAAU;AACd;;AAEA;IACI,WAAW;AACf;;AAEA;IACI,cAAc;AAClB;;AAEA;IACI,mBAAmB;AACvB;;AAEA;IACI,YAAY;IACZ,aAAa;IACb,gBAAgB;IAChB,kBAAkB;AACtB;;AAEA;IACI,iBAAiB;IACjB,kBAAkB;IAClB,OAAO;IACP,QAAQ;IACR,sBAAsB;IACtB,2BAA2B;AAC/B;;AAEA;IACI;QACI,iBAAiB;QACjB,kBAAkB;QAClB,OAAO;QACP,QAAQ;QACR,sBAAsB;IAC1B;AACJ","sourcesContent":["/*!\n * Toastify js 1.12.0\n * https://github.com/apvarun/toastify-js\n * @license MIT licensed\n *\n * Copyright (C) 2018 Varun A P\n */\n\n.toastify {\n padding: 12px 20px;\n color: #ffffff;\n display: inline-block;\n box-shadow: 0 3px 6px -1px rgba(0, 0, 0, 0.12), 0 10px 36px -4px rgba(77, 96, 232, 0.3);\n background: -webkit-linear-gradient(315deg, #73a5ff, #5477f5);\n background: linear-gradient(135deg, #73a5ff, #5477f5);\n position: fixed;\n opacity: 0;\n transition: all 0.4s cubic-bezier(0.215, 0.61, 0.355, 1);\n border-radius: 2px;\n cursor: pointer;\n text-decoration: none;\n max-width: calc(50% - 20px);\n z-index: 2147483647;\n}\n\n.toastify.on {\n opacity: 1;\n}\n\n.toast-close {\n background: transparent;\n border: 0;\n color: white;\n cursor: pointer;\n font-family: inherit;\n font-size: 1em;\n opacity: 0.4;\n padding: 0 5px;\n}\n\n.toastify-right {\n right: 15px;\n}\n\n.toastify-left {\n left: 15px;\n}\n\n.toastify-top {\n top: -150px;\n}\n\n.toastify-bottom {\n bottom: -150px;\n}\n\n.toastify-rounded {\n border-radius: 25px;\n}\n\n.toastify-avatar {\n width: 1.5em;\n height: 1.5em;\n margin: -7px 5px;\n border-radius: 2px;\n}\n\n.toastify-center {\n margin-left: auto;\n margin-right: auto;\n left: 0;\n right: 0;\n max-width: fit-content;\n max-width: -moz-fit-content;\n}\n\n@media only screen and (max-width: 360px) {\n .toastify-right, .toastify-left {\n margin-left: auto;\n margin-right: auto;\n left: 0;\n right: 0;\n max-width: fit-content;\n }\n}\n"],"sourceRoot":""}]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
/***/ },
/***/ "./node_modules/css-loader/dist/runtime/api.js"
/*!*****************************************************!*\
!*** ./node_modules/css-loader/dist/runtime/api.js ***!
\*****************************************************/
(module) {
"use strict";
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
module.exports = function (cssWithMappingToString) {
var list = [];
// return the list of modules as css string
list.toString = function toString() {
return this.map(function (item) {
var content = "";
var needLayer = typeof item[5] !== "undefined";
if (item[4]) {
content += "@supports (".concat(item[4], ") {");
}
if (item[2]) {
content += "@media ".concat(item[2], " {");
}
if (needLayer) {
content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
}
content += cssWithMappingToString(item);
if (needLayer) {
content += "}";
}
if (item[2]) {
content += "}";
}
if (item[4]) {
content += "}";
}
return content;
}).join("");
};
// import a list of modules into the list
list.i = function i(modules, media, dedupe, supports, layer) {
if (typeof modules === "string") {
modules = [[null, modules, undefined]];
}
var alreadyImportedModules = {};
if (dedupe) {
for (var k = 0; k < this.length; k++) {
var id = this[k][0];
if (id != null) {
alreadyImportedModules[id] = true;
}
}
}
for (var _k = 0; _k < modules.length; _k++) {
var item = [].concat(modules[_k]);
if (dedupe && alreadyImportedModules[item[0]]) {
continue;
}
if (typeof layer !== "undefined") {
if (typeof item[5] === "undefined") {
item[5] = layer;
} else {
item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
item[5] = layer;
}
}
if (media) {
if (!item[2]) {
item[2] = media;
} else {
item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
item[2] = media;
}
}
if (supports) {
if (!item[4]) {
item[4] = "".concat(supports);
} else {
item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
item[4] = supports;
}
}
list.push(item);
}
};
return list;
};
/***/ },
/***/ "./node_modules/css-loader/dist/runtime/sourceMaps.js"
/*!************************************************************!*\
!*** ./node_modules/css-loader/dist/runtime/sourceMaps.js ***!
\************************************************************/
(module) {
"use strict";
module.exports = function (item) {
var content = item[1];
var cssMapping = item[3];
if (!cssMapping) {
return content;
}
if (typeof btoa === "function") {
var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
var sourceMapping = "/*# ".concat(data, " */");
return [content].concat([sourceMapping]).join("\n");
}
return [content].join("\n");
};
/***/ },
/***/ "./node_modules/toastify-js/src/toastify.css"
/*!***************************************************!*\
!*** ./node_modules/toastify-js/src/toastify.css ***!
\***************************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js");
/* harmony import */ var _style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !../../style-loader/dist/runtime/styleDomAPI.js */ "./node_modules/style-loader/dist/runtime/styleDomAPI.js");
/* harmony import */ var _style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! !../../style-loader/dist/runtime/insertBySelector.js */ "./node_modules/style-loader/dist/runtime/insertBySelector.js");
/* harmony import */ var _style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! !../../style-loader/dist/runtime/setAttributesWithoutAttributes.js */ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js");
/* harmony import */ var _style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! !../../style-loader/dist/runtime/insertStyleElement.js */ "./node_modules/style-loader/dist/runtime/insertStyleElement.js");
/* harmony import */ var _style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var _style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! !../../style-loader/dist/runtime/styleTagTransform.js */ "./node_modules/style-loader/dist/runtime/styleTagTransform.js");
/* harmony import */ var _style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _css_loader_dist_cjs_js_toastify_css__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! !!../../css-loader/dist/cjs.js!./toastify.css */ "./node_modules/css-loader/dist/cjs.js!./node_modules/toastify-js/src/toastify.css");
var options = {};
options.styleTagTransform = (_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___default());
options.setAttributes = (_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODULE_3___default());
options.insert = _style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default().bind(null, "head");
options.domAPI = (_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default());
options.insertStyleElement = (_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___default());
var update = _style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_css_loader_dist_cjs_js_toastify_css__WEBPACK_IMPORTED_MODULE_6__["default"], options);
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_css_loader_dist_cjs_js_toastify_css__WEBPACK_IMPORTED_MODULE_6__["default"] && _css_loader_dist_cjs_js_toastify_css__WEBPACK_IMPORTED_MODULE_6__["default"].locals ? _css_loader_dist_cjs_js_toastify_css__WEBPACK_IMPORTED_MODULE_6__["default"].locals : undefined);
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"
/*!****************************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js ***!
\****************************************************************************/
(module) {
"use strict";
var stylesInDOM = [];
function getIndexByIdentifier(identifier) {
var result = -1;
for (var i = 0; i < stylesInDOM.length; i++) {
if (stylesInDOM[i].identifier === identifier) {
result = i;
break;
}
}
return result;
}
function modulesToDom(list, options) {
var idCountMap = {};
var identifiers = [];
for (var i = 0; i < list.length; i++) {
var item = list[i];
var id = options.base ? item[0] + options.base : item[0];
var count = idCountMap[id] || 0;
var identifier = "".concat(id, " ").concat(count);
idCountMap[id] = count + 1;
var indexByIdentifier = getIndexByIdentifier(identifier);
var obj = {
css: item[1],
media: item[2],
sourceMap: item[3],
supports: item[4],
layer: item[5]
};
if (indexByIdentifier !== -1) {
stylesInDOM[indexByIdentifier].references++;
stylesInDOM[indexByIdentifier].updater(obj);
} else {
var updater = addElementStyle(obj, options);
options.byIndex = i;
stylesInDOM.splice(i, 0, {
identifier: identifier,
updater: updater,
references: 1
});
}
identifiers.push(identifier);
}
return identifiers;
}
function addElementStyle(obj, options) {
var api = options.domAPI(options);
api.update(obj);
var updater = function updater(newObj) {
if (newObj) {
if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {
return;
}
api.update(obj = newObj);
} else {
api.remove();
}
};
return updater;
}
module.exports = function (list, options) {
options = options || {};
list = list || [];
var lastIdentifiers = modulesToDom(list, options);
return function update(newList) {
newList = newList || [];
for (var i = 0; i < lastIdentifiers.length; i++) {
var identifier = lastIdentifiers[i];
var index = getIndexByIdentifier(identifier);
stylesInDOM[index].references--;
}
var newLastIdentifiers = modulesToDom(newList, options);
for (var _i = 0; _i < lastIdentifiers.length; _i++) {
var _identifier = lastIdentifiers[_i];
var _index = getIndexByIdentifier(_identifier);
if (stylesInDOM[_index].references === 0) {
stylesInDOM[_index].updater();
stylesInDOM.splice(_index, 1);
}
}
lastIdentifiers = newLastIdentifiers;
};
};
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/insertBySelector.js"
/*!********************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/insertBySelector.js ***!
\********************************************************************/
(module) {
"use strict";
var memo = {};
/* istanbul ignore next */
function getTarget(target) {
if (typeof memo[target] === "undefined") {
var styleTarget = document.querySelector(target);
// Special case to return head of iframe instead of iframe itself
if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
try {
// This will throw an exception if access to iframe is blocked
// due to cross-origin restrictions
styleTarget = styleTarget.contentDocument.head;
} catch (e) {
// istanbul ignore next
styleTarget = null;
}
}
memo[target] = styleTarget;
}
return memo[target];
}
/* istanbul ignore next */
function insertBySelector(insert, style) {
var target = getTarget(insert);
if (!target) {
throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
}
target.appendChild(style);
}
module.exports = insertBySelector;
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/insertStyleElement.js"
/*!**********************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/insertStyleElement.js ***!
\**********************************************************************/
(module) {
"use strict";
/* istanbul ignore next */
function insertStyleElement(options) {
var element = document.createElement("style");
options.setAttributes(element, options.attributes);
options.insert(element, options.options);
return element;
}
module.exports = insertStyleElement;
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js"
/*!**********************************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js ***!
\**********************************************************************************/
(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/* istanbul ignore next */
function setAttributesWithoutAttributes(styleElement) {
var nonce = true ? __webpack_require__.nc : 0;
if (nonce) {
styleElement.setAttribute("nonce", nonce);
}
}
module.exports = setAttributesWithoutAttributes;
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/styleDomAPI.js"
/*!***************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/styleDomAPI.js ***!
\***************************************************************/
(module) {
"use strict";
/* istanbul ignore next */
function apply(styleElement, options, obj) {
var css = "";
if (obj.supports) {
css += "@supports (".concat(obj.supports, ") {");
}
if (obj.media) {
css += "@media ".concat(obj.media, " {");
}
var needLayer = typeof obj.layer !== "undefined";
if (needLayer) {
css += "@layer".concat(obj.layer.length > 0 ? " ".concat(obj.layer) : "", " {");
}
css += obj.css;
if (needLayer) {
css += "}";
}
if (obj.media) {
css += "}";
}
if (obj.supports) {
css += "}";
}
var sourceMap = obj.sourceMap;
if (sourceMap && typeof btoa !== "undefined") {
css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */");
}
// For old IE
/* istanbul ignore if */
options.styleTagTransform(css, styleElement, options.options);
}
function removeStyleElement(styleElement) {
// istanbul ignore if
if (styleElement.parentNode === null) {
return false;
}
styleElement.parentNode.removeChild(styleElement);
}
/* istanbul ignore next */
function domAPI(options) {
if (typeof document === "undefined") {
return {
update: function update() {},
remove: function remove() {}
};
}
var styleElement = options.insertStyleElement(options);
return {
update: function update(obj) {
apply(styleElement, options, obj);
},
remove: function remove() {
removeStyleElement(styleElement);
}
};
}
module.exports = domAPI;
/***/ },
/***/ "./node_modules/style-loader/dist/runtime/styleTagTransform.js"
/*!*********************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/styleTagTransform.js ***!
\*********************************************************************/
(module) {
"use strict";
/* istanbul ignore next */
function styleTagTransform(css, styleElement) {
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = css;
} else {
while (styleElement.firstChild) {
styleElement.removeChild(styleElement.firstChild);
}
styleElement.appendChild(document.createTextNode(css));
}
}
module.exports = styleTagTransform;
/***/ },
/***/ "./node_modules/sweetalert2/dist/sweetalert2.all.js"
/*!**********************************************************!*\
!*** ./node_modules/sweetalert2/dist/sweetalert2.all.js ***!
\**********************************************************/
(module) {
/*!
* sweetalert2 v11.26.17
* Released under the MIT License.
*/
(function (global, factory) {
true ? module.exports = factory() :
0;
})(this, (function () { 'use strict';
function _assertClassBrand(e, t, n) {
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
throw new TypeError("Private element is not present on this object");
}
function _checkPrivateRedeclaration(e, t) {
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classPrivateFieldGet2(s, a) {
return s.get(_assertClassBrand(s, a));
}
function _classPrivateFieldInitSpec(e, t, a) {
_checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _classPrivateFieldSet2(s, a, r) {
return s.set(_assertClassBrand(s, a), r), r;
}
const RESTORE_FOCUS_TIMEOUT = 100;
/** @type {GlobalState} */
const globalState = {};
const 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}
*/
const restoreActiveElement = returnFocus => {
return new Promise(resolve => {
if (!returnFocus) {
return resolve();
}
const x = window.scrollX;
const y = window.scrollY;
globalState.restoreFocusTimeout = setTimeout(() => {
focusPreviousActiveElement();
resolve();
}, RESTORE_FOCUS_TIMEOUT); // issues/900
window.scrollTo(x, y);
});
};
const swalPrefix = 'swal2-';
/**
* @typedef {Record} SwalClasses
*/
/**
* @typedef {'success' | 'warning' | 'info' | 'question' | 'error'} SwalIcon
* @typedef {Record} SwalIcons
*/
/** @type {SwalClass[]} */
const 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', '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', 'draggable', 'dragging'];
const swalClasses = classNames.reduce((acc, className) => {
acc[className] = swalPrefix + className;
return acc;
}, /** @type {SwalClasses} */{});
/** @type {SwalIcon[]} */
const icons = ['success', 'warning', 'info', 'question', 'error'];
const iconTypes = icons.reduce((acc, icon) => {
acc[icon] = swalPrefix + icon;
return acc;
}, /** @type {SwalIcons} */{});
const consolePrefix = 'SweetAlert2:';
/**
* Capitalize the first letter of a string
*
* @param {string} str
* @returns {string}
*/
const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
/**
* Standardize console warnings
*
* @param {string | string[]} message
*/
const warn = message => {
console.warn(`${consolePrefix} ${typeof message === 'object' ? message.join(' ') : message}`);
};
/**
* Standardize console errors
*
* @param {string} message
*/
const error = message => {
console.error(`${consolePrefix} ${message}`);
};
/**
* Private global state for `warnOnce`
*
* @type {string[]}
* @private
*/
const previousWarnOnceMessages = [];
/**
* Show a console warning, but only if it hasn't already been shown
*
* @param {string} message
*/
const 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
*/
const warnAboutDeprecation = (deprecatedParam, useInstead = null) => {
warnOnce(`"${deprecatedParam}" is deprecated and will be removed in the next major release.${useInstead ? ` Use "${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 {(() => *) | *} arg
* @returns {*}
*/
const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
/**
* @param {*} arg
* @returns {boolean}
*/
const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
/**
* @param {*} arg
* @returns {Promise<*>}
*/
const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
/**
* @param {*} arg
* @returns {boolean}
*/
const isPromise = arg => arg && Promise.resolve(arg) === arg;
/**
* Gets the popup container which contains the backdrop and the popup itself.
*
* @returns {HTMLElement | null}
*/
const getContainer = () => document.body.querySelector(`.${swalClasses.container}`);
/**
* @param {string} selectorString
* @returns {HTMLElement | null}
*/
const elementBySelector = selectorString => {
const container = getContainer();
return container ? container.querySelector(selectorString) : null;
};
/**
* @param {string} className
* @returns {HTMLElement | null}
*/
const elementByClass = className => {
return elementBySelector(`.${className}`);
};
/**
* @returns {HTMLElement | null}
*/
const getPopup = () => elementByClass(swalClasses.popup);
/**
* @returns {HTMLElement | null}
*/
const getIcon = () => elementByClass(swalClasses.icon);
/**
* @returns {HTMLElement | null}
*/
const getIconContent = () => elementByClass(swalClasses['icon-content']);
/**
* @returns {HTMLElement | null}
*/
const getTitle = () => elementByClass(swalClasses.title);
/**
* @returns {HTMLElement | null}
*/
const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
/**
* @returns {HTMLElement | null}
*/
const getImage = () => elementByClass(swalClasses.image);
/**
* @returns {HTMLElement | null}
*/
const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
/**
* @returns {HTMLElement | null}
*/
const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
/**
* @returns {HTMLButtonElement | null}
*/
const getConfirmButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.confirm}`));
/**
* @returns {HTMLButtonElement | null}
*/
const getCancelButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.cancel}`));
/**
* @returns {HTMLButtonElement | null}
*/
const getDenyButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.deny}`));
/**
* @returns {HTMLElement | null}
*/
const getInputLabel = () => elementByClass(swalClasses['input-label']);
/**
* @returns {HTMLElement | null}
*/
const getLoader = () => elementBySelector(`.${swalClasses.loader}`);
/**
* @returns {HTMLElement | null}
*/
const getActions = () => elementByClass(swalClasses.actions);
/**
* @returns {HTMLElement | null}
*/
const getFooter = () => elementByClass(swalClasses.footer);
/**
* @returns {HTMLElement | null}
*/
const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
/**
* @returns {HTMLElement | null}
*/
const getCloseButton = () => elementByClass(swalClasses.close);
// https://github.com/jkup/focusable/blob/master/index.js
const focusable = `
a[href],
area[href],
input:not([disabled]),
select:not([disabled]),
textarea:not([disabled]),
button:not([disabled]),
iframe,
object,
embed,
[tabindex="0"],
[contenteditable],
audio[controls],
video[controls],
summary
`;
/**
* @returns {HTMLElement[]}
*/
const getFocusableElements = () => {
const popup = getPopup();
if (!popup) {
return [];
}
/** @type {NodeListOf} */
const focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])');
const focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)
// sort according to tabindex
.sort((a, b) => {
const tabindexA = parseInt(a.getAttribute('tabindex') || '0');
const tabindexB = parseInt(b.getAttribute('tabindex') || '0');
if (tabindexA > tabindexB) {
return 1;
} else if (tabindexA < tabindexB) {
return -1;
}
return 0;
});
/** @type {NodeListOf} */
const otherFocusableElements = popup.querySelectorAll(focusable);
const otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(el => el.getAttribute('tabindex') !== '-1');
return [...new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))].filter(el => isVisible$1(el));
};
/**
* @returns {boolean}
*/
const isModal = () => {
return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
};
/**
* @returns {boolean}
*/
const isToast = () => {
const popup = getPopup();
if (!popup) {
return false;
}
return hasClass(popup, swalClasses.toast);
};
/**
* @returns {boolean}
*/
const isLoading = () => {
const 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
*/
const setInnerHtml = (elem, html) => {
elem.textContent = '';
if (html) {
const parser = new DOMParser();
const parsed = parser.parseFromString(html, `text/html`);
const head = parsed.querySelector('head');
if (head) {
Array.from(head.childNodes).forEach(child => {
elem.appendChild(child);
});
}
const body = parsed.querySelector('body');
if (body) {
Array.from(body.childNodes).forEach(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}
*/
const hasClass = (elem, className) => {
if (!className) {
return false;
}
const classList = className.split(/\s+/);
for (let i = 0; i < classList.length; i++) {
if (!elem.classList.contains(classList[i])) {
return false;
}
}
return true;
};
/**
* @param {HTMLElement} elem
* @param {SweetAlertOptions} params
*/
const removeCustomClasses = (elem, params) => {
Array.from(elem.classList).forEach(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
*/
const applyCustomClass = (elem, params, className) => {
removeCustomClasses(elem, params);
if (!params.customClass) {
return;
}
const customClass = params.customClass[(/** @type {keyof SweetAlertCustomClass} */className)];
if (!customClass) {
return;
}
if (typeof customClass !== 'string' && !customClass.forEach) {
warn(`Invalid type of customClass.${className}! Expected string or iterable object, got "${typeof customClass}"`);
return;
}
addClass(elem, customClass);
};
/**
* @param {HTMLElement} popup
* @param {import('./renderers/renderInput').InputClass | SweetAlertInput} inputClass
* @returns {HTMLInputElement | null}
*/
const getInput$1 = (popup, inputClass) => {
if (!inputClass) {
return null;
}
switch (inputClass) {
case 'select':
case 'textarea':
case 'file':
return popup.querySelector(`.${swalClasses.popup} > .${swalClasses[inputClass]}`);
case 'checkbox':
return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.checkbox} input`);
case 'radio':
return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:checked`) || popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:first-child`);
case 'range':
return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.range} input`);
default:
return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.input}`);
}
};
/**
* @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
*/
const focusInput = input => {
input.focus();
// place cursor at end of text in text input
if (input.type !== 'file') {
// http://stackoverflow.com/a/2345915
const val = input.value;
input.value = '';
input.value = val;
}
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
* @param {boolean} condition
*/
const toggleClass = (target, classList, condition) => {
if (!target || !classList) {
return;
}
if (typeof classList === 'string') {
classList = classList.split(/\s+/).filter(Boolean);
}
classList.forEach(className => {
if (Array.isArray(target)) {
target.forEach(elem => {
if (condition) {
elem.classList.add(className);
} else {
elem.classList.remove(className);
}
});
} else {
if (condition) {
target.classList.add(className);
} else {
target.classList.remove(className);
}
}
});
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
*/
const addClass = (target, classList) => {
toggleClass(target, classList, true);
};
/**
* @param {HTMLElement | HTMLElement[] | null} target
* @param {string | string[] | readonly string[] | undefined} classList
*/
const 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}
*/
const getDirectChildByClass = (elem, className) => {
const children = Array.from(elem.children);
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child instanceof HTMLElement && hasClass(child, className)) {
return child;
}
}
};
/**
* @param {HTMLElement} elem
* @param {string} property
* @param {string | number | null | undefined} value
*/
const applyNumericalStyle = (elem, property, value) => {
if (value === `${parseInt(`${value}`)}`) {
value = parseInt(value);
}
if (value || parseInt(`${value}`) === 0) {
elem.style.setProperty(property, typeof value === 'number' ? `${value}px` : (/** @type {string} */value));
} else {
elem.style.removeProperty(property);
}
};
/**
* @param {HTMLElement | null} elem
* @param {string} display
*/
const show = (elem, display = 'flex') => {
if (!elem) {
return;
}
elem.style.display = display;
};
/**
* @param {HTMLElement | null} elem
*/
const hide = elem => {
if (!elem) {
return;
}
elem.style.display = 'none';
};
/**
* @param {HTMLElement | null} elem
* @param {string} display
*/
const showWhenInnerHtmlPresent = (elem, display = 'block') => {
if (!elem) {
return;
}
new MutationObserver(() => {
toggle(elem, elem.innerHTML, display);
}).observe(elem, {
childList: true,
subtree: true
});
};
/**
* @param {HTMLElement} parent
* @param {string} selector
* @param {string} property
* @param {string} value
*/
const setStyle = (parent, selector, property, value) => {
/** @type {HTMLElement | null} */
const el = parent.querySelector(selector);
if (el) {
el.style.setProperty(property, value);
}
};
/**
* @param {HTMLElement} elem
* @param {boolean | string | null | undefined} condition
* @param {string} display
*/
const toggle = (elem, condition, display = 'flex') => {
if (condition) {
show(elem, display);
} else {
hide(elem);
}
};
/**
* borrowed from jquery $(elem).is(':visible') implementation
*
* @param {HTMLElement | null} elem
* @returns {boolean}
*/
const isVisible$1 = elem => Boolean(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
/**
* @returns {boolean}
*/
const allButtonsAreHidden = () => !isVisible$1(getConfirmButton()) && !isVisible$1(getDenyButton()) && !isVisible$1(getCancelButton());
/**
* @param {HTMLElement} elem
* @returns {boolean}
*/
const isScrollable = elem => Boolean(elem.scrollHeight > elem.clientHeight);
/**
* @param {HTMLElement} element
* @param {HTMLElement} stopElement
* @returns {boolean}
*/
const selfOrParentIsScrollable = (element, stopElement) => {
let parent = /** @type {HTMLElement | null} */element;
while (parent && parent !== stopElement) {
if (isScrollable(parent)) {
return true;
}
parent = parent.parentElement;
}
return false;
};
/**
* borrowed from https://stackoverflow.com/a/46352119
*
* @param {HTMLElement} elem
* @returns {boolean}
*/
const hasCssAnimation = elem => {
const style = window.getComputedStyle(elem);
const animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
const transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
return animDuration > 0 || transDuration > 0;
};
/**
* @param {number} timer
* @param {boolean} reset
*/
const animateTimerProgressBar = (timer, reset = false) => {
const timerProgressBar = getTimerProgressBar();
if (!timerProgressBar) {
return;
}
if (isVisible$1(timerProgressBar)) {
if (reset) {
timerProgressBar.style.transition = 'none';
timerProgressBar.style.width = '100%';
}
setTimeout(() => {
timerProgressBar.style.transition = `width ${timer / 1000}s linear`;
timerProgressBar.style.width = '0%';
}, 10);
}
};
const stopTimerProgressBar = () => {
const timerProgressBar = getTimerProgressBar();
if (!timerProgressBar) {
return;
}
const timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
timerProgressBar.style.removeProperty('transition');
timerProgressBar.style.width = '100%';
const timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
const timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
timerProgressBar.style.width = `${timerProgressBarPercent}%`;
};
/**
* Detect Node env
*
* @returns {boolean}
*/
const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';
const sweetHTML = `
`.replace(/(^|\n)\s*/g, '');
/**
* @returns {boolean}
*/
const resetOldContainer = () => {
const oldContainer = getContainer();
if (!oldContainer) {
return false;
}
oldContainer.remove();
removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'],
// @ts-ignore: 'has-column' is not defined in swalClasses but may be set dynamically
swalClasses['has-column']]);
return true;
};
const resetValidationMessage$1 = () => {
if (globalState.currentInstance) {
globalState.currentInstance.resetValidationMessage();
}
};
const addInputChangeListeners = () => {
const popup = getPopup();
if (!popup) {
return;
}
const input = getDirectChildByClass(popup, swalClasses.input);
const file = getDirectChildByClass(popup, swalClasses.file);
/** @type {HTMLInputElement | null} */
const range = popup.querySelector(`.${swalClasses.range} input`);
/** @type {HTMLOutputElement | null} */
const rangeOutput = popup.querySelector(`.${swalClasses.range} output`);
const select = getDirectChildByClass(popup, swalClasses.select);
/** @type {HTMLInputElement | null} */
const checkbox = popup.querySelector(`.${swalClasses.checkbox} input`);
const textarea = getDirectChildByClass(popup, swalClasses.textarea);
if (input) {
input.oninput = resetValidationMessage$1;
}
if (file) {
file.onchange = resetValidationMessage$1;
}
if (select) {
select.onchange = resetValidationMessage$1;
}
if (checkbox) {
checkbox.onchange = resetValidationMessage$1;
}
if (textarea) {
textarea.oninput = resetValidationMessage$1;
}
if (range && rangeOutput) {
range.oninput = () => {
resetValidationMessage$1();
rangeOutput.value = range.value;
};
range.onchange = () => {
resetValidationMessage$1();
rangeOutput.value = range.value;
};
}
};
/**
* @param {string | HTMLElement} target
* @returns {HTMLElement}
*/
const getTarget = target => {
if (typeof target === 'string') {
const element = document.querySelector(target);
if (!element) {
throw new Error(`Target element "${target}" not found`);
}
return /** @type {HTMLElement} */element;
}
return target;
};
/**
* @param {SweetAlertOptions} params
*/
const setupAccessibility = params => {
const popup = getPopup();
if (!popup) {
return;
}
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
*/
const setupRTL = targetElement => {
if (window.getComputedStyle(targetElement).direction === 'rtl') {
addClass(getContainer(), swalClasses.rtl);
globalState.isRTL = true;
}
};
/**
* Add modal + backdrop to DOM
*
* @param {SweetAlertOptions} params
*/
const init = params => {
// Clean up the old popup container if it exists
const oldContainerExisted = resetOldContainer();
if (isNodeEnv()) {
error('SweetAlert2 requires document to initialize');
return;
}
const container = document.createElement('div');
container.className = swalClasses.container;
if (oldContainerExisted) {
addClass(container, swalClasses['no-transition']);
}
setInnerHtml(container, sweetHTML);
container.dataset['swal2Theme'] = params.theme;
const targetElement = getTarget(params.target || 'body');
targetElement.appendChild(container);
if (params.topLayer) {
container.setAttribute('popover', '');
container.showPopover();
}
setupAccessibility(params);
setupRTL(targetElement);
addInputChangeListeners();
};
/**
* @param {HTMLElement | object | string} param
* @param {HTMLElement} target
*/
const 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 {object} param
* @param {HTMLElement} target
*/
const handleObject = (param, target) => {
// JQuery element(s)
if ('jquery' in param) {
handleJqueryElem(target, param);
}
// For other objects use their string representation
else {
setInnerHtml(target, param.toString());
}
};
/**
* @param {HTMLElement} target
* @param {any} elem
*/
const handleJqueryElem = (target, elem) => {
target.textContent = '';
if (0 in elem) {
for (let i = 0; i in elem; i++) {
target.appendChild(elem[i].cloneNode(true));
}
} else {
target.appendChild(elem.cloneNode(true));
}
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderActions = (instance, params) => {
const actions = getActions();
const 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) {
const confirmButton = getConfirmButton();
const denyButton = getDenyButton();
const 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);
// Apply custom background colors to action buttons
if (params.confirmButtonColor) {
confirmButton.style.setProperty('--swal2-confirm-button-background-color', params.confirmButtonColor);
}
if (params.denyButtonColor) {
denyButton.style.setProperty('--swal2-deny-button-background-color', params.denyButtonColor);
}
if (params.cancelButtonColor) {
cancelButton.style.setProperty('--swal2-cancel-button-background-color', params.cancelButtonColor);
}
// Apply the outline color to action buttons
applyOutlineColor(confirmButton);
applyOutlineColor(denyButton);
applyOutlineColor(cancelButton);
}
/**
* @param {HTMLElement} button
*/
function applyOutlineColor(button) {
const buttonStyle = window.getComputedStyle(button);
if (buttonStyle.getPropertyValue('--swal2-action-button-focus-box-shadow')) {
// If the button already has a custom outline color, no need to change it
return;
}
const outlineColor = buttonStyle.backgroundColor.replace(/rgba?\((\d+), (\d+), (\d+).*/, 'rgba($1, $2, $3, 0.5)');
button.style.setProperty('--swal2-action-button-focus-box-shadow', buttonStyle.getPropertyValue('--swal2-outline').replace(/ rgba\(.*/, ` ${outlineColor}`));
}
/**
* @param {HTMLElement} button
* @param {'confirm' | 'deny' | 'cancel'} buttonType
* @param {SweetAlertOptions} params
*/
function renderButton(button, buttonType, params) {
const buttonName = /** @type {'Confirm' | 'Deny' | 'Cancel'} */capitalizeFirstLetter(buttonType);
toggle(button, params[`show${buttonName}Button`], 'inline-block');
setInnerHtml(button, params[`${buttonType}ButtonText`] || ''); // Set caption text
button.setAttribute('aria-label', params[`${buttonType}ButtonAriaLabel`] || ''); // ARIA label
// Add buttons custom classes
button.className = swalClasses[buttonType];
applyCustomClass(button, params, `${buttonType}Button`);
}
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderCloseButton = (instance, params) => {
const 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
*/
const renderContainer = (instance, params) => {
const 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-${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[]} */
const inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderInput = (instance, params) => {
const popup = getPopup();
if (!popup) {
return;
}
const innerParams = privateProps.innerParams.get(instance);
const rerender = !innerParams || params.input !== innerParams.input;
inputClasses.forEach(inputClass => {
const 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
*/
const showInput = params => {
if (!params.input) {
return;
}
if (!renderInputType[params.input]) {
error(`Unexpected type of input! Expected ${Object.keys(renderInputType).join(' | ')}, got "${params.input}"`);
return;
}
const inputContainer = getInputContainer(params.input);
if (!inputContainer) {
return;
}
const input = renderInputType[params.input](inputContainer, params);
show(inputContainer);
// input autofocus
if (params.inputAutoFocus) {
setTimeout(() => {
focusInput(input);
});
}
};
/**
* @param {HTMLInputElement} input
*/
const removeAttributes = input => {
for (let i = 0; i < input.attributes.length; i++) {
const attrName = input.attributes[i].name;
if (!['id', 'type', 'value', 'style'].includes(attrName)) {
input.removeAttribute(attrName);
}
}
};
/**
* @param {InputClass} inputClass
* @param {SweetAlertOptions['inputAttributes']} inputAttributes
*/
const setAttributes = (inputClass, inputAttributes) => {
const popup = getPopup();
if (!popup) {
return;
}
const input = getInput$1(popup, inputClass);
if (!input) {
return;
}
removeAttributes(input);
for (const attr in inputAttributes) {
input.setAttribute(attr, inputAttributes[attr]);
}
};
/**
* @param {SweetAlertOptions} params
*/
const setCustomClass = params => {
if (!params.input) {
return;
}
const inputContainer = getInputContainer(params.input);
if (inputContainer) {
applyCustomClass(inputContainer, params, 'input');
}
};
/**
* @param {HTMLInputElement | HTMLTextAreaElement} input
* @param {SweetAlertOptions} params
*/
const setInputPlaceholder = (input, params) => {
if (!input.placeholder && params.inputPlaceholder) {
input.placeholder = params.inputPlaceholder;
}
};
/**
* @param {Input} input
* @param {Input} prependTo
* @param {SweetAlertOptions} params
*/
const setInputLabel = (input, prependTo, params) => {
if (params.inputLabel) {
const label = document.createElement('label');
const 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 {SweetAlertInput} inputType
* @returns {HTMLElement | undefined}
*/
const getInputContainer = inputType => {
const popup = getPopup();
if (!popup) {
return;
}
return getDirectChildByClass(popup, swalClasses[(/** @type {SwalClass} */inputType)] || swalClasses.input);
};
/**
* @param {HTMLInputElement | HTMLOutputElement | HTMLTextAreaElement} input
* @param {SweetAlertOptions['inputValue']} inputValue
*/
const checkAndSetInputValue = (input, inputValue) => {
if (['string', 'number'].includes(typeof inputValue)) {
input.value = `${inputValue}`;
} else if (!isPromise(inputValue)) {
warn(`Unexpected type of inputValue! Expected "string", "number" or "Promise", got "${typeof inputValue}"`);
}
};
/** @type {Record Input>} */
const renderInputType = {};
/**
* @param {Input | HTMLElement} input
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = renderInputType.search = renderInputType.date = renderInputType['datetime-local'] = renderInputType.time = renderInputType.week = renderInputType.month = /** @type {(input: Input | HTMLElement, params: SweetAlertOptions) => Input} */
(input, params) => {
const inputElement = /** @type {HTMLInputElement} */input;
checkAndSetInputValue(inputElement, params.inputValue);
setInputLabel(inputElement, inputElement, params);
setInputPlaceholder(inputElement, params);
inputElement.type = /** @type {string} */params.input;
return inputElement;
};
/**
* @param {Input | HTMLElement} input
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.file = (input, params) => {
const inputElement = /** @type {HTMLInputElement} */input;
setInputLabel(inputElement, inputElement, params);
setInputPlaceholder(inputElement, params);
return inputElement;
};
/**
* @param {Input | HTMLElement} range
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.range = (range, params) => {
const rangeContainer = /** @type {HTMLElement} */range;
const rangeInput = rangeContainer.querySelector('input');
const rangeOutput = rangeContainer.querySelector('output');
if (rangeInput) {
checkAndSetInputValue(rangeInput, params.inputValue);
rangeInput.type = /** @type {string} */params.input;
setInputLabel(rangeInput, /** @type {Input} */range, params);
}
if (rangeOutput) {
checkAndSetInputValue(rangeOutput, params.inputValue);
}
return /** @type {Input} */range;
};
/**
* @param {Input | HTMLElement} select
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.select = (select, params) => {
const selectElement = /** @type {HTMLSelectElement} */select;
selectElement.textContent = '';
if (params.inputPlaceholder) {
const placeholder = document.createElement('option');
setInnerHtml(placeholder, params.inputPlaceholder);
placeholder.value = '';
placeholder.disabled = true;
placeholder.selected = true;
selectElement.appendChild(placeholder);
}
setInputLabel(selectElement, selectElement, params);
return selectElement;
};
/**
* @param {Input | HTMLElement} radio
* @returns {Input}
*/
renderInputType.radio = radio => {
const radioElement = /** @type {HTMLElement} */radio;
radioElement.textContent = '';
return /** @type {Input} */radio;
};
/**
* @param {Input | HTMLElement} checkboxContainer
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.checkbox = (checkboxContainer, params) => {
const popup = getPopup();
if (!popup) {
throw new Error('Popup not found');
}
const checkbox = getInput$1(popup, 'checkbox');
if (!checkbox) {
throw new Error('Checkbox input not found');
}
checkbox.value = '1';
checkbox.checked = Boolean(params.inputValue);
const containerElement = /** @type {HTMLElement} */checkboxContainer;
const label = containerElement.querySelector('span');
if (label) {
const placeholderOrLabel = params.inputPlaceholder || params.inputLabel;
if (placeholderOrLabel) {
setInnerHtml(label, placeholderOrLabel);
}
}
return checkbox;
};
/**
* @param {Input | HTMLElement} textarea
* @param {SweetAlertOptions} params
* @returns {Input}
*/
renderInputType.textarea = (textarea, params) => {
const textareaElement = /** @type {HTMLTextAreaElement} */textarea;
checkAndSetInputValue(textareaElement, params.inputValue);
setInputPlaceholder(textareaElement, params);
setInputLabel(textareaElement, textareaElement, params);
/**
* @param {HTMLElement} el
* @returns {number}
*/
const getMargin = el => parseInt(window.getComputedStyle(el).marginLeft) + parseInt(window.getComputedStyle(el).marginRight);
// https://github.com/sweetalert2/sweetalert2/issues/2291
setTimeout(() => {
// https://github.com/sweetalert2/sweetalert2/issues/1699
if ('MutationObserver' in window) {
const popup = getPopup();
if (!popup) {
return;
}
const initialPopupWidth = parseInt(window.getComputedStyle(popup).width);
const textareaResizeHandler = () => {
// check if texarea is still in document (i.e. popup wasn't closed in the meantime)
if (!document.body.contains(textareaElement)) {
return;
}
const textareaWidth = textareaElement.offsetWidth + getMargin(textareaElement);
const popupElement = getPopup();
if (popupElement) {
if (textareaWidth > initialPopupWidth) {
popupElement.style.width = `${textareaWidth}px`;
} else {
applyNumericalStyle(popupElement, 'width', params.width);
}
}
};
new MutationObserver(textareaResizeHandler).observe(textareaElement, {
attributes: true,
attributeFilter: ['style']
});
}
});
return textareaElement;
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderContent = (instance, params) => {
const htmlContainer = getHtmlContainer();
if (!htmlContainer) {
return;
}
showWhenInnerHtmlPresent(htmlContainer);
applyCustomClass(htmlContainer, params, 'htmlContainer');
// Content as HTML
if (params.html) {
parseHtmlToContainer(params.html, htmlContainer);
show(htmlContainer, 'block');
}
// Content as plain text
else if (params.text) {
htmlContainer.textContent = params.text;
show(htmlContainer, 'block');
}
// No content
else {
hide(htmlContainer);
}
renderInput(instance, params);
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderFooter = (instance, params) => {
const footer = getFooter();
if (!footer) {
return;
}
showWhenInnerHtmlPresent(footer);
toggle(footer, Boolean(params.footer), 'block');
if (params.footer) {
parseHtmlToContainer(params.footer, footer);
}
// Custom class
applyCustomClass(footer, params, 'footer');
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderIcon = (instance, params) => {
const innerParams = privateProps.innerParams.get(instance);
const icon = getIcon();
if (!icon) {
return;
}
// if the given icon already rendered, apply the styling without re-rendering the icon
if (innerParams && params.icon === innerParams.icon) {
// Custom or default content
setContent(icon, params);
applyStyles(icon, params);
return;
}
if (!params.icon && !params.iconHtml) {
hide(icon);
return;
}
if (params.icon && Object.keys(iconTypes).indexOf(params.icon) === -1) {
error(`Unknown icon! Expected "success", "error", "warning", "info" or "question", got "${params.icon}"`);
hide(icon);
return;
}
show(icon);
// Custom or default content
setContent(icon, params);
applyStyles(icon, params);
// Animate icon
addClass(icon, params.showClass && params.showClass.icon);
// Re-adjust the success icon on system theme change
const colorSchemeQueryList = window.matchMedia('(prefers-color-scheme: dark)');
colorSchemeQueryList.addEventListener('change', adjustSuccessIconBackgroundColor);
};
/**
* @param {HTMLElement} icon
* @param {SweetAlertOptions} params
*/
const applyStyles = (icon, params) => {
for (const [iconType, iconClassName] of Object.entries(iconTypes)) {
if (params.icon !== iconType) {
removeClass(icon, iconClassName);
}
}
addClass(icon, params.icon && iconTypes[params.icon]);
// Icon color
setColor(icon, params);
// Success icon background color
adjustSuccessIconBackgroundColor();
// Custom class
applyCustomClass(icon, params, 'icon');
};
// Adjust success icon background color to match the popup background color
const adjustSuccessIconBackgroundColor = () => {
const popup = getPopup();
if (!popup) {
return;
}
const popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');
/** @type {NodeListOf} */
const successIconParts = popup.querySelectorAll('[class^=swal2-success-circular-line], .swal2-success-fix');
for (let i = 0; i < successIconParts.length; i++) {
successIconParts[i].style.backgroundColor = popupBackgroundColor;
}
};
/**
*
* @param {SweetAlertOptions} params
* @returns {string}
*/
const successIconHtml = params => `
${params.animation ? '' : ''}
${params.animation ? '' : ''}
${params.animation ? '' : ''}
`;
const errorIconHtml = `
`;
/**
* @param {HTMLElement} icon
* @param {SweetAlertOptions} params
*/
const setContent = (icon, params) => {
if (!params.icon && !params.iconHtml) {
return;
}
let oldContent = icon.innerHTML;
let newContent = '';
if (params.iconHtml) {
newContent = iconContent(params.iconHtml);
} else if (params.icon === 'success') {
newContent = successIconHtml(params);
oldContent = oldContent.replace(/ style=".*?"/g, ''); // undo adjustSuccessIconBackgroundColor()
} else if (params.icon === 'error') {
newContent = errorIconHtml;
} else if (params.icon) {
const defaultIconHtml = {
question: '?',
warning: '!',
info: 'i'
};
newContent = iconContent(defaultIconHtml[params.icon]);
}
if (oldContent.trim() !== newContent.trim()) {
setInnerHtml(icon, newContent);
}
};
/**
* @param {HTMLElement} icon
* @param {SweetAlertOptions} params
*/
const setColor = (icon, params) => {
if (!params.iconColor) {
return;
}
icon.style.color = params.iconColor;
icon.style.borderColor = params.iconColor;
for (const sel of ['.swal2-success-line-tip', '.swal2-success-line-long', '.swal2-x-mark-line-left', '.swal2-x-mark-line-right']) {
setStyle(icon, sel, 'background-color', params.iconColor);
}
setStyle(icon, '.swal2-success-ring', 'border-color', params.iconColor);
};
/**
* @param {string} content
* @returns {string}
*/
const iconContent = content => `${content}
`;
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderImage = (instance, params) => {
const image = getImage();
if (!image) {
return;
}
if (!params.imageUrl) {
hide(image);
return;
}
show(image, '');
// Src, alt
image.setAttribute('src', params.imageUrl);
image.setAttribute('alt', params.imageAlt || '');
// Width, height
applyNumericalStyle(image, 'width', params.imageWidth);
applyNumericalStyle(image, 'height', params.imageHeight);
// Class
image.className = swalClasses.image;
applyCustomClass(image, params, 'image');
};
let dragging = false;
let mousedownX = 0;
let mousedownY = 0;
let initialX = 0;
let initialY = 0;
/**
* @param {HTMLElement} popup
*/
const addDraggableListeners = popup => {
popup.addEventListener('mousedown', down);
document.body.addEventListener('mousemove', move);
popup.addEventListener('mouseup', up);
popup.addEventListener('touchstart', down);
document.body.addEventListener('touchmove', move);
popup.addEventListener('touchend', up);
};
/**
* @param {HTMLElement} popup
*/
const removeDraggableListeners = popup => {
popup.removeEventListener('mousedown', down);
document.body.removeEventListener('mousemove', move);
popup.removeEventListener('mouseup', up);
popup.removeEventListener('touchstart', down);
document.body.removeEventListener('touchmove', move);
popup.removeEventListener('touchend', up);
};
/**
* @param {MouseEvent | TouchEvent} event
*/
const down = event => {
const popup = getPopup();
if (!popup) {
return;
}
const icon = getIcon();
if (event.target === popup || icon && icon.contains(/** @type {HTMLElement} */event.target)) {
dragging = true;
const clientXY = getClientXY(event);
mousedownX = clientXY.clientX;
mousedownY = clientXY.clientY;
initialX = parseInt(popup.style.insetInlineStart) || 0;
initialY = parseInt(popup.style.insetBlockStart) || 0;
addClass(popup, 'swal2-dragging');
}
};
/**
* @param {MouseEvent | TouchEvent} event
*/
const move = event => {
const popup = getPopup();
if (!popup) {
return;
}
if (dragging) {
let {
clientX,
clientY
} = getClientXY(event);
const deltaX = clientX - mousedownX;
// In RTL mode, negate the horizontal delta since insetInlineStart refers to the right edge
popup.style.insetInlineStart = `${initialX + (globalState.isRTL ? -deltaX : deltaX)}px`;
popup.style.insetBlockStart = `${initialY + (clientY - mousedownY)}px`;
}
};
const up = () => {
const popup = getPopup();
dragging = false;
removeClass(popup, 'swal2-dragging');
};
/**
* @param {MouseEvent | TouchEvent} event
* @returns {{ clientX: number, clientY: number }}
*/
const getClientXY = event => {
let clientX = 0,
clientY = 0;
if (event.type.startsWith('mouse')) {
clientX = /** @type {MouseEvent} */event.clientX;
clientY = /** @type {MouseEvent} */event.clientY;
} else if (event.type.startsWith('touch')) {
clientX = /** @type {TouchEvent} */event.touches[0].clientX;
clientY = /** @type {TouchEvent} */event.touches[0].clientY;
}
return {
clientX,
clientY
};
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderPopup = (instance, params) => {
const container = getContainer();
const popup = getPopup();
if (!container || !popup) {
return;
}
// Width
// https://github.com/sweetalert2/sweetalert2/issues/2170
if (params.toast) {
applyNumericalStyle(container, 'width', params.width);
popup.style.width = '100%';
const loader = getLoader();
if (loader) {
popup.insertBefore(loader, getIcon());
}
} else {
applyNumericalStyle(popup, 'width', params.width);
}
// Padding
applyNumericalStyle(popup, 'padding', params.padding);
// Color
if (params.color) {
popup.style.color = params.color;
}
// Background
if (params.background) {
popup.style.background = params.background;
}
hide(getValidationMessage());
// Classes
addClasses$1(popup, params);
if (params.draggable && !params.toast) {
addClass(popup, swalClasses.draggable);
addDraggableListeners(popup);
} else {
removeClass(popup, swalClasses.draggable);
removeDraggableListeners(popup);
}
};
/**
* @param {HTMLElement} popup
* @param {SweetAlertOptions} params
*/
const addClasses$1 = (popup, params) => {
const showClass = params.showClass || {};
// Default Class + showClass when updating Swal.update({})
popup.className = `${swalClasses.popup} ${isVisible$1(popup) ? showClass.popup : ''}`;
if (params.toast) {
addClass([document.documentElement, document.body], swalClasses['toast-shown']);
addClass(popup, swalClasses.toast);
} else {
addClass(popup, swalClasses.modal);
}
// Custom class
applyCustomClass(popup, params, 'popup');
// TODO: remove in the next major
if (typeof params.customClass === 'string') {
addClass(popup, params.customClass);
}
// Icon class (#1842)
if (params.icon) {
addClass(popup, swalClasses[`icon-${params.icon}`]);
}
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderProgressSteps = (instance, params) => {
const progressStepsContainer = getProgressSteps();
if (!progressStepsContainer) {
return;
}
const {
progressSteps,
currentProgressStep
} = params;
if (!progressSteps || progressSteps.length === 0 || currentProgressStep === undefined) {
hide(progressStepsContainer);
return;
}
show(progressStepsContainer);
progressStepsContainer.textContent = '';
if (currentProgressStep >= progressSteps.length) {
warn('Invalid currentProgressStep parameter, it should be less than progressSteps.length ' + '(currentProgressStep like JS arrays starts from 0)');
}
progressSteps.forEach((step, index) => {
const stepEl = createStepElement(step);
progressStepsContainer.appendChild(stepEl);
if (index === currentProgressStep) {
addClass(stepEl, swalClasses['active-progress-step']);
}
if (index !== progressSteps.length - 1) {
const lineEl = createLineElement(params);
progressStepsContainer.appendChild(lineEl);
}
});
};
/**
* @param {string} step
* @returns {HTMLLIElement}
*/
const createStepElement = step => {
const stepEl = document.createElement('li');
addClass(stepEl, swalClasses['progress-step']);
setInnerHtml(stepEl, step);
return stepEl;
};
/**
* @param {SweetAlertOptions} params
* @returns {HTMLLIElement}
*/
const createLineElement = params => {
const lineEl = document.createElement('li');
addClass(lineEl, swalClasses['progress-step-line']);
if (params.progressStepsDistance) {
applyNumericalStyle(lineEl, 'width', params.progressStepsDistance);
}
return lineEl;
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const renderTitle = (instance, params) => {
const title = getTitle();
if (!title) {
return;
}
showWhenInnerHtmlPresent(title);
toggle(title, Boolean(params.title || params.titleText), 'block');
if (params.title) {
parseHtmlToContainer(params.title, title);
}
if (params.titleText) {
title.innerText = params.titleText;
}
// Custom class
applyCustomClass(title, params, 'title');
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const render = (instance, params) => {
var _globalState$eventEmi;
renderPopup(instance, params);
renderContainer(instance, params);
renderProgressSteps(instance, params);
renderIcon(instance, params);
renderImage(instance, params);
renderTitle(instance, params);
renderCloseButton(instance, params);
renderContent(instance, params);
renderActions(instance, params);
renderFooter(instance, params);
const popup = getPopup();
if (typeof params.didRender === 'function' && popup) {
params.didRender(popup);
}
(_globalState$eventEmi = globalState.eventEmitter) === null || _globalState$eventEmi === void 0 || _globalState$eventEmi.emit('didRender', popup);
};
/*
* Global function to determine if SweetAlert2 popup is shown
*/
const isVisible = () => {
return isVisible$1(getPopup());
};
/*
* Global function to click 'Confirm' button
*/
const clickConfirm = () => {
var _dom$getConfirmButton;
return (_dom$getConfirmButton = getConfirmButton()) === null || _dom$getConfirmButton === void 0 ? void 0 : _dom$getConfirmButton.click();
};
/*
* Global function to click 'Deny' button
*/
const clickDeny = () => {
var _dom$getDenyButton;
return (_dom$getDenyButton = getDenyButton()) === null || _dom$getDenyButton === void 0 ? void 0 : _dom$getDenyButton.click();
};
/*
* Global function to click 'Cancel' button
*/
const clickCancel = () => {
var _dom$getCancelButton;
return (_dom$getCancelButton = getCancelButton()) === null || _dom$getCancelButton === void 0 ? void 0 : _dom$getCancelButton.click();
};
/** @type {Record} */
const DismissReason = Object.freeze({
cancel: 'cancel',
backdrop: 'backdrop',
close: 'close',
esc: 'esc',
timer: 'timer'
});
/**
* @param {GlobalState} globalState
*/
const removeKeydownHandler = globalState => {
if (globalState.keydownTarget && globalState.keydownHandlerAdded && globalState.keydownHandler) {
const handler = /** @type {EventListenerOrEventListenerObject} */ /** @type {unknown} */globalState.keydownHandler;
globalState.keydownTarget.removeEventListener('keydown', handler, {
capture: globalState.keydownListenerCapture
});
globalState.keydownHandlerAdded = false;
}
};
/**
* @param {GlobalState} globalState
* @param {SweetAlertOptions} innerParams
* @param {(dismiss: DismissReason) => void} dismissWith
*/
const addKeydownHandler = (globalState, innerParams, dismissWith) => {
removeKeydownHandler(globalState);
if (!innerParams.toast) {
/** @type {(this: HTMLElement, event: KeyboardEvent) => void} */
const handler = e => keydownHandler(innerParams, e, dismissWith);
globalState.keydownHandler = handler;
const target = innerParams.keydownListenerCapture ? window : getPopup();
if (target) {
globalState.keydownTarget = target;
globalState.keydownListenerCapture = innerParams.keydownListenerCapture;
const eventHandler = /** @type {EventListenerOrEventListenerObject} */ /** @type {unknown} */handler;
globalState.keydownTarget.addEventListener('keydown', eventHandler, {
capture: globalState.keydownListenerCapture
});
globalState.keydownHandlerAdded = true;
}
}
};
/**
* @param {number} index
* @param {number} increment
*/
const setFocus = (index, increment) => {
var _dom$getPopup;
const focusableElements = getFocusableElements();
// search for visible elements and select the next possible match
if (focusableElements.length) {
index = index + increment;
// shift + tab when .swal2-popup is focused
if (index === -2) {
index = focusableElements.length - 1;
}
// rollover to first item
if (index === focusableElements.length) {
index = 0;
// go to last item
} else if (index === -1) {
index = focusableElements.length - 1;
}
focusableElements[index].focus();
return;
}
// no visible focusable elements, focus the popup
(_dom$getPopup = getPopup()) === null || _dom$getPopup === void 0 || _dom$getPopup.focus();
};
const arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];
const arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];
/**
* @param {SweetAlertOptions} innerParams
* @param {KeyboardEvent} event
* @param {(dismiss: DismissReason) => void} dismissWith
*/
const keydownHandler = (innerParams, event, dismissWith) => {
if (!innerParams) {
return; // This instance has already been destroyed
}
// Ignore keydown during IME composition
// https://developer.mozilla.org/en-US/docs/Web/API/Document/keydown_event#ignoring_keydown_during_ime_composition
// https://github.com/sweetalert2/sweetalert2/issues/720
// https://github.com/sweetalert2/sweetalert2/issues/2406
if (event.isComposing || event.keyCode === 229) {
return;
}
if (innerParams.stopKeydownPropagation) {
event.stopPropagation();
}
// ENTER
if (event.key === 'Enter') {
handleEnter(event, innerParams);
}
// TAB
else if (event.key === 'Tab') {
handleTab(event);
}
// ARROWS - switch focus between buttons
else if ([...arrowKeysNextButton, ...arrowKeysPreviousButton].includes(event.key)) {
handleArrows(event.key);
}
// ESC
else if (event.key === 'Escape') {
handleEsc(event, innerParams, dismissWith);
}
};
/**
* @param {KeyboardEvent} event
* @param {SweetAlertOptions} innerParams
*/
const handleEnter = (event, innerParams) => {
// https://github.com/sweetalert2/sweetalert2/issues/2386
if (!callIfFunction(innerParams.allowEnterKey)) {
return;
}
const popup = getPopup();
if (!popup || !innerParams.input) {
return;
}
const input = getInput$1(popup, innerParams.input);
if (event.target && input && event.target instanceof HTMLElement && event.target.outerHTML === input.outerHTML) {
if (['textarea', 'file'].includes(innerParams.input)) {
return; // do not submit
}
clickConfirm();
event.preventDefault();
}
};
/**
* @param {KeyboardEvent} event
*/
const handleTab = event => {
const targetElement = event.target;
const focusableElements = getFocusableElements();
let btnIndex = -1;
for (let i = 0; i < focusableElements.length; i++) {
if (targetElement === focusableElements[i]) {
btnIndex = i;
break;
}
}
// Cycle to the next button
if (!event.shiftKey) {
setFocus(btnIndex, 1);
}
// Cycle to the prev button
else {
setFocus(btnIndex, -1);
}
event.stopPropagation();
event.preventDefault();
};
/**
* @param {string} key
*/
const handleArrows = key => {
const actions = getActions();
const confirmButton = getConfirmButton();
const denyButton = getDenyButton();
const cancelButton = getCancelButton();
if (!actions || !confirmButton || !denyButton || !cancelButton) {
return;
}
/** @type HTMLElement[] */
const buttons = [confirmButton, denyButton, cancelButton];
if (document.activeElement instanceof HTMLElement && !buttons.includes(document.activeElement)) {
return;
}
const sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';
let buttonToFocus = document.activeElement;
if (!buttonToFocus) {
return;
}
for (let i = 0; i < actions.children.length; i++) {
buttonToFocus = buttonToFocus[sibling];
if (!buttonToFocus) {
return;
}
if (buttonToFocus instanceof HTMLButtonElement && isVisible$1(buttonToFocus)) {
break;
}
}
if (buttonToFocus instanceof HTMLButtonElement) {
buttonToFocus.focus();
}
};
/**
* @param {KeyboardEvent} event
* @param {SweetAlertOptions} innerParams
* @param {(dismiss: DismissReason) => void} dismissWith
*/
const handleEsc = (event, innerParams, dismissWith) => {
event.preventDefault();
if (callIfFunction(innerParams.allowEscapeKey)) {
dismissWith(DismissReason.esc);
}
};
/**
* 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 privateMethods = {
swalPromiseResolve: new WeakMap(),
swalPromiseReject: new WeakMap()
};
// From https://developer.paciellogroup.com/blog/2018/06/the-current-state-of-modal-dialog-accessibility/
// Adding aria-hidden="true" to elements outside of the active modal dialog ensures that
// elements not within the active modal dialog will not be surfaced if a user opens a screen
// reader’s list of elements (headings, form controls, landmarks, etc.) in the document.
const setAriaHidden = () => {
const container = getContainer();
const bodyChildren = Array.from(document.body.children);
bodyChildren.forEach(el => {
if (el.contains(container)) {
return;
}
if (el.hasAttribute('aria-hidden')) {
el.setAttribute('data-previous-aria-hidden', el.getAttribute('aria-hidden') || '');
}
el.setAttribute('aria-hidden', 'true');
});
};
const unsetAriaHidden = () => {
const bodyChildren = Array.from(document.body.children);
bodyChildren.forEach(el => {
if (el.hasAttribute('data-previous-aria-hidden')) {
el.setAttribute('aria-hidden', el.getAttribute('data-previous-aria-hidden') || '');
el.removeAttribute('data-previous-aria-hidden');
} else {
el.removeAttribute('aria-hidden');
}
});
};
// @ts-ignore
const isSafariOrIOS = typeof window !== 'undefined' && Boolean(window.GestureEvent); // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394
/**
* Fix iOS scrolling
* http://stackoverflow.com/q/39626302
*/
const iOSfix = () => {
if (isSafariOrIOS && !hasClass(document.body, swalClasses.iosfix)) {
const offset = document.body.scrollTop;
document.body.style.top = `${offset * -1}px`;
addClass(document.body, swalClasses.iosfix);
lockBodyScroll();
}
};
/**
* https://github.com/sweetalert2/sweetalert2/issues/1246
*/
const lockBodyScroll = () => {
const container = getContainer();
if (!container) {
return;
}
/** @type {boolean} */
let preventTouchMove;
/**
* @param {TouchEvent} event
*/
container.ontouchstart = event => {
preventTouchMove = shouldPreventTouchMove(event);
};
/**
* @param {TouchEvent} event
*/
container.ontouchmove = event => {
if (preventTouchMove) {
event.preventDefault();
event.stopPropagation();
}
};
};
/**
* @param {TouchEvent} event
* @returns {boolean}
*/
const shouldPreventTouchMove = event => {
const target = event.target;
const container = getContainer();
const htmlContainer = getHtmlContainer();
if (!container || !htmlContainer) {
return false;
}
if (isStylus(event) || isZoom(event)) {
return false;
}
if (target === container) {
return true;
}
if (!isScrollable(container) && target instanceof HTMLElement && !selfOrParentIsScrollable(target, htmlContainer) &&
// #2823
target.tagName !== 'INPUT' &&
// #1603
target.tagName !== 'TEXTAREA' &&
// #2266
!(isScrollable(htmlContainer) &&
// #1944
htmlContainer.contains(target))) {
return true;
}
return false;
};
/**
* https://github.com/sweetalert2/sweetalert2/issues/1786
*
* @param {TouchEvent} event
* @returns {boolean}
*/
const isStylus = event => {
return Boolean(event.touches && event.touches.length &&
// @ts-ignore - touchType is not a standard property
event.touches[0].touchType === 'stylus');
};
/**
* https://github.com/sweetalert2/sweetalert2/issues/1891
*
* @param {TouchEvent} event
* @returns {boolean}
*/
const isZoom = event => {
return event.touches && event.touches.length > 1;
};
const undoIOSfix = () => {
if (hasClass(document.body, swalClasses.iosfix)) {
const offset = parseInt(document.body.style.top, 10);
removeClass(document.body, swalClasses.iosfix);
document.body.style.top = '';
document.body.scrollTop = offset * -1;
}
};
/**
* Measure scrollbar width for padding body during modal show/hide
* https://github.com/twbs/bootstrap/blob/master/js/src/modal.js
*
* @returns {number}
*/
const measureScrollbar = () => {
const scrollDiv = document.createElement('div');
scrollDiv.className = swalClasses['scrollbar-measure'];
document.body.appendChild(scrollDiv);
const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
document.body.removeChild(scrollDiv);
return scrollbarWidth;
};
/**
* Remember state in cases where opening and handling a modal will fiddle with it.
* @type {number | null}
*/
let previousBodyPadding = null;
/**
* @param {string} initialBodyOverflow
*/
const replaceScrollbarWithPadding = initialBodyOverflow => {
// for queues, do not do this more than once
if (previousBodyPadding !== null) {
return;
}
// if the body has overflow
if (document.body.scrollHeight > window.innerHeight || initialBodyOverflow === 'scroll' // https://github.com/sweetalert2/sweetalert2/issues/2663
) {
// add padding so the content doesn't shift after removal of scrollbar
previousBodyPadding = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'));
document.body.style.paddingRight = `${previousBodyPadding + measureScrollbar()}px`;
}
};
const undoReplaceScrollbarWithPadding = () => {
if (previousBodyPadding !== null) {
document.body.style.paddingRight = `${previousBodyPadding}px`;
previousBodyPadding = null;
}
};
/**
* @param {SweetAlert} instance
* @param {HTMLElement} container
* @param {boolean} returnFocus
* @param {(() => void) | undefined} didClose
*/
function removePopupAndResetState(instance, container, returnFocus, didClose) {
if (isToast()) {
triggerDidCloseAndDispose(instance, didClose);
} else {
restoreActiveElement(returnFocus).then(() => triggerDidCloseAndDispose(instance, didClose));
removeKeydownHandler(globalState);
}
// workaround for https://github.com/sweetalert2/sweetalert2/issues/2088
// for some reason removing the container in Safari will scroll the document to bottom
if (isSafariOrIOS) {
container.setAttribute('style', 'display:none !important');
container.removeAttribute('class');
container.innerHTML = '';
} else {
container.remove();
}
if (isModal()) {
undoReplaceScrollbarWithPadding();
undoIOSfix();
unsetAriaHidden();
}
removeBodyClasses();
}
/**
* Remove SweetAlert2 classes from body
*/
function removeBodyClasses() {
removeClass([document.documentElement, document.body], [swalClasses.shown, swalClasses['height-auto'], swalClasses['no-backdrop'], swalClasses['toast-shown']]);
}
/**
* Instance method to close sweetAlert
*
* @param {SweetAlertResult | undefined} resolveValue
* @this {SweetAlert}
*/
function close(resolveValue) {
resolveValue = prepareResolveValue(resolveValue);
const swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);
const didClose = triggerClosePopup(this);
if (this.isAwaitingPromise) {
// A swal awaiting for a promise (after a click on Confirm or Deny) cannot be dismissed anymore #2335
if (!resolveValue.isDismissed) {
handleAwaitingPromise(this);
swalPromiseResolve(resolveValue);
}
} else if (didClose) {
// Resolve Swal promise
swalPromiseResolve(resolveValue);
}
}
/**
* @param {SweetAlert} instance
* @returns {boolean}
*/
const triggerClosePopup = instance => {
const popup = getPopup();
if (!popup) {
return false;
}
const innerParams = privateProps.innerParams.get(instance);
if (!innerParams || hasClass(popup, innerParams.hideClass.popup)) {
return false;
}
removeClass(popup, innerParams.showClass.popup);
addClass(popup, innerParams.hideClass.popup);
const backdrop = getContainer();
removeClass(backdrop, innerParams.showClass.backdrop);
addClass(backdrop, innerParams.hideClass.backdrop);
handlePopupAnimation(instance, popup, innerParams);
return true;
};
/**
* @param {Error | string} error
* @this {SweetAlert}
*/
function rejectPromise(error) {
const rejectPromise = privateMethods.swalPromiseReject.get(this);
handleAwaitingPromise(this);
if (rejectPromise) {
// Reject Swal promise
rejectPromise(error);
}
}
/**
* @param {SweetAlert} instance
*/
const handleAwaitingPromise = instance => {
if (instance.isAwaitingPromise) {
// @ts-ignore
delete instance.isAwaitingPromise;
// The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335
if (!privateProps.innerParams.get(instance)) {
instance._destroy();
}
}
};
/**
* @param {SweetAlertResult | undefined} resolveValue
* @returns {SweetAlertResult}
*/
const prepareResolveValue = resolveValue => {
// When user calls Swal.close()
if (typeof resolveValue === 'undefined') {
return {
isConfirmed: false,
isDenied: false,
isDismissed: true
};
}
return Object.assign({
isConfirmed: false,
isDenied: false,
isDismissed: false
}, resolveValue);
};
/**
* @param {SweetAlert} instance
* @param {HTMLElement} popup
* @param {SweetAlertOptions} innerParams
*/
const handlePopupAnimation = (instance, popup, innerParams) => {
var _globalState$eventEmi;
const container = getContainer();
// If animation is supported, animate
const animationIsSupported = hasCssAnimation(popup);
if (typeof innerParams.willClose === 'function') {
innerParams.willClose(popup);
}
(_globalState$eventEmi = globalState.eventEmitter) === null || _globalState$eventEmi === void 0 || _globalState$eventEmi.emit('willClose', popup);
if (animationIsSupported && container) {
animatePopup(instance, popup, container, Boolean(innerParams.returnFocus), innerParams.didClose);
} else if (container) {
// Otherwise, remove immediately
removePopupAndResetState(instance, container, Boolean(innerParams.returnFocus), innerParams.didClose);
}
};
/**
* @param {SweetAlert} instance
* @param {HTMLElement} popup
* @param {HTMLElement} container
* @param {boolean} returnFocus
* @param {(() => void) | undefined} didClose
*/
const animatePopup = (instance, popup, container, returnFocus, didClose) => {
globalState.swalCloseEventFinishedCallback = removePopupAndResetState.bind(null, instance, container, returnFocus, didClose);
/**
* @param {AnimationEvent | TransitionEvent} e
*/
const swalCloseAnimationFinished = function (e) {
if (e.target === popup) {
var _globalState$swalClos;
(_globalState$swalClos = globalState.swalCloseEventFinishedCallback) === null || _globalState$swalClos === void 0 || _globalState$swalClos.call(globalState);
delete globalState.swalCloseEventFinishedCallback;
popup.removeEventListener('animationend', swalCloseAnimationFinished);
popup.removeEventListener('transitionend', swalCloseAnimationFinished);
}
};
popup.addEventListener('animationend', swalCloseAnimationFinished);
popup.addEventListener('transitionend', swalCloseAnimationFinished);
};
/**
* @param {SweetAlert} instance
* @param {(() => void) | undefined} didClose
*/
const triggerDidCloseAndDispose = (instance, didClose) => {
setTimeout(() => {
var _globalState$eventEmi2;
if (typeof didClose === 'function') {
didClose.bind(instance.params)();
}
(_globalState$eventEmi2 = globalState.eventEmitter) === null || _globalState$eventEmi2 === void 0 || _globalState$eventEmi2.emit('didClose');
// instance might have been destroyed already
if (instance._destroy) {
instance._destroy();
}
});
};
/**
* Shows loader (spinner), this is useful with AJAX requests.
* By default the loader be shown instead of the "Confirm" button.
*
* @param {HTMLButtonElement | null} [buttonToReplace]
*/
const showLoading = buttonToReplace => {
let popup = getPopup();
if (!popup) {
new Swal();
}
popup = getPopup();
if (!popup) {
return;
}
const loader = getLoader();
if (isToast()) {
hide(getIcon());
} else {
replaceButton(popup, buttonToReplace);
}
show(loader);
popup.setAttribute('data-loading', 'true');
popup.setAttribute('aria-busy', 'true');
popup.focus();
};
/**
* @param {HTMLElement} popup
* @param {HTMLButtonElement | null} [buttonToReplace]
*/
const replaceButton = (popup, buttonToReplace) => {
const actions = getActions();
const loader = getLoader();
if (!actions || !loader) {
return;
}
if (!buttonToReplace && isVisible$1(getConfirmButton())) {
buttonToReplace = getConfirmButton();
}
show(actions);
if (buttonToReplace) {
hide(buttonToReplace);
loader.setAttribute('data-button-to-replace', buttonToReplace.className);
actions.insertBefore(loader, buttonToReplace);
}
addClass([popup, actions], swalClasses.loading);
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const handleInputOptionsAndValue = (instance, params) => {
if (params.input === 'select' || params.input === 'radio') {
handleInputOptions(instance, params);
} else if (['text', 'email', 'number', 'tel', 'textarea'].some(i => i === params.input) && (hasToPromiseFn(params.inputValue) || isPromise(params.inputValue))) {
showLoading(getConfirmButton());
handleInputValue(instance, params);
}
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} innerParams
* @returns {SweetAlertInputValue}
*/
const getInputValue = (instance, innerParams) => {
const input = instance.getInput();
if (!input) {
return null;
}
switch (innerParams.input) {
case 'checkbox':
return getCheckboxValue(input);
case 'radio':
return getRadioValue(input);
case 'file':
return getFileValue(input);
default:
return innerParams.inputAutoTrim ? input.value.trim() : input.value;
}
};
/**
* @param {HTMLInputElement} input
* @returns {number}
*/
const getCheckboxValue = input => input.checked ? 1 : 0;
/**
* @param {HTMLInputElement} input
* @returns {string | null}
*/
const getRadioValue = input => input.checked ? input.value : null;
/**
* @param {HTMLInputElement} input
* @returns {FileList | File | null}
*/
const getFileValue = input => input.files && input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const handleInputOptions = (instance, params) => {
const popup = getPopup();
if (!popup) {
return;
}
/**
* @param {*} inputOptions
*/
const processInputOptions = inputOptions => {
if (params.input === 'select') {
populateSelectOptions(popup, formatInputOptions(inputOptions), params);
} else if (params.input === 'radio') {
populateRadioOptions(popup, formatInputOptions(inputOptions), params);
}
};
if (hasToPromiseFn(params.inputOptions) || isPromise(params.inputOptions)) {
showLoading(getConfirmButton());
asPromise(params.inputOptions).then(inputOptions => {
instance.hideLoading();
processInputOptions(inputOptions);
});
} else if (typeof params.inputOptions === 'object') {
processInputOptions(params.inputOptions);
} else {
error(`Unexpected type of inputOptions! Expected object, Map or Promise, got ${typeof params.inputOptions}`);
}
};
/**
* @param {SweetAlert} instance
* @param {SweetAlertOptions} params
*/
const handleInputValue = (instance, params) => {
const input = instance.getInput();
if (!input) {
return;
}
hide(input);
asPromise(params.inputValue).then(inputValue => {
input.value = params.input === 'number' ? `${parseFloat(inputValue) || 0}` : `${inputValue}`;
show(input);
input.focus();
instance.hideLoading();
}).catch(err => {
error(`Error in inputValue promise: ${err}`);
input.value = '';
show(input);
input.focus();
instance.hideLoading();
});
};
/**
* @param {HTMLElement} popup
* @param {InputOptionFlattened[]} inputOptions
* @param {SweetAlertOptions} params
*/
function populateSelectOptions(popup, inputOptions, params) {
const select = getDirectChildByClass(popup, swalClasses.select);
if (!select) {
return;
}
/**
* @param {HTMLElement} parent
* @param {string} optionLabel
* @param {string} optionValue
*/
const renderOption = (parent, optionLabel, optionValue) => {
const option = document.createElement('option');
option.value = optionValue;
setInnerHtml(option, optionLabel);
option.selected = isSelected(optionValue, params.inputValue);
parent.appendChild(option);
};
inputOptions.forEach(inputOption => {
const optionValue = inputOption[0];
const optionLabel = inputOption[1];
//