voyager-ionic-core 8.2.0 → 8.2.5

package/dist/collection/themes/test/colors/theme.e2e.js

@@ -1,170 +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";
-/**
- * Small text is defined as 14pt (~18.5px)
- * when computing color contrast: https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum.html
- */
-const styleTestHelpers = `
-  <style>
-    main {
-      background: var(--ion-color-contrast);
-      font-size: 14pt;
-    }
-    .ion-background {
-      background: var(--ion-color-base);
-    }
-    .ion-background-shade {
-      background: var(--ion-color-shade);
-    }
-    .ion-background-tint {
-      background: var(--ion-color-tint);
-    }
-    .ion-background-opacity-08 {
-      background: rgba(var(--ion-color-base-rgb), 0.08);
-    }
-    .ion-background-opacity-12 {
-      background: rgba(var(--ion-color-base-rgb), 0.12);
-    }
-    .ion-background-opacity-16 {
-      background: rgba(var(--ion-color-base-rgb), 0.16);
-    }
-    .ion-color {
-      color: var(--ion-color-base);
-    }
-    .ion-color-contrast {
-      color: var(--ion-color-contrast);
-    }
-  </style>
-`;
-/**
- * All colors should be tested in the following scenarios:
- * 1) The base color as the text color against the contrast color as the background color
- * 2) The contrast color as the text color against the base color as the background color
- * 3) The contrast color as the text color against the shade color as the background color
- * 4) The contrast color as the text color against the tint color as the background color
- * 5) The base color as the text color against the base color at 0.08 opacity as the background color
- * 6) The base color as the text color against the base color at 0.12 opacity as the background color
- * 7) The base color as the text color against the base color at 0.16 opacity as the background color
- */
-configs({ modes: ['md'], directions: ['ltr'], palettes: ['light', 'dark'] }).forEach(({ config, title }) => {
-    const colors = ['primary', 'secondary', 'tertiary', 'success', 'warning', 'danger', 'light', 'medium', 'dark'];
-    test.describe(title('theme'), () => {
-        test.beforeEach(({ skip }) => {
-            skip.browser('firefox', 'Color contrast ratio is consistent across browsers');
-            skip.browser('webkit', 'Color contrast ratio is consistent across browsers');
-        });
-        for (const color of colors) {
-            test(`color "${color}" should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background shade should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background-shade">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background tint should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background-tint">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`color "${color}" on 0.08 opacity background should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color ion-background-opacity-08">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`color "${color}" on 0.12 opacity background should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color ion-background-opacity-12">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`color "${color}" on 0.16 opacity background should pass AA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color ion-background-opacity-16">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page }).analyze();
-                expect(results.violations).toEqual([]);
-            });
-        }
-    });
-});
-configs({ modes: ['md'], directions: ['ltr'], palettes: ['high-contrast', 'high-contrast-dark'] }).forEach(({ config, title }) => {
-    const colors = ['primary', 'secondary', 'tertiary', 'success', 'warning', 'danger', 'light', 'medium', 'dark'];
-    test.describe(title('theme'), () => {
-        test.beforeEach(({ skip }) => {
-            skip.browser('firefox', 'Color contrast ratio is consistent across browsers');
-            skip.browser('webkit', 'Color contrast ratio is consistent across browsers');
-        });
-        for (const color of colors) {
-            test(`color "${color}" should pass AAA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page })
-                    .options({ rules: { 'color-contrast-enhanced': { enabled: true } } })
-                    .analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background should pass AAA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page })
-                    .options({ rules: { 'color-contrast-enhanced': { enabled: true } } })
-                    .analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background shade should pass AAA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background-shade">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page })
-                    .options({ rules: { 'color-contrast-enhanced': { enabled: true } } })
-                    .analyze();
-                expect(results.violations).toEqual([]);
-            });
-            test(`contrast color on "${color}" background tint should pass AAA guidelines`, async ({ page }) => {
-                await page.setContent(`${styleTestHelpers}
-          <main class="ion-color-${color}">
-            <p class="ion-color-contrast ion-background-tint">Hello World</p>
-          </main>`, config);
-                const results = await new AxeBuilder({ page })
-                    .options({ rules: { 'color-contrast-enhanced': { enabled: true } } })
-                    .analyze();
-                expect(results.violations).toEqual([]);
-            });
-        }
-    });
-});

package/dist/collection/utils/animation/test/animation.spec.js

@@ -1,358 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { createAnimation } from "../animation";
-import { getTimeGivenProgression } from "../cubic-bezier";
-describe('Animation Class', () => {
-    describe('progressEnd callbacks', () => {
-        test('coerced state should be reset before onFinish runs', (done) => {
-            const el = document.createElement('div');
-            const animation = createAnimation()
-                .addElement(el)
-                .fromTo('transform', 'translateX(0px)', 'translateX(100px)')
-                .duration(50);
-            animation
-                .onFinish(() => {
-                expect(animation.getDirection()).toBe('normal');
-                expect(animation.getDuration()).toBe(50);
-                done();
-            })
-                .progressEnd(0, 0.5, 10);
-        });
-    });
-    describe('play()', () => {
-        it('should resolve when the animation is cancelled', async () => {
-            // Tell Jest to expect 1 assertion for async code
-            expect.assertions(1);
-            const el = document.createElement('div');
-            const animation = createAnimation()
-                .addElement(el)
-                .fromTo('transform', 'translateX(0px)', 'translateX(100px)')
-                .duration(100000);
-            const animationPromise = animation.play();
-            animation.stop();
-            // Expect that the promise resolves and returns undefined
-            expect(animationPromise).resolves.toEqual(undefined);
-        });
-    });
-    describe('isRunning()', () => {
-        let animation;
-        beforeEach(() => {
-            animation = createAnimation();
-        });
-        it('should not be running initially', () => {
-            expect(animation.isRunning()).toEqual(false);
-        });
-        it('should not be running due to not having keyframes', () => {
-            animation.play();
-            expect(animation.isRunning()).toEqual(false);
-        });
-    });
-    describe('addElement()', () => {
-        let animation;
-        beforeEach(() => {
-            animation = createAnimation();
-        });
-        it('should add 1 element', () => {
-            const el = document.createElement('p');
-            animation.addElement(el);
-            expect(animation.elements.length).toEqual(1);
-        });
-        it('should add multiple elements', () => {
-            const els = [document.createElement('p'), document.createElement('p'), document.createElement('p')];
-            animation.addElement(els);
-            expect(animation.elements.length).toEqual(els.length);
-        });
-        it('should not error when trying to add null or undefined', () => {
-            const el = document.createElement('p');
-            animation.addElement(el);
-            animation.addElement(null);
-            animation.addElement(undefined);
-            expect(animation.elements.length).toEqual(1);
-        });
-    });
-    describe('addAnimation()', () => {
-        let animation;
-        beforeEach(() => {
-            animation = createAnimation();
-        });
-        it('should add 1 animation', () => {
-            const newAnimation = createAnimation();
-            animation.addAnimation(newAnimation);
-            expect(animation.childAnimations.length).toEqual(1);
-        });
-        it('should add multiple animations', () => {
-            animation.addAnimation([createAnimation(), createAnimation(), createAnimation()]);
-            expect(animation.childAnimations.length).toEqual(3);
-        });
-        it('should not error when trying to add null or undefined', () => {
-            animation.addAnimation(null);
-            animation.addAnimation(undefined);
-            expect(animation.childAnimations.length).toEqual(0);
-        });
-    });
-    describe('Animation Keyframes', () => {
-        let animation;
-        beforeEach(() => {
-            animation = createAnimation();
-        });
-        it('should generate a keyframe', () => {
-            animation.keyframes([
-                { transform: 'scale(1)', opacity: 1, offset: 0 },
-                { transform: 'scale(0.5)', opacity: 0.5, offset: 0.5 },
-                { transform: 'scale(0)', opacity: 0, offset: 1 },
-            ]);
-            expect(animation.getKeyframes().length).toEqual(3);
-        });
-        it('should set the from keyframe properly', () => {
-            animation.from('opacity', 0).from('background', 'red').from('color', 'purple');
-            const keyframes = animation.getKeyframes();
-            expect(keyframes.length).toEqual(1);
-            expect(keyframes[0]).toEqual({
-                opacity: 0,
-                color: 'purple',
-                background: 'red',
-                offset: 0,
-            });
-        });
-        it('should set the to keyframe properly', () => {
-            animation.to('opacity', 0).to('background', 'red').to('color', 'purple');
-            const keyframes = animation.getKeyframes();
-            expect(keyframes.length).toEqual(1);
-            expect(keyframes[0]).toEqual({
-                opacity: 0,
-                color: 'purple',
-                background: 'red',
-                offset: 1,
-            });
-        });
-        it('should mix keyframes and fromTo properly', () => {
-            animation
-                .keyframes([
-                { offset: 0, background: 'red' },
-                { offset: 0.99, background: 'blue' },
-                { offset: 1, background: 'green' },
-            ])
-                .fromTo('opacity', 0, 1);
-            const keyframes = animation.getKeyframes();
-            expect(keyframes.length).toEqual(3);
-            expect(keyframes[0]).toEqual({
-                opacity: 0,
-                background: 'red',
-                offset: 0,
-            });
-            expect(keyframes[1]).toEqual({
-                background: 'blue',
-                offset: 0.99,
-            });
-            expect(keyframes[2]).toEqual({
-                opacity: 1,
-                background: 'green',
-                offset: 1,
-            });
-        });
-    });
-    describe('Animation Config Methods', () => {
-        let animation;
-        beforeEach(() => {
-            animation = createAnimation();
-        });
-        it('should get "linear" when easing not set', () => {
-            expect(animation.getEasing()).toEqual('linear');
-        });
-        it('should get parent easing when child easing is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).easing('ease-in-out');
-            expect(childAnimation.getEasing()).toEqual('ease-in-out');
-        });
-        it('should get prefer child easing over parent easing', () => {
-            const childAnimation = createAnimation();
-            childAnimation.easing('linear');
-            animation.addAnimation(childAnimation).easing('ease-in-out');
-            expect(childAnimation.getEasing()).toEqual('linear');
-        });
-        it('should get linear easing when forceLinear is set', () => {
-            animation.easing('ease-in-out');
-            animation.progressStart(true);
-            expect(animation.getEasing()).toEqual('linear');
-            animation.progressEnd(0, 0);
-            expect(animation.getEasing()).toEqual('ease-in-out');
-        });
-        it('should get 0 when duration not set', () => {
-            expect(animation.getDuration()).toEqual(0);
-        });
-        it('should get parent duration when child duration is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).duration(500);
-            expect(childAnimation.getDuration()).toEqual(500);
-        });
-        it('should get prefer child duration over parent duration', () => {
-            const childAnimation = createAnimation();
-            childAnimation.duration(500);
-            animation.addAnimation(childAnimation).duration(1000);
-            expect(childAnimation.getDuration()).toEqual(500);
-        });
-        it('should get 0 when delay not set', () => {
-            expect(animation.getDelay()).toEqual(0);
-        });
-        it('should get parent delay when child delay is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).delay(500);
-            expect(childAnimation.getDelay()).toEqual(500);
-        });
-        it('should get prefer child delay over parent delay', () => {
-            const childAnimation = createAnimation();
-            childAnimation.delay(500);
-            animation.addAnimation(childAnimation).delay(1000);
-            expect(childAnimation.getDelay()).toEqual(500);
-        });
-        it('should get 1 when iterations not set', () => {
-            expect(animation.getIterations()).toEqual(1);
-        });
-        it('should get parent iterations when child iterations is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).iterations(2);
-            expect(childAnimation.getIterations()).toEqual(2);
-        });
-        it('should get prefer child iterations over parent iterations', () => {
-            const childAnimation = createAnimation();
-            childAnimation.iterations(2);
-            animation.addAnimation(childAnimation).iterations(1);
-            expect(childAnimation.getIterations()).toEqual(2);
-        });
-        it('should get "both" when fill not set', () => {
-            expect(animation.getFill()).toEqual('both');
-        });
-        it('should get parent fill when child fill is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).fill('both');
-            expect(childAnimation.getFill()).toEqual('both');
-        });
-        it('should get prefer child fill over parent fill', () => {
-            const childAnimation = createAnimation();
-            childAnimation.fill('none');
-            animation.addAnimation(childAnimation).fill('forwards');
-            expect(childAnimation.getFill()).toEqual('none');
-        });
-        it('should get "normal" when direction not set', () => {
-            expect(animation.getDirection()).toEqual('normal');
-        });
-        it('should get parent direction when child direction is not set', () => {
-            const childAnimation = createAnimation();
-            animation.addAnimation(childAnimation).direction('alternate');
-            expect(childAnimation.getDirection()).toEqual('alternate');
-        });
-        it('should get prefer child direction over parent direction', () => {
-            const childAnimation = createAnimation();
-            childAnimation.direction('alternate-reverse');
-            animation.addAnimation(childAnimation).direction('normal');
-            expect(childAnimation.getDirection()).toEqual('alternate-reverse');
-        });
-    });
-});
-describe('cubic-bezier conversion', () => {
-    describe('should properly get a time value (x value) given a progression value (y value)', () => {
-        it('cubic-bezier(0.32, 0.72, 0, 1)', () => {
-            const equation = [
-                [0, 0],
-                [0.32, 0.72],
-                [0, 1],
-                [1, 1],
-            ];
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.5), [
-                0.16,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.97), [
-                0.56,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.33), [
-                0.11,
-            ]);
-        });
-        it('cubic-bezier(1, 0, 0.68, 0.28)', () => {
-            const equation = [
-                [0, 0],
-                [1, 0],
-                [0.68, 0.28],
-                [1, 1],
-            ];
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.08), [
-                0.6,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.5), [
-                0.84,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.94), [
-                0.98,
-            ]);
-        });
-        it('cubic-bezier(0.4, 0, 0.6, 1)', () => {
-            const equation = [
-                [0, 0],
-                [0.4, 0],
-                [0.6, 1],
-                [1, 1],
-            ];
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.39), [
-                0.43,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.03), [
-                0.11,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.89), [
-                0.78,
-            ]);
-        });
-        it('cubic-bezier(0, 0, 0.2, 1)', () => {
-            const equation = [
-                [0, 0],
-                [0, 0],
-                [0.2, 1],
-                [1, 1],
-            ];
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.95), [
-                0.71,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.1), [
-                0.03,
-            ]);
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.7), [
-                0.35,
-            ]);
-        });
-        it('cubic-bezier(0.32, 0.72, 0, 1) (with out of bounds progression)', () => {
-            const equation = [
-                [0, 0],
-                [0.05, 0.2],
-                [0.14, 1.72],
-                [1, 1],
-            ];
-            expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.32)[0]).toBeUndefined();
-            expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], -0.32)[0]).toBeUndefined();
-        });
-        it('cubic-bezier(0.21, 1.71, 0.88, 0.9) (multiple solutions)', () => {
-            const equation = [
-                [0, 0],
-                [0.21, 1.71],
-                [0.88, 0.9],
-                [1, 1],
-            ];
-            shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.02), [0.35, 0.87]);
-        });
-        it('cubic-bezier(0.32, 0.72, 0, 1) (with out of bounds progression)', () => {
-            const equation = [
-                [0, 0],
-                [0.05, 0.2],
-                [0.14, 1.72],
-                [1, 1],
-            ];
-            expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.32)).toEqual([]);
-            expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], -0.32)).toEqual([]);
-        });
-    });
-});
-const shouldApproximatelyEqual = (givenValues, expectedValues) => {
-    givenValues.forEach((givenValue, i) => {
-        expect(Math.abs(expectedValues[i] - givenValue)).toBeLessThanOrEqual(0.01);
-    });
-};

package/dist/collection/utils/animation/test/animationbuilder/animation.e2e.js

@@ -1,31 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { configs, test } from "../../../test/playwright/index";
-configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('animation: animationbuilder'), async () => {
-        test('backwards-compatibility animation', async ({ page }) => {
-            await page.goto('/src/utils/animation/test/animationbuilder', config);
-            await testNavigation(page);
-        });
-        test('ios-transition web', async ({ page }) => {
-            await page.goto('/src/utils/animation/test/animationbuilder', config);
-            await testNavigation(page);
-        });
-    });
-});
-const testNavigation = async (page) => {
-    const ionRouteDidChange = await page.spyOnEvent('ionRouteDidChange');
-    await page.click('page-root ion-button.next');
-    await ionRouteDidChange.next();
-    page.click('page-one ion-button.next');
-    await ionRouteDidChange.next();
-    page.click('page-two ion-button.next');
-    await ionRouteDidChange.next();
-    page.click('page-three ion-back-button');
-    await ionRouteDidChange.next();
-    page.click('page-two ion-back-button');
-    await ionRouteDidChange.next();
-    page.click('page-one ion-back-button');
-    await ionRouteDidChange.next();
-};

package/dist/collection/utils/animation/test/basic/animation.e2e.js

@@ -1,17 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { configs, test } from "../../../test/playwright/index";
-configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('animation: basic'), async () => {
-        test(`should resolve using web animations`, async ({ page }) => {
-            await page.goto('/src/utils/animation/test/basic', config);
-            await testPage(page);
-        });
-    });
-});
-const testPage = async (page) => {
-    const ionAnimationFinished = await page.spyOnEvent('ionAnimationFinished');
-    await page.click('.play');
-    await ionAnimationFinished.next();
-};

package/dist/collection/utils/animation/test/display/animation.e2e.js

@@ -1,24 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../test/playwright/index";
-configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('animation: display'), async () => {
-        test(`should resolve using web animations`, async ({ page }) => {
-            await page.goto('/src/utils/animation/test/display', config);
-            await testDisplay(page);
-        });
-    });
-});
-const testDisplay = async (page) => {
-    const ionAnimationFinished = await page.spyOnEvent('ionAnimationFinished');
-    await page.click('.play');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationBFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationAFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationRootFinished');
-    await expect(ionAnimationFinished).toHaveReceivedEventTimes(3);
-};

package/dist/collection/utils/animation/test/hooks/animation.e2e.js

@@ -1,45 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { expect } from "@playwright/test";
-import { configs, test } from "../../../test/playwright/index";
-configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
-    test.describe(title('animation: hooks'), async () => {
-        test(`should fire hooks using web animations`, async ({ page }) => {
-            await page.goto('/src/utils/animation/test/hooks', config);
-            await testHooks(page);
-        });
-    });
-});
-const testHooks = async (page) => {
-    const square = page.locator('.square-a');
-    const ionAnimationFinished = await page.spyOnEvent('ionAnimationFinished');
-    const beforeRead = await page.spyOnEvent('beforeRead');
-    const beforeWrite = await page.spyOnEvent('beforeWrite');
-    const afterRead = await page.spyOnEvent('afterRead');
-    const afterWrite = await page.spyOnEvent('afterWrite');
-    // Test initial classes
-    await expect(square).toHaveClass(/hello-world/);
-    await expect(square).not.toHaveClass(/test-class/);
-    // Test initial styles
-    await expect(square).toHaveCSS('padding-bottom', '20px');
-    await expect(square).toHaveCSS('color', 'rgb(0, 0, 0)');
-    await page.click('.play');
-    // Test beforeRemoveClass and beforeAddClass
-    await expect(square).not.toHaveClass(/hello-world/);
-    await expect(square).toHaveClass(/test-class/);
-    // Test beforeStyles and beforeClearStyles
-    await expect(square).toHaveCSS('padding-bottom', '0px');
-    await expect(square).toHaveCSS('color', 'rgb(128, 0, 128)');
-    await beforeRead.next();
-    await beforeWrite.next();
-    await ionAnimationFinished.next();
-    await afterRead.next();
-    await afterWrite.next();
-    // Test afterRemoveClass and afterAddClass
-    await expect(square).toHaveClass(/hello-world/);
-    await expect(square).not.toHaveClass(/test-class/);
-    // Test afterStyles and afterClearStyles
-    await expect(square).toHaveCSS('padding-bottom', '20px');
-    await expect(square).toHaveCSS('color', 'rgb(0, 0, 0)');
-};