@ionic/core 7.7.2-dev.11707926434.1affaed4 → 7.7.2-dev.11707932366.16baf005

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionic/core",
-  "version": "7.7.2-dev.11707926434.1affaed4",
+  "version": "7.7.2-dev.11707932366.16baf005",
   "description": "Base components for Ionic",
   "keywords": [
     "ionic",

package/components/ion-picker-column-internal.d.ts

@@ -1,11 +0,0 @@
-import type { Components, JSX } from "../dist/types/components";
-
-interface IonPickerColumnInternal extends Components.IonPickerColumnInternal, HTMLElement {}
-export const IonPickerColumnInternal: {
-    prototype: IonPickerColumnInternal;
-    new (): IonPickerColumnInternal;
-};
-/**
- * Used to define this component and all nested components recursively.
- */
-export const defineCustomElement: () => void;

package/components/ion-picker-column-internal.js

@@ -1,9 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { P as PickerColumnInternal, d as defineCustomElement$1 } from './picker-column-internal.js';
-
-const IonPickerColumnInternal = PickerColumnInternal;
-const defineCustomElement = defineCustomElement$1;
-
-export { IonPickerColumnInternal, defineCustomElement };

package/components/ion-picker-internal.js

@@ -1,9 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { P as PickerInternal, d as defineCustomElement$1 } from './picker-internal.js';
-
-const IonPickerInternal = PickerInternal;
-const defineCustomElement = defineCustomElement$1;
-
-export { IonPickerInternal, defineCustomElement };

package/components/picker-column-internal.js

@@ -1,392 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
-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 pickerColumnInternalIosCss = ":host{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0px;padding-bottom:0px;height:200px;outline:none;font-size:22px;-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;text-align:center}:host::-webkit-scrollbar{display:none}:host .picker-item{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;cursor:pointer;overflow:hidden;scroll-snap-align:center}:host .picker-item-empty,:host .picker-item[disabled]{cursor:default}:host .picker-item-empty,:host(:not([disabled])) .picker-item[disabled]{scroll-snap-align:none}:host([disabled]){overflow-y:hidden}:host .picker-item[disabled]{opacity:0.4}:host(.picker-column-active) .picker-item.picker-item-active{color:var(--ion-color-base)}@media (any-hover: hover){:host(:focus){outline:none;background:rgba(var(--ion-color-base-rgb), 0.2)}}";
-const IonPickerColumnInternalIosStyle0 = pickerColumnInternalIosCss;
-
-const pickerColumnInternalMdCss = ":host{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0px;padding-bottom:0px;height:200px;outline:none;font-size:22px;-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;text-align:center}:host::-webkit-scrollbar{display:none}:host .picker-item{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;cursor:pointer;overflow:hidden;scroll-snap-align:center}:host .picker-item-empty,:host .picker-item[disabled]{cursor:default}:host .picker-item-empty,:host(:not([disabled])) .picker-item[disabled]{scroll-snap-align:none}:host([disabled]){overflow-y:hidden}:host .picker-item[disabled]{opacity:0.4}:host(.picker-column-active) .picker-item.picker-item-active{color:var(--ion-color-base)}@media (any-hover: hover){:host(:focus){outline:none;background:rgba(var(--ion-color-base-rgb), 0.2)}}:host .picker-item-active{color:var(--ion-color-base)}";
-const IonPickerColumnInternalMdStyle0 = pickerColumnInternalMdCss;
-
-const PickerColumnInternal = /*@__PURE__*/ proxyCustomElement(class PickerColumnInternal extends HTMLElement {
-    constructor() {
-        super();
-        this.__registerHost();
-        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 { el, isColumnVisible } = this;
-            if (isColumnVisible) {
-                // (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 (el.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;
-                    el.scroll({
-                        top,
-                        left: 0,
-                        behavior: smooth ? 'smooth' : undefined,
-                    });
-                }
-            }
-        };
-        this.setPickerItemActiveState = (item, isActive) => {
-            if (isActive) {
-                item.classList.add(PICKER_ITEM_ACTIVE_CLASS);
-                item.part.add(PICKER_ITEM_ACTIVE_PART);
-            }
-            else {
-                item.classList.remove(PICKER_ITEM_ACTIVE_CLASS);
-                item.part.remove(PICKER_ITEM_ACTIVE_PART);
-            }
-        };
-        /**
-         * 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 } = this;
-            let timeout;
-            let activeEl = this.activeItem;
-            const scrollCallback = () => {
-                raf(() => {
-                    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 = el.getBoundingClientRect();
-                    const centerX = bbox.x + bbox.width / 2;
-                    const centerY = bbox.y + bbox.height / 2;
-                    const activeElement = el.shadowRoot.elementFromPoint(centerX, centerY);
-                    if (activeEl !== null) {
-                        this.setPickerItemActiveState(activeEl, false);
-                    }
-                    if (activeElement === null || activeElement.disabled) {
-                        return;
-                    }
-                    /**
-                     * If we are selecting a new value,
-                     * we need to run haptics again.
-                     */
-                    if (activeElement !== 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 = activeElement;
-                    this.setPickerItemActiveState(activeElement, 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;
-                        const dataIndex = activeElement.getAttribute('data-index');
-                        /**
-                         * If no value it is
-                         * possible we hit one of the
-                         * empty padding columns.
-                         */
-                        if (dataIndex === null) {
-                            return;
-                        }
-                        const index = parseInt(dataIndex, 10);
-                        const selectedItem = this.items[index];
-                        if (selectedItem.value !== this.value) {
-                            this.setValue(selectedItem.value);
-                        }
-                    }, 250);
-                });
-            };
-            /**
-             * Wrap this in an raf so that the scroll callback
-             * does not fire when component is initially shown.
-             */
-            raf(() => {
-                el.addEventListener('scroll', scrollCallback);
-                this.destroyScrollListener = () => {
-                    el.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.items = [];
-        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();
-        }
-    }
-    /**
-     * 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.isColumnVisible = false;
-                if (this.destroyScrollListener) {
-                    this.destroyScrollListener();
-                    this.destroyScrollListener = undefined;
-                }
-            }
-        };
-        new IntersectionObserver(visibleCallback, { threshold: 0.001 }).observe(this.el);
-        const parentEl = (this.parentEl = this.el.closest('ion-picker-internal'));
-        if (parentEl !== null) {
-            // TODO(FW-2832): type
-            parentEl.addEventListener('ionInputModeChange', (ev) => this.inputModeChange(ev));
-        }
-    }
-    componentDidRender() {
-        var _a;
-        const { activeItem, items, isColumnVisible, value } = this;
-        if (isColumnVisible) {
-            if (activeItem) {
-                this.scrollActiveItemIntoView();
-            }
-            else if (((_a = items[0]) === null || _a === void 0 ? void 0 : _a.value) !== value) {
-                /**
-                 * 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.
-                 *
-                 */
-                this.setValue(items[0].value);
-            }
-        }
-    }
-    /** @internal  */
-    async scrollActiveItemIntoView() {
-        const activeEl = this.activeItem;
-        if (activeEl) {
-            this.centerPickerItemInView(activeEl, false, false);
-        }
-    }
-    /**
-     * 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) {
-        const { items } = this;
-        this.value = value;
-        const findItem = items.find((item) => item.value === value && item.disabled !== true);
-        if (findItem) {
-            this.ionChange.emit(findItem);
-        }
-    }
-    get activeItem() {
-        // 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
-        const selector = `.picker-item[data-value="${this.value}"]${this.disabled ? '' : ':not([disabled])'}`;
-        return getElementRoot(this.el).querySelector(selector);
-    }
-    render() {
-        const { items, color, disabled: pickerDisabled, isActive, numericInput } = this;
-        const mode = getIonMode(this);
-        /**
-         * exportparts is needed so ion-datetime can expose the parts
-         * from two layers of shadow nesting. If this causes problems,
-         * the attribute can be moved to datetime.tsx and set on every
-         * instance of ion-picker-column-internal there instead.
-         */
-        return (h(Host, { key: 'd0e3818aa4ab06aefd988d1b42ae754244727b8f', exportparts: `${PICKER_ITEM_PART}, ${PICKER_ITEM_ACTIVE_PART}`, disabled: pickerDisabled, tabindex: pickerDisabled ? null : 0, class: createColorClasses(color, {
-                [mode]: true,
-                ['picker-column-active']: isActive,
-                ['picker-column-numeric-input']: numericInput,
-            }) }, h("div", { key: 'ec3b16415db5f64e3fab37fda023560ebcdc9423', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: '40c78c9a1277807572d73e23048c2730cab88f5a', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'c51fa817f6999356cf3568a46098e954936b45d5', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0"), items.map((item, index) => {
-            const isItemDisabled = pickerDisabled || item.disabled || false;
-            return (h("button", { tabindex: "-1", class: {
-                    'picker-item': true,
-                }, "data-value": item.value, "data-index": index, onClick: (ev) => {
-                    this.centerPickerItemInView(ev.target, true);
-                }, disabled: isItemDisabled, part: PICKER_ITEM_PART }, item.text));
-        }), h("div", { key: '80a7461dfe571f46466219b05007b021711aed32', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'fed82263295f58c51e2b753d0c06c7d71872b8a7', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0"), h("div", { key: 'e805dff4122cc4e5fb4d7dcb96054fee8ad3bd07', class: "picker-item picker-item-empty", "aria-hidden": "true" }, "\u00A0")));
-    }
-    get el() { return this; }
-    static get watchers() { return {
-        "value": ["valueChange"]
-    }; }
-    static get style() { return {
-        ios: IonPickerColumnInternalIosStyle0,
-        md: IonPickerColumnInternalMdStyle0
-    }; }
-}, [33, "ion-picker-column-internal", {
-        "disabled": [4],
-        "items": [16],
-        "value": [1032],
-        "color": [513],
-        "numericInput": [4, "numeric-input"],
-        "isActive": [32],
-        "scrollActiveItemIntoView": [64],
-        "setValue": [64]
-    }, undefined, {
-        "value": ["valueChange"]
-    }]);
-const PICKER_ITEM_ACTIVE_CLASS = 'picker-item-active';
-const PICKER_ITEM_PART = 'wheel-item';
-const PICKER_ITEM_ACTIVE_PART = 'active';
-function defineCustomElement() {
-    if (typeof customElements === "undefined") {
-        return;
-    }
-    const components = ["ion-picker-column-internal"];
-    components.forEach(tagName => { switch (tagName) {
-        case "ion-picker-column-internal":
-            if (!customElements.get(tagName)) {
-                customElements.define(tagName, PickerColumnInternal);
-            }
-            break;
-    } });
-}
-
-export { PickerColumnInternal as P, defineCustomElement as d };

package/dist/collection/components/input/test/item/input.spec.js

@@ -1,24 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { newSpecPage } from "@stencil/core/testing";
-import { Item } from "../../../item/item";
-import { Input } from "../../input";
-it('should render as modern when label is set asynchronously', async () => {
-    const page = await newSpecPage({
-        components: [Item, Input],
-        html: `
-      <ion-item>
-        <ion-input></ion-input>
-      </ion-item>
-    `,
-    });
-    const input = page.body.querySelector('ion-input');
-    // Template should be modern
-    expect(input.classList.contains('legacy-input')).toBe(false);
-    // Update the input label
-    input.label = 'New label';
-    await page.waitForChanges();
-    // Template should still be modern
-    expect(input.classList.contains('legacy-input')).toBe(false);
-});

package/dist/collection/components/input/test/legacy/a11y/input.e2e.js

@@ -1,28 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../../../utils/test/playwright/index";
-configs({ directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('input: a11y'), () => {
-        test('does not set a default aria-labelledby when there is not a neighboring ion-label', async ({ page }) => {
-            await page.setContent('<ion-input legacy="true"></ion-input>', config);
-            const input = page.locator('ion-input > input');
-            const ariaLabelledBy = await input.getAttribute('aria-labelledby');
-            await expect(ariaLabelledBy).toBe(null);
-        });
-        test('set a default aria-labelledby when a neighboring ion-label exists', async ({ page }) => {
-            await page.setContent(`
-          <ion-item>
-            <ion-label>A11y Test</ion-label>
-            <ion-input></ion-input>
-          </ion-item>
-        `, config);
-            const label = page.locator('ion-label');
-            const input = page.locator('ion-input > input');
-            const ariaLabelledBy = await input.getAttribute('aria-labelledby');
-            const labelId = await label.getAttribute('id');
-            await expect(ariaLabelledBy).toBe(labelId);
-        });
-    });
-});

