voyager-ionic-core 7.4.3 → 7.4.4

package/components/animation.js

@@ -159,6 +159,7 @@ const createAnimation = (animationId) => {
   const id = animationId;
   const onFinishCallbacks = [];
   const onFinishOneTimeCallbacks = [];
+  const onStopOneTimeCallbacks = [];
   const elements = [];
   const childAnimations = [];
   const stylesheets = [];
@@ -216,6 +217,28 @@ const createAnimation = (animationId) => {
   const isRunning = () => {
     return numAnimationsRunning !== 0 && !paused;
   };
+  /**
+   * @internal
+   * Remove a callback from a chosen callback array
+   * @param callbackToRemove: A reference to the callback that should be removed
+   * @param callbackObjects: An array of callbacks that callbackToRemove should be removed from.
+   */
+  const clearCallback = (callbackToRemove, callbackObjects) => {
+    const index = callbackObjects.findIndex((callbackObject) => callbackObject.c === callbackToRemove);
+    if (index > -1) {
+      callbackObjects.splice(index, 1);
+    }
+  };
+  /**
+   * @internal
+   * Add a callback to be fired when an animation is stopped/cancelled.
+   * @param callback: A reference to the callback that should be fired
+   * @param opts: Any options associated with this particular callback
+   */
+  const onStop = (callback, opts) => {
+    onStopOneTimeCallbacks.push({ c: callback, o: opts });
+    return ani;
+  };
   const onFinish = (callback, opts) => {
     const callbacks = (opts === null || opts === void 0 ? void 0 : opts.oneTimeCallback) ? onFinishOneTimeCallbacks : onFinishCallbacks;
     callbacks.push({ c: callback, o: opts });
@@ -884,7 +907,33 @@ const createAnimation = (animationId) => {
         numAnimationsRunning = childAnimations.length + 1;
         shouldCalculateNumAnimations = false;
       }
-      onFinish(() => resolve(), { oneTimeCallback: true });
+      /**
+       * When one of these callbacks fires we
+       * need to clear the other's callback otherwise
+       * you can potentially get these callbacks
+       * firing multiple times if the play method
+       * is subsequently called.
+       * Example:
+       * animation.play() (onStop and onFinish callbacks are registered)
+       * animation.stop() (onStop callback is fired, onFinish is not)
+       * animation.play() (onStop and onFinish callbacks are registered)
+       * Total onStop callbacks: 1
+       * Total onFinish callbacks: 2
+       */
+      const onStopCallback = () => {
+        clearCallback(onFinishCallback, onFinishOneTimeCallbacks);
+        resolve();
+      };
+      const onFinishCallback = () => {
+        clearCallback(onStopCallback, onStopOneTimeCallbacks);
+        resolve();
+      };
+      /**
+       * The play method resolves when an animation
+       * run either finishes or is cancelled.
+       */
+      onFinish(onFinishCallback, { oneTimeCallback: true });
+      onStop(onStopCallback, { oneTimeCallback: true });
       childAnimations.forEach((animation) => {
         animation.play();
       });
@@ -897,6 +946,14 @@ const createAnimation = (animationId) => {
       paused = false;
     });
   };
+  /**
+   * Stops an animation and resets it state to the
+   * beginning. This does not fire any onFinish
+   * callbacks because the animation did not finish.
+   * However, since the animation was not destroyed
+   * (i.e. the animation could run again) we do not
+   * clear the onFinish callbacks.
+   */
   const stop = () => {
     childAnimations.forEach((animation) => {
       animation.stop();
@@ -906,6 +963,8 @@ const createAnimation = (animationId) => {
       initialized = false;
     }
     resetFlags();
+    onStopOneTimeCallbacks.forEach((onStopCallback) => onStopCallback.c(0, ani));
+    onStopOneTimeCallbacks.length = 0;
   };
   const from = (property, value) => {
     const firstFrame = _keyframes[0];

package/components/checkbox.js

@@ -52,6 +52,9 @@ const Checkbox = /*@__PURE__*/ proxyCustomElement(class Checkbox extends HTMLEle
       this.ionBlur.emit();
     };
     this.onClick = (ev) => {
+      if (this.disabled) {
+        return;
+      }
       this.toggleChecked(ev);
     };
     this.color = undefined;

package/components/ion-menu.js

@@ -33,6 +33,14 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
     this.lastOnEnd = 0;
     this.blocker = GESTURE_CONTROLLER.createBlocker({ disableScroll: true });
     this.didLoad = false;
+    /**
+     * Flag used to determine if an open/close
+     * operation was cancelled. For example, if
+     * an app calls "menu.open" then disables the menu
+     * part way through the animation, then this would
+     * be considered a cancelled operation.
+     */
+    this.operationCancelled = false;
     this.isAnimating = false;
     this._isOpen = false;
     this.inheritedAttributes = {};
@@ -301,6 +309,15 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
     this.beforeAnimation(shouldOpen);
     await this.loadAnimation();
     await this.startAnimation(shouldOpen, animated);
+    /**
+     * If the animation was cancelled then
+     * return false because the operation
+     * did not succeed.
+     */
+    if (this.operationCancelled) {
+      this.operationCancelled = false;
+      return false;
+    }
     this.afterAnimation(shouldOpen);
     return true;
   }
@@ -337,18 +354,23 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
     const easingReverse = mode === 'ios' ? iosEasingReverse : mdEasingReverse;
     const ani = this.animation
       .direction(isReversed ? 'reverse' : 'normal')
-      .easing(isReversed ? easingReverse : easing)
-      .onFinish(() => {
-      if (ani.getDirection() === 'reverse') {
-        ani.direction('normal');
-      }
-    });
+      .easing(isReversed ? easingReverse : easing);
     if (animated) {
       await ani.play();
     }
     else {
       ani.play({ sync: true });
     }
+    /**
+     * We run this after the play invocation
+     * instead of using ani.onFinish so that
+     * multiple onFinish callbacks do not get
+     * run if an animation is played, stopped,
+     * and then played again.
+     */
+    if (ani.getDirection() === 'reverse') {
+      ani.direction('normal');
+    }
   }
   _isActive() {
     return !this.disabled && !this.isPaneVisible;
@@ -485,7 +507,6 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
   }
   afterAnimation(isOpen) {
     var _a;
-    assert(this.isAnimating, '_before() should be called while animating');
     // keep opening/closing the menu disabled for a touch more yet
     // only add listeners/css if it's enabled and isOpen
     // and only remove listeners/css if it's not open
@@ -544,10 +565,29 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
     if (this.gesture) {
       this.gesture.enable(isActive && this.swipeGesture);
     }
-    // Close menu immediately
-    if (!isActive && this._isOpen) {
-      // close if this menu is open, and should not be enabled
-      this.forceClosing();
+    /**
+     * If the menu is disabled but it is still open
+     * then we should close the menu immediately.
+     * Additionally, if the menu is in the process
+     * of animating {open, close} and the menu is disabled
+     * then it should still be closed immediately.
+     */
+    if (!isActive) {
+      /**
+       * It is possible to disable the menu while
+       * it is mid-animation. When this happens, we
+       * need to set the operationCancelled flag
+       * so that this._setOpen knows to return false
+       * and not run the "afterAnimation" callback.
+       */
+      if (this.isAnimating) {
+        this.operationCancelled = true;
+      }
+      /**
+       * If the menu is disabled then we should
+       * forcibly close the menu even if it is open.
+       */
+      this.afterAnimation(false);
     }
     if (doc === null || doc === void 0 ? void 0 : doc.contains(this.el)) {
       /**
@@ -560,14 +600,6 @@ const Menu = /*@__PURE__*/ proxyCustomElement(class Menu extends HTMLElement {
         menuController._setActiveMenu(this);
       }
     }
-    assert(!this.isAnimating, 'can not be animating');
-  }
-  forceClosing() {
-    assert(this._isOpen, 'menu cannot be closed');
-    this.isAnimating = true;
-    const ani = this.animation.direction('reverse');
-    ani.play({ sync: true });
-    this.afterAnimation(false);
   }
   render() {
     const { type, disabled, isPaneVisible, inheritedAttributes, side } = this;

package/components/ion-select.js

@@ -137,25 +137,39 @@ const Select = /*@__PURE__*/ proxyCustomElement(class Select extends HTMLElement
     await overlay.present();
     // focus selected option for popovers
     if (this.interface === 'popover') {
-      let indexOfSelected = this.childOpts.map((o) => o.value).indexOf(this.value);
-      indexOfSelected = indexOfSelected > -1 ? indexOfSelected : 0; // default to first option if nothing selected
-      const selectedItem = overlay.querySelector(`.select-interface-option:nth-child(${indexOfSelected + 1})`);
-      if (selectedItem) {
-        focusElement(selectedItem);
+      const indexOfSelected = this.childOpts.map((o) => o.value).indexOf(this.value);
+      if (indexOfSelected > -1) {
+        const selectedItem = overlay.querySelector(`.select-interface-option:nth-child(${indexOfSelected + 1})`);
+        if (selectedItem) {
+          focusElement(selectedItem);
+          /**
+           * Browsers such as Firefox do not
+           * correctly delegate focus when manually
+           * focusing an element with delegatesFocus.
+           * We work around this by manually focusing
+           * the interactive element.
+           * ion-radio and ion-checkbox are the only
+           * elements that ion-select-popover uses, so
+           * we only need to worry about those two components
+           * when focusing.
+           */
+          const interactiveEl = selectedItem.querySelector('ion-radio, ion-checkbox');
+          if (interactiveEl) {
+            interactiveEl.focus();
+          }
+        }
+      }
+      else {
         /**
-         * Browsers such as Firefox do not
-         * correctly delegate focus when manually
-         * focusing an element with delegatesFocus.
-         * We work around this by manually focusing
-         * the interactive element.
-         * ion-radio and ion-checkbox are the only
-         * elements that ion-select-popover uses, so
-         * we only need to worry about those two components
-         * when focusing.
+         * If no value is set then focus the first enabled option.
          */
-        const interactiveEl = selectedItem.querySelector('ion-radio, ion-checkbox');
-        if (interactiveEl) {
-          interactiveEl.focus();
+        const firstEnabledOption = overlay.querySelector('ion-radio:not(.radio-disabled), ion-checkbox:not(.checkbox-disabled)');
+        if (firstEnabledOption) {
+          focusElement(firstEnabledOption.closest('ion-item'));
+          /**
+           * Focus the option for the same reason as we do above.
+           */
+          firstEnabledOption.focus();
         }
       }
     }

package/components/ion-toggle.js

@@ -48,6 +48,9 @@ const Toggle = /*@__PURE__*/ proxyCustomElement(class Toggle extends HTMLElement
       }
     };
     this.onClick = (ev) => {
+      if (this.disabled) {
+        return;
+      }
       ev.preventDefault();
       if (this.lastDrag + 300 < Date.now()) {
         this.toggleChecked();

package/components/radio-group.js

@@ -38,7 +38,7 @@ const RadioGroup = /*@__PURE__*/ proxyCustomElement(class RadioGroup extends HTM
        * using the `name` attribute.
        */
       const selectedRadio = ev.target && ev.target.closest('ion-radio');
-      if (selectedRadio) {
+      if (selectedRadio && selectedRadio.disabled === false) {
         const currentValue = this.value;
         const newValue = selectedRadio.value;
         if (newValue !== currentValue) {

package/components/radio.js

@@ -30,7 +30,10 @@ const Radio = /*@__PURE__*/ proxyCustomElement(class Radio extends HTMLElement {
       }
     };
     this.onClick = () => {
-      const { radioGroup, checked } = this;
+      const { radioGroup, checked, disabled } = this;
+      if (disabled) {
+        return;
+      }
       /**
        * The legacy control uses a native input inside
        * of the radio host, so we can set this.checked

package/components/swipe-back.js

@@ -62,6 +62,10 @@ const createSwipeBackGesture = (el, canStartHandler, onStartHandler, onMoveHandl
   return createGesture({
     el,
     gestureName: 'goback-swipe',
+    /**
+     * Swipe to go back should have priority over other horizontal swipe
+     * gestures. These gestures have a priority of 100 which is why 101 was chosen here.
+     */
     gesturePriority: 101,
     threshold: 10,
     canStart,

package/dist/cjs/{animation-2bb33618.js → animation-c8bdd3c7.js}

@@ -161,6 +161,7 @@ const createAnimation = (animationId) => {
   const id = animationId;
   const onFinishCallbacks = [];
   const onFinishOneTimeCallbacks = [];
+  const onStopOneTimeCallbacks = [];
   const elements = [];
   const childAnimations = [];
   const stylesheets = [];
@@ -218,6 +219,28 @@ const createAnimation = (animationId) => {
   const isRunning = () => {
     return numAnimationsRunning !== 0 && !paused;
   };
+  /**
+   * @internal
+   * Remove a callback from a chosen callback array
+   * @param callbackToRemove: A reference to the callback that should be removed
+   * @param callbackObjects: An array of callbacks that callbackToRemove should be removed from.
+   */
+  const clearCallback = (callbackToRemove, callbackObjects) => {
+    const index = callbackObjects.findIndex((callbackObject) => callbackObject.c === callbackToRemove);
+    if (index > -1) {
+      callbackObjects.splice(index, 1);
+    }
+  };
+  /**
+   * @internal
+   * Add a callback to be fired when an animation is stopped/cancelled.
+   * @param callback: A reference to the callback that should be fired
+   * @param opts: Any options associated with this particular callback
+   */
+  const onStop = (callback, opts) => {
+    onStopOneTimeCallbacks.push({ c: callback, o: opts });
+    return ani;
+  };
   const onFinish = (callback, opts) => {
     const callbacks = (opts === null || opts === void 0 ? void 0 : opts.oneTimeCallback) ? onFinishOneTimeCallbacks : onFinishCallbacks;
     callbacks.push({ c: callback, o: opts });
@@ -886,7 +909,33 @@ const createAnimation = (animationId) => {
         numAnimationsRunning = childAnimations.length + 1;
         shouldCalculateNumAnimations = false;
       }
-      onFinish(() => resolve(), { oneTimeCallback: true });
+      /**
+       * When one of these callbacks fires we
+       * need to clear the other's callback otherwise
+       * you can potentially get these callbacks
+       * firing multiple times if the play method
+       * is subsequently called.
+       * Example:
+       * animation.play() (onStop and onFinish callbacks are registered)
+       * animation.stop() (onStop callback is fired, onFinish is not)
+       * animation.play() (onStop and onFinish callbacks are registered)
+       * Total onStop callbacks: 1
+       * Total onFinish callbacks: 2
+       */
+      const onStopCallback = () => {
+        clearCallback(onFinishCallback, onFinishOneTimeCallbacks);
+        resolve();
+      };
+      const onFinishCallback = () => {
+        clearCallback(onStopCallback, onStopOneTimeCallbacks);
+        resolve();
+      };
+      /**
+       * The play method resolves when an animation
+       * run either finishes or is cancelled.
+       */
+      onFinish(onFinishCallback, { oneTimeCallback: true });
+      onStop(onStopCallback, { oneTimeCallback: true });
       childAnimations.forEach((animation) => {
         animation.play();
       });
@@ -899,6 +948,14 @@ const createAnimation = (animationId) => {
       paused = false;
     });
   };
+  /**
+   * Stops an animation and resets it state to the
+   * beginning. This does not fire any onFinish
+   * callbacks because the animation did not finish.
+   * However, since the animation was not destroyed
+   * (i.e. the animation could run again) we do not
+   * clear the onFinish callbacks.
+   */
   const stop = () => {
     childAnimations.forEach((animation) => {
       animation.stop();
@@ -908,6 +965,8 @@ const createAnimation = (animationId) => {
       initialized = false;
     }
     resetFlags();
+    onStopOneTimeCallbacks.forEach((onStopCallback) => onStopCallback.c(0, ani));
+    onStopOneTimeCallbacks.length = 0;
   };
   const from = (property, value) => {
     const firstFrame = _keyframes[0];

package/dist/cjs/{app-globals-84b6a756.js → app-globals-fe1ad535.js}

@@ -3,7 +3,7 @@
  */
 'use strict';
 
-const ionicGlobal = require('./ionic-global-a71608df.js');
+const ionicGlobal = require('./ionic-global-fb752503.js');
 
 const globalScripts = ionicGlobal.initialize;
 

package/dist/cjs/{button-active-c358e83c.js → button-active-0932cee9.js}

@@ -3,7 +3,7 @@
  */
 'use strict';
 
-const index$1 = require('./index-14a4821e.js');
+const index$1 = require('./index-305a23dc.js');
 const haptic = require('./haptic-c5f6b4d5.js');
 const index = require('./index-0ee995e4.js');