@ionic/core 9.0.1-dev.11788285010.17561004 → 9.0.1-dev.11788375537.1f38f077

package/hydrate/index.js

@@ -422,7 +422,7 @@ const appGlobalScript = initialize || (() => {});
 const globalScripts = appGlobalScript;
 
 /*
- Stencil Hydrate Platform v4.43.5 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Platform v4.44.1 | MIT Licensed | https://stenciljs.com
  */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -757,6 +757,8 @@ var DEFAULT_DOC_DATA = {
 };
 var SLOT_FB_CSS = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
+var MAX_LAZY_LOAD_RETRIES = 3;
+var LAZY_LOAD_RETRY_INTERVAL_MS = 1e3;
 
 // src/utils/style.ts
 function createStyleSheetIfNeededAndSupported(styles2) {
@@ -820,7 +822,7 @@ function getHostSlotNodes(childNodes, hostName, slotName) {
       slottedNodes.push(childNode);
       if (typeof slotName !== "undefined") return slottedNodes;
     }
-    slottedNodes = [...slottedNodes, ...getHostSlotNodes(childNode.childNodes, hostName, slotName)];
+    slottedNodes = [...slottedNodes, ...getHostSlotNodes(internalCall(childNode, "childNodes"), hostName, slotName)];
   }
   return slottedNodes;
 }