package/dist/collection/components/input/test/legacy/basic/input.e2e.js

@@ -1,181 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../../../utils/test/playwright/index";
-configs().forEach(({ title, screenshot, config }) => {
-    test.describe(title('input: basic'), () => {
-        test.describe('input with overflow', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-          <ion-content>
-            <ion-list>
-              <ion-item>
-                <ion-input value="reallylonglonglonginputtoseetheedgesreallylonglonglonginputtoseetheedges" legacy="true"></ion-input>
-              </ion-item>
-            </ion-list>
-          </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                // Validates the display of an input where text extends off the edge of the component.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-text-overflow`));
-            });
-        });
-        test.describe('input with placeholder', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item>
-              <ion-input placeholder="Placeholder" legacy="true"></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                // Validates the display of an input with a placeholder.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-placeholder`));
-            });
-        });
-        test.describe('input disabled', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item>
-              <ion-input value="Input disabled" disabled legacy="true"></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                // Validates the display of an input in a disabled state.
-                await expect(item).toHaveScreenshot(screenshot(`input-disabled`));
-            });
-        });
-        test.describe('input with lines="full"', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item lines="full">
-              <ion-input placeholder="Full" legacy="true"></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                const input = page.locator('ion-input');
-                // Validates the display of an input with an ion-item using lines="full".
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-full`));
-                await input.click();
-                // Verifies that the parent item receives .item-has-focus when the input is focused.
-                await expect(item).toHaveClass(/item-has-focus/);
-                // Validates the display of an input with an ion-item using lines="full" when focused.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-full-focused`));
-            });
-        });
-        test.describe('input with lines="inset"', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item lines="inset">
-              <ion-input placeholder="Inset" legacy="true"></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                const input = page.locator('ion-input');
-                // Validates the display of an input with an ion-item using lines="inset".
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-inset`));
-                await input.click();
-                // Verifies that the parent item receives .item-has-focus when the input is focused.
-                await expect(item).toHaveClass(/item-has-focus/);
-                // Validates the display of an input with an ion-item using lines="inset" when focused.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-inset-focused`));
-            });
-        });
-        test.describe('input with lines="none"', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item lines="none">
-              <ion-input placeholder="None" legacy="true"></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                const input = page.locator('ion-input');
-                // Validates the display of an input with an ion-item using lines="none".
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-none`));
-                await input.click();
-                // Verifies that the parent item receives .item-has-focus when the input is focused.
-                await expect(item).toHaveClass(/item-has-focus/);
-                // Validates the display of an input with an ion-item using lines="none" when focused.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-lines-none-focused`));
-            });
-        });
-        test.describe('input with clear button', () => {
-            test('should not have visual regressions', async ({ page }) => {
-                await page.setContent(`
-        <ion-content>
-          <ion-list>
-            <ion-item>
-              <ion-label>Clear Input</ion-label>
-              <ion-input
-                clear-input
-                value="reallylonglonglonginputtoseetheedgesreallylonglonglonginputtoseetheedges"
-                legacy="true"
-              ></ion-input>
-            </ion-item>
-          </ion-list>
-        </ion-content>
-        `, config);
-                const item = page.locator('ion-item');
-                // Validates the display of an input with a clear button.
-                await expect(item).toHaveScreenshot(screenshot(`input-with-clear-button`));
-            });
-        });
-    });
-});
-/**
- * This behavior does not vary across modes/directions.
- */
-configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('input: clear button'), () => {
-        test('should clear the input when pressed', async ({ page }) => {
-            await page.setContent(`
-        <ion-input value="abc" clear-input="true" legacy="true"></ion-input>
-      `, config);
-            const input = page.locator('ion-input');
-            const clearButton = input.locator('.input-clear-icon');
-            await expect(input).toHaveJSProperty('value', 'abc');
-            await clearButton.click();
-            await page.waitForChanges();
-            await expect(input).toHaveJSProperty('value', '');
-        });
-        /**
-         * Note: This only tests the desktop focus behavior.
-         * Mobile browsers have different restrictions around
-         * focusing inputs, so these platforms should always
-         * be tested when making changes to the focus behavior.
-         */
-        test('should keep the input focused when the clear button is pressed', async ({ page }) => {
-            await page.setContent(`
-        <ion-input value="abc" clear-input="true" legacy="true"></ion-input>
-      `, config);
-            const input = page.locator('ion-input');
-            const nativeInput = input.locator('input');
-            const clearButton = input.locator('.input-clear-icon');
-            await input.click();
-            await expect(nativeInput).toBeFocused();
-            await clearButton.click();
-            await page.waitForChanges();
-            await expect(nativeInput).toBeFocused();
-        });
-    });
-});