@ionic/core 8.2.3-dev.11719301373.17616928 → 8.2.3-dev.11719439159.152ff050

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)');
-};

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

@@ -1,30 +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: multiple'), async () => {
-        test(`should resolve grouped animations using web animations`, async ({ page }) => {
-            await page.goto('/src/utils/animation/test/multiple', config);
-            await testMultiple(page);
-        });
-    });
-});
-const testMultiple = async (page) => {
-    const ionAnimationFinished = await page.spyOnEvent('ionAnimationFinished');
-    await page.click('.play');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationCSubBFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationBFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationCSubAFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationCFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationAFinished');
-    await ionAnimationFinished.next();
-    await expect(ionAnimationFinished).toHaveReceivedEventDetail('AnimationRootFinished');
-    await expect(ionAnimationFinished).toHaveReceivedEventTimes(6);
-};

package/dist/collection/utils/content/content.utils.spec.js

@@ -1,137 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { scrollToTop, scrollByPoint, printIonContentErrorMsg, findClosestIonContent, findIonContent, getScrollElement, } from "./index";
-describe('Content Utils', () => {
-    describe('getScrollElement', () => {
-        it('should return the scroll element for ion-content', async () => {
-            const res = await getScrollElement({
-                tagName: 'ION-CONTENT',
-                getScrollElement: () => Promise.resolve({
-                    tagName: 'my-scroll-element',
-                }),
-            });
-            expect(res).toStrictEqual({
-                tagName: 'my-scroll-element',
-            });
-        });
-    });
-    describe('findIonContent', () => {
-        it('should query the ion-content element', () => {
-            const querySelectorMock = jest.fn();
-            findIonContent({
-                querySelector: querySelectorMock,
-            });
-            expect(querySelectorMock).toHaveBeenCalledWith('ion-content, .ion-content-scroll-host');
-        });
-    });
-    describe('findClosestIonContent', () => {
-        it('should query the closest ion-content', () => {
-            const closestMock = jest.fn();
-            findClosestIonContent({
-                closest: closestMock,
-            });
-            expect(closestMock).toHaveBeenCalledWith('ion-content, .ion-content-scroll-host');
-        });
-    });
-    describe('scrollToTop', () => {
-        describe('scroll duration is 0', () => {
-            it('should call scrollToTop when the tag name is ion-content', () => {
-                const scrollToTopMock = jest.fn();
-                scrollToTop({
-                    tagName: 'ION-CONTENT',
-                    scrollToTop: scrollToTopMock,
-                }, 0);
-                expect(scrollToTopMock).toHaveBeenCalledWith(0);
-            });
-            it('should call the element scrollTo when the tag name is not ion-content', async () => {
-                const scrollToMock = jest.fn();
-                await scrollToTop({
-                    tagName: 'DIV',
-                    scrollTo: scrollToMock,
-                }, 0);
-                expect(scrollToMock).toHaveBeenCalledWith({
-                    top: 0,
-                    left: 0,
-                    behavior: 'auto',
-                });
-            });
-        });
-        describe('scroll duration is greater than 0', () => {
-            it('should smooth scroll ion-content', () => {
-                const scrollToTopMock = jest.fn();
-                scrollToTop({
-                    tagName: 'ION-CONTENT',
-                    scrollToTop: scrollToTopMock,
-                }, 300);
-                expect(scrollToTopMock).toHaveBeenCalledWith(300);
-            });
-            it('should smooth scroll the element', async () => {
-                const scrollToMock = jest.fn();
-                await scrollToTop({
-                    tagName: 'DIV',
-                    scrollTo: scrollToMock,
-                }, 300);
-                expect(scrollToMock).toHaveBeenCalledWith({
-                    top: 0,
-                    left: 0,
-                    behavior: 'smooth',
-                });
-            });
-        });
-    });
-    describe('scrollByPoint', () => {
-        describe('scroll duration is 0', () => {
-            it('should call scrollByPoint when the tag name is ion-content', async () => {
-                const scrollByPointMock = jest.fn();
-                await scrollByPoint({
-                    tagName: 'ION-CONTENT',
-                    scrollByPoint: scrollByPointMock,
-                }, 10, 15, 0);
-                expect(scrollByPointMock).toHaveBeenCalledWith(10, 15, 0);
-            });
-            it('should call the element scrollBy when the tag name is not ion-content', async () => {
-                const scrollByMock = jest.fn();
-                await scrollByPoint({
-                    tagName: 'DIV',
-                    scrollBy: scrollByMock,
-                }, 10, 15, 0);
-                expect(scrollByMock).toHaveBeenCalledWith({
-                    top: 15,
-                    left: 10,
-                    behavior: 'auto',
-                });
-            });
-        });
-        describe('scroll duration is greater than 0', () => {
-            it('should smooth scroll ion-content', async () => {
-                const scrollByPointMock = jest.fn();
-                await scrollByPoint({
-                    tagName: 'ION-CONTENT',
-                    scrollByPoint: scrollByPointMock,
-                }, 10, 15, 300);
-                expect(scrollByPointMock).toHaveBeenCalledWith(10, 15, 300);
-            });
-            it('should smooth scroll the element', async () => {
-                const scrollByMock = jest.fn();
-                await scrollByPoint({
-                    tagName: 'DIV',
-                    scrollBy: scrollByMock,
-                }, 10, 15, 300);
-                expect(scrollByMock).toHaveBeenCalledWith({
-                    top: 15,
-                    left: 10,
-                    behavior: 'smooth',
-                });
-            });
-        });
-    });
-    it('printIonContentErrorMsg should display "<my-el> must be used inside ion-content."', () => {
-        const consoleErrorMock = jest.spyOn(console, 'error').mockImplementation();
-        printIonContentErrorMsg({
-            tagName: 'MY-EL',
-        });
-        expect(consoleErrorMock).toHaveBeenCalledWith('<my-el> must be used inside ion-content.');
-        consoleErrorMock.mockRestore();
-    });
-});

package/dist/collection/utils/floating-point/floating-point.spec.js

@@ -1,22 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { getDecimalPlaces, roundToMaxDecimalPlaces } from "./index";
-describe('floating point utils', () => {
-    describe('getDecimalPlaces', () => {
-        it('should calculate decimal places for a float', async () => {
-            const n = getDecimalPlaces(5.001);
-            expect(n).toBe(3);
-        });
-        it('should return no decimal places for a whole number', async () => {
-            const n = getDecimalPlaces(5);
-            expect(n).toBe(0);
-        });
-    });
-    describe('roundToMaxDecimalPlaces', () => {
-        it('should round to the highest number of places as references', async () => {
-            const n = roundToMaxDecimalPlaces(5.12345, 1.12, 2.123);
-            expect(n).toBe(5.123);
-        });
-    });
-});