@@ -1064,6 +1066,11 @@ var h = (nodeName, vnodeData, ...children) => {
       } else if (child != null && typeof child !== "boolean") {
         if (simple = typeof nodeName !== "function" && !isComplexType(child)) {
           child = String(child);
+        } else if (typeof nodeName !== "function" && child.$flags$ === void 0) {
+          {
+            consoleError("Invalid vNode child");
+          }
+          continue;
         }
         if (simple && lastSimple) {
           vNodeChildren[vNodeChildren.length - 1].$text$ += child;
@@ -2299,7 +2306,7 @@ var setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRen
       }
     }
     if (newValue == null || newValue === false) {
-      if (newValue !== false || elm.getAttribute(memberName) === "") {
+      if (newValue !== false || elm.getAttribute(memberName) === "" || flags & 4 /* isHost */ && !isEnumeratedAttribute(memberName)) {
         if (xlink) {
           elm.removeAttributeNS(XLINK_NS, memberName);
         } else {
@@ -2316,6 +2323,8 @@ var setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRen
     }
   }
 };
+var ENUMERATED_ATTRIBUTES = /* @__PURE__ */ new Set(["draggable", "contenteditable", "spellcheck"]);
+var isEnumeratedAttribute = (attrName) => ENUMERATED_ATTRIBUTES.has(attrName) || attrName.startsWith("aria-");
 var parseClassListRegex = /\s/;
 var parseClassList = (value) => {
   if (typeof value === "object" && value && "baseVal" in value) {
@@ -2718,7 +2727,10 @@ var markSlotContentForRelocation = (elm) => {
       const slotName = childNode["s-sn"];
       for (j = hostContentNodes.length - 1; j >= 0; j--) {
         node = hostContentNodes[j];
-        if (!node["s-cn"] && !node["s-nr"] && node["s-hn"] !== childNode["s-hn"] && (!node["s-sh"] || node["s-sh"] !== childNode["s-hn"])) {
+        if (!node["s-cn"] && !node["s-nr"] && node["s-hn"] !== childNode["s-hn"] && // let an exact named-slot match override a stale default-slot claim. Skip this for
+        // `slotName === ''` itself - a matched default node's cached `s-sn` is `''` too, which
+        // would trivially "match" on every re-render and force pointless re-insertion.
+        (!node["s-sh"] || node["s-sh"] !== childNode["s-hn"] || slotName !== "" && getSlotName(node) === slotName)) {
           if (isNodeLocatedInSlot(node, slotName)) {
             let relocateNodeData = relocateNodes.find((r) => r.$nodeToRelocate$ === node);
             checkSlotFallbackVisibility = true;
@@ -2788,7 +2800,7 @@ var insertBefore = (parent, newNode, reference, isInitialLoad) => {
       return newNode;
     }
   }
-  if (parent.__insertBefore) {
+  if ((parent == null ? void 0 : parent.__insertBefore)) {
     return parent.__insertBefore(newNode, reference);
   } else {
     return parent == null ? void 0 : parent.insertBefore(newNode, reference);
@@ -3293,10 +3305,12 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
 
 // src/runtime/initialize-component.ts
 var initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
+  var _a2;
   let Cstr;
   try {
     if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) {
       hostRef.$flags$ |= 32 /* hasInitializedComponent */;
+      hostRef.$flags$ &= -1025 /* hasFailedLoad */;
       const bundleId = cmpMeta.$lazyBundleId$;
       if (bundleId) {
         const CstrImport = loadModule(cmpMeta);
@@ -3308,6 +3322,11 @@ var initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
           Cstr = CstrImport;
         }
         if (!Cstr) {
+          hostRef.$flags$ &= -33 /* hasInitializedComponent */;
+          hostRef.$loadRetryCount$ = ((_a2 = hostRef.$loadRetryCount$) != null ? _a2 : 0) + 1;
+          if (hostRef.$loadRetryCount$ < MAX_LAZY_LOAD_RETRIES) {
+            hostRef.$flags$ |= 1024 /* hasFailedLoad */;
+          }
           throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`);
         }
         if (!Cstr.isProxied) {
@@ -3387,7 +3406,7 @@ var initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
       hostRef.$onRenderResolve$();
       hostRef.$onRenderResolve$ = void 0;
     }
-    if (hostRef.$onReadyResolve$) {
+    if (hostRef.$onReadyResolve$ && !(hostRef.$flags$ & 1024 /* hasFailedLoad */)) {
       hostRef.$onReadyResolve$(elm);
     }
   }
@@ -3446,6 +3465,8 @@ var connectedCallback = (elm) => {
       addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);
       if (hostRef == null ? void 0 : hostRef.$lazyInstance$) {
         fireConnectedCallback(hostRef.$lazyInstance$, elm);
+      } else if (hostRef.$flags$ & 1024 /* hasFailedLoad */) {
+        setTimeout(() => initializeComponent(elm, hostRef, cmpMeta), LAZY_LOAD_RETRY_INTERVAL_MS);
       } else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
         hostRef.$onReadyPromise$.then(() => fireConnectedCallback(hostRef.$lazyInstance$, elm));
       }
@@ -17028,7 +17049,6 @@ class Datetime {
     }
     renderCombinedDatePickerColumn() {
         const { defaultParts, disabled, workingParts, locale, minParts, maxParts, todayParts, isDateEnabled } = this;
-        const activePart = this.getActivePartsWithFallback();
         /**
          * By default, generate a range of 3 months:
          * Previous month, current month, and next month
@@ -17084,8 +17104,10 @@ class Datetime {
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a date", class: "date-column", color: this.color, disabled: disabled, value: todayString, onIonChange: (ev) => {
                 const { value } = ev.detail;
                 const findPart = parts.find(({ month, day, year }) => value === `${year}-${month}-${day}`);
+                // Read live so parts a sibling column just committed are included.
+                const activePart = this.getActivePartsWithFallback();
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     ...findPart,
                 });
                 this.setActiveParts({
@@ -17162,11 +17184,12 @@ class Datetime {
             return [];
         }
         const { disabled, workingParts } = this;
-        const activePart = this.getActivePartsWithFallback();
         const pickerColumnValue = (workingParts.day !== null ? workingParts.day : this.defaultParts.day) ?? undefined;
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a day", class: "day-column", color: this.color, disabled: disabled, value: pickerColumnValue, onIonChange: (ev) => {
+                // Read live so parts a sibling column just committed are included.
+                const activePart = this.getActivePartsWithFallback();
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     day: ev.detail.value,
                 });
                 this.setActiveParts({
@@ -17181,10 +17204,11 @@ class Datetime {
             return [];
         }
         const { disabled, workingParts } = this;
-        const activePart = this.getActivePartsWithFallback();
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a month", class: "month-column", color: this.color, disabled: disabled, value: workingParts.month, onIonChange: (ev) => {
+                // Read live so parts a sibling column just committed are included.
+                const activePart = this.getActivePartsWithFallback();
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     month: ev.detail.value,
                 });
                 // Month wheel is navigation-only in multi-select mode as a fix for https://github.com/ionic-team/ionic-framework/issues/29673
@@ -17202,10 +17226,11 @@ class Datetime {
             return [];
         }
         const { disabled, workingParts } = this;
-        const activePart = this.getActivePartsWithFallback();
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a year", class: "year-column", color: this.color, disabled: disabled, value: workingParts.year, onIonChange: (ev) => {
+                // Read live so parts a sibling column just committed are included.
+                const activePart = this.getActivePartsWithFallback();
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     year: ev.detail.value,
                 });
                 // Year wheel is navigation-only in multi-select mode as a fix for https://github.com/ionic-team/ionic-framework/issues/29673
@@ -17241,13 +17266,14 @@ class Datetime {
         ];
     }
     renderHourPickerColumn(hoursData) {
-        const { disabled, workingParts } = this;
+        const { disabled } = this;
         if (hoursData.length === 0)
             return [];
         const activePart = this.getActivePartsWithFallback();
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select an hour", color: this.color, disabled: disabled, value: activePart.hour, numericInput: true, onIonChange: (ev) => {
+                // Read live so parts a sibling column just committed are included.
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     hour: ev.detail.value,
                 });
                 this.setActiveParts({
@@ -17258,13 +17284,14 @@ class Datetime {
             } }, hoursData.map((hour) => (hAsync("ion-picker-column-option", { color: this.color, part: hour.value === activePart.hour ? `${WHEEL_ITEM_PART} ${WHEEL_ITEM_ACTIVE_PART}` : WHEEL_ITEM_PART, key: hour.value, disabled: hour.disabled, value: hour.value }, hour.text)))));
     }
     renderMinutePickerColumn(minutesData) {
-        const { disabled, workingParts } = this;
+        const { disabled } = this;
         if (minutesData.length === 0)
             return [];
         const activePart = this.getActivePartsWithFallback();
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a minute", color: this.color, disabled: disabled, value: activePart.minute, numericInput: true, onIonChange: (ev) => {
+                // Read live so parts a sibling column just committed are included.
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...this.workingParts,
                     minute: ev.detail.value,
                 });
                 this.setActiveParts({
@@ -17275,16 +17302,18 @@ class Datetime {
             } }, minutesData.map((minute) => (hAsync("ion-picker-column-option", { color: this.color, part: minute.value === activePart.minute ? `${WHEEL_ITEM_PART} ${WHEEL_ITEM_ACTIVE_PART}` : WHEEL_ITEM_PART, key: minute.value, disabled: minute.disabled, value: minute.value }, minute.text)))));
     }
     renderDayPeriodPickerColumn(dayPeriodData) {
-        const { disabled, workingParts } = this;
+        const { disabled } = this;
         if (dayPeriodData.length === 0) {
             return [];
         }
         const activePart = this.getActivePartsWithFallback();
         const isDayPeriodRTL = isLocaleDayPeriodRTL(this.locale);
         return (hAsync("ion-picker-column", { part: WHEEL_PART, "aria-label": "Select a day period", style: isDayPeriodRTL ? { order: '-1' } : {}, color: this.color, disabled: disabled, value: activePart.ampm, onIonChange: (ev) => {
-                const hour = calculateHourFromAMPM(workingParts, ev.detail.value);
+                // Read live so parts a sibling column just committed are included.
+                const currentParts = this.workingParts;
+                const hour = calculateHourFromAMPM(currentParts, ev.detail.value);
                 this.setWorkingParts({
-                    ...workingParts,
+                    ...currentParts,
                     ampm: ev.detail.value,
                     hour,
                 });
@@ -17636,7 +17665,7 @@ class Datetime {
         const hasDatePresentation = presentation === 'date' || presentation === 'date-time' || presentation === 'time-date';
         const hasWheelVariant = hasDatePresentation && preferWheel;
         renderHiddenInput(true, el, name, formatValue(value), disabled);
-        return (hAsync(Host, { key: 'd8e6dfe5e3bffb1c38a3e37b63b3aec099f40d29', "aria-disabled": disabled ? 'true' : null, onFocus: this.onFocus, onBlur: this.onBlur, class: {
+        return (hAsync(Host, { key: '4e0b529a70924b065bcc6191e08550428b5a52a0', "aria-disabled": disabled ? 'true' : null, onFocus: this.onFocus, onBlur: this.onBlur, class: {
                 ...createColorClasses$1(color, {
                     [mode]: true,
                     ['datetime-readonly']: readonly,
@@ -17648,7 +17677,7 @@ class Datetime {
                     [`datetime-prefer-wheel`]: hasWheelVariant,
                     [`datetime-grid`]: isGridStyle,
                 }),
-            } }, hAsync("div", { key: '20889d3c68dd5109633c0e214411a63d6f3025bb', class: "intersection-tracker", ref: (el) => (this.intersectionTrackerRef = el) }), this.renderDatetime(mode)));
+            } }, hAsync("div", { key: 'cc9d1b92f960984cb0466d0003a240ace67da243', class: "intersection-tracker", ref: (el) => (this.intersectionTrackerRef = el) }), this.renderDatetime(mode)));
     }
     get el() { return getElement(this); }
     static get watchers() { return {
@@ -22330,19 +22359,17 @@ class ItemSliding {
         }
     }
     async updateOptions() {
-        const options = this.el.querySelectorAll('ion-item-options');
+        const options = Array.from(this.el.querySelectorAll('ion-item-options'));
+        /**
+         * Frameworks that assign element props after inserting the element haven't set
+         * `side` while `connectedCallback` runs, so reading it any earlier reports every
+         * option as `end`.
+         */
+        await Promise.all(options.map((option) => new Promise((resolve) => componentOnReady(option, resolve))));
         let sides = 0;
         // Reset left and right options in case they were removed
         this.leftOptions = this.rightOptions = undefined;
-        for (let i = 0; i < options.length; i++) {
-            const item = options.item(i);
-            /**
-             * We cannot use the componentOnReady helper
-             * util here since we need to wait for all of these items
-             * to be ready before we set `this.sides` and `this.optsDirty`.
-             */
-            // eslint-disable-next-line custom-rules/no-component-on-ready-method
-            const option = item.componentOnReady !== undefined ? await item.componentOnReady() : item;
+        for (const option of options) {
             const side = isEndSide(option.side ?? option.getAttribute('side')) ? 'end' : 'start';
             if (side === 'start') {
                 this.leftOptions = option;
@@ -22541,7 +22568,7 @@ class ItemSliding {
     }
     render() {
         const mode = getIonMode$1(this);
-        return (hAsync(Host, { key: '15f6a98f8c888e86c29827cdf55d98ace08699dd', class: {
+        return (hAsync(Host, { key: '02174ca963753d3a51a4249068f3d436f8acb03d', class: {
                 [mode]: true,
                 'item-sliding-active-slide': this.state !== 2 /* SlidingState.Disabled */,
                 'item-sliding-active-options-end': (this.state & 8 /* SlidingState.End */) !== 0,
@@ -29259,6 +29286,12 @@ class PickerColumn {
         this.isColumnVisible = false;
         this.canExitInputMode = true;
         this.updateValueTextOnScroll = false;
+        this.isUserScroll = false;
+        /**
+         * The haptics for the wheel picker are an iOS-only feature. As a result,
+         * they should be disabled on Android.
+         */
+        this.enableHaptics = false;
         this.ariaLabel = null;
         this.isActive = false;
         /**
@@ -29290,6 +29323,12 @@ class PickerColumn {
                      */
                     this.canExitInputMode = canExitInputMode;
                     this.updateValueTextOnScroll = false;
+                    /**
+                     * This scroll takes over from whatever the user was doing, so an outside
+                     * press must not commit an option the column is only passing through.
+                     */
+                    this.isUserScroll = false;
+                    this.stopWatchingForOutsidePress();
                     scrollEl.scroll({
                         top,
                         left: 0,
@@ -29344,6 +29383,117 @@ class PickerColumn {
             }
             this.isActive = state;
         };
+        this.clearScrollEndTimeout = () => {
+            if (this.scrollEndTimeout) {
+                clearTimeout(this.scrollEndTimeout);
+                this.scrollEndTimeout = undefined;
+            }
+        };
+        /**
+         * Resets the idle timer that commits the centered option.
+         */
+        this.resetScrollEndTimeout = () => {
+            this.clearScrollEndTimeout();
+            this.scrollEndTimeout = setTimeout(this.settle, SCROLL_END_DELAY);
+        };
+        /**
+         * Capture so the column still commits if an application's own pointerdown
+         * handler stops the event before it reaches the document.
+         */
+        this.watchForOutsidePress = () => {
+            doc?.addEventListener('pointerdown', this.onPointerDownOutside, { capture: true });
+        };
+        this.stopWatchingForOutsidePress = () => {
+            doc?.removeEventListener('pointerdown', this.onPointerDownOutside, { capture: true });
+        };
+        /**
+         * Resets everything the current scroll interaction is holding, so nothing
+         * pending on it can commit later.
+         */
+        this.discardScroll = () => {
+            this.stopWatchingForOutsidePress();
+            this.clearScrollEndTimeout();
+            this.scrollEndCallback = undefined;
+            this.centeredOption = undefined;
+            this.haltedAtScrollTop = undefined;
+            this.isScrolling = false;
+            this.isUserScroll = false;
+            this.canExitInputMode = true;
+        };
+        /**
+         * Commits the option that is currently centered under the highlight and ends
+         * the scroll interaction.
+         */
+        this.settle = () => {
+            const { centeredOption } = this;
+            this.clearScrollEndTimeout();
+            this.stopWatchingForOutsidePress();
+            this.isUserScroll = false;
+            this.isScrolling = false;
+            this.updateValueTextOnScroll = true;
+            this.enableHaptics && hapticSelectionEnd();
+            /**
+             * Certain tasks (such as those that
+             * cause re-renders) should only be done
+             * once scrolling has finished, otherwise
+             * flickering may occur.
+             */
+            const { scrollEndCallback } = this;
+            if (scrollEndCallback) {
+                scrollEndCallback();
+                this.scrollEndCallback = undefined;
+            }
+            /**
+             * Reset this flag as the
+             * next scroll interaction could
+             * be a scroll from the user. In this
+             * case, we should exit input mode.
+             */
+            this.canExitInputMode = true;
+            if (centeredOption !== undefined) {
+                // Cleared here so a later scroll that centers nothing cannot fall back on it.
+                this.centeredOption = undefined;
+                if (centeredOption.isConnected) {
+                    this.setValue(centeredOption.value);
+                }
+            }
+        };
+        /**
+         * Commits the option the user can see when they press anything outside of the
+         * column during a scroll they started. This runs on pointerdown rather than
+         * click so the value is up to date by the time an application's own click
+         * handler (a Save button, for example) reads it.
+         */
+        this.onPointerDownOutside = (ev) => {
+            const { centeredOption, parentEl, scrollEl } = this;
+            if (!this.isScrolling) {
+                return;
+            }
+            /**
+             * The column can live in another component's Shadow DOM, where a document
+             * listener sees the target retargeted to the outer host. The composed path
+             * is the only reliable way to tell a press on the column apart.
+             */
+            const path = ev.composedPath();
+            /**
+             * A press anywhere in the parent picker counts as inside, so reaching for a
+             * sibling wheel leaves this column coasting.
+             */
+            if (path.includes(this.el) || (parentEl != null && path.includes(parentEl))) {
+                return;
+            }
+            /**
+             * Landing on the centered option halts the in-flight momentum scroll, so the
+             * committed value and the option the user is left looking at agree. The
+             * option list can be replaced mid-scroll, and a detached option has no
+             * offset to center on.
+             */
+            if (centeredOption !== undefined && centeredOption.isConnected) {
+                this.centerPickerItemInView(centeredOption, false, false);
+                this.haltedAtScrollTop = scrollEl?.scrollTop;
+            }
+            this.settle();
+        };
         /**
          * When the column scrolls, the component
          * needs to determine which item is centered
@@ -29351,27 +29501,42 @@ class PickerColumn {
          * the item object.
          */
         this.initializeScrollListener = () => {
-            /**
-             * The haptics for the wheel picker are
-             * an iOS-only feature. As a result, they should
-             * be disabled on Android.
-             */
-            const enableHaptics = isPlatform('ios');
+            this.enableHaptics = isPlatform('ios');
             const { el, scrollEl } = this;
-            let timeout;
             let activeEl = this.activeItem;
             const scrollCallback = () => {
                 raf(() => {
-                    if (!scrollEl)
+                    /**
+                     * This frame cannot be cancelled, and moving the column disconnects it
+                     * without the observer reporting a change, so this checks live state.
+                     */
+                    if (!this.el.isConnected || !this.isColumnVisible || !scrollEl)
                         return;
-                    if (timeout) {
-                        clearTimeout(timeout);
-                        timeout = undefined;
+                    const { haltedAtScrollTop } = this;
+                    if (haltedAtScrollTop !== undefined) {
+                        /**
+                         * Still at the halted position, so this frame is the halt landing
+                         * rather than the wheel moving, and re-arming would start a second
+                         * commit cycle.
+                         */
+                        if (Math.abs(scrollEl.scrollTop - haltedAtScrollTop) <= HALT_TOLERANCE)
+                            return;
+                        this.haltedAtScrollTop = undefined;
                     }
+                    // Armed before the early returns below, so a scroll never ends uncommitted.
+                    this.resetScrollEndTimeout();
                     if (!this.isScrolling) {
-                        enableHaptics && hapticSelectionStart();
+                        this.enableHaptics && hapticSelectionStart();
                         this.isScrolling = true;
                     }
+                    /**
+                     * Only a user-driven scroll holds an uncommitted selection. Checked every
+                     * frame because the user can take hold of the wheel mid-scroll, and
+                     * re-adding the same listener is a no-op.
+                     */
+                    if (this.isUserScroll) {
+                        this.watchForOutsidePress();
+                    }
                     /**
                      * Select item in the center of the column
                      * which is the month/year that we want to select
@@ -29431,18 +29596,23 @@ class PickerColumn {
                             newActiveElement = fallbackActiveElement;
                         }
                     }
-                    if (activeEl !== undefined) {
-                        this.setPickerItemActiveState(activeEl, false);
-                    }
+                    /**
+                     * A scroll can land with no selectable option centered, such as an
+                     * overscroll bounce briefly centering the empty padding rows. Keep the
+                     * current selection until an option is centered again.
+                     */
                     if (newActiveElement === undefined || newActiveElement.disabled) {
                         return;
                     }
+                    if (activeEl !== undefined) {
+                        this.setPickerItemActiveState(activeEl, false);
+                    }
                     /**
                      * If we are selecting a new value,
                      * we need to run haptics again.
                      */
                     if (newActiveElement !== activeEl) {
-                        enableHaptics && hapticSelectionChanged();
+                        this.enableHaptics && hapticSelectionChanged();
                         if (this.canExitInputMode) {
                             /**
                              * The native iOS wheel picker
@@ -29474,32 +29644,14 @@ class PickerColumn {
                     if (this.updateValueTextOnScroll) {
                         this.assistiveFocusable?.setAttribute('aria-valuetext', this.getOptionValueText(newActiveElement));
                     }
-                    timeout = setTimeout(() => {
-                        this.isScrolling = false;
-                        this.updateValueTextOnScroll = true;
-                        enableHaptics && hapticSelectionEnd();
-                        /**
-                         * Certain tasks (such as those that
-                         * cause re-renders) should only be done
-                         * once scrolling has finished, otherwise
-                         * flickering may occur.
-                         */
-                        const { scrollEndCallback } = this;
-                        if (scrollEndCallback) {
-                            scrollEndCallback();
-                            this.scrollEndCallback = undefined;
-                        }
-                        /**
-                         * Reset this flag as the
-                         * next scroll interaction could
-                         * be a scroll from the user. In this
-                         * case, we should exit input mode.
-                         */
-                        this.canExitInputMode = true;
-                        this.setValue(newActiveElement.value);
-                    }, 250);
+                    this.centeredOption = newActiveElement;
                 });
             };
+            const userScrollCallback = () => {
+                this.isUserScroll = true;
+                // Taking hold of the wheel ends the halt even if it has not moved yet.
+                this.haltedAtScrollTop = undefined;
+            };
             /**
              * Wrap this in an raf so that the scroll callback
              * does not fire when component is initially shown.
@@ -29508,8 +29660,19 @@ class PickerColumn {
                 if (!scrollEl)
                     return;
                 scrollEl.addEventListener('scroll', scrollCallback);
+                scrollEl.addEventListener('pointerdown', userScrollCallback);
+                scrollEl.addEventListener('wheel', userScrollCallback, { passive: true });
+                /**
+                 * A `pointerdown` fires once per touch, so a drag that pauses long enough
+                 * to commit would look like a scroll the column started. A `touchmove`
+                 * keeps arriving while the finger moves.
+                 */
+                scrollEl.addEventListener('touchmove', userScrollCallback, { passive: true });
                 this.destroyScrollListener = () => {
                     scrollEl.removeEventListener('scroll', scrollCallback);
+                    scrollEl.removeEventListener('pointerdown', userScrollCallback);
+                    scrollEl.removeEventListener('wheel', userScrollCallback);
+                    scrollEl.removeEventListener('touchmove', userScrollCallback);
                 };
             });
         };
@@ -29692,6 +29855,14 @@ class PickerColumn {
             }
             else {
                 this.isColumnVisible = false;
+                /**
+                 * The pending timer still runs so it resets the scroll state, but the
+                 * option it would have committed is dropped. A column the user cannot
+                 * see should not change its value.
+                 */
+                this.stopWatchingForOutsidePress();
+                this.centeredOption = undefined;
+                this.haltedAtScrollTop = undefined;
                 if (this.destroyScrollListener) {
                     this.destroyScrollListener();
                     this.destroyScrollListener = undefined;
@@ -29762,6 +29933,13 @@ class PickerColumn {
     connectedCallback() {
         this.ariaLabel = this.el.getAttribute('aria-label') ?? 'Select a value';
     }
+    disconnectedCallback() {
+        /**
+         * A pending settle would otherwise commit a value on a column that is no
+         * longer in the DOM.
+         */
+        this.discardScroll();
+    }
     get activeItem() {
         const { value } = this;
         const options = Array.from(this.el.querySelectorAll('ion-picker-column-option'));
@@ -29779,14 +29957,14 @@ class PickerColumn {
     render() {
         const { color, disabled, isActive, numericInput } = this;
         const mode = getIonMode$1(this);
-        return (hAsync(Host, { key: '78b46ad10d88ea1bb43ca8c36748767912f03224', class: createColorClasses$1(color, {
+        return (hAsync(Host, { key: '60a893619d0b01fba53fbccef67a10d533a22657', class: createColorClasses$1(color, {
                 [mode]: true,
                 ['picker-column-active']: isActive,
                 ['picker-column-numeric-input']: numericInput,
                 ['picker-column-disabled']: disabled,
-            }) }, hAsync("slot", { key: '761e501df77f7de896ffb3ebb99ebf88c5c3bf70', name: "prefix" }), hAsync("div", { key: '9f4caaeef8ab704522a85f30876d371712f47c5c', class: "picker-opts", ref: (el) => {
+            }) }, hAsync("slot", { key: '79f1e047f89c5ec916ed02efaac56ef3f73b8969', name: "prefix" }), hAsync("div", { key: 'c45c86e88353a196ff38159f40f390bc27852c9e', class: "picker-opts", ref: (el) => {
                 this.scrollEl = el;
-            }, role: "slider", tabindex: this.disabled ? undefined : 0, "aria-label": this.ariaLabel, "aria-valuemin": 0, "aria-valuemax": 0, "aria-valuenow": 0, "aria-valuetext": this.getOptionValueText(this.activeItem), "aria-orientation": "vertical", onKeyDown: (ev) => this.onKeyDown(ev) }, hAsync("div", { key: '9d3533436aba6c61c93f65f84a077fba832194a0', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: '3f18d3a47361f06f55321b65fdf5742a61722b26', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: 'eac0d20ab8c533ef829875e323e93e1ee2067d6d', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("slot", { key: '92e25989ef41cf6f910c73238e1a0a5ac03f1c1f' }), hAsync("div", { key: '33a84644ebdc84108b44a8e3a129b54e824939c8', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: '128ad61a3a68c7ff2d2e44a6e968424fcc608a15', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: '6e4d59a4f75befcbbf47279a263f28a69b12dbbd', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0")), hAsync("slot", { key: '3c6621b64438792a3024c90e3d9916a0a3614506', name: "suffix" })));
+            }, role: "slider", tabindex: this.disabled ? undefined : 0, "aria-label": this.ariaLabel, "aria-valuemin": 0, "aria-valuemax": 0, "aria-valuenow": 0, "aria-valuetext": this.getOptionValueText(this.activeItem), "aria-orientation": "vertical", onKeyDown: (ev) => this.onKeyDown(ev) }, hAsync("div", { key: 'e02d76752f5d3dd4cd2846fbc28645f1508a4b49', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: 'd577bcbadc530970b2781692b050811633625c5a', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: 'c89e78c3a896bc1f55b922d01df16fdbb1259bdd', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("slot", { key: '6c597ff899692597432ee2aa0b42de53b86deed4' }), hAsync("div", { key: '91686ed94f14c47647836ed4d63e54b5c54ee3b9', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: '2ff058c6d0e8cef4e143c2d848f9a52684579af1', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), hAsync("div", { key: 'bc7386bec6fced36e44084a7a137b3fe6506c996', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0")), hAsync("slot", { key: '8835fd3f4e025bce964e6f05984c9aaadc20d7fb', name: "suffix" })));
     }
     get el() { return getElement(this); }
     static get watchers() { return {
@@ -29818,6 +29996,19 @@ class PickerColumn {
     }; }
 }
 const PICKER_ITEM_ACTIVE_CLASS = 'option-active';
+/**
+ * How long the column must be idle before the centered option is treated as
+ * the user's selection. Replaceable by the `scrollend` event once that is
+ * supported everywhere (https://caniuse.com/?search=scrollend).
+ */
+const SCROLL_END_DELAY = 250;
+/**
+ * How far, in pixels, the column may report from where it was halted and still
+ * count as having stayed there. Centering targets a position between two snap
+ * points, so mandatory snapping corrects it by half the column height less
+ * three option heights: 2px at the default sizes.
+ */
+const HALT_TOLERANCE = 2;
 
 const pickerColumnOptionIosCss = () => `.picker-column-option-button{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;width:100%;height:34px;border:0px;outline:none;background:transparent;color:inherit;font-family:var(--ion-font-family, inherit);font-size:inherit;line-height:34px;text-align:inherit;text-overflow:ellipsis;white-space:nowrap;cursor:pointer;overflow:hidden}:host(.option-disabled){opacity:0.4}:host(.option-disabled) .picker-column-option-button{cursor:default}`;
 
@@ -37275,11 +37466,6 @@ class SegmentButton {
             addEventListener$1(segmentEl, 'ionSelect', this.updateState);
             addEventListener$1(segmentEl, 'ionStyle', this.updateStyle);
         }
-        // Prevent buttons from being disabled when associated with segment content
-        if (this.contentId && this.disabled) {
-            printIonWarning(`[ion-segment-button] - Segment buttons cannot be disabled when associated with an <ion-segment-content>.`);
-            this.disabled = false;
-        }
     }
     disconnectedCallback() {
         const segmentEl = this.segmentEl;
@@ -37296,6 +37482,15 @@ class SegmentButton {
         // Return if there is no contentId defined
         if (!this.contentId)
             return;
+        /**
+         * Checked here rather than in `connectedCallback` so frameworks that assign element
+         * props after inserting the element have set `disabled` by now. A disabled ion-segment
+         * pushes that onto its buttons too, which this guard should not undo.
+         */
+        if (this.disabled && this.segmentEl?.disabled !== true) {
+            printIonWarning(`[ion-segment-button] - Segment buttons cannot be disabled when associated with an <ion-segment-content>.`);
+            this.disabled = false;
+        }
         // Attempt to find the Segment Content by its contentId
         const segmentContent = document.getElementById(this.contentId);
         // If no associated Segment Content exists, log an error and return
@@ -37330,7 +37525,7 @@ class SegmentButton {
         const { checked, type, disabled, hasIcon, hasLabel, layout, segmentEl } = this;
         const mode = getIonMode$1(this);
         const hasSegmentColor = () => segmentEl?.color !== undefined;
-        return (hAsync(Host, { key: '2b4b7ad8b981d2ee39aba5b9c734de8a5bd045ba', class: {
+        return (hAsync(Host, { key: 'd8acc71d87e26b32f20b2d0f9a6acc9f0dab0dee', class: {
                 [mode]: true,
                 'in-toolbar': hostContext('ion-toolbar', this.el),
                 'in-toolbar-color': hostContext('ion-toolbar[color]', this.el),
@@ -37346,7 +37541,7 @@ class SegmentButton {
                 'ion-activatable': true,
                 'ion-activatable-instant': true,
                 'ion-focusable': true,
-            } }, hAsync("button", { key: '9cc58cfbe70844a0f5e1a307002e0d04e044be99', "aria-selected": checked ? 'true' : 'false', role: "tab", ref: (el) => (this.nativeEl = el), type: type, class: "button-native", part: "native", disabled: disabled, ...this.inheritedAttributes }, hAsync("span", { key: '6443551951ce589efdb2d0e1fd1a14e35b82ed19', class: "button-inner" }, hAsync("slot", { key: 'c3548b469ae6e5477d8372cb28bc70dff3a24d18' })), mode === 'md' && hAsync("ion-ripple-effect", { key: 'fb176415ca1702766c4d7a5964ec0bb467bdcb55' })), hAsync("div", { key: 'aa22b4752f8336d0e232a1e0894e87023b284a08', part: "indicator", class: "segment-button-indicator segment-button-indicator-animated" }, hAsync("div", { key: '61e29ea52048fa0583fce6c20c81614a4d0199cb', part: "indicator-background", class: "segment-button-indicator-background" }))));
+            } }, hAsync("button", { key: 'ce65da07b1a012bce353b3c6c24eecfbd4071d54', "aria-selected": checked ? 'true' : 'false', role: "tab", ref: (el) => (this.nativeEl = el), type: type, class: "button-native", part: "native", disabled: disabled, ...this.inheritedAttributes }, hAsync("span", { key: '6c4b4dcd20e407e5dc31674bea23633d8a09187a', class: "button-inner" }, hAsync("slot", { key: '817145ae77a3c5ada88ab95723d881f1bde96b2a' })), mode === 'md' && hAsync("ion-ripple-effect", { key: '054d7e5e2a13013914fac6bbde8efdb28d9b459e' })), hAsync("div", { key: 'c48074881a302510ad4752eeb9383222cd3a54cb', part: "indicator", class: "segment-button-indicator segment-button-indicator-animated" }, hAsync("div", { key: '7672a6b10ee18ad026b798fbd8207dc3cd5683f9', part: "indicator-background", class: "segment-button-indicator-background" }))));
     }
     get el() { return getElement(this); }
     static get watchers() { return {
@@ -38390,7 +38585,7 @@ class Select {
         const hasOutlineFill = mode === 'md' && fill === 'outline';
         renderHiddenInput(true, el, name, parseValue(value), disabled);
         const labelShouldFloat = labelPlacement === 'stacked' || (labelPlacement === 'floating' && (hasValue || hasFocus || isExpanded));
-        return (hAsync(Host, { key: '5d1e5bf46d0f204efdcb55cc42cfde52e6db304b', onClick: this.onClick, class: createColorClasses$1(this.color, {
+        return (hAsync(Host, { key: 'b2f161e3706e139e61440cd13e162714b1b75d72', onClick: this.onClick, class: createColorClasses$1(this.color, {
                 [mode]: true,
                 'in-item': inItem,
                 'in-item-color': hostContext('ion-item.ion-color', el),
@@ -38408,7 +38603,7 @@ class Select {
                 [`select-justify-${justify}`]: justifyEnabled,
                 [`select-shape-${shape}`]: shape !== undefined,
                 [`select-label-placement-${labelPlacement}`]: true,
-            }) }, hAsync("label", { key: '15fd1f8e06510ae8472c621cf8cf90e51172e0be', class: "select-wrapper", id: "select-label", onClick: this.onLabelClick, part: "wrapper" }, hasOutlineFill && this.renderOutlineContainer(), hAsync("div", { key: '7964e3d9351671899793b117896acdda25ec24c4', class: "select-start", part: "start", ref: (el) => (this.startContainerEl = el) }, hAsync("slot", { key: 'aa309ef155c4025acfd7ed5739b5221c85097b36', name: "start" })), hAsync("div", { key: '23d5a9dfea64a9d81b0b36d9426b15bed98901b9', class: "select-control", part: "control" }, this.renderLabel(), hAsync("div", { key: '810da9fbfa8771e09b5fb768d64e5f04858b5833', class: "native-wrapper", ref: (el) => (this.nativeWrapperEl = el), part: "container" }, this.renderSelectText(), this.renderListbox(), !hasFloatingOrStackedLabel && this.renderSelectIcon())), hAsync("div", { key: 'bf1c04704326ecfa14cf2e49bb76d3fb45beb08d', class: "select-end", part: "end" }, hasFloatingOrStackedLabel && this.renderSelectIcon(), hAsync("slot", { key: '76a8bcaeefdcaa908aebd820d93171b08165cee3', name: "end" })), shouldRenderHighlight && hAsync("div", { key: '55a9c417a82323a44e16328fd62a634d9d7c558b', class: "select-highlight" })), this.renderBottomContent()));
+            }) }, hAsync("label", { key: '944a2eb468154a21260d181fdaf67828a71eb902', class: "select-wrapper", id: "select-label", onClick: this.onLabelClick, part: "wrapper" }, hasOutlineFill && this.renderOutlineContainer(), hAsync("div", { key: '927200c53548b1bb4f52d6a167605b724a7b7d0d', class: "select-start", part: "start", ref: (el) => (this.startContainerEl = el) }, hAsync("slot", { key: '6e14b95e9b95c116b16744d630600e90977782bc', name: "start" })), hAsync("div", { key: '8451ed4300ac005963075be36a04ea8763bc0fdd', class: "select-control", part: "control" }, this.renderLabel(), hAsync("div", { key: '207e7b63f3224a4870579365ac992da6784fb31f', class: "native-wrapper", ref: (el) => (this.nativeWrapperEl = el), part: "container" }, this.renderSelectText(), this.renderListbox(), !hasFloatingOrStackedLabel && this.renderSelectIcon())), hAsync("div", { key: '5c17367d488db4d570f31b25e33560efa9011500', class: "select-end", part: "end" }, hasFloatingOrStackedLabel && this.renderSelectIcon(), hAsync("slot", { key: '21fd8c0d9bee8cffef9ef6984cacd31e8f38211c', name: "end" })), shouldRenderHighlight && hAsync("div", { key: '1fff767db9a1ec07b274ef65ff7ae8fb976e6ad2', class: "select-highlight" })), this.renderBottomContent()));
     }
     get el() { return getElement(this); }
     static get watchers() { return {
@@ -38517,29 +38712,14 @@ const textForValue = (opts, value, compareWith, useHTML = false) => {
         return getOptionContent(selectOpt, undefined, true);
     }
     /**
-     * When custom HTML is enabled, extract only the default slot content.
-     * This ensures aria-label and other text-only contexts read only
-     * the relevant option text.
+     * Every text-only context reads only the default slot, so the start
+     * and end slots stay out of the `aria-label` and the overlay labels.
+     * Both config paths derive that text through the same helper, so they
+     * cannot disagree about what an option's text is. `null` marks an
+     * option with no text, which is dropped from the joined text of a
+     * `multiple` select rather than joined in as an empty entry.
      */
-    if (customHTMLEnabled) {
-        const content = getOptionContent(selectOpt);
-        if (typeof content === 'string') {
-            return content;
-        }
-        /**
-         * Elements were found in the default slot, extract and concatenate
-         * their text content while trimming whitespace.
-         */
-        if (content) {
-            const texts = Array.from(content.childNodes)
-                .map((n) => n.textContent?.trim())
-                .filter((t) => t);
-            return texts.join(' ') || null;
-        }
-        // Empty option
-        return null;
-    }
-    return getDefaultSlotPlainText(selectOpt);
+    return getDefaultSlotPlainText(selectOpt) || null;
 };
 /**
  * Trims whitespace from all text nodes within a DOM tree.
@@ -38595,9 +38775,13 @@ const getOptionContent = (option, slotName, useHTML = false) => {
     if (nodes.length === 0) {
         return null;
     }
-    // Return plain text if no elements are found
+    /**
+     * Return plain text if no elements are found. This reads the option the
+     * same way the non-custom-HTML path does, so the two do not disagree
+     * about what an option's text is.
+     */
     if (!slotName && nodes.every((n) => n.nodeType === Node.TEXT_NODE)) {
-        return nodes.map((n) => n.textContent?.trim()).join(' ') || null;
+        return getDefaultSlotPlainText(option) || null;
     }
     /**
      * Mirror known custom-element properties (e.g. ion-icon's `icon`)
@@ -38653,22 +38837,43 @@ const getOptionDefaultSlot = (option) => {
     }
     return defaultSlotNodes;
 };
+/**
+ * Concatenates the text a node renders, skipping the subtrees of tags
+ * whose contents the browser never paints (`script`, `style`, and the
+ * rest of `blockedTags`). `textContent` includes those, so reading it
+ * directly would put stylesheet or script source into the select text
+ * and the `aria-label`.
+ *
+ * @param node - The node to read text from.
+ * @returns The node's rendered text.
+ */
+const getRenderedTextContent = (node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+        return node.textContent ?? '';
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+        return '';
+    }
+    if (blockedTags.includes(node.tagName.toLowerCase())) {
+        return '';
+    }
+    return Array.from(node.childNodes)
+        .map((child) => getRenderedTextContent(child))
+        .join('');
+};
 /**
  * Extracts plain text from only the default slot of an option,
- * excluding content assigned to named slots (start/end).
+ * excluding content assigned to named slots (start/end). Text is
+ * concatenated with no separator and collapsible whitespace is
+ * collapsed, approximating how the browser renders the option.
+ * NBSP is not collapsible, so it is preserved.
+ *
+ * @param option - The `ion-select-option` element to read text from.
+ * @returns The option's default slot text.
  */
 const getDefaultSlotPlainText = (option) => {
-    const texts = Array.from(option.childNodes)
-        .filter((node) => {
-        if (node.nodeType === Node.ELEMENT_NODE) {
-            return !node.hasAttribute('slot');
-        }
-        return node.nodeType === Node.TEXT_NODE;
-    })
-        .filter((node) => node.nodeType === Node.TEXT_NODE)
-        .map((n) => n.textContent?.trim())
-        .filter((t) => t);
-    return texts.join(' ');
+    const text = (getOptionDefaultSlot(option) ?? []).map((node) => getRenderedTextContent(node)).join('');
+    return text.replace(/[ \t\n\r\f]+/g, ' ').replace(/^[ \t\n\r\f]+|[ \t\n\r\f]+$/g, '');
 };
 /**
  * Extracts the rich content from an `ion-select-option`.
@@ -42744,7 +42949,7 @@ var NAMESPACE = (
 );
 
 /*
- Stencil Hydrate Runner v4.43.5 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Runner v4.44.1 | MIT Licensed | https://stenciljs.com
  */
 var __create = Object.create;
 var __defProp = Object.defineProperty;