@ionic/core 7.6.2-dev.11703182244.1165aeec → 7.6.2-dev.11704390532.1202188d

package/components/picker-column.js

@@ -2,366 +2,395 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
-import { m as clamp } from './helpers.js';
-import { b as hapticSelectionChanged, h as hapticSelectionEnd, a as hapticSelectionStart } from './haptic.js';
-import { g as getClassMap } from './theme.js';
-import { b as getIonMode } from './ionic-global.js';
+import { d as doc } from './index5.js';
+import { r as raf, g as getElementRoot } from './helpers.js';
+import { a as hapticSelectionStart, b as hapticSelectionChanged, h as hapticSelectionEnd } from './haptic.js';
+import { a as isPlatform, b as getIonMode } from './ionic-global.js';
+import { c as createColorClasses } from './theme.js';
 
-const pickerColumnIosCss = ".picker-col{display:-ms-flexbox;display:flex;position:relative;-ms-flex:1;flex:1;-ms-flex-pack:center;justify-content:center;height:100%;-webkit-box-sizing:content-box;box-sizing:content-box;contain:content}.picker-opts{position:relative;-ms-flex:1;flex:1;max-width:100%}.picker-opt{top:0;display:block;position:absolute;width:100%;border:0;text-align:center;text-overflow:ellipsis;white-space:nowrap;contain:strict;overflow:hidden;will-change:transform}@supports (inset-inline-start: 0){.picker-opt{inset-inline-start:0}}@supports not (inset-inline-start: 0){.picker-opt{left:0}:host-context([dir=rtl]) .picker-opt{left:unset;right:unset;right:0}[dir=rtl] .picker-opt{left:unset;right:unset;right:0}@supports selector(:dir(rtl)){.picker-opt:dir(rtl){left:unset;right:unset;right:0}}}.picker-opt.picker-opt-disabled{pointer-events:none}.picker-opt-disabled{opacity:0}.picker-opts-left{-ms-flex-pack:start;justify-content:flex-start}.picker-opts-right{-ms-flex-pack:end;justify-content:flex-end}.picker-opt:active,.picker-opt:focus{outline:none}.picker-prefix{position:relative;-ms-flex:1;flex:1;text-align:end;white-space:nowrap}.picker-suffix{position:relative;-ms-flex:1;flex:1;text-align:start;white-space:nowrap}.picker-col{-webkit-padding-start:4px;padding-inline-start:4px;-webkit-padding-end:4px;padding-inline-end:4px;padding-top:0;padding-bottom:0;-webkit-transform-style:preserve-3d;transform-style:preserve-3d}.picker-prefix,.picker-suffix,.picker-opts{top:77px;-webkit-transform-style:preserve-3d;transform-style:preserve-3d;color:inherit;font-size:20px;line-height:42px;pointer-events:none}.picker-opt{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;-webkit-transform-origin:center center;transform-origin:center center;height:46px;-webkit-transform-style:preserve-3d;transform-style:preserve-3d;-webkit-transition-timing-function:ease-out;transition-timing-function:ease-out;background:transparent;color:inherit;font-size:20px;line-height:42px;-webkit-backface-visibility:hidden;backface-visibility:hidden;pointer-events:auto}:host-context([dir=rtl]) .picker-opt{-webkit-transform-origin:calc(100% - center) center;transform-origin:calc(100% - center) center}[dir=rtl] .picker-opt{-webkit-transform-origin:calc(100% - center) center;transform-origin:calc(100% - center) center}@supports selector(:dir(rtl)){.picker-opt:dir(rtl){-webkit-transform-origin:calc(100% - center) center;transform-origin:calc(100% - center) center}}";
+const pickerColumnCss = ":host{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center;max-width:100%;height:200px;font-size:22px;text-align:center}.picker-opts{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0px;padding-bottom:0px;min-width:26px;max-height:200px;outline:none;text-align:inherit;-webkit-scroll-snap-type:y mandatory;-ms-scroll-snap-type:y mandatory;scroll-snap-type:y mandatory;overflow-x:hidden;overflow-y:scroll;scrollbar-width:none}.picker-item-empty{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;display:block;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;overflow:hidden}.picker-opts::-webkit-scrollbar{display:none}::slotted(ion-picker-column-option){display:block;scroll-snap-align:center}.picker-item-empty,:host(:not([disabled])) ::slotted(ion-picker-column-option.option-disabled){scroll-snap-align:none}::slotted([slot=prefix]),::slotted([slot=suffix]){max-width:200px;text-overflow:ellipsis;white-space:nowrap;overflow:hidden}::slotted([slot=prefix]){-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0;padding-bottom:0;-ms-flex-pack:end;justify-content:end}::slotted([slot=suffix]){-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0;padding-bottom:0;-ms-flex-pack:start;justify-content:start}:host(.picker-column-disabled) .picker-opts{overflow-y:hidden}:host(.picker-column-disabled) ::slotted(ion-picker-column-option){cursor:default;opacity:0.4;pointer-events:none}@media (any-hover: hover){:host(:focus) .picker-opts{outline:none;background:rgba(var(--ion-color-base-rgb), 0.2)}}";
 
