@ionic/core 8.2.3-nightly.20240625 → 8.2.3

package/dist/collection/components/router/test/parser.spec.js

@@ -1,133 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { mockWindow } from "@stencil/core/testing";
-import { flattenRouterTree, readRedirects, readRouteNodes } from "../utils/parser";
-describe('parser', () => {
-    describe('readRoutes', () => {
-        it('should read URL', () => {
-            const root = win.document.createElement('div');
-            const r1 = mockRouteElement(win, '/', 'MAIN-PAGE');
-            const r2 = mockRouteElement(win, '/one-page', 'one-page');
-            const r3 = mockRouteElement(win, 'secondpage', 'second-page');
-            const r4 = mockRouteElement(win, '/5/hola', '4');
-            const r5 = mockRouteElement(win, '/path/to/five', '5');
-            const r6 = mockRouteElement(win, '/path/to/five2', '6');
-            const r7 = mockRouteElement(win, '/path?flag=true', '6');
-            root.appendChild(r1);
-            root.appendChild(r2);
-            root.appendChild(r3);
-            root.appendChild(r7);
-            r3.appendChild(r4);
-            r4.appendChild(r5);
-            r4.appendChild(r6);
-            const expected = [
-                { segments: [''], id: 'main-page', children: [], params: undefined },
-                { segments: ['one-page'], id: 'one-page', children: [], params: undefined },
-                {
-                    segments: ['secondpage'],
-                    id: 'second-page',
-                    params: undefined,
-                    children: [
-                        {
-                            segments: ['5', 'hola'],
-                            id: '4',
-                            params: undefined,
-                            children: [
-                                { segments: ['path', 'to', 'five'], id: '5', children: [], params: undefined },
-                                { segments: ['path', 'to', 'five2'], id: '6', children: [], params: undefined },
-                            ],
-                        },
-                    ],
-                },
-                { segments: ['path'], id: '6', children: [], params: undefined },
-            ];
-            expect(readRouteNodes(root)).toEqual(expected);
-        });
-    });
-    describe('readRedirects', () => {
-        it('should read redirects', () => {
-            const root = win.document.createElement('div');
-            const r1 = mockRedirectElement(win, '/', undefined);
-            const r2 = mockRedirectElement(win, undefined, '/workout');
-            const r3 = mockRedirectElement(win, '*', null);
-            const r4 = mockRedirectElement(win, '/workout/*', '');
-            const r5 = mockRedirectElement(win, 'path/hey', '/path/to//login');
-            const r6 = mockRedirectElement(win, 'path/qs', '/path?qs=true');
-            root.appendChild(r1);
-            root.appendChild(r2);
-            root.appendChild(r3);
-            root.appendChild(r4);
-            root.appendChild(r5);
-            root.appendChild(r6);
-            const expected = [
-                { from: [''], to: undefined },
-                { from: [''], to: { segments: ['workout'] } },
-                { from: ['*'], to: undefined },
-                { from: ['workout', '*'], to: { segments: [''] } },
-                { from: ['path', 'hey'], to: { segments: ['path', 'to', 'login'] } },
-                { from: ['path', 'qs'], to: { segments: ['path'], queryString: 'qs=true' } },
-            ];
-            expect(readRedirects(root)).toEqual(expected);
-        });
-    });
-    describe('flattenRouterTree', () => {
-        it('should process routes', () => {
-            const entries = [
-                { segments: [''], id: 'hola', children: [], params: undefined },
-                { segments: ['one-page'], id: 'one-page', children: [], params: undefined },
-                {
-                    segments: ['secondpage'],
-                    id: 'second-page',
-                    params: undefined,
-                    children: [
-                        {
-                            segments: ['5', 'hola'],
-                            id: '4',
-                            params: undefined,
-                            children: [
-                                { segments: ['path', 'to', 'five'], id: '5', children: [], params: undefined },
-                                { segments: ['path', 'to', 'five2'], id: '6', children: [], params: undefined },
-                            ],
-                        },
-                    ],
-                },
-            ];
-            const routes = flattenRouterTree(entries);
-            expect(routes).toEqual([
-                [{ segments: [''], id: 'hola' }],
-                [{ segments: ['one-page'], id: 'one-page' }],
-                [
-                    { segments: ['secondpage'], id: 'second-page' },
-                    { segments: ['5', 'hola'], id: '4' },
-                    { segments: ['path', 'to', 'five'], id: '5' },
-                ],
-                [
-                    { segments: ['secondpage'], id: 'second-page' },
-                    { segments: ['5', 'hola'], id: '4' },
-                    { segments: ['path', 'to', 'five2'], id: '6' },
-                ],
-            ]);
-        });
-    });
-    let win;
-    beforeEach(() => {
-        win = mockWindow();
-    });
-});
-export function mockRouteElement(win, path, component) {
-    const el = win.document.createElement('ion-route');
-    el.setAttribute('url', path);
-    el.component = component;
-    return el;
-}
-function mockRedirectElement(win, from, to) {
-    const el = win.document.createElement('ion-route-redirect');
-    if (from != null) {
-        el.setAttribute('from', from);
-    }
-    if (to != null) {
-        el.setAttribute('to', to);
-    }
-    return el;
-}

