sweetalert2 11.26.11 → 11.26.13

package/dist/sweetalert2.esm.js

@@ -1,5 +1,5 @@
 /*!
-* sweetalert2 v11.26.11
+* sweetalert2 v11.26.13
 * Released under the MIT License.
 */
 function _assertClassBrand(e, t, n) {
@@ -620,7 +620,7 @@ const toggle = (elem, condition, display = 'flex') => {
  * @param {HTMLElement | null} elem
  * @returns {boolean}
  */
-const isVisible$1 = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
+const isVisible$1 = elem => Boolean(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
 
 /**
  * @returns {boolean}
@@ -631,7 +631,7 @@ const allButtonsAreHidden = () => !isVisible$1(getConfirmButton()) && !isVisible
  * @param {HTMLElement} elem
  * @returns {boolean}
  */
-const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight);
+const isScrollable = elem => Boolean(elem.scrollHeight > elem.clientHeight);
 
 /**
  * @param {HTMLElement} element
@@ -1263,96 +1263,119 @@ const checkAndSetInputValue = (input, inputValue) => {
 const renderInputType = {};
 
 /**
- * @param {HTMLInputElement} input
+ * @param {Input | HTMLElement} input
  * @param {SweetAlertOptions} params
- * @returns {HTMLInputElement}
+ * @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) => {
-  checkAndSetInputValue(input, params.inputValue);
-  setInputLabel(input, input, params);
-  setInputPlaceholder(input, params);
-  input.type = params.input;
-  return input;
+  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 {HTMLInputElement} input
+ * @param {Input | HTMLElement} input
  * @param {SweetAlertOptions} params
- * @returns {HTMLInputElement}
+ * @returns {Input}
  */
 renderInputType.file = (input, params) => {
-  setInputLabel(input, input, params);
-  setInputPlaceholder(input, params);
-  return input;
+  const inputElement = /** @type {HTMLInputElement} */input;
+  setInputLabel(inputElement, inputElement, params);
+  setInputPlaceholder(inputElement, params);
+  return inputElement;
 };
 
 /**
- * @param {HTMLInputElement} range
+ * @param {Input | HTMLElement} range
  * @param {SweetAlertOptions} params
- * @returns {HTMLInputElement}
+ * @returns {Input}
  */
 renderInputType.range = (range, params) => {
-  const rangeInput = range.querySelector('input');
-  const rangeOutput = range.querySelector('output');
-  checkAndSetInputValue(rangeInput, params.inputValue);
-  rangeInput.type = params.input;
-  checkAndSetInputValue(rangeOutput, params.inputValue);
-  setInputLabel(rangeInput, range, params);
-  return range;
+  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 {HTMLSelectElement} select
+ * @param {Input | HTMLElement} select
  * @param {SweetAlertOptions} params
- * @returns {HTMLSelectElement}
+ * @returns {Input}
  */
 renderInputType.select = (select, params) => {
-  select.textContent = '';
+  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;
-    select.appendChild(placeholder);
+    selectElement.appendChild(placeholder);
   }
-  setInputLabel(select, select, params);
-  return select;
+  setInputLabel(selectElement, selectElement, params);
+  return selectElement;
 };
 
 /**
- * @param {HTMLInputElement} radio
- * @returns {HTMLInputElement}
+ * @param {Input | HTMLElement} radio
+ * @returns {Input}
  */
 renderInputType.radio = radio => {
-  radio.textContent = '';
-  return radio;
+  const radioElement = /** @type {HTMLElement} */radio;
+  radioElement.textContent = '';
+  return /** @type {Input} */radio;
 };
 
 /**
- * @param {HTMLLabelElement} checkboxContainer
+ * @param {Input | HTMLElement} checkboxContainer
  * @param {SweetAlertOptions} params
- * @returns {HTMLInputElement}
+ * @returns {Input}
  */
 renderInputType.checkbox = (checkboxContainer, params) => {
-  const checkbox = getInput$1(getPopup(), 'checkbox');
+  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 label = checkboxContainer.querySelector('span');
-  setInnerHtml(label, params.inputPlaceholder || params.inputLabel);
+  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 {HTMLTextAreaElement} textarea
+ * @param {Input | HTMLElement} textarea
  * @param {SweetAlertOptions} params
- * @returns {HTMLTextAreaElement}
+ * @returns {Input}
  */
 renderInputType.textarea = (textarea, params) => {
-  checkAndSetInputValue(textarea, params.inputValue);
-  setInputPlaceholder(textarea, params);
-  setInputLabel(textarea, textarea, params);
+  const textareaElement = /** @type {HTMLTextAreaElement} */textarea;
+  checkAndSetInputValue(textareaElement, params.inputValue);
+  setInputPlaceholder(textareaElement, params);
+  setInputLabel(textareaElement, textareaElement, params);
 
   /**
    * @param {HTMLElement} el
@@ -1364,26 +1387,33 @@ renderInputType.textarea = (textarea, params) => {
   setTimeout(() => {
     // https://github.com/sweetalert2/sweetalert2/issues/1699
     if ('MutationObserver' in window) {
-      const initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);
+      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(textarea)) {
+        if (!document.body.contains(textareaElement)) {
           return;
         }
-        const textareaWidth = textarea.offsetWidth + getMargin(textarea);
-        if (textareaWidth > initialPopupWidth) {
-          getPopup().style.width = `${textareaWidth}px`;
-        } else {
-          applyNumericalStyle(getPopup(), 'width', params.width);
+        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(textarea, {
+      new MutationObserver(textareaResizeHandler).observe(textareaElement, {
         attributes: true,
         attributeFilter: ['style']
       });
     }
   });
-  return textarea;
+  return textareaElement;
 };
 
 /**
@@ -1647,7 +1677,11 @@ const removeDraggableListeners = popup => {
  */
 const down = event => {
   const popup = getPopup();
-  if (event.target === popup || getIcon().contains(/** @type {HTMLElement} */event.target)) {
+  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;
@@ -1663,6 +1697,9 @@ const down = event => {
  */
 const move = event => {
   const popup = getPopup();
+  if (!popup) {
+    return;
+  }
   if (dragging) {
     let {
       clientX,
@@ -2164,7 +2201,7 @@ const unsetAriaHidden = () => {
 };
 
 // @ts-ignore
-const isSafariOrIOS = typeof window !== 'undefined' && !!window.GestureEvent; // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394
+const isSafariOrIOS = typeof window !== 'undefined' && Boolean(window.GestureEvent); // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394
 
 /**
  * Fix iOS scrolling
@@ -2240,11 +2277,13 @@ const shouldPreventTouchMove = event => {
 /**
  * https://github.com/sweetalert2/sweetalert2/issues/1786
  *
- * @param {object} event
+ * @param {TouchEvent} event
  * @returns {boolean}
  */
 const isStylus = event => {
-  return event.touches && event.touches.length && event.touches[0].touchType === 'stylus';
+  return Boolean(event.touches && event.touches.length &&
+  // @ts-ignore - touchType is not a standard property
+  event.touches[0].touchType === 'stylus');
 };
 
 /**
@@ -2769,7 +2808,7 @@ const formatInputOptions = inputOptions => {
  * @returns {boolean}
  */
 const isSelected = (optionValue, inputValue) => {
-  return !!inputValue && inputValue.toString() === optionValue.toString();
+  return Boolean(inputValue) && inputValue.toString() === optionValue.toString();
 };
 
 /**
@@ -3449,7 +3488,7 @@ const handleToastClick = (innerParams, domCache, dismissWith) => {
  * @returns {boolean}
  */
 const isAnyButtonShown = innerParams => {
-  return !!(innerParams.showConfirmButton || innerParams.showDenyButton || innerParams.showCancelButton || innerParams.showCloseButton);
+  return Boolean(innerParams.showConfirmButton || innerParams.showDenyButton || innerParams.showCancelButton || innerParams.showCloseButton);
 };
 let ignoreOutsideClick = false;
 
@@ -3634,7 +3673,7 @@ const increaseTimer = ms => {
  * @returns {boolean}
  */
 const isTimerRunning = () => {
-  return !!(globalState.timeout && globalState.timeout.isRunning());
+  return Boolean(globalState.timeout && globalState.timeout.isRunning());
 };
 
 let bodyClickListenerAdded = false;
@@ -3702,10 +3741,11 @@ class EventEmitter {
    */
   once(eventName, eventHandler) {
     /**
-     * @param {Array} args
+     * @param {...any} args
      */
     const onceFn = (...args) => {
       this.removeListener(eventName, onceFn);
+      // @ts-ignore
       eventHandler.apply(this, args);
     };
     this.on(eventName, onceFn);
@@ -3713,7 +3753,7 @@ class EventEmitter {
 
   /**
    * @param {string} eventName
-   * @param {Array} args
+   * @param {...any} args
    */
   emit(eventName, ...args) {
     this._getHandlersByEventName(eventName).forEach(
@@ -3722,6 +3762,7 @@ class EventEmitter {
      */
     eventHandler => {
       try {
+        // @ts-ignore
         eventHandler.apply(this, args);
       } catch (error) {
         console.error(error);
@@ -4140,12 +4181,16 @@ const SHOW_CLASS_TIMEOUT = 10;
  * @param {SweetAlertOptions} params
  */
 const openPopup = params => {
+  var _globalState$eventEmi, _globalState$eventEmi2;
   const container = getContainer();
   const popup = getPopup();
+  if (!container || !popup) {
+    return;
+  }
   if (typeof params.willOpen === 'function') {
     params.willOpen(popup);
   }
-  globalState.eventEmitter.emit('willOpen', popup);
+  (_globalState$eventEmi = globalState.eventEmitter) === null || _globalState$eventEmi === void 0 || _globalState$eventEmi.emit('willOpen', popup);
   const bodyStyles = window.getComputedStyle(document.body);
   const initialBodyOverflow = bodyStyles.overflowY;
   addClasses(container, popup, params);
@@ -4155,27 +4200,32 @@ const openPopup = params => {
     setScrollingVisibility(container, popup);
   }, SHOW_CLASS_TIMEOUT);
   if (isModal()) {
-    fixScrollContainer(container, params.scrollbarPadding, initialBodyOverflow);
+    // Using ternary instead of ?? operator for Webpack 4 compatibility
+    fixScrollContainer(container, params.scrollbarPadding !== undefined ? params.scrollbarPadding : false, initialBodyOverflow);
     setAriaHidden();
   }
   if (!isToast() && !globalState.previousActiveElement) {
     globalState.previousActiveElement = document.activeElement;
   }
   if (typeof params.didOpen === 'function') {
-    setTimeout(() => params.didOpen(popup));
+    const didOpen = params.didOpen;
+    setTimeout(() => didOpen(popup));
   }
-  globalState.eventEmitter.emit('didOpen', popup);
+  (_globalState$eventEmi2 = globalState.eventEmitter) === null || _globalState$eventEmi2 === void 0 || _globalState$eventEmi2.emit('didOpen', popup);
 };
 
 /**
- * @param {AnimationEvent} event
+ * @param {Event} event
  */
 const swalOpenAnimationFinished = event => {
   const popup = getPopup();
-  if (event.target !== popup) {
+  if (!popup || event.target !== popup) {
     return;
   }
   const container = getContainer();
+  if (!container) {
+    return;
+  }
   popup.removeEventListener('animationend', swalOpenAnimationFinished);
   popup.removeEventListener('transitionend', swalOpenAnimationFinished);
   container.style.overflowY = 'auto';
@@ -4221,14 +4271,20 @@ const fixScrollContainer = (container, scrollbarPadding, initialBodyOverflow) =>
  * @param {SweetAlertOptions} params
  */
 const addClasses = (container, popup, params) => {
-  addClass(container, params.showClass.backdrop);
+  var _params$showClass;
+  if ((_params$showClass = params.showClass) !== null && _params$showClass !== void 0 && _params$showClass.backdrop) {
+    addClass(container, params.showClass.backdrop);
+  }
   if (params.animation) {
     // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059
     popup.style.setProperty('opacity', '0', 'important');
     show(popup, 'grid');
     setTimeout(() => {
+      var _params$showClass2;
       // Animate popup right after showing it
-      addClass(popup, params.showClass.popup);
+      if ((_params$showClass2 = params.showClass) !== null && _params$showClass2 !== void 0 && _params$showClass2.popup) {
+        addClass(popup, params.showClass.popup);
+      }
       // and remove the opacity workaround
       popup.style.removeProperty('opacity');
     }, SHOW_CLASS_TIMEOUT); // 10ms in order to fix #2062
@@ -4605,7 +4661,7 @@ Object.keys(instanceMethods).forEach(key => {
   };
 });
 SweetAlert.DismissReason = DismissReason;
-SweetAlert.version = '11.26.11';
+SweetAlert.version = '11.26.13';
 
 const Swal = SweetAlert;
 // @ts-ignore