voyager-ionic-core 8.8.12 → 9.0.1

package/dist/collection/global/ionic-global.js

@@ -19,7 +19,13 @@ export const initialize = (userConfig = {}) => {
     const Ionic = (win.Ionic = win.Ionic || {});
     // create the Ionic.config from raw config object (if it exists)
     // and convert Ionic.config into a ConfigApi that has a get() fn
-    const configObj = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, configFromSession(win)), { persistConfig: false }), Ionic.config), configFromURL(win)), userConfig);
+    const configObj = {
+        ...configFromSession(win),
+        persistConfig: false,
+        ...Ionic.config,
+        ...configFromURL(win),
+        ...userConfig,
+    };
     config.reset(configObj);
     if (config.getBoolean('persistConfig')) {
         saveConfig(win, configObj);
@@ -37,7 +43,7 @@ export const initialize = (userConfig = {}) => {
     if (config.getBoolean('_testing')) {
         config.set('animated', false);
     }
-    const isIonicElement = (elm) => { var _a; return (_a = elm.tagName) === null || _a === void 0 ? void 0 : _a.startsWith('ION-'); };
+    const isIonicElement = (elm) => elm.tagName?.startsWith('ION-');
     const isAllowedIonicModeValue = (elmMode) => ['ios', 'md'].includes(elmMode);
     setMode((elm) => {
         while (elm) {

package/dist/collection/index.js

@@ -17,5 +17,5 @@ export { getMode, setupConfig } from './utils/config';
 export { openURL } from './utils/theme';
 export { LIFECYCLE_WILL_ENTER, LIFECYCLE_DID_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_UNLOAD, } from './components/nav/constants';
 export { menuController } from './utils/menu-controller';
-export { alertController, actionSheetController, modalController, loadingController, pickerController, popoverController, toastController, } from './utils/overlays';
+export { alertController, actionSheetController, modalController, loadingController, popoverController, toastController, } from './utils/overlays';
 export { IonicSlides } from './components/slides/IonicSlides';

package/dist/collection/utils/animation/animation.js

@@ -122,7 +122,7 @@ export const createAnimation = (animationId) => {
         return ani;
     };
     const onFinish = (callback, opts) => {
-        const callbacks = (opts === null || opts === void 0 ? void 0 : opts.oneTimeCallback) ? onFinishOneTimeCallbacks : onFinishCallbacks;
+        const callbacks = opts?.oneTimeCallback ? onFinishOneTimeCallbacks : onFinishCallbacks;
         callbacks.push({ c: callback, o: opts });
         return ani;
     };
@@ -155,7 +155,7 @@ export const createAnimation = (animationId) => {
              * for another animation to have already
              * cleaned up a particular stylesheet
              */
-            if (stylesheet === null || stylesheet === void 0 ? void 0 : stylesheet.parentNode) {
+            if (stylesheet?.parentNode) {
                 stylesheet.parentNode.removeChild(stylesheet);
             }
         });
@@ -655,7 +655,7 @@ export const createAnimation = (animationId) => {
     };
     const play = (opts) => {
         return new Promise((resolve) => {
-            if (opts === null || opts === void 0 ? void 0 : opts.sync) {
+            if (opts?.sync) {
                 shouldForceSyncPlayback = true;
                 onFinish(() => (shouldForceSyncPlayback = false), { oneTimeCallback: true });
             }

package/dist/collection/utils/config.js

@@ -4,18 +4,19 @@
 export const setupConfig = (config) => {
     const win = window;
     const Ionic = win.Ionic;
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
     if (Ionic && Ionic.config && Ionic.config.constructor.name !== 'Object') {
         return;
     }
     win.Ionic = win.Ionic || {};
-    win.Ionic.config = Object.assign(Object.assign({}, win.Ionic.config), config);
+    win.Ionic.config = {
+        ...win.Ionic.config,
+        ...config,
+    };
     return win.Ionic.config;
 };
 export const getMode = () => {
-    var _a;
     const win = window;
-    const config = (_a = win === null || win === void 0 ? void 0 : win.Ionic) === null || _a === void 0 ? void 0 : _a.config;
+    const config = win?.Ionic?.config;
     if (config) {
         if (config.mode) {
             return config.mode;

package/dist/collection/utils/content/index.js

@@ -54,6 +54,36 @@ export const findIonContent = (el) => {
 export const findClosestIonContent = (el) => {
     return el.closest(ION_CONTENT_SELECTOR);
 };
+/**
+ * Queries the custom scroll host an `ion-refresher` scrolls with in the given
+ * `ion-content`. A refresher only pairs with the first host.
+ */
+export const findRefresherScrollHost = (ionContent) => {
+    return ionContent.querySelector(ION_CONTENT_CLASS_SELECTOR);
+};
+/**
+ * Queries the `ion-refresher` that scrolls with the given content element,
+ * which may be an `ion-content` or a custom scroll host. A refresher is a
+ * `slot="fixed"` child of `ion-content`, so it is a sibling of a scroll host
+ * rather than a descendant of it.
+ */
+export const findRefresherInContent = (contentEl) => {
+    // An `ion-content` owns any refresher inside it, scroll host or not.
+    if (isIonContent(contentEl)) {
+        return contentEl.querySelector('ion-refresher');
+    }
+    // A refresher needs an `ion-content` ancestor to initialize.
+    const ionContent = contentEl.closest(ION_CONTENT_ELEMENT_SELECTOR);
+    if (ionContent === null) {
+        return null;
+    }
+    // Any scroll host other than the refresher's own has no refresher.
+    const refresherScrollHost = findRefresherScrollHost(ionContent);
+    if (refresherScrollHost === null || !refresherScrollHost.contains(contentEl)) {
+        return null;
+    }
+    return ionContent.querySelector('ion-refresher');
+};
 /**
  * Scrolls to the top of the element. If an `ion-content` is found, it will scroll
  * using the public API `scrollToTop` with a duration.

package/dist/collection/utils/focus-controller/index.js

@@ -36,7 +36,7 @@ export const createFocusController = () => {
          */
         if (focusManagerEnabled) {
             const activeEl = document.activeElement;
-            if (activeEl !== null && (referenceEl === null || referenceEl === void 0 ? void 0 : referenceEl.contains(activeEl))) {
+            if (activeEl !== null && referenceEl?.contains(activeEl)) {
                 activeEl.setAttribute(LAST_FOCUS, 'true');
             }
         }

package/dist/collection/utils/focus-trap.js

@@ -27,7 +27,7 @@ export const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden
  */
 export const focusFirstDescendant = (ref, fallbackElement) => {
     const firstInput = ref.querySelector(focusableQueryString);
-    focusElementInContext(firstInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+    focusElementInContext(firstInput, fallbackElement ?? ref);
 };
 /**
  * Focuses the last descendant in a context
@@ -42,7 +42,7 @@ export const focusFirstDescendant = (ref, fallbackElement) => {
 export const focusLastDescendant = (ref, fallbackElement) => {
     const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
     const lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
-    focusElementInContext(lastInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+    focusElementInContext(lastInput, fallbackElement ?? ref);
 };
 /**
  * Focuses a particular element in a context. If the element
@@ -63,7 +63,7 @@ export const focusLastDescendant = (ref, fallbackElement) => {
  */
 const focusElementInContext = (hostToFocus, fallbackElement) => {
     let elementToFocus = hostToFocus;
-    const shadowRoot = hostToFocus === null || hostToFocus === void 0 ? void 0 : hostToFocus.shadowRoot;
+    const shadowRoot = hostToFocus?.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
         elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;

package/dist/collection/utils/forms/index.js

@@ -2,5 +2,7 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 export * from './notch-controller';
+export * from './start-container-controller';
 export * from './compare-with-utils';
+export * from './item-multiple-inputs';
 export * from './validity';

package/dist/collection/utils/forms/item-multiple-inputs.js

@@ -0,0 +1,33 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { Build } from "@stencil/core";
+/**
+ * `item-multiple-inputs` is toggled on the item after its form controls render,
+ * so a control whose focus styling depends on it needs to re-render when it flips.
+ *
+ * @internal
+ * @param el The form control whose closest `ion-item` should be observed.
+ * @param onChange Called whenever one of `classNames` is added or removed.
+ * @param classNames The item classes the caller's rendering depends on. A caller
+ * reading more than one must list them all, or changes to the rest are ignored.
+ * @returns The observer to disconnect in `disconnectedCallback`, or `undefined`
+ * if it could not be created.
+ */
+export const createItemMultipleInputsObserver = (el, onChange, classNames = ['item-multiple-inputs']) => {
+    const item = el.closest('ion-item');
+    if (!item || !Build.isBrowser || typeof MutationObserver === 'undefined') {
+        return undefined;
+    }
+    const readClasses = () => classNames.map((name) => item.classList.contains(name)).join(',');
+    let previousClasses = readClasses();
+    const observer = new MutationObserver(() => {
+        const currentClasses = readClasses();
+        if (currentClasses !== previousClasses) {
+            previousClasses = currentClasses;
+            onChange();
+        }
+    });
+    observer.observe(item, { attributes: true, attributeFilter: ['class'] });
+    return observer;
+};

package/dist/collection/utils/forms/start-container-controller.js

@@ -0,0 +1,132 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { raf } from "../helpers";
+import { isRTL } from "../rtl/index";
+/**
+ * Applied to the host while the label is being repositioned. The
+ * component stylesheets style this class, so it must stay in sync with
+ * the `skip-label-transition` selector in those files. Renaming it here
+ * requires renaming it there too.
+ */
+export const SKIP_LABEL_TRANSITION_CLASS = 'skip-label-transition';
+/**
+ * Set on the host as an inline style. The component stylesheets declare
+ * this property and read it with `var()`, so it must stay in sync with
+ * the `--internal-start-container-adjustment` references in those files.
+ * Renaming it here requires renaming it there too.
+ */
+export const START_CONTAINER_ADJUSTMENT_VAR = '--internal-start-container-adjustment';
+/**
+ * A utility to measure and update the start container width adjustment
+ * for form components (input, textarea, select) with `fill="outline"`.
+ * This adjustment compensates for the start container width when
+ * positioning floating/stacked labels within the outline border.
+ *
+ * Measurement is deferred with raf() to avoid forcing layout during
+ * component updates, and a ResizeObserver watches for dynamic width
+ * changes (e.g., when web fonts load or async content changes).
+ *
+ * @internal
+ * @param el - The host element (ion-input, ion-textarea, or ion-select).
+ * @param getStartContainer - A callback that returns the start container element.
+ * @param shouldApplyAdjustment - A callback that determines whether the adjustment should be applied.
+ */
+export const createStartContainerController = (el, getStartContainer, shouldApplyAdjustment) => {
+    let resizeObserver;
+    let observedContainer;
+    let measurementRaf;
+    let transitionRaf;
+    let appliedAdjustment;
+    const calculateAdjustment = () => {
+        const startSlot = getStartContainer();
+        if (!startSlot || !shouldApplyAdjustment()) {
+            return '';
+        }
+        /*
+         * Round to one decimal place so fractional widths produce a stable
+         * label offset when the start container is added, removed, or resized.
+         */
+        const startContainerWidth = startSlot.getBoundingClientRect().width;
+        const roundedWidth = Math.round(startContainerWidth * 10) / 10;
+        const sign = isRTL(el) ? '' : '-';
+        return roundedWidth ? `${sign}${roundedWidth}px` : '0px';
+    };
+    const scheduleAdjustmentUpdate = () => {
+        // Return if there is already a measurement queued to avoid a flicker
+        if (measurementRaf !== undefined) {
+            return;
+        }
+        /*
+         * Defer the measurement until the next animation frame so layout
+         * is measured after the current update has been applied.
+         */
+        measurementRaf = raf(() => {
+            measurementRaf = undefined;
+            const adjustment = calculateAdjustment();
+            // Only suppress the label transition when the label has to move
+            if (adjustment !== appliedAdjustment) {
+                // Discard a removal queued by an earlier change
+                if (transitionRaf !== undefined) {
+                    cancelAnimationFrame(transitionRaf);
+                }
+                el.classList.add(SKIP_LABEL_TRANSITION_CLASS);
+                el.style.setProperty(START_CONTAINER_ADJUSTMENT_VAR, adjustment);
+                appliedAdjustment = adjustment;
+                // Re-enable the transition once the new offset has been painted
+                transitionRaf = raf(() => {
+                    transitionRaf = undefined;
+                    el.classList.remove(SKIP_LABEL_TRANSITION_CLASS);
+                });
+            }
+            setupResizeObserver();
+        });
+    };
+    const disconnectResizeObserver = () => {
+        if (resizeObserver) {
+            resizeObserver.disconnect();
+            resizeObserver = undefined;
+            observedContainer = undefined;
+        }
+    };
+    const setupResizeObserver = () => {
+        const startSlot = getStartContainer();
+        // Stop watching once the adjustment no longer applies
+        if (!startSlot || !shouldApplyAdjustment()) {
+            disconnectResizeObserver();
+            return;
+        }
+        // Return when prerendering or already watching this container
+        if (typeof ResizeObserver !== 'function' || (resizeObserver && observedContainer === startSlot)) {
+            return;
+        }
+        disconnectResizeObserver();
+        resizeObserver = new ResizeObserver(() => {
+            scheduleAdjustmentUpdate();
+        });
+        observedContainer = startSlot;
+        resizeObserver.observe(startSlot);
+    };
+    const calculateStartContainerWidth = () => {
+        scheduleAdjustmentUpdate();
+    };
+    const destroy = () => {
+        disconnectResizeObserver();
+        if (measurementRaf !== undefined) {
+            cancelAnimationFrame(measurementRaf);
+            measurementRaf = undefined;
+        }
+        // Tearing down mid-toggle would leave the transition disabled
+        if (transitionRaf !== undefined) {
+            cancelAnimationFrame(transitionRaf);
+            transitionRaf = undefined;
+            el.classList.remove(SKIP_LABEL_TRANSITION_CLASS);
+        }
+        // Re-apply from scratch if the element is connected again
+        appliedAdjustment = undefined;
+    };
+    return {
+        calculateStartContainerWidth,
+        destroy,
+    };
+};

package/dist/collection/utils/framework-delegate.js

@@ -4,14 +4,13 @@
 import { componentOnReady } from "./helpers";
 // TODO(FW-2832): types
 export const attachComponent = async (delegate, container, component, cssClasses, componentProps, inline) => {
-    var _a;
     if (delegate) {
         return delegate.attachViewToDom(container, component, componentProps, cssClasses);
     }
     if (!inline && typeof component !== 'string' && !(component instanceof HTMLElement)) {
         throw new Error('framework delegate is missing');
     }
-    const el = typeof component === 'string' ? (_a = container.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(component) : component;
+    const el = typeof component === 'string' ? container.ownerDocument?.createElement(component) : component;
     if (cssClasses) {
         cssClasses.forEach((c) => el.classList.add(c));
     }
@@ -36,7 +35,6 @@ export const CoreDelegate = () => {
     let BaseComponent;
     let Reference;
     const attachViewToDom = async (parentElement, userComponent, userComponentProps = {}, cssClasses = []) => {
-        var _a, _b;
         BaseComponent = parentElement;
         let ChildComponent;
         /**
@@ -49,7 +47,7 @@ export const CoreDelegate = () => {
              * the element otherwise just get a reference
              * to the component.
              */
-            const el = typeof userComponent === 'string' ? (_a = BaseComponent.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(userComponent) : userComponent;
+            const el = typeof userComponent === 'string' ? BaseComponent.ownerDocument?.createElement(userComponent) : userComponent;
             /**
              * Add any css classes passed in
              * via the cssClasses prop on the overlay.
@@ -81,7 +79,7 @@ export const CoreDelegate = () => {
                  * that the overlay has not been presented yet and we need
                  * to create the containing element with the specified classes.
                  */
-                const el = (_b = BaseComponent.ownerDocument) === null || _b === void 0 ? void 0 : _b.createElement('div');
+                const el = BaseComponent.ownerDocument?.createElement('div');
                 // Add a class to track if the root element was created by the delegate.
                 el.classList.add('ion-delegate-host');
                 cssClasses.forEach((c) => el.classList.add(c));
@@ -121,7 +119,7 @@ export const CoreDelegate = () => {
          * in the event that a modal or popover is presented
          * with no child content.
          */
-        return ChildComponent !== null && ChildComponent !== void 0 ? ChildComponent : BaseComponent;
+        return ChildComponent ?? BaseComponent;
     };
     const removeViewFromDom = () => {
         /**

package/dist/collection/utils/gesture/gesture-controller.js

@@ -12,8 +12,7 @@ class GestureController {
      * Creates a gesture delegate based on the GestureConfig passed
      */
     createGesture(config) {
-        var _a;
-        return new GestureDelegate(this, this.newID(), config.name, (_a = config.priority) !== null && _a !== void 0 ? _a : 0, !!config.disableScroll);
+        return new GestureDelegate(this, this.newID(), config.name, config.priority ?? 0, !!config.disableScroll);
     }
     /**
      * Creates a blocker that will block any other gesture events from firing. Set in the ion-gesture component.

package/dist/collection/utils/gesture/index.js

@@ -10,7 +10,15 @@ export const createGesture = (config) => {
     let hasStartedPan = false;
     let hasFiredStart = true;
     let isMoveQueued = false;
-    const finalConfig = Object.assign({ disableScroll: false, direction: 'x', gesturePriority: 0, passive: true, maxAngle: 40, threshold: 10 }, config);
+    const finalConfig = {
+        disableScroll: false,
+        direction: 'x',
+        gesturePriority: 0,
+        passive: true,
+        maxAngle: 40,
+        threshold: 10,
+        ...config,
+    };
     const canStart = finalConfig.canStart;
     const onWillStart = finalConfig.onWillStart;
     const onStart = finalConfig.onStart;
@@ -125,7 +133,7 @@ export const createGesture = (config) => {
     const blurActiveElement = () => {
         if (typeof document !== 'undefined') {
             const activeElement = document.activeElement;
-            if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.blur) {
+            if (activeElement?.blur) {
                 activeElement.blur();
             }
         }

package/dist/collection/utils/gesture/listener.js

@@ -3,14 +3,10 @@
  */
 export const addEventListener = (el, // TODO(FW-2832): type
 eventName, callback, opts) => {
-    // use event listener options when supported
-    // otherwise it's just a boolean for the "capture" arg
-    const listenerOpts = supportsPassive(el)
-        ? {
-            capture: !!opts.capture,
-            passive: !!opts.passive,
-        }
-        : !!opts.capture;
+    const listenerOpts = {
+        capture: !!opts.capture,
+        passive: !!opts.passive,
+    };
     let add;
     let remove;
     if (el['__zone_symbol__addEventListener']) {
@@ -26,22 +22,3 @@ eventName, callback, opts) => {
         el[remove](eventName, callback, listenerOpts);
     };
 };
-const supportsPassive = (node) => {
-    if (_sPassive === undefined) {
-        try {
-            const opts = Object.defineProperty({}, 'passive', {
-                get: () => {
-                    _sPassive = true;
-                },
-            });
-            node.addEventListener('optsTest', () => {
-                return;
-            }, opts);
-        }
-        catch (e) {
-            _sPassive = false;
-        }
-    }
-    return !!_sPassive;
-};
-let _sPassive;

package/dist/collection/utils/hardware-back-button.js

@@ -28,7 +28,7 @@ export const shouldUseCloseWatcher = () => config.get('experimentalCloseWatcher'
  * will still happen.
  */
 export const blockHardwareBackButton = () => {
-    document.addEventListener('backbutton', () => { }); // eslint-disable-line
+    document.addEventListener('backbutton', () => { });
 };
 export const startHardwareBackButton = () => {
     const doc = document;
@@ -50,7 +50,7 @@ export const startHardwareBackButton = () => {
         doc.dispatchEvent(ev);
         const executeAction = async (handlerRegister) => {
             try {
-                if (handlerRegister === null || handlerRegister === void 0 ? void 0 : handlerRegister.handler) {
+                if (handlerRegister?.handler) {
                     const result = handlerRegister.handler(processHandlers);
                     if (result != null) {
                         await result;
@@ -89,7 +89,7 @@ export const startHardwareBackButton = () => {
     if (shouldUseCloseWatcher()) {
         let watcher;
         const configureWatcher = () => {
-            watcher === null || watcher === void 0 ? void 0 : watcher.destroy();
+            watcher?.destroy();
             watcher = new win.CloseWatcher();
             /**
              * Once a close request happens

package/dist/collection/utils/helpers.js

@@ -2,6 +2,7 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { printIonError } from "./logging/index";
+import { isRTL } from "./rtl/index";
 export const transitionEndAsync = (el, expectedDuration = 0) => {
     return new Promise((resolve) => {
         transitionEnd(el, expectedDuration, resolve);
@@ -277,18 +278,21 @@ export const pointerCoord = (ev) => {
 };
 /**
  * @hidden
- * Given a side, return if it should be on the end
- * based on the value of dir
- * @param side the side
- * @param isRTL whether the application dir is rtl
+ * Given a side, returns whether it resolves to the end side for the current
+ * direction. In RTL `start` is the end side, and in LTR `end` is.
+ *
+ * @param side The current side before being redefined based on the direction.
+ * @param hostEl The component's host element. The direction is resolved from
+ * it or its nearest ancestor that declares one. When omitted, the direction
+ * is resolved from the document.
  */
-export const isEndSide = (side) => {
-    const isRTL = document.dir === 'rtl';
+export const isEndSide = (side, hostEl) => {
+    const rtl = isRTL(hostEl);
     switch (side) {
         case 'start':
-            return isRTL;
+            return rtl;
         case 'end':
-            return !isRTL;
+            return !rtl;
         default:
             throw new Error(`"${side}" is not a valid value for [side]. Use "start" or "end" instead.`);
     }
@@ -318,8 +322,8 @@ export const debounce = (func, wait = 0) => {
  * @returns whether the keys are the same and the values are shallow equal.
  */
 export const shallowEqualStringMap = (map1, map2) => {
-    map1 !== null && map1 !== void 0 ? map1 : (map1 = {});
-    map2 !== null && map2 !== void 0 ? map2 : (map2 = {});
+    map1 ??= {};
+    map2 ??= {};
     if (map1 === map2) {
         return true;
     }

package/dist/collection/utils/input-shims/hacks/scroll-assist.js

@@ -94,7 +94,7 @@ export const enableScrollAssist = (componentEl, inputEl, contentEl, footerEl, ke
      */
     const focusOut = () => {
         hasKeyboardBeenPresentedForTextField = false;
-        win === null || win === void 0 ? void 0 : win.removeEventListener('ionKeyboardDidShow', keyboardShow);
+        win?.removeEventListener('ionKeyboardDidShow', keyboardShow);
         componentEl.removeEventListener('focusout', focusOut);
     };
     /**
@@ -114,13 +114,13 @@ export const enableScrollAssist = (componentEl, inputEl, contentEl, footerEl, ke
             return;
         }
         jsSetFocus(componentEl, inputEl, contentEl, footerEl, keyboardHeight, addScrollPadding, disableClonedInput, platformHeight);
-        win === null || win === void 0 ? void 0 : win.addEventListener('ionKeyboardDidShow', keyboardShow);
+        win?.addEventListener('ionKeyboardDidShow', keyboardShow);
         componentEl.addEventListener('focusout', focusOut);
     };
     componentEl.addEventListener('focusin', focusIn);
     return () => {
         componentEl.removeEventListener('focusin', focusIn);
-        win === null || win === void 0 ? void 0 : win.removeEventListener('ionKeyboardDidShow', keyboardShow);
+        win?.removeEventListener('ionKeyboardDidShow', keyboardShow);
         componentEl.removeEventListener('focusout', focusOut);
     };
 };
@@ -129,7 +129,6 @@ export const enableScrollAssist = (componentEl, inputEl, contentEl, footerEl, ke
  * focus an input but not have scroll assist run again.
  */
 const setManualFocus = (el) => {
-    var _a;
     /**
      * If element is already focused then
      * a new focusin event will not be dispatched
@@ -154,7 +153,7 @@ const setManualFocus = (el) => {
      */
     const inputId = el.getAttribute('id');
     const label = el.closest(`label[for="${inputId}"]`);
-    const activeElLabel = (_a = document.activeElement) === null || _a === void 0 ? void 0 : _a.closest(`label[for="${inputId}"]`);
+    const activeElLabel = document.activeElement?.closest(`label[for="${inputId}"]`);
     if (label !== null && label === activeElLabel) {
         // If the label is the same as the active element label, then
         // we don't need to set the `SKIP_SCROLL_ASSIST` and reset focus.

package/dist/collection/utils/input-shims/hacks/scroll-data.js

@@ -4,8 +4,7 @@
 import { SCROLL_AMOUNT_PADDING } from "./common";
 const SCROLL_ASSIST_SPEED = 0.3;
 export const getScrollData = (componentEl, contentEl, keyboardHeight, platformHeight) => {
-    var _a;
-    const itemEl = (_a = componentEl.closest('ion-item,[ion-item]')) !== null && _a !== void 0 ? _a : componentEl;
+    const itemEl = componentEl.closest('ion-item,[ion-item]') ?? componentEl;
     return calcScrollData(itemEl.getBoundingClientRect(), contentEl.getBoundingClientRect(), keyboardHeight, platformHeight);
 };
 const calcScrollData = (inputRect, contentRect, keyboardHeight, platformHeight) => {

package/dist/collection/utils/keyboard/keyboard-controller.js

@@ -26,7 +26,7 @@ const getResizeContainer = (resizeMode) => {
      * we can fall back to `body`.
      */
     const ionApp = doc.querySelector('ion-app');
-    return ionApp !== null && ionApp !== void 0 ? ionApp : doc.body;
+    return ionApp ?? doc.body;
 };
 /**
  * Get the height of ion-app or body.
@@ -74,8 +74,8 @@ export const createKeyboardController = async (keyboardChangeCallback) => {
             keyboardVisible = false;
             fireChangeCallback(keyboardVisible, resizeMode);
         };
-        win === null || win === void 0 ? void 0 : win.addEventListener('keyboardWillShow', keyboardWillShowHandler);
-        win === null || win === void 0 ? void 0 : win.addEventListener('keyboardWillHide', keyboardWillHideHandler);
+        win?.addEventListener('keyboardWillShow', keyboardWillShowHandler);
+        win?.addEventListener('keyboardWillHide', keyboardWillHideHandler);
     };
     const fireChangeCallback = (state, resizeMode) => {
         if (keyboardChangeCallback) {
@@ -152,8 +152,8 @@ export const createKeyboardController = async (keyboardChangeCallback) => {
         });
     };
     const destroy = () => {
-        win === null || win === void 0 ? void 0 : win.removeEventListener('keyboardWillShow', keyboardWillShowHandler);
-        win === null || win === void 0 ? void 0 : win.removeEventListener('keyboardWillHide', keyboardWillHideHandler);
+        win?.removeEventListener('keyboardWillShow', keyboardWillShowHandler);
+        win?.removeEventListener('keyboardWillHide', keyboardWillHideHandler);
         keyboardWillShowHandler = keyboardWillHideHandler = undefined;
     };
     const isKeyboardVisible = () => keyboardVisible;

package/dist/collection/utils/keyboard/keyboard.js

@@ -121,7 +121,7 @@ const fireKeyboardCloseEvent = (win) => {
  * layout viewport states
  */
 export const trackViewportChanges = (win) => {
-    previousVisualViewport = Object.assign({}, currentVisualViewport);
+    previousVisualViewport = { ...currentVisualViewport };
     currentVisualViewport = copyVisualViewport(win.visualViewport);
 };
 /**