package/dist/collection/components/router/test/path.spec.js

@@ -1,218 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { ROUTER_INTENT_FORWARD } from "../utils/constants";
-import { chainToSegments, generatePath, parsePath, readSegments, writeSegments } from "../utils/path";
-describe('parsePath', () => {
-    it('should parse empty path', () => {
-        expect(parsePath('').segments).toEqual(['']);
-    });
-    it('should parse slash path', () => {
-        expect(parsePath('/').segments).toEqual(['']);
-        expect(parsePath(' / ').segments).toEqual(['']);
-    });
-    it('should parse empty path (2)', () => {
-        expect(parsePath('   ').segments).toEqual(['']);
-    });
-    it('should parse null path', () => {
-        expect(parsePath(null).segments).toEqual(['']);
-    });
-    it('should parse undefined path', () => {
-        expect(parsePath(undefined).segments).toEqual(['']);
-    });
-    it('should parse single segment', () => {
-        expect(parsePath('path').segments).toEqual(['path']);
-        expect(parsePath('path/').segments).toEqual(['path']);
-        expect(parsePath('/path/').segments).toEqual(['path']);
-        expect(parsePath('/path').segments).toEqual(['path']);
-    });
-    it('should parse relative path', () => {
-        expect(parsePath('path/to/file.js').segments).toEqual(['path', 'to', 'file.js']);
-    });
-    it('should parse absolute path', () => {
-        expect(parsePath('/path/to/file.js').segments).toEqual(['path', 'to', 'file.js']);
-    });
-    it('should parse absolute path with multiple slashes', () => {
-        expect(parsePath('/PATH///to//file.js//').segments).toEqual(['PATH', 'to', 'file.js']);
-    });
-    it('should parse query string', () => {
-        expect(parsePath(null).queryString).toBe(undefined);
-        expect(parsePath('path/to/file.js').queryString).toBe(undefined);
-        expect(parsePath('path/to/file.js?').queryString).toEqual('');
-        expect(parsePath('path/to/file.js?a=b').queryString).toEqual('a=b');
-    });
-});
-describe('generatePath', () => {
-    it('should generate an empty URL', () => {
-        expect(generatePath([])).toEqual('/');
-        expect(generatePath([{ segments: '' }])).toEqual('/');
-        expect(generatePath([{ segments: '/' }])).toEqual('/');
-        expect(generatePath([{ segments: '//' }])).toEqual('/');
-        expect(generatePath([{ segments: '  ' }])).toEqual('/');
-    });
-    it('should genenerate a basic url', () => {
-        const stack = ['', '', '', 'path/to', 'page', 'number-TWO', ''];
-        expect(generatePath(stack)).toEqual('/path/to/page/number-TWO');
-    });
-});
-describe('chainToSegments', () => {
-    it('should generate a simple URL', () => {
-        const chain = [
-            { id: '2', segments: [''], params: undefined },
-            { id: '1', segments: [''], params: undefined },
-            { id: '3', segments: ['segment', 'to'], params: undefined },
-            { id: '4', segments: [''], params: undefined },
-            { id: '5', segments: ['hola', '', 'hey'], params: undefined },
-            { id: '6', segments: [''], params: undefined },
-            { id: '7', segments: [':param'], params: { param: 'name' } },
-            { id: '8', segments: ['adios', ':name', ':id'], params: { name: 'manu', id: '123' } },
-        ];
-        expect(chainToSegments(chain)).toEqual(['segment', 'to', 'hola', 'hey', 'name', 'adios', 'manu', '123']);
-    });
-    it('should return null on missing parameters', () => {
-        const chain = [
-            { id: '3', segments: ['segment'], params: undefined },
-            { id: '8', segments: [':name'], params: undefined },
-        ];
-        expect(chainToSegments(chain)).toBeNull();
-    });
-    it('should return null on missing parameters 2', () => {
-        const chain = [
-            { id: '3', segments: ['segment'], params: undefined },
-            { id: '8', segments: [':name', ':id'], params: { name: 'hey' } },
-        ];
-        expect(chainToSegments(chain)).toBeNull();
-    });
-});
-describe('readSegments', () => {
-    it('should read the URL from root (no hash)', () => {
-        const loc = mockLocation('/', '');
-        expect(readSegments(loc, '', false)).toEqual(['']);
-        expect(readSegments(loc, '/', false)).toEqual(['']);
-        expect(readSegments(loc, '  / ', false)).toEqual(['']);
-        expect(readSegments(loc, '', true)).toEqual(['']);
-        expect(readSegments(loc, '/', true)).toEqual(['']);
-        expect(readSegments(loc, '  /  ', true)).toEqual(['']);
-    });
-    it('should read the URL from root (hash)', () => {
-        const loc = mockLocation('/', '#');
-        expect(readSegments(loc, '', true)).toEqual(['']);
-        expect(readSegments(loc, '/', true)).toEqual(['']);
-        expect(readSegments(loc, '  /  ', true)).toEqual(['']);
-        const loc2 = mockLocation('/', '#/');
-        expect(readSegments(loc2, '', true)).toEqual(['']);
-        expect(readSegments(loc2, '/', true)).toEqual(['']);
-        expect(readSegments(loc2, '  /  ', true)).toEqual(['']);
-    });
-    it('should not read the URL from root', () => {
-        const loc = mockLocation('/', '');
-        expect(readSegments(loc, '/hola', false)).toBeNull();
-        expect(readSegments(loc, 'hola', false)).toBeNull();
-        expect(readSegments(loc, '/hola', true)).toBeNull();
-        expect(readSegments(loc, 'hola', true)).toBeNull();
-    });
-    it('should read the URL from non root (no hash)', () => {
-        const loc = mockLocation('/path/to/component', '#hello');
-        expect(readSegments(loc, '', false)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, '/', false)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, 'path', false)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path', false)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/', false)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/to', false)).toEqual(['component']);
-        expect(readSegments(loc, '/path/to/component', false)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/', false)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/path', false)).toBeNull();
-    });
-    it('should read the URL from non root (hash)', () => {
-        const loc = mockLocation('/index.html', '#path/to/component');
-        expect(readSegments(loc, '', true)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, '/', true)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, 'path', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/to', true)).toEqual(['component']);
-        expect(readSegments(loc, '/path/to/component', true)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/', true)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/path', true)).toBeNull();
-        expect(readSegments(loc, '/path/to/component2', true)).toBeNull();
-    });
-    it('should read the URL from non root (hash) 2', () => {
-        const loc = mockLocation('/index.html', '#/path/to/component');
-        expect(readSegments(loc, '', true)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, '/', true)).toEqual(['path', 'to', 'component']);
-        expect(readSegments(loc, 'path', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/', true)).toEqual(['to', 'component']);
-        expect(readSegments(loc, '/path/to', true)).toEqual(['component']);
-        expect(readSegments(loc, '/path/to/component', true)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/', true)).toEqual(['']);
-        expect(readSegments(loc, '/path/to/component/path', true)).toBeNull();
-    });
-});
-describe('writeSegments', () => {
-    it('should write root path (no hash)', () => {
-        const history = mockHistory();
-        writeSegments(history, '', false, [''], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '/');
-        writeSegments(history, '', false, ['schedule'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '/schedule');
-        writeSegments(history, '/', false, [''], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '/');
-        writeSegments(history, '/', false, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '/to/schedule');
-        writeSegments(history, '/', false, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '/to/schedule?flag=true');
-    });
-    it('should write non root path (no hash)', () => {
-        const history = mockHistory();
-        writeSegments(history, '/path', false, [''], ROUTER_INTENT_FORWARD, 2);
-        expect(history.pushState).toHaveBeenCalledWith(2, '', '/path');
-        writeSegments(history, '/path', false, ['to', 'page'], ROUTER_INTENT_FORWARD, 2);
-        expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/page');
-        writeSegments(history, 'path/to', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2);
-        expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page');
-        writeSegments(history, '/path/to/', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2);
-        expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page');
-        writeSegments(history, '/path/to/', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2, 'flag=true');
-        expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page?flag=true');
-    });
-    it('should write root path (no hash)', () => {
-        const history = mockHistory();
-        writeSegments(history, '', true, [''], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/');
-        writeSegments(history, '', true, ['schedule'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/schedule');
-        writeSegments(history, '/', true, [''], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/');
-        writeSegments(history, '/', true, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/to/schedule');
-        writeSegments(history, '/', true, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/to/schedule?flag=true');
-    });
-    it('should write non root path (no hash)', () => {
-        const history = mockHistory();
-        writeSegments(history, '/path', true, [''], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path');
-        writeSegments(history, '/path', true, ['to', 'page'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/page');
-        writeSegments(history, 'path/to', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page');
-        writeSegments(history, '/path/to/', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123);
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page');
-        writeSegments(history, '/path/to/', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
-        expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page?flag=true');
-    });
-});
-function mockHistory() {
-    return {
-        replaceState: jest.fn(),
-        pushState: jest.fn(),
-        length: 0,
-    };
-}
-function mockLocation(pathname, hash) {
-    return {
-        pathname,
-        hash,
-    };
-}

package/dist/collection/components/router/test/router.spec.js

@@ -1,55 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { mockWindow } from "@stencil/core/testing";
-import { findChainForSegments, findChainForIDs } from "../utils/matching";
-import { readRoutes } from "../utils/parser";
-import { chainToSegments, generatePath, parsePath } from "../utils/path";
-import { mockRouteElement } from "./parser.spec";
-describe('ionic-conference-app', () => {
-    it('should match conference-app routing', () => {
-        const root = conferenceAppRouting();
-        const routes = readRoutes(root);
-        expect(getRouteIDs('/', routes)).toEqual(['page-tabs', 'tab-schedule', 'page-schedule']);
-        expect(getRouteIDs('/speaker', routes)).toEqual(['page-tabs', 'tab-speaker', 'page-speaker-list']);
-        expect(getRouteIDs('/map', routes)).toEqual(['page-tabs', 'page-map']);
-        expect(getRouteIDs('/about', routes)).toEqual(['page-tabs', 'page-about']);
-        expect(getRouteIDs('/tutorial', routes)).toEqual(['page-tutorial']);
-        expect(getRoutePath([{ id: 'PAGE-TABS' }, { id: 'tab-schedule' }, { id: 'page-schedule' }], routes)).toEqual('/');
-        expect(getRoutePath([{ id: 'page-tabs' }, { id: 'TAB-SPEAKER' }], routes)).toEqual('/speaker');
-        expect(getRoutePath([{ id: 'page-tabs' }, { id: 'TAB-SPEAKER' }, { id: 'page-speaker-list' }], routes)).toEqual('/speaker');
-        expect(getRoutePath([{ id: 'page-tabs' }, { id: 'PAGE-MAP' }], routes)).toEqual('/map');
-        expect(getRoutePath([{ id: 'page-tabs' }, { id: 'page-about' }], routes)).toEqual('/about');
-        expect(getRoutePath([{ id: 'page-tutorial' }], routes)).toEqual('/tutorial');
-    });
-    let win;
-    beforeEach(() => {
-        win = mockWindow();
-    });
-    function conferenceAppRouting() {
-        const p2 = mockRouteElement(win, '/', 'tab-schedule');
-        const p3 = mockRouteElement(win, '/', 'PAGE-SCHEDULE');
-        p2.appendChild(p3);
-        const p4 = mockRouteElement(win, '/speaker', 'tab-speaker');
-        const p5 = mockRouteElement(win, '/', 'page-speaker-list');
-        p4.appendChild(p5);
-        const p6 = mockRouteElement(win, '/map', 'page-map');
-        const p7 = mockRouteElement(win, '/about', 'page-about');
-        const p1 = mockRouteElement(win, '/', 'page-tabs');
-        p1.appendChild(p2);
-        p1.appendChild(p4);
-        p1.appendChild(p6);
-        p1.appendChild(p7);
-        const p8 = mockRouteElement(win, '/tutorial', 'page-tutorial');
-        const container = win.document.createElement('div');
-        container.appendChild(p1);
-        container.appendChild(p8);
-        return container;
-    }
-});
-function getRouteIDs(path, routes) {
-    return findChainForSegments(parsePath(path).segments, routes).map((r) => r.id);
-}
-function getRoutePath(ids, routes) {
-    return generatePath(chainToSegments(findChainForIDs(ids, routes)));
-}

package/dist/collection/components/router-link/test/a11y/router-link.e2e.js

@@ -1,23 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import AxeBuilder from "@axe-core/playwright";
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../../utils/test/playwright/index";
-configs({ directions: ['ltr'], palettes: ['light', 'dark'] }).forEach(({ title, config }) => {
-    test.describe(title('router-link: a11y'), () => {
-        test('should not have accessibility violations', async ({ page }) => {
-            /**
-             * All page content should be contained by landmarks (main, nav, etc.)
-             * By containing the badge in a main element, we can avoid this violation.
-             */
-            await page.setContent(`
-          <main>
-            <ion-router-link href="#">Router Link</ion-router-link>
-          </main>
-        `, config);
-            const results = await new AxeBuilder({ page }).analyze();
-            expect(results.violations).toEqual([]);
-        });
-    });
-});

package/dist/collection/components/router-outlet/test/basic/router-outlet.e2e.js

@@ -1,39 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../../utils/test/playwright/index";
-configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('router outlet: basic'), () => {
-        test('getRouteId() should return the segment parameters', async ({ page }) => {
-            await page.goto('/src/components/router-outlet/test/basic', config);
-            await page.click('ion-button[href="#/two/segment"]');
-            await page.waitForChanges();
-            const routerOutlet = page.locator('ion-router-outlet');
-            const routeId = await routerOutlet.evaluate((el) => el.getRouteId());
-            expect(routeId.id).toEqual('PAGE-TWO');
-            expect(routeId.params).toEqual({ param: 'segment' });
-        });
-        test('getRouteId() should return the route parameters', async ({ page }) => {
-            await page.goto('/src/components/router-outlet/test/basic', config);
-            await page.click('ion-button[href="#/page-3"]');
-            await page.waitForChanges();
-            const routerOutlet = page.locator('ion-router-outlet');
-            const routeId = await routerOutlet.evaluate((el) => el.getRouteId());
-            expect(routeId.id).toEqual('PAGE-THREE');
-            expect(routeId.params).toEqual({ param: 'route' });
-        });
-        test('it should be possible to activate the same component provided parameters are different', async ({ page }) => {
-            await page.goto('/src/components/router-outlet/test/basic', config);
-            await page.click('ion-button[href="#/page-4.1/foo"]');
-            await page.waitForChanges();
-            await page.$eval('ion-item[href="#/page-4.1/foo"] ion-label', (el) => el.click());
-            await page.waitForChanges();
-            const routerOutlet = page.locator('ion-router-outlet');
-            await expect(routerOutlet).toHaveText(/text = foo/);
-            await page.click('ion-button[href="#/page-4.2/bar"]');
-            await page.waitForChanges();
-            await expect(routerOutlet).toHaveText(/text = bar/);
-        });
-    });
-});

package/dist/collection/components/searchbar/test/a11y/searchbar.e2e.js

@@ -1,37 +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, screenshot, config }) => {
-    test.describe(title('searchbar: font scaling'), () => {
-        test('should scale text on larger font sizes', async ({ page }) => {
-            await page.setContent(`
-        <style>
-          html {
-            font-size: 36px;
-          }
-        </style>
-        <ion-searchbar value="My Text" show-cancel-button="always" show-clear-button="always"></ion-searchbar>
-      `, config);
-            const searchbar = page.locator('ion-searchbar');
-            await expect(searchbar).toHaveScreenshot(screenshot(`searchbar-scale`));
-        });
-        test('should scale text on larger font sizes in a toolbar', async ({ page }) => {
-            await page.setContent(`
-        <style>
-          html {
-            font-size: 36px;
-          }
-        </style>
-        <ion-header>
-          <ion-toolbar>
-            <ion-searchbar value="My Text" show-cancel-button="always" show-clear-button="always"></ion-searchbar>
-          </ion-toolbar>
-        </ion-header>
-      `, config);
-            const searchbar = page.locator('ion-searchbar');
-            await expect(searchbar).toHaveScreenshot(screenshot(`searchbar-scale-toolbar`));
-        });
-    });
-});