@ionic/core 8.2.3-dev.11719513154.1075733b → 8.2.3-dev.11719565135.1ab35bb2

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

@@ -0,0 +1,358 @@
+/*!
+ * (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

@@ -0,0 +1,31 @@
+/*!
+ * (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

@@ -0,0 +1,17 @@
+/*!
+ * (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

@@ -0,0 +1,24 @@
+/*!
+ * (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

@@ -0,0 +1,45 @@
+/*!
+ * (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

@@ -0,0 +1,30 @@
+/*!
+ * (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

@@ -0,0 +1,137 @@
+/*!
+ * (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

@@ -0,0 +1,22 @@
+/*!
+ * (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);
+        });
+    });
+});