-const pickerColumnMdCss = ".picker-col{display:-ms-flexbox;display:flex;position:relative;-ms-flex:1;flex:1;-ms-flex-pack:center;justify-content:center;height:100%;-webkit-box-sizing:content-box;box-sizing:content-box;contain:content}.picker-opts{position:relative;-ms-flex:1;flex:1;max-width:100%}.picker-opt{top:0;display:block;position:absolute;width:100%;border:0;text-align:center;text-overflow:ellipsis;white-space:nowrap;contain:strict;overflow:hidden;will-change:transform}@supports (inset-inline-start: 0){.picker-opt{inset-inline-start:0}}@supports not (inset-inline-start: 0){.picker-opt{left:0}:host-context([dir=rtl]) .picker-opt{left:unset;right:unset;right:0}[dir=rtl] .picker-opt{left:unset;right:unset;right:0}@supports selector(:dir(rtl)){.picker-opt:dir(rtl){left:unset;right:unset;right:0}}}.picker-opt.picker-opt-disabled{pointer-events:none}.picker-opt-disabled{opacity:0}.picker-opts-left{-ms-flex-pack:start;justify-content:flex-start}.picker-opts-right{-ms-flex-pack:end;justify-content:flex-end}.picker-opt:active,.picker-opt:focus{outline:none}.picker-prefix{position:relative;-ms-flex:1;flex:1;text-align:end;white-space:nowrap}.picker-suffix{position:relative;-ms-flex:1;flex:1;text-align:start;white-space:nowrap}.picker-col{-webkit-padding-start:8px;padding-inline-start:8px;-webkit-padding-end:8px;padding-inline-end:8px;padding-top:0;padding-bottom:0;-webkit-transform-style:preserve-3d;transform-style:preserve-3d}.picker-prefix,.picker-suffix,.picker-opts{top:77px;-webkit-transform-style:preserve-3d;transform-style:preserve-3d;color:inherit;font-size:22px;line-height:42px;pointer-events:none}.picker-opt{margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;height:43px;-webkit-transition-timing-function:ease-out;transition-timing-function:ease-out;background:transparent;color:inherit;font-size:22px;line-height:42px;-webkit-backface-visibility:hidden;backface-visibility:hidden;pointer-events:auto}.picker-prefix,.picker-suffix,.picker-opt.picker-opt-selected{color:var(--ion-color-primary, #3880ff)}";
-
-const PickerColumnCmp = /*@__PURE__*/ proxyCustomElement(class PickerColumnCmp extends HTMLElement {
+const PickerColumn = /*@__PURE__*/ proxyCustomElement(class PickerColumn extends HTMLElement {
     constructor() {
         super();
         this.__registerHost();
-        this.ionPickerColChange = createEvent(this, "ionPickerColChange", 7);
-        this.optHeight = 0;
-        this.rotateFactor = 0;
-        this.scaleFactor = 1;
-        this.velocity = 0;
-        this.y = 0;
-        this.noAnimate = true;
-        // `colDidChange` is a flag that gets set when the column is changed
-        // dynamically. When this flag is set, the column will refresh
-        // after the component re-renders to incorporate the new column data.
-        // This is necessary because `this.refresh` queries for the option elements,
-        // so it needs to wait for the latest elements to be available in the DOM.
-        // Ex: column is created with 3 options. User updates the column data
-        // to have 5 options. The column will still think it only has 3 options.
-        this.colDidChange = false;
-        this.col = undefined;
-    }
-    colChanged() {
-        this.colDidChange = true;
-    }
-    async connectedCallback() {
-        let pickerRotateFactor = 0;
-        let pickerScaleFactor = 0.81;
-        const mode = getIonMode(this);
-        if (mode === 'ios') {
-            pickerRotateFactor = -0.46;
-            pickerScaleFactor = 1;
-        }
-        this.rotateFactor = pickerRotateFactor;
-        this.scaleFactor = pickerScaleFactor;
-        this.gesture = (await import('./index3.js')).createGesture({
-            el: this.el,
-            gestureName: 'picker-swipe',
-            gesturePriority: 100,
-            threshold: 0,
-            passive: false,
-            onStart: (ev) => this.onStart(ev),
-            onMove: (ev) => this.onMove(ev),
-            onEnd: (ev) => this.onEnd(ev),
-        });
-        this.gesture.enable();
-        // Options have not been initialized yet
-        // Animation must be disabled through the `noAnimate` flag
-        // Otherwise, the options will render
-        // at the top of the column and transition down
-        this.tmrId = setTimeout(() => {
-            this.noAnimate = false;
-            // After initialization, `refresh()` will be called
-            // At this point, animation will be enabled. The options will
-            // animate as they are being selected.
-            this.refresh(true);
-        }, 250);
-    }
-    componentDidLoad() {
-        this.onDomChange();
-    }
-    componentDidUpdate() {
-        // Options may have changed since last update.
-        if (this.colDidChange) {
-            // Animation must be disabled through the `onDomChange` parameter.
-            // Otherwise, the recently added options will render
-            // at the top of the column and transition down
-            this.onDomChange(true, false);
-            this.colDidChange = false;
-        }
-    }
-    disconnectedCallback() {
-        if (this.rafId !== undefined)
-            cancelAnimationFrame(this.rafId);
-        if (this.tmrId)
-            clearTimeout(this.tmrId);
-        if (this.gesture) {
-            this.gesture.destroy();
-            this.gesture = undefined;
-        }
-    }
-    emitColChange() {
-        this.ionPickerColChange.emit(this.col);
-    }
-    setSelected(selectedIndex, duration) {
-        // if there is a selected index, then figure out it's y position
-        // if there isn't a selected index, then just use the top y position
-        const y = selectedIndex > -1 ? -(selectedIndex * this.optHeight) : 0;
-        this.velocity = 0;
-        // set what y position we're at
-        if (this.rafId !== undefined)
-            cancelAnimationFrame(this.rafId);
-        this.update(y, duration, true);
-        this.emitColChange();
-    }
-    update(y, duration, saveY) {
-        if (!this.optsEl) {
-            return;
-        }
-        // ensure we've got a good round number :)
-        let translateY = 0;
-        let translateZ = 0;
-        const { col, rotateFactor } = this;
-        const prevSelected = col.selectedIndex;
-        const selectedIndex = (col.selectedIndex = this.indexForY(-y));
-        const durationStr = duration === 0 ? '' : duration + 'ms';
-        const scaleStr = `scale(${this.scaleFactor})`;
-        const children = this.optsEl.children;
-        for (let i = 0; i < children.length; i++) {
-            const button = children[i];
-            const opt = col.options[i];
-            const optOffset = i * this.optHeight + y;
-            let transform = '';
-            if (rotateFactor !== 0) {
-                const rotateX = optOffset * rotateFactor;
-                if (Math.abs(rotateX) <= 90) {
-                    translateY = 0;
-                    translateZ = 90;
-                    transform = `rotateX(${rotateX}deg) `;
-                }
-                else {
-                    translateY = -9999;
+        this.__attachShadow();
+        this.ionChange = createEvent(this, "ionChange", 7);
+        this.isScrolling = false;
+        this.isColumnVisible = false;
+        this.canExitInputMode = true;
+        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;
+                    scrollEl.scroll({
+                        top,
+                        left: 0,
+                        behavior: smooth ? 'smooth' : undefined,
+                    });
                 }
             }
-            else {
-                translateZ = 0;
-                translateY = optOffset;
-            }
-            const selected = selectedIndex === i;
-            transform += `translate3d(0px,${translateY}px,${translateZ}px) `;
-            if (this.scaleFactor !== 1 && !selected) {
-                transform += scaleStr;
+        };
+        this.setPickerItemActiveState = (item, isActive) => {
+            if (isActive) {
+                item.classList.add(PICKER_ITEM_ACTIVE_CLASS);
             }
-            // Update transition duration
-            if (this.noAnimate) {
-                opt.duration = 0;
-                button.style.transitionDuration = '';
-            }
-            else if (duration !== opt.duration) {
-                opt.duration = duration;
-                button.style.transitionDuration = durationStr;
+            else {
+                item.classList.remove(PICKER_ITEM_ACTIVE_CLASS);
             }
-            // Update transform
-            if (transform !== opt.transform) {
-                opt.transform = transform;
+        };
+        /**
+         * 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;
             }
-            button.style.transform = transform;
+            const { useInputMode, inputModeColumn } = ev.detail;
             /**
-             * Ensure that the select column
-             * item has the selected class
+             * If inputModeColumn is undefined then this means
+             * all numericInput columns are being selected.
              */
-            opt.selected = selected;
-            if (selected) {
-                button.classList.add(PICKER_OPT_SELECTED);
+            const isColumnActive = inputModeColumn === undefined || inputModeColumn === this.el;
+            if (!useInputMode || !isColumnActive) {
+                this.setInputModeActive(false);
+                return;
             }
-            else {
-                button.classList.remove(PICKER_OPT_SELECTED);
+            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.col.prevSelected = prevSelected;
-        if (saveY) {
-            this.y = y;
-        }
-        if (this.lastIndex !== selectedIndex) {
-            // have not set a last index yet
-            hapticSelectionChanged();
-            this.lastIndex = selectedIndex;
+            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(() => {
+                    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.
+                     */
+                    const newActiveElement = elementsAtPoint.find((el) => el.tagName === 'ION-PICKER-COLUMN-OPTION');
+                    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);
+                    timeout = setTimeout(() => {
+                        this.isScrolling = false;
+                        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');
+        };
+        this.isActive = false;
+        this.disabled = false;
+        this.value = undefined;
+        this.color = 'primary';
+        this.numericInput = false;
+    }
+    valueChange() {
+        if (this.isColumnVisible) {
+            /**
+             * Only scroll the active item into view when the picker column
+             * is actively visible to the user.
+             */
+            this.scrollActiveItemIntoView(true);
         }
     }
-    decelerate() {
-        if (this.velocity !== 0) {
-            // still decelerating
-            this.velocity *= DECELERATION_FRICTION;
-            // do not let it go slower than a velocity of 1
-            this.velocity = this.velocity > 0 ? Math.max(this.velocity, 1) : Math.min(this.velocity, -1);
-            let y = this.y + this.velocity;
-            if (y > this.minY) {
-                // whoops, it's trying to scroll up farther than the options we have!
-                y = this.minY;
-                this.velocity = 0;
-            }
-            else if (y < this.maxY) {
-                // gahh, it's trying to scroll down farther than we can!
-                y = this.maxY;
-                this.velocity = 0;
-            }
-            this.update(y, 0, true);
-            const notLockedIn = Math.round(y) % this.optHeight !== 0 || Math.abs(this.velocity) > 1;
-            if (notLockedIn) {
-                // isn't locked in yet, keep decelerating until it is
-                this.rafId = requestAnimationFrame(() => this.decelerate());
+    /**
+     * Only setup scroll listeners
+     * when the picker is visible, otherwise
+     * the container will have a scroll
+     * height of 0px.
+     */
+    componentWillLoad() {
+        const visibleCallback = (entries) => {
+            const ev = entries[0];
+            if (ev.isIntersecting) {
+                const { activeItem, el } = this;
+                this.isColumnVisible = true;
+                /**
+                 * Because this initial call to scrollActiveItemIntoView has to fire before
+                 * the scroll listener is set up, we need to manage the active class manually.
+                 */
+                const oldActive = getElementRoot(el).querySelector(`.${PICKER_ITEM_ACTIVE_CLASS}`);
+                if (oldActive) {
+                    this.setPickerItemActiveState(oldActive, false);
+                }
+                this.scrollActiveItemIntoView();
+                if (activeItem) {
+                    this.setPickerItemActiveState(activeItem, true);
+                }
+                this.initializeScrollListener();
             }
             else {
-                this.velocity = 0;
-                this.emitColChange();
-                hapticSelectionEnd();
+                this.isColumnVisible = false;
+                if (this.destroyScrollListener) {
+                    this.destroyScrollListener();
+                    this.destroyScrollListener = undefined;
+                }
             }
-        }
-        else if (this.y % this.optHeight !== 0) {
-            // needs to still get locked into a position so options line up
-            const currentPos = Math.abs(this.y % this.optHeight);
-            // create a velocity in the direction it needs to scroll
-            this.velocity = currentPos > this.optHeight / 2 ? 1 : -1;
-            this.decelerate();
+        };
+        new IntersectionObserver(visibleCallback, { threshold: 0.001 }).observe(this.el);
+        const parentEl = (this.parentEl = this.el.closest('ion-picker'));
+        if (parentEl !== null) {
+            // TODO(FW-2832): type
+            parentEl.addEventListener('ionInputModeChange', (ev) => this.inputModeChange(ev));
         }
     }
-    indexForY(y) {
-        return Math.min(Math.max(Math.abs(Math.round(y / this.optHeight)), 0), this.col.options.length - 1);
-    }
-    onStart(detail) {
-        // We have to prevent default in order to block scrolling under the picker
-        // but we DO NOT have to stop propagation, since we still want
-        // some "click" events to capture
-        if (detail.event.cancelable) {
-            detail.event.preventDefault();
-        }
-        detail.event.stopPropagation();
-        hapticSelectionStart();
-        // reset everything
-        if (this.rafId !== undefined)
-            cancelAnimationFrame(this.rafId);
-        const options = this.col.options;
-        let minY = options.length - 1;
-        let maxY = 0;
-        for (let i = 0; i < options.length; i++) {
-            if (!options[i].disabled) {
-                minY = Math.min(minY, i);
-                maxY = Math.max(maxY, i);
+    componentDidRender() {
+        const { el, activeItem, isColumnVisible, value } = this;
+        if (isColumnVisible && !activeItem) {
+            const firstOption = el.querySelector('ion-picker-column-option');
+            /**
+             * If the picker column does not have an active item and the current value
+             * does not match the first item in the picker column, that means
+             * the value is out of bounds. In this case, we assign the value to the
+             * first item to match the scroll position of the column.
+             *
+             */
+            if (firstOption !== null && firstOption.value !== value) {
+                this.setValue(firstOption.value);
             }
         }
-        this.minY = -(minY * this.optHeight);
-        this.maxY = -(maxY * this.optHeight);
     }
-    onMove(detail) {
-        if (detail.event.cancelable) {
-            detail.event.preventDefault();
-        }
-        detail.event.stopPropagation();
-        // update the scroll position relative to pointer start position
-        let y = this.y + detail.deltaY;
-        if (y > this.minY) {
-            // scrolling up higher than scroll area
-            y = Math.pow(y, 0.8);
-            this.bounceFrom = y;
+    /** @internal  */
+    async scrollActiveItemIntoView(smooth = false) {
+        const activeEl = this.activeItem;
+        if (activeEl) {
+            this.centerPickerItemInView(activeEl, smooth, false);
         }
-        else if (y < this.maxY) {
-            // scrolling down below scroll area
-            y += Math.pow(this.maxY - y, 0.9);
-            this.bounceFrom = y;
-        }
-        else {
-            this.bounceFrom = 0;
-        }
-        this.update(y, 0, false);
     }
-    onEnd(detail) {
-        if (this.bounceFrom > 0) {
-            // bounce back up
-            this.update(this.minY, 100, true);
-            this.emitColChange();
-            return;
-        }
-        else if (this.bounceFrom < 0) {
-            // bounce back down
-            this.update(this.maxY, 100, true);
-            this.emitColChange();
+    /**
+     * Sets the value prop and fires the ionChange event.
+     * This is used when we need to fire ionChange from
+     * user-generated events that cannot be caught with normal
+     * input/change event listeners.
+     * @internal
+     */
+    async setValue(value) {
+        if (this.disabled === true || this.value === value) {
             return;
         }
-        this.velocity = clamp(-MAX_PICKER_SPEED, detail.velocityY * 23, MAX_PICKER_SPEED);
-        if (this.velocity === 0 && detail.deltaY === 0) {
-            const opt = detail.event.target.closest('.picker-opt');
-            if (opt === null || opt === void 0 ? void 0 : opt.hasAttribute('opt-index')) {
-                this.setSelected(parseInt(opt.getAttribute('opt-index'), 10), TRANSITION_DURATION);
-            }
-        }
-        else {
-            this.y += detail.deltaY;
-            if (Math.abs(detail.velocityY) < 0.05) {
-                const isScrollingUp = detail.deltaY > 0;
-                const optHeightFraction = (Math.abs(this.y) % this.optHeight) / this.optHeight;
-                if (isScrollingUp && optHeightFraction > 0.5) {
-                    this.velocity = Math.abs(this.velocity) * -1;
-                }
-                else if (!isScrollingUp && optHeightFraction <= 0.5) {
-                    this.velocity = Math.abs(this.velocity);
-                }
-            }
-            this.decelerate();
-        }
+        this.value = value;
+        this.ionChange.emit({ value });
     }
-    refresh(forceRefresh, animated) {
-        var _a;
-        let min = this.col.options.length - 1;
-        let max = 0;
-        const options = this.col.options;
-        for (let i = 0; i < options.length; i++) {
-            if (!options[i].disabled) {
-                min = Math.min(min, i);
-                max = Math.max(max, i);
-            }
-        }
-        /**
-         * Only update selected value if column has a
-         * velocity of 0. If it does not, then the
-         * column is animating might land on
-         * a value different than the value at
-         * selectedIndex
-         */
-        if (this.velocity !== 0) {
-            return;
-        }
-        const selectedIndex = clamp(min, (_a = this.col.selectedIndex) !== null && _a !== void 0 ? _a : 0, max);
-        if (this.col.prevSelected !== selectedIndex || forceRefresh) {
-            const y = selectedIndex * this.optHeight * -1;
-            const duration = animated ? TRANSITION_DURATION : 0;
-            this.velocity = 0;
-            this.update(y, duration, true);
+    /**
+     * Sets focus on the scrollable container within the picker column.
+     * Use this method instead of the global `pickerColumn.focus()`.
+     */
+    async setFocus() {
+        if (this.scrollEl) {
+            this.scrollEl.focus();
         }
     }
-    onDomChange(forceRefresh, animated) {
-        const colEl = this.optsEl;
-        if (colEl) {
-            // DOM READ
-            // We perfom a DOM read over a rendered item, this needs to happen after the first render or after the the column has changed
-            this.optHeight = colEl.firstElementChild ? colEl.firstElementChild.clientHeight : 0;
-        }
-        this.refresh(forceRefresh, animated);
+    get activeItem() {
+        const { value } = this;
+        const options = Array.from(this.el.querySelectorAll('ion-picker-column-option'));
+        return options.find((option) => {
+            /**
+             * If the whole picker column is disabled, the current value should appear active
+             * If the current value item is specifically disabled, it should not appear active
+             */
+            if (!this.disabled && option.disabled) {
+                return false;
+            }
+            return option.value === value;
+        });
     }
     render() {
-        const col = this.col;
+        const { color, disabled, isActive, numericInput } = this;
         const mode = getIonMode(this);
-        return (h(Host, { class: Object.assign({ [mode]: true, 'picker-col': true, 'picker-opts-left': this.col.align === 'left', 'picker-opts-right': this.col.align === 'right' }, getClassMap(col.cssClass)), style: {
-                'max-width': this.col.columnWidth,
-            } }, col.prefix && (h("div", { class: "picker-prefix", style: { width: col.prefixWidth } }, col.prefix)), h("div", { class: "picker-opts", style: { maxWidth: col.optionsWidth }, ref: (el) => (this.optsEl = el) }, col.options.map((o, index) => (h("button", { "aria-label": o.ariaLabel, class: { 'picker-opt': true, 'picker-opt-disabled': !!o.disabled }, "opt-index": index }, o.text)))), col.suffix && (h("div", { class: "picker-suffix", style: { width: col.suffixWidth } }, col.suffix))));
+        return (h(Host, { class: createColorClasses(color, {
+                [mode]: true,
+                ['picker-column-active']: isActive,
+                ['picker-column-numeric-input']: numericInput,
+                ['picker-column-disabled']: disabled,
+            }) }, h("slot", { name: "prefix" }), h("div", { class: "picker-opts", tabindex: disabled ? undefined : 0, ref: (el) => {
+                this.scrollEl = el;
+            } }, h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("slot", null), h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { class: "picker-item-empty", "aria-hidden": "true" }, "\u00A0")), h("slot", { name: "suffix" })));
     }
     get el() { return this; }
     static get watchers() { return {
-        "col": ["colChanged"]
-    }; }
-    static get style() { return {
-        ios: pickerColumnIosCss,
-        md: pickerColumnMdCss
+        "value": ["valueChange"]
     }; }
-}, [32, "ion-picker-column", {
-        "col": [16]
+    static get style() { return pickerColumnCss; }
+}, [1, "ion-picker-column", {
+        "disabled": [4],
+        "value": [1032],
+        "color": [513],
+        "numericInput": [4, "numeric-input"],
+        "isActive": [32],
+        "scrollActiveItemIntoView": [64],
+        "setValue": [64],
+        "setFocus": [64]
     }, undefined, {
-        "col": ["colChanged"]
+        "value": ["valueChange"]
     }]);
-const PICKER_OPT_SELECTED = 'picker-opt-selected';
-const DECELERATION_FRICTION = 0.97;
-const MAX_PICKER_SPEED = 90;
-const TRANSITION_DURATION = 150;
+const PICKER_ITEM_ACTIVE_CLASS = 'option-active';
 function defineCustomElement() {
     if (typeof customElements === "undefined") {
         return;
@@ -370,10 +399,10 @@ function defineCustomElement() {
     components.forEach(tagName => { switch (tagName) {
         case "ion-picker-column":
             if (!customElements.get(tagName)) {
-                customElements.define(tagName, PickerColumnCmp);
+                customElements.define(tagName, PickerColumn);
             }
             break;
     } });
 }
 
-export { PickerColumnCmp as P, defineCustomElement as d };
+export { PickerColumn as P, defineCustomElement as d };