sweetalert2 11.26.13 → 11.26.15

package/dist/sweetalert2.esm.all.js

@@ -1,5 +1,5 @@
 /*!
-* sweetalert2 v11.26.13
+* sweetalert2 v11.26.15
 * Released under the MIT License.
 */
 function _assertClassBrand(e, t, n) {
@@ -544,7 +544,7 @@ const applyNumericalStyle = (elem, property, value) => {
     value = parseInt(value);
   }
   if (value || parseInt(`${value}`) === 0) {
-    elem.style.setProperty(property, typeof value === 'number' ? `${value}px` : value);
+    elem.style.setProperty(property, typeof value === 'number' ? `${value}px` : (/** @type {string} */value));
   } else {
     elem.style.removeProperty(property);
   }
@@ -639,7 +639,7 @@ const isScrollable = elem => Boolean(elem.scrollHeight > elem.clientHeight);
  * @returns {boolean}
  */
 const selfOrParentIsScrollable = (element, stopElement) => {
-  let parent = element;
+  let parent = /** @type {HTMLElement | null} */element;
   while (parent && parent !== stopElement) {
     if (isScrollable(parent)) {
       return true;
@@ -746,50 +746,81 @@ const resetOldContainer = () => {
     return false;
   }
   oldContainer.remove();
-  removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
+  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 = () => {
-  globalState.currentInstance.resetValidationMessage();
+  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} */
+  /** @type {HTMLInputElement | null} */
   const range = popup.querySelector(`.${swalClasses.range} input`);
-  /** @type {HTMLOutputElement} */
+  /** @type {HTMLOutputElement | null} */
   const rangeOutput = popup.querySelector(`.${swalClasses.range} output`);
   const select = getDirectChildByClass(popup, swalClasses.select);
-  /** @type {HTMLInputElement} */
+  /** @type {HTMLInputElement | null} */
   const checkbox = popup.querySelector(`.${swalClasses.checkbox} input`);
   const textarea = getDirectChildByClass(popup, swalClasses.textarea);
-  input.oninput = resetValidationMessage$1;
-  file.onchange = resetValidationMessage$1;
-  select.onchange = resetValidationMessage$1;
-  checkbox.onchange = resetValidationMessage$1;
-  textarea.oninput = resetValidationMessage$1;
-  range.oninput = () => {
-    resetValidationMessage$1();
-    rangeOutput.value = range.value;
-  };
-  range.onchange = () => {
-    resetValidationMessage$1();
-    rangeOutput.value = range.value;
-  };
+  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 => typeof target === 'string' ? document.querySelector(target) : target;
+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) {
@@ -826,7 +857,7 @@ const init = params => {
   }
   setInnerHtml(container, sweetHTML);
   container.dataset['swal2Theme'] = params.theme;
-  const targetElement = getTarget(params.target);
+  const targetElement = getTarget(params.target || 'body');
   targetElement.appendChild(container);
   if (params.topLayer) {
     container.setAttribute('popover', '');
@@ -864,7 +895,7 @@ const parseHtmlToContainer = (param, target) => {
  */
 const handleObject = (param, target) => {
   // JQuery element(s)
-  if (param.jquery) {
+  if ('jquery' in param) {
     handleJqueryElem(target, param);
   }
 
@@ -876,7 +907,7 @@ const handleObject = (param, target) => {
 
 /**
  * @param {HTMLElement} target
- * @param {object} elem
+ * @param {any} elem
  */
 const handleJqueryElem = (target, elem) => {
   target.textContent = '';
@@ -1900,6 +1931,7 @@ const renderTitle = (instance, params) => {
  * @param {SweetAlertOptions} params
  */
 const render = (instance, params) => {
+  var _globalState$eventEmi;
   renderPopup(instance, params);
   renderContainer(instance, params);
   renderProgressSteps(instance, params);
@@ -1914,7 +1946,7 @@ const render = (instance, params) => {
   if (typeof params.didRender === 'function' && popup) {
     params.didRender(popup);
   }
-  globalState.eventEmitter.emit('didRender', popup);
+  (_globalState$eventEmi = globalState.eventEmitter) === null || _globalState$eventEmi === void 0 || _globalState$eventEmi.emit('didRender', popup);
 };
 
 /*
@@ -2808,7 +2840,7 @@ const formatInputOptions = inputOptions => {
  * @returns {boolean}
  */
 const isSelected = (optionValue, inputValue) => {
-  return Boolean(inputValue) && inputValue.toString() === optionValue.toString();
+  return Boolean(inputValue) && inputValue !== null && inputValue !== undefined && inputValue.toString() === optionValue.toString();
 };
 
 /**
@@ -3591,9 +3623,15 @@ function fire(...args) {
  *
  * @param {SweetAlertOptions} mixinParams
  * @returns {SweetAlert}
+ * @this {typeof import('../SweetAlert.js').SweetAlert}
  */
 function mixin(mixinParams) {
+  // @ts-ignore: 'this' refers to the SweetAlert constructor
   class MixinSwal extends this {
+    /**
+     * @param {any} params
+     * @param {any} priorityMixinParams
+     */
     _main(params, priorityMixinParams) {
       return super._main(params, Object.assign({}, mixinParams, priorityMixinParams));
     }
@@ -3984,9 +4022,9 @@ const getSwalParams = templateContent => {
     if (!paramName || !value) {
       return;
     }
-    if (typeof defaultParams[paramName] === 'boolean') {
+    if (paramName in defaultParams && typeof defaultParams[(/** @type {keyof typeof defaultParams} */paramName)] === 'boolean') {
       result[paramName] = value !== 'false';
-    } else if (typeof defaultParams[paramName] === 'object') {
+    } else if (paramName in defaultParams && typeof defaultParams[(/** @type {keyof typeof defaultParams} */paramName)] === 'object') {
       result[paramName] = JSON.parse(value);
     } else {
       result[paramName] = value;
@@ -4033,10 +4071,16 @@ const getSwalButtons = templateContent => {
     result[`${type}ButtonText`] = button.innerHTML;
     result[`show${capitalizeFirstLetter(type)}Button`] = true;
     if (button.hasAttribute('color')) {
-      result[`${type}ButtonColor`] = button.getAttribute('color');
+      const color = button.getAttribute('color');
+      if (color !== null) {
+        result[`${type}ButtonColor`] = color;
+      }
     }
     if (button.hasAttribute('aria-label')) {
-      result[`${type}ButtonAriaLabel`] = button.getAttribute('aria-label');
+      const ariaLabel = button.getAttribute('aria-label');
+      if (ariaLabel !== null) {
+        result[`${type}ButtonAriaLabel`] = ariaLabel;
+      }
     }
   });
   return result;
@@ -4094,7 +4138,7 @@ const getSwalIcon = templateContent => {
  * @returns {object}
  */
 const getSwalInput = templateContent => {
-  /** @type {object} */
+  /** @type {Record<string, any>} */
   const result = {};
   /** @type {HTMLElement | null} */
   const input = templateContent.querySelector('swal-input');
@@ -4377,7 +4421,11 @@ class SweetAlert {
     /**
      * @type {Promise<SweetAlertResult>}
      */
-    _classPrivateFieldInitSpec(this, _promise, void 0);
+    _classPrivateFieldInitSpec(this, _promise, /** @type {Promise<SweetAlertResult>} */Promise.resolve({
+      isConfirmed: false,
+      isDenied: false,
+      isDismissed: true
+    }));
     // Prevent run in Node env
     if (typeof window === 'undefined') {
       return;
@@ -4394,6 +4442,11 @@ class SweetAlert {
     this.isAwaitingPromise = false;
     _classPrivateFieldSet2(_promise, this, this._main(currentInstance.params));
   }
+
+  /**
+   * @param {any} userParams
+   * @param {any} mixinParams
+   */
   _main(userParams, mixinParams = {}) {
     showWarningsForParams(Object.assign({}, mixinParams, userParams));
     if (globalState.currentInstance) {
@@ -4431,9 +4484,16 @@ class SweetAlert {
   }
 
   // `catch` cannot be the name of a module export, so we define our thenable methods here instead
+  /**
+   * @param {any} onFulfilled
+   */
   then(onFulfilled) {
     return _classPrivateFieldGet2(_promise, this).then(onFulfilled);
   }
+
+  /**
+   * @param {any} onFinally
+   */
   finally(onFinally) {
     return _classPrivateFieldGet2(_promise, this).finally(onFinally);
   }
@@ -4443,7 +4503,7 @@ class SweetAlert {
  * @param {SweetAlert} instance
  * @param {DomCache} domCache
  * @param {SweetAlertOptions} innerParams
- * @returns {Promise}
+ * @returns {Promise<SweetAlertResult>}
  */
 const swalPromise = (instance, domCache, innerParams) => {
   return new Promise((resolve, reject) => {
@@ -4511,17 +4571,17 @@ const prepareParams = (userParams, mixinParams) => {
  * @returns {DomCache}
  */
 const populateDomCache = instance => {
-  const domCache = {
-    popup: getPopup(),
-    container: getContainer(),
-    actions: getActions(),
-    confirmButton: getConfirmButton(),
-    denyButton: getDenyButton(),
-    cancelButton: getCancelButton(),
-    loader: getLoader(),
-    closeButton: getCloseButton(),
-    validationMessage: getValidationMessage(),
-    progressSteps: getProgressSteps()
+  const domCache = /** @type {DomCache} */{
+    popup: (/** @type {HTMLElement} */getPopup()),
+    container: (/** @type {HTMLElement} */getContainer()),
+    actions: (/** @type {HTMLElement} */getActions()),
+    confirmButton: (/** @type {HTMLElement} */getConfirmButton()),
+    denyButton: (/** @type {HTMLElement} */getDenyButton()),
+    cancelButton: (/** @type {HTMLElement} */getCancelButton()),
+    loader: (/** @type {HTMLElement} */getLoader()),
+    closeButton: (/** @type {HTMLElement} */getCloseButton()),
+    validationMessage: (/** @type {HTMLElement} */getValidationMessage()),
+    progressSteps: (/** @type {HTMLElement} */getProgressSteps())
   };
   privateProps.domCache.set(instance, domCache);
   return domCache;
@@ -4540,13 +4600,13 @@ const setupTimer = (globalState, innerParams, dismissWith) => {
       dismissWith('timer');
       delete globalState.timeout;
     }, innerParams.timer);
-    if (innerParams.timerProgressBar) {
+    if (innerParams.timerProgressBar && timerProgressBar) {
       show(timerProgressBar);
       applyCustomClass(timerProgressBar, innerParams, 'timerProgressBar');
       setTimeout(() => {
         if (globalState.timeout && globalState.timeout.running) {
           // timer can be already stopped or unset at this point
-          animateTimerProgressBar(innerParams.timer);
+          animateTimerProgressBar(/** @type {number} */innerParams.timer);
         }
       });
     }
@@ -4653,15 +4713,18 @@ Object.keys(instanceMethods).forEach(key => {
    * @param {...(SweetAlertOptions | string | undefined)} args
    * @returns {SweetAlertResult | Promise<SweetAlertResult> | undefined}
    */
+  // @ts-ignore: Dynamic property assignment for backwards compatibility
   SweetAlert[key] = function (...args) {
+    // @ts-ignore
     if (currentInstance && currentInstance[key]) {
+      // @ts-ignore
       return currentInstance[key](...args);
     }
-    return null;
+    return undefined;
   };
 });
 SweetAlert.DismissReason = DismissReason;
-SweetAlert.version = '11.26.13';
+SweetAlert.version = '11.26.15';
 
 const Swal = SweetAlert;
 // @ts-ignore