@ionic/core 8.8.20-dev.11787158518.168a2fea → 8.8.20-dev.11788449221.155f9f1e

package/dist/collection/components/picker-column/picker-column.js

@@ -7,59 +7,415 @@ import { raf } from "../../utils/helpers";
 import { hapticSelectionChanged, hapticSelectionEnd, hapticSelectionStart } from "../../utils/native/haptic";
 import { isPlatform } from "../../utils/platform";
 import { createColorClasses } from "../../utils/theme";
-import { getIonMode } from "../../global/ionic-global";
+import { getIonTheme } from "../../global/ionic-global";
 /**
- * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
  *
  * @slot prefix - Content to show on the left side of the picker options.
  * @slot suffix - Content to show on the right side of the picker options.
  */
 export class PickerColumn {
-    scrollEl;
-    destroyScrollListener;
-    isScrolling = false;
-    scrollEndCallback;
-    isColumnVisible = false;
-    parentEl;
-    canExitInputMode = true;
-    assistiveFocusable;
-    updateValueTextOnScroll = false;
-    ariaLabel = null;
+    constructor() {
+        this.isScrolling = false;
+        this.isColumnVisible = false;
+        this.canExitInputMode = true;
+        this.updateValueTextOnScroll = false;
+        this.ariaLabel = null;
+        this.isActive = false;
+        /**
+         * If `true`, the user cannot interact with the picker.
+         */
+        this.disabled = false;
+        /**
+         * The color to use from your application's color palette.
+         * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
+         * For more information on colors, see [theming](/docs/theming/basics).
+         */
+        this.color = 'primary';
+        /**
+         * If `true`, tapping the picker will
+         * reveal a number input keyboard that lets
+         * the user type in values for each picker
+         * column. This is useful when working
+         * with time pickers.
+         *
+         * @internal
+         */
+        this.numericInput = false;
+        this.centerPickerItemInView = (target, smooth = true, canExitInputMode = true) => {
+            const { isColumnVisible, scrollEl } = this;
+            if (isColumnVisible && scrollEl) {
+                // (Vertical offset from parent) - (three empty picker rows) + (half the height of the target to ensure the scroll triggers)
+                const top = target.offsetTop - 3 * target.clientHeight + target.clientHeight / 2;
+                if (scrollEl.scrollTop !== top) {
+                    /**
+                     * Setting this flag prevents input
+                     * mode from exiting in the picker column's
+                     * scroll callback. This is useful when the user manually
+                     * taps an item or types on the keyboard as both
+                     * of these can cause a scroll to occur.
+                     */
+                    this.canExitInputMode = canExitInputMode;
+                    this.updateValueTextOnScroll = false;
+                    scrollEl.scroll({
+                        top,
+                        left: 0,
+                        behavior: smooth ? 'smooth' : undefined,
+                    });
+                }
+            }
+        };
+        this.setPickerItemActiveState = (item, isActive) => {
+            if (isActive) {
+                item.classList.add(PICKER_ITEM_ACTIVE_CLASS);
+            }
+            else {
+                item.classList.remove(PICKER_ITEM_ACTIVE_CLASS);
+            }
+        };
+        /**
+         * When ionInputModeChange is emitted, each column
+         * needs to check if it is the one being made available
+         * for text entry.
+         */
+        this.inputModeChange = (ev) => {
+            if (!this.numericInput) {
+                return;
+            }
+            const { useInputMode, inputModeColumn } = ev.detail;
+            /**
+             * If inputModeColumn is undefined then this means
+             * all numericInput columns are being selected.
+             */
+            const isColumnActive = inputModeColumn === undefined || inputModeColumn === this.el;
+            if (!useInputMode || !isColumnActive) {
+                this.setInputModeActive(false);
+                return;
+            }
+            this.setInputModeActive(true);
+        };
+        /**
+         * Setting isActive will cause a re-render.
+         * As a result, we do not want to cause the
+         * re-render mid scroll as this will cause
+         * the picker column to jump back to
+         * whatever value was selected at the
+         * start of the scroll interaction.
+         */
+        this.setInputModeActive = (state) => {
+            if (this.isScrolling) {
+                this.scrollEndCallback = () => {
+                    this.isActive = state;
+                };
+                return;
+            }
+            this.isActive = state;
+        };
+        /**
+         * When the column scrolls, the component
+         * needs to determine which item is centered
+         * in the view and will emit an ionChange with
+         * 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');
+            const { el, scrollEl } = this;
+            let timeout;
+            let activeEl = this.activeItem;
+            const scrollCallback = () => {
+                raf(() => {
+                    var _a;
+                    if (!scrollEl)
+                        return;
+                    if (timeout) {
+                        clearTimeout(timeout);
+                        timeout = undefined;
+                    }
+                    if (!this.isScrolling) {
+                        enableHaptics && hapticSelectionStart();
+                        this.isScrolling = true;
+                    }
+                    /**
+                     * Select item in the center of the column
+                     * which is the month/year that we want to select
+                     */
+                    const bbox = scrollEl.getBoundingClientRect();
+                    const centerX = bbox.x + bbox.width / 2;
+                    const centerY = bbox.y + bbox.height / 2;
+                    /**
+                     * elementFromPoint returns the top-most element.
+                     * This means that if an ion-backdrop is overlaying the
+                     * picker then the appropriate picker column option will
+                     * not be selected. To account for this, we use elementsFromPoint
+                     * and use an Array.find to find the appropriate column option
+                     * at that point.
+                     *
+                     * Additionally, the picker column could be used in the
+                     * Shadow DOM (i.e. in ion-datetime) so we need to make
+                     * sure we are choosing the correct host otherwise
+                     * the elements returns by elementsFromPoint will be
+                     * retargeted. To account for this, we check to see
+                     * if the picker column has a parent shadow root. If
+                     * so, we use that shadow root when doing elementsFromPoint.
+                     * Otherwise, we just use the document.
+                     */
+                    const rootNode = el.getRootNode();
+                    const hasParentShadow = rootNode instanceof ShadowRoot;
+                    const referenceNode = hasParentShadow ? rootNode : doc;
+                    /**
+                     * If the reference node is undefined
+                     * then it's likely that doc is undefined
+                     * due to being in an SSR environment.
+                     */
+                    if (referenceNode === undefined) {
+                        return;
+                    }
+                    const elementsAtPoint = referenceNode.elementsFromPoint(centerX, centerY);
+                    /**
+                     * elementsFromPoint can returns multiple elements
+                     * so find the relevant picker column option if one exists.
+                     */
+                    let newActiveElement = elementsAtPoint.find((el) => el.tagName === 'ION-PICKER-COLUMN-OPTION');
+                    /**
+                     * TODO(FW-6594): Remove this workaround when iOS 16 is no longer
+                     * supported.
+                     *
+                     * If `elementsFromPoint` failed to find the active element (a known
+                     * issue on iOS 16 when elements are in a Shadow DOM and the
+                     * referenceNode is the document), a fallback to `elementFromPoint`
+                     * is used. While `elementsFromPoint` returns all elements,
+                     * `elementFromPoint` returns only the top-most, which is sufficient
+                     * for this use case and appears to handle Shadow DOM retargeting
+                     * more reliably in this specific iOS bug.
+                     */
+                    if (newActiveElement === undefined) {
+                        const fallbackActiveElement = referenceNode.elementFromPoint(centerX, centerY);
+                        if ((fallbackActiveElement === null || fallbackActiveElement === void 0 ? void 0 : fallbackActiveElement.tagName) === 'ION-PICKER-COLUMN-OPTION') {
+                            newActiveElement = fallbackActiveElement;
+                        }
+                    }
+                    if (activeEl !== undefined) {
+                        this.setPickerItemActiveState(activeEl, false);
+                    }
+                    if (newActiveElement === undefined || newActiveElement.disabled) {
+                        return;
+                    }
+                    /**
+                     * If we are selecting a new value,
+                     * we need to run haptics again.
+                     */
+                    if (newActiveElement !== activeEl) {
+                        enableHaptics && hapticSelectionChanged();
+                        if (this.canExitInputMode) {
+                            /**
+                             * The native iOS wheel picker
+                             * only dismisses the keyboard
+                             * once the selected item has changed
+                             * as a result of a swipe
+                             * from the user. If `canExitInputMode` is
+                             * `false` then this means that the
+                             * scroll is happening as a result of
+                             * the `value` property programmatically changing
+                             * either by an application or by the user via the keyboard.
+                             */
+                            this.exitInputMode();
+                        }
+                    }
+                    activeEl = newActiveElement;
+                    this.setPickerItemActiveState(newActiveElement, true);
+                    /**
+                     * Set the aria-valuetext even though the value prop has not been updated yet.
+                     * This enables some screen readers to announce the value as the users drag
+                     * as opposed to when their release their pointer from the screen.
+                     *
+                     * When the value is programmatically updated, we will smoothly scroll
+                     * to the new option. However, we do not want to update aria-valuetext mid-scroll
+                     * as that can cause the old value to be briefly set before being set to the
+                     * correct option. This will cause some screen readers to announce the old value
+                     * again before announcing the new value. The correct valuetext will be set on render.
+                     */
+                    if (this.updateValueTextOnScroll) {
+                        (_a = this.assistiveFocusable) === null || _a === void 0 ? void 0 : _a.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);
+                });
+            };
+            /**
+             * Wrap this in an raf so that the scroll callback
+             * does not fire when component is initially shown.
+             */
+            raf(() => {
+                if (!scrollEl)
+                    return;
+                scrollEl.addEventListener('scroll', scrollCallback);
+                this.destroyScrollListener = () => {
+                    scrollEl.removeEventListener('scroll', scrollCallback);
+                };
+            });
+        };
+        /**
+         * Tells the parent picker to
+         * exit text entry mode. This is only called
+         * when the selected item changes during scroll, so
+         * we know that the user likely wants to scroll
+         * instead of type.
+         */
+        this.exitInputMode = () => {
+            const { parentEl } = this;
+            if (parentEl == null)
+                return;
+            parentEl.exitInputMode();
+            /**
+             * setInputModeActive only takes
+             * effect once scrolling stops to avoid
+             * a component re-render while scrolling.
+             * However, we want the visual active
+             * indicator to go away immediately, so
+             * we call classList.remove here.
+             */
+            this.el.classList.remove('picker-column-active');
+        };
+        /**
+         * Find the next enabled option after the active option.
+         * @param stride - How many options to "jump" over in order to select the next option.
+         * This can be used to implement PageUp/PageDown behaviors where pressing these keys
+         * scrolls the picker by more than 1 option. For example, a stride of 5 means select
+         * the enabled option 5 options after the active one. Note that the actual option selected
+         * may be past the stride if the option at the stride is disabled.
+         */
+        this.findNextOption = (stride = 1) => {
+            const { activeItem } = this;
+            if (!activeItem)
+                return null;
+            let prevNode = activeItem;
+            let node = activeItem.nextElementSibling;
+            while (node != null) {
+                if (stride > 0) {
+                    stride--;
+                }
+                if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
+                    return node;
+                }
+                prevNode = node;
+                // Use nextElementSibling instead of nextSibling to avoid text/comment nodes
+                node = node.nextElementSibling;
+            }
+            return prevNode;
+        };
+        /**
+         * Find the next enabled option after the active option.
+         * @param stride - How many options to "jump" over in order to select the next option.
+         * This can be used to implement PageUp/PageDown behaviors where pressing these keys
+         * scrolls the picker by more than 1 option. For example, a stride of 5 means select
+         * the enabled option 5 options before the active one. Note that the actual option selected
+         *  may be past the stride if the option at the stride is disabled.
+         */
+        this.findPreviousOption = (stride = 1) => {
+            const { activeItem } = this;
+            if (!activeItem)
+                return null;
+            let nextNode = activeItem;
+            let node = activeItem.previousElementSibling;
+            while (node != null) {
+                if (stride > 0) {
+                    stride--;
+                }
+                if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
+                    return node;
+                }
+                nextNode = node;
+                // Use previousElementSibling instead of previousSibling to avoid text/comment nodes
+                node = node.previousElementSibling;
+            }
+            return nextNode;
+        };
+        this.onKeyDown = (ev) => {
+            /**
+             * The below operations should be inverted when running on a mobile device.
+             * For example, swiping up will dispatch an "ArrowUp" event. On desktop,
+             * this should cause the previous option to be selected. On mobile, swiping
+             * up causes a view to scroll down. As a result, swiping up on mobile should
+             * cause the next option to be selected. The Home/End operations remain
+             * unchanged because those always represent the first/last options, respectively.
+             */
+            const mobile = isPlatform('mobile');
+            let newOption = null;
+            switch (ev.key) {
+                case 'ArrowDown':
+                    newOption = mobile ? this.findPreviousOption() : this.findNextOption();
+                    break;
+                case 'ArrowUp':
+                    newOption = mobile ? this.findNextOption() : this.findPreviousOption();
+                    break;
+                case 'PageUp':
+                    newOption = mobile ? this.findNextOption(5) : this.findPreviousOption(5);
+                    break;
+                case 'PageDown':
+                    newOption = mobile ? this.findPreviousOption(5) : this.findNextOption(5);
+                    break;
+                case 'Home':
+                    /**
+                     * There is no guarantee that the first child will be an ion-picker-column-option,
+                     * so we do not use firstElementChild.
+                     */
+                    newOption = this.el.querySelector('ion-picker-column-option:first-of-type');
+                    break;
+                case 'End':
+                    /**
+                     * There is no guarantee that the last child will be an ion-picker-column-option,
+                     * so we do not use lastElementChild.
+                     */
+                    newOption = this.el.querySelector('ion-picker-column-option:last-of-type');
+                    break;
+                default:
+                    break;
+            }
+            if (newOption !== null) {
+                this.setValue(newOption.value);
+                // This stops any default browser behavior such as scrolling
+                ev.preventDefault();
+            }
+        };
+        /**
+         * Utility to generate the correct text for aria-valuetext.
+         */
+        this.getOptionValueText = (el) => {
+            var _a;
+            return el ? (_a = el.getAttribute('aria-label')) !== null && _a !== void 0 ? _a : el.innerText : '';
+        };
+    }
     ariaLabelChanged(newValue) {
         this.ariaLabel = newValue;
     }
-    isActive = false;
-    el;
-    /**
-     * If `true`, the user cannot interact with the picker.
-     */
-    disabled = false;
-    /**
-     * The selected option in the picker.
-     */
-    value;
-    /**
-     * The color to use from your application's color palette.
-     * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
-     * For more information on colors, see [theming](/docs/theming/basics).
-     */
-    color;
-    /**
-     * If `true`, tapping the picker will
-     * reveal a number input keyboard that lets
-     * the user type in values for each picker
-     * column. This is useful when working
-     * with time pickers.
-     *
-     * @internal
-     */
-    numericInput = false;
-    /**
-     * Emitted when the value has changed.
-     *
-     * This event will not emit when programmatically setting the `value` property.
-     */
-    ionChange;
     valueChange() {
         if (this.isColumnVisible) {
             /**
@@ -176,268 +532,9 @@ export class PickerColumn {
         }
     }
     connectedCallback() {
-        this.ariaLabel = this.el.getAttribute('aria-label') ?? 'Select a value';
+        var _a;
+        this.ariaLabel = (_a = this.el.getAttribute('aria-label')) !== null && _a !== void 0 ? _a : 'Select a value';
     }
-    centerPickerItemInView = (target, smooth = true, canExitInputMode = true) => {
-        const { isColumnVisible, scrollEl } = this;
-        if (isColumnVisible && scrollEl) {
-            // (Vertical offset from parent) - (three empty picker rows) + (half the height of the target to ensure the scroll triggers)
-            const top = target.offsetTop - 3 * target.clientHeight + target.clientHeight / 2;
-            if (scrollEl.scrollTop !== top) {
-                /**
-                 * Setting this flag prevents input
-                 * mode from exiting in the picker column's
-                 * scroll callback. This is useful when the user manually
-                 * taps an item or types on the keyboard as both
-                 * of these can cause a scroll to occur.
-                 */
-                this.canExitInputMode = canExitInputMode;
-                this.updateValueTextOnScroll = false;
-                scrollEl.scroll({
-                    top,
-                    left: 0,
-                    behavior: smooth ? 'smooth' : undefined,
-                });
-            }
-        }
-    };
-    setPickerItemActiveState = (item, isActive) => {
-        if (isActive) {
-            item.classList.add(PICKER_ITEM_ACTIVE_CLASS);
-        }
-        else {
-            item.classList.remove(PICKER_ITEM_ACTIVE_CLASS);
-        }
-    };
-    /**
-     * When ionInputModeChange is emitted, each column
-     * needs to check if it is the one being made available
-     * for text entry.
-     */
-    inputModeChange = (ev) => {
-        if (!this.numericInput) {
-            return;
-        }
-        const { useInputMode, inputModeColumn } = ev.detail;
-        /**
-         * If inputModeColumn is undefined then this means
-         * all numericInput columns are being selected.
-         */
-        const isColumnActive = inputModeColumn === undefined || inputModeColumn === this.el;
-        if (!useInputMode || !isColumnActive) {
-            this.setInputModeActive(false);
-            return;
-        }
-        this.setInputModeActive(true);
-    };
-    /**
-     * Setting isActive will cause a re-render.
-     * As a result, we do not want to cause the
-     * re-render mid scroll as this will cause
-     * the picker column to jump back to
-     * whatever value was selected at the
-     * start of the scroll interaction.
-     */
-    setInputModeActive = (state) => {
-        if (this.isScrolling) {
-            this.scrollEndCallback = () => {
-                this.isActive = state;
-            };
-            return;
-        }
-        this.isActive = state;
-    };
-    /**
-     * When the column scrolls, the component
-     * needs to determine which item is centered
-     * in the view and will emit an ionChange with
-     * the item object.
-     */
-    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');
-        const { el, scrollEl } = this;
-        let timeout;
-        let activeEl = this.activeItem;
-        const scrollCallback = () => {
-            raf(() => {
-                if (!scrollEl)
-                    return;
-                if (timeout) {
-                    clearTimeout(timeout);
-                    timeout = undefined;
-                }
-                if (!this.isScrolling) {
-                    enableHaptics && hapticSelectionStart();
-                    this.isScrolling = true;
-                }
-                /**
-                 * Select item in the center of the column
-                 * which is the month/year that we want to select
-                 */
-                const bbox = scrollEl.getBoundingClientRect();
-                const centerX = bbox.x + bbox.width / 2;
-                const centerY = bbox.y + bbox.height / 2;
-                /**
-                 * elementFromPoint returns the top-most element.
-                 * This means that if an ion-backdrop is overlaying the
-                 * picker then the appropriate picker column option will
-                 * not be selected. To account for this, we use elementsFromPoint
-                 * and use an Array.find to find the appropriate column option
-                 * at that point.
-                 *
-                 * Additionally, the picker column could be used in the
-                 * Shadow DOM (i.e. in ion-datetime) so we need to make
-                 * sure we are choosing the correct host otherwise
-                 * the elements returns by elementsFromPoint will be
-                 * retargeted. To account for this, we check to see
-                 * if the picker column has a parent shadow root. If
-                 * so, we use that shadow root when doing elementsFromPoint.
-                 * Otherwise, we just use the document.
-                 */
-                const rootNode = el.getRootNode();
-                const hasParentShadow = rootNode instanceof ShadowRoot;
-                const referenceNode = hasParentShadow ? rootNode : doc;
-                /**
-                 * If the reference node is undefined
-                 * then it's likely that doc is undefined
-                 * due to being in an SSR environment.
-                 */
-                if (referenceNode === undefined) {
-                    return;
-                }
-                const elementsAtPoint = referenceNode.elementsFromPoint(centerX, centerY);
-                /**
-                 * elementsFromPoint can returns multiple elements
-                 * so find the relevant picker column option if one exists.
-                 */
-                let newActiveElement = elementsAtPoint.find((el) => el.tagName === 'ION-PICKER-COLUMN-OPTION');
-                /**
-                 * TODO(FW-6594): Remove this workaround when iOS 16 is no longer
-                 * supported.
-                 *
-                 * If `elementsFromPoint` failed to find the active element (a known
-                 * issue on iOS 16 when elements are in a Shadow DOM and the
-                 * referenceNode is the document), a fallback to `elementFromPoint`
-                 * is used. While `elementsFromPoint` returns all elements,
-                 * `elementFromPoint` returns only the top-most, which is sufficient
-                 * for this use case and appears to handle Shadow DOM retargeting
-                 * more reliably in this specific iOS bug.
-                 */
-                if (newActiveElement === undefined) {
-                    const fallbackActiveElement = referenceNode.elementFromPoint(centerX, centerY);
-                    if (fallbackActiveElement?.tagName === 'ION-PICKER-COLUMN-OPTION') {
-                        newActiveElement = fallbackActiveElement;
-                    }
-                }
-                if (activeEl !== undefined) {
-                    this.setPickerItemActiveState(activeEl, false);
-                }
-                if (newActiveElement === undefined || newActiveElement.disabled) {
-                    return;
-                }
-                /**
-                 * If we are selecting a new value,
-                 * we need to run haptics again.
-                 */
-                if (newActiveElement !== activeEl) {
-                    enableHaptics && hapticSelectionChanged();
-                    if (this.canExitInputMode) {
-                        /**
-                         * The native iOS wheel picker
-                         * only dismisses the keyboard
-                         * once the selected item has changed
-                         * as a result of a swipe
-                         * from the user. If `canExitInputMode` is
-                         * `false` then this means that the
-                         * scroll is happening as a result of
-                         * the `value` property programmatically changing
-                         * either by an application or by the user via the keyboard.
-                         */
-                        this.exitInputMode();
-                    }
-                }
-                activeEl = newActiveElement;
-                this.setPickerItemActiveState(newActiveElement, true);
-                /**
-                 * Set the aria-valuetext even though the value prop has not been updated yet.
-                 * This enables some screen readers to announce the value as the users drag
-                 * as opposed to when their release their pointer from the screen.
-                 *
-                 * When the value is programmatically updated, we will smoothly scroll
-                 * to the new option. However, we do not want to update aria-valuetext mid-scroll
-                 * as that can cause the old value to be briefly set before being set to the
-                 * correct option. This will cause some screen readers to announce the old value
-                 * again before announcing the new value. The correct valuetext will be set on render.
-                 */
-                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);
-            });
-        };
-        /**
-         * Wrap this in an raf so that the scroll callback
-         * does not fire when component is initially shown.
-         */
-        raf(() => {
-            if (!scrollEl)
-                return;
-            scrollEl.addEventListener('scroll', scrollCallback);
-            this.destroyScrollListener = () => {
-                scrollEl.removeEventListener('scroll', scrollCallback);
-            };
-        });
-    };
-    /**
-     * Tells the parent picker to
-     * exit text entry mode. This is only called
-     * when the selected item changes during scroll, so
-     * we know that the user likely wants to scroll
-     * instead of type.
-     */
-    exitInputMode = () => {
-        const { parentEl } = this;
-        if (parentEl == null)
-            return;
-        parentEl.exitInputMode();
-        /**
-         * setInputModeActive only takes
-         * effect once scrolling stops to avoid
-         * a component re-render while scrolling.
-         * However, we want the visual active
-         * indicator to go away immediately, so
-         * we call classList.remove here.
-         */
-        this.el.classList.remove('picker-column-active');
-    };
     get activeItem() {
         const { value } = this;
         const options = Array.from(this.el.querySelectorAll('ion-picker-column-option'));
@@ -452,124 +549,17 @@ export class PickerColumn {
             return option.value === value;
         });
     }
-    /**
-     * Find the next enabled option after the active option.
-     * @param stride - How many options to "jump" over in order to select the next option.
-     * This can be used to implement PageUp/PageDown behaviors where pressing these keys
-     * scrolls the picker by more than 1 option. For example, a stride of 5 means select
-     * the enabled option 5 options after the active one. Note that the actual option selected
-     * may be past the stride if the option at the stride is disabled.
-     */
-    findNextOption = (stride = 1) => {
-        const { activeItem } = this;
-        if (!activeItem)
-            return null;
-        let prevNode = activeItem;
-        let node = activeItem.nextElementSibling;
-        while (node != null) {
-            if (stride > 0) {
-                stride--;
-            }
-            if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
-                return node;
-            }
-            prevNode = node;
-            // Use nextElementSibling instead of nextSibling to avoid text/comment nodes
-            node = node.nextElementSibling;
-        }
-        return prevNode;
-    };
-    /**
-     * Find the next enabled option after the active option.
-     * @param stride - How many options to "jump" over in order to select the next option.
-     * This can be used to implement PageUp/PageDown behaviors where pressing these keys
-     * scrolls the picker by more than 1 option. For example, a stride of 5 means select
-     * the enabled option 5 options before the active one. Note that the actual option selected
-     *  may be past the stride if the option at the stride is disabled.
-     */
-    findPreviousOption = (stride = 1) => {
-        const { activeItem } = this;
-        if (!activeItem)
-            return null;
-        let nextNode = activeItem;
-        let node = activeItem.previousElementSibling;
-        while (node != null) {
-            if (stride > 0) {
-                stride--;
-            }
-            if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
-                return node;
-            }
-            nextNode = node;
-            // Use previousElementSibling instead of previousSibling to avoid text/comment nodes
-            node = node.previousElementSibling;
-        }
-        return nextNode;
-    };
-    onKeyDown = (ev) => {
-        /**
-         * The below operations should be inverted when running on a mobile device.
-         * For example, swiping up will dispatch an "ArrowUp" event. On desktop,
-         * this should cause the previous option to be selected. On mobile, swiping
-         * up causes a view to scroll down. As a result, swiping up on mobile should
-         * cause the next option to be selected. The Home/End operations remain
-         * unchanged because those always represent the first/last options, respectively.
-         */
-        const mobile = isPlatform('mobile');
-        let newOption = null;
-        switch (ev.key) {
-            case 'ArrowDown':
-                newOption = mobile ? this.findPreviousOption() : this.findNextOption();
-                break;
-            case 'ArrowUp':
-                newOption = mobile ? this.findNextOption() : this.findPreviousOption();
-                break;
-            case 'PageUp':
-                newOption = mobile ? this.findNextOption(5) : this.findPreviousOption(5);
-                break;
-            case 'PageDown':
-                newOption = mobile ? this.findPreviousOption(5) : this.findNextOption(5);
-                break;
-            case 'Home':
-                /**
-                 * There is no guarantee that the first child will be an ion-picker-column-option,
-                 * so we do not use firstElementChild.
-                 */
-                newOption = this.el.querySelector('ion-picker-column-option:first-of-type');
-                break;
-            case 'End':
-                /**
-                 * There is no guarantee that the last child will be an ion-picker-column-option,
-                 * so we do not use lastElementChild.
-                 */
-                newOption = this.el.querySelector('ion-picker-column-option:last-of-type');
-                break;
-            default:
-                break;
-        }
-        if (newOption !== null) {
-            this.setValue(newOption.value);
-            // This stops any default browser behavior such as scrolling
-            ev.preventDefault();
-        }
-    };
-    /**
-     * Utility to generate the correct text for aria-valuetext.
-     */
-    getOptionValueText = (el) => {
-        return el ? el.getAttribute('aria-label') ?? el.innerText : '';
-    };
     render() {
         const { color, disabled, isActive, numericInput } = this;
-        const mode = getIonMode(this);
-        return (h(Host, { key: '78b46ad10d88ea1bb43ca8c36748767912f03224', class: createColorClasses(color, {
-                [mode]: true,
+        const theme = getIonTheme(this);
+        return (h(Host, { key: 'f93a206d4f4b96bf4e574e5c920910ea22e1b447', class: createColorClasses(color, {
+                [theme]: true,
                 ['picker-column-active']: isActive,
                 ['picker-column-numeric-input']: numericInput,
                 ['picker-column-disabled']: disabled,
-            }) }, h("slot", { key: '761e501df77f7de896ffb3ebb99ebf88c5c3bf70', name: "prefix" }), h("div", { key: '9f4caaeef8ab704522a85f30876d371712f47c5c', class: "picker-opts", ref: (el) => {
+            }) }, h("slot", { key: 'c2954a494c50a907529dc71e6fb91092773ad8a6', name: "prefix" }), h("div", { key: '1957b8a3a3835980bb22ea3b46b2cb5e6bcc2432', 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) }, h("div", { key: '9d3533436aba6c61c93f65f84a077fba832194a0', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: '3f18d3a47361f06f55321b65fdf5742a61722b26', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'eac0d20ab8c533ef829875e323e93e1ee2067d6d', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("slot", { key: '92e25989ef41cf6f910c73238e1a0a5ac03f1c1f' }), h("div", { key: '33a84644ebdc84108b44a8e3a129b54e824939c8', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: '128ad61a3a68c7ff2d2e44a6e968424fcc608a15', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: '6e4d59a4f75befcbbf47279a263f28a69b12dbbd', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0")), h("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) }, h("div", { key: 'c7218ed79d73cef4de55b248d3a4808146e2eee4', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: '00d6c9dd149302d006a3a97b9ab61a5399196494', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'f47359409deae7f7d73c8a8a64bc23053efc20d9', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("slot", { key: '791172a636d85a1b49c140066ce867a4f6e8403d' }), h("div", { key: 'f442c5ab5d84acf7b41782fd2b3908ca68a4bd1e', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'b378ca562795326183353f35e328957ac592148c', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'f0c8e825cb890718389395b741aa1b7839dba1b1', class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0")), h("slot", { key: '6a11f3a2c46181d4b982a4d14170e71e3345973b', name: "suffix" })));
     }
     static get is() { return "ion-picker-column"; }
     static get encapsulation() { return "shadow"; }
@@ -648,7 +638,8 @@ export class PickerColumn {
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "color"
+                "attribute": "color",
+                "defaultValue": "'primary'"
             },
             "numericInput": {
                 "type": "boolean",