genesys-spark-components 4.82.0 → 4.83.0

package/dist/collection/components/stable/gux-calendar/tests/gux-calendar.methods.spec.js

@@ -1,235 +0,0 @@
-import * as utils from "../../../../utils/dom/manipulate-elements-classes";
-import { GuxCalendar } from "../gux-calendar";
-describe('gux-calendar', () => {
-    let component;
-    let componentRoot;
-    let componentShadowRoot;
-    beforeEach(async () => {
-        component = new GuxCalendar();
-        component.calendarSelect = {
-            emit: jest.fn()
-        };
-        componentRoot = component.root;
-        componentShadowRoot = {};
-        componentRoot.shadowRoot = componentShadowRoot;
-        componentShadowRoot.querySelector = () => {
-            return null;
-        };
-        componentShadowRoot.querySelectorAll = () => {
-            return [];
-        };
-    });
-    it('builds', () => {
-        component.componentWillLoad();
-        component.render();
-        expect(component).toBeTruthy();
-    });
-    // Methods
-    describe('methods', () => {
-        const testDate = new Date(2020, 0, 15);
-        const testDateIso = '2020-01-15';
-        const rangeStart = new Date(1970, 0, 15);
-        const rangeEnd = new Date(1970, 0, 20);
-        const rangeIso = '1970-01-15/1970-01-20';
-        const spyEl = {
-            classList: {
-                add: jest.fn(),
-                contains: () => false
-            },
-            focus: jest.fn(),
-            setAttribute: jest.fn()
-        };
-        // Public
-        describe('public', () => {
-            it('setValue with single mode', async () => {
-                await component.setValue(testDate);
-                expect(component.previewValue).toEqual(testDate);
-                expect(component.value).toEqual(testDateIso);
-            });
-            it('setValue with range mode from-to', async () => {
-                component.mode = "range" /* CalendarModes.Range */;
-                await component.setValue([rangeStart, rangeEnd]);
-                expect(component.previewValue).toEqual(rangeStart);
-                expect(component.value).toEqual(rangeIso);
-            });
-            it('setValue with range mode to-from', async () => {
-                component.mode = "range" /* CalendarModes.Range */;
-                await component.setValue([rangeEnd, rangeStart]);
-                expect(component.previewValue).toEqual(rangeStart);
-                expect(component.value).toEqual(rangeIso);
-            });
-            it('focusPreviewDate', async () => {
-                await component.focusPreviewDate();
-                expect(spyEl.focus).not.toHaveBeenCalled();
-                componentShadowRoot.querySelector = () => {
-                    return spyEl;
-                };
-                await component.focusPreviewDate();
-                expect(spyEl.focus).toHaveBeenCalled();
-            });
-        });
-        // Private
-        describe('private', () => {
-            it('incrementPreviewDateByMonth', () => {
-                jest.useFakeTimers({ legacyFakeTimers: true });
-                const startingMonth = component.previewValue.getMonth();
-                component.incrementPreviewDateByMonth(3);
-                jest.runAllTimers();
-                expect(component.previewValue.getMonth()).toEqual((startingMonth + 3) % 12);
-            });
-            it('generateDatesFrom', () => {
-                component.value = rangeIso;
-                component.mode = "range" /* CalendarModes.Range */;
-                const result = component.generateDatesFrom(1, rangeEnd, 42);
-                expect(result[0].selected).toEqual(true);
-                expect(result).toEqual(expect.arrayContaining([
-                    expect.objectContaining({
-                        hidden: true
-                    })
-                ]));
-            });
-            it('addDays', () => {
-                const inc = 2;
-                const result = component.addDays(rangeEnd, inc);
-                expect(result.getDate()).toEqual(rangeEnd.getDate() + inc);
-            });
-            it('getAllDatesElements', () => {
-                const dummy = ['one', 'two'];
-                componentShadowRoot.querySelectorAll = () => {
-                    return dummy;
-                };
-                const result = component.getAllDatesElements();
-                expect(result).toEqual(dummy);
-            });
-            it('getRangeDatesElements', () => {
-                jest.spyOn(component, 'getRangeDates');
-                component.getRangeDatesElements(rangeStart, rangeEnd);
-                expect(component.getRangeDates).toHaveBeenCalledWith(rangeStart, rangeEnd);
-                componentShadowRoot.querySelector = () => {
-                    return 'dummy';
-                };
-                const result = component.getRangeDatesElements(rangeEnd, rangeStart);
-                expect(component.getRangeDates).toHaveBeenCalledWith(rangeStart, rangeEnd);
-                expect(result.length).toEqual(6);
-            });
-            it('onDateClick with single mode', async () => {
-                jest.spyOn(component, 'setValue').mockImplementation(() => {
-                    return Promise.resolve();
-                });
-                jest.spyOn(component, 'emitCalendarSelect').mockImplementation(() => {
-                    return;
-                });
-                await component.onDateClick(testDate);
-                expect(component.setValue).toHaveBeenCalledWith(testDate);
-                expect(component.emitCalendarSelect).toHaveBeenCalled();
-            });
-            it('onDateClick with range mode', async () => {
-                component.mode = "range" /* CalendarModes.Range */;
-                jest.spyOn(component, 'getAllDatesElements').mockImplementation(() => {
-                    return [];
-                });
-                jest.spyOn(utils, 'removeClassToElements').mockImplementation(() => {
-                    return;
-                });
-                jest.spyOn(component, 'emitCalendarSelect').mockImplementation(() => {
-                    return;
-                });
-                jest.spyOn(component, 'updateRangeElements').mockImplementation(() => {
-                    return;
-                });
-                await component.onDateClick(rangeStart);
-                await component.onDateClick(rangeEnd);
-                expect(component.emitCalendarSelect).toHaveBeenCalled();
-            });
-            it('onDateMouseEnter', () => {
-                jest.spyOn(component, 'updateRangeElements').mockImplementation(() => {
-                    return;
-                });
-                component.mode = "range" /* CalendarModes.Range */;
-                component.selectingDate = rangeStart;
-                component.onDateMouseEnter(rangeEnd);
-                expect(component.value.split('/')[1]).toEqual(rangeIso.split('/')[1]);
-                expect(component.updateRangeElements).toHaveBeenCalled();
-            });
-            it('onKeyDown', async () => {
-                jest.useFakeTimers({ legacyFakeTimers: true });
-                jest
-                    .spyOn(component, 'incrementPreviewDateByMonth')
-                    .mockImplementation(() => {
-                    return;
-                });
-                jest.spyOn(component, 'setValue').mockImplementation(() => {
-                    return Promise.resolve();
-                });
-                jest.spyOn(component, 'emitCalendarSelect').mockImplementation(() => {
-                    return;
-                });
-                const initialPreviewValue = rangeEnd;
-                component.previewValue = new Date(rangeEnd);
-                const days = initialPreviewValue.getDate();
-                let event = new KeyboardEvent('keydown', { key: 'ArrowDown' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.previewValue.getDate()).toEqual(days + 7);
-                event = new KeyboardEvent('keydown', { key: 'ArrowUp' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.previewValue.getDate()).toEqual(days);
-                event = new KeyboardEvent('keydown', { key: 'ArrowLeft' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.previewValue.getDate()).toEqual(days - 1);
-                event = new KeyboardEvent('keydown', { key: 'ArrowRight' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.previewValue.getDate()).toEqual(days);
-                event = new KeyboardEvent('keydown', { key: 'PageUp' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.incrementPreviewDateByMonth).toHaveBeenCalledWith(1);
-                event = new KeyboardEvent('keydown', { key: 'PageDown' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.incrementPreviewDateByMonth).toHaveBeenCalledWith(-1);
-                event = new KeyboardEvent('keydown', { key: 'Enter' });
-                await component.onKeyDown(event);
-                jest.runAllTimers();
-                expect(component.setValue).toHaveBeenCalledWith(initialPreviewValue);
-                expect(component.emitCalendarSelect).toHaveBeenCalled();
-            });
-        });
-    });
-    // Events
-    describe('events', () => {
-        it('onInput', () => {
-            const value = '2020-01-15';
-            component.value = value;
-            component.emitCalendarSelect();
-            expect(component.calendarSelect.emit).toHaveBeenCalledWith(value);
-        });
-    });
-    describe('check that when the clocks go forward at the end of march that april days are aligned correctly', () => {
-        it('checks to see if the first day of april is a friday', async () => {
-            //create date object that facilitates the extra hour for DST.
-            const apr = new Date(2022, 3, 1, 1, 0, 0, 0);
-            //set the components value to the apr date.
-            await component.setValue(apr);
-            //the expected value for the day should be equal to 5 which is Friday.
-            const expectedDay = 5;
-            //compare calendar component with expected value.
-            expect(component.previewValue.getDay()).toEqual(expectedDay);
-        });
-    });
-    describe('check that when the clocks fall back at the end of october that november days are aligned correctly', () => {
-        it('checks to see if the first day of november is a tuesday', async () => {
-            //create date object that facilitates the extra hour for DST.
-            const nov = new Date(2022, 10, 1, 1, 0, 0, 0);
-            //set the components value to the nov date.
-            await component.setValue(nov);
-            //the expected value for the day should be equal to 2 which is Tuesday.
-            const expectedDay = 2;
-            //compare calendar component with expected value.
-            expect(component.previewValue.getDay()).toEqual(expectedDay);
-        });
-    });
-});

package/dist/collection/components/stable/gux-calendar/tests/gux-calendar.service.spec.js

@@ -1,160 +0,0 @@
-import { firstDateInMonth, getWeekdays, getOffsetMonthDate, getDateMonthAndYearString } from "../gux-calendar.service";
-describe('calendar.service', () => {
-    describe('firstDateInMonth', () => {
-        [
-            {
-                year: 2022,
-                month: 0,
-                startDayOfWeek: 0,
-                expectedOutput: new Date('2021-12-26T01:00:00.000Z')
-            },
-            {
-                year: 2022,
-                month: 0,
-                startDayOfWeek: 1,
-                expectedOutput: new Date('2021-12-27T01:00:00.000Z')
-            },
-            {
-                year: 2022,
-                month: 0,
-                startDayOfWeek: 6,
-                expectedOutput: new Date('2022-01-01T01:00:00.000Z')
-            },
-            {
-                year: 2022,
-                month: 0,
-                startDayOfWeek: 7,
-                expectedOutput: new Date('2021-12-26T01:00:00.000Z')
-            }
-        ].forEach(({ year, month, startDayOfWeek, expectedOutput }) => {
-            it(`should work as expected for ${year}, ${month} and ${startDayOfWeek}`, () => {
-                expect(firstDateInMonth(month, year, startDayOfWeek)).toEqual(expectedOutput);
-            });
-        });
-    });
-    describe('getWeekdays', () => {
-        [
-            {
-                locale: 'en',
-                startDayOfWeek: 0,
-                expectedOutput: ['S', 'M', 'T', 'W', 'T', 'F', 'S']
-            },
-            {
-                locale: 'en',
-                startDayOfWeek: 1,
-                expectedOutput: ['M', 'T', 'W', 'T', 'F', 'S', 'S']
-            },
-            {
-                locale: 'en',
-                startDayOfWeek: 6,
-                expectedOutput: ['S', 'S', 'M', 'T', 'W', 'T', 'F']
-            },
-            {
-                locale: 'en',
-                startDayOfWeek: 7,
-                expectedOutput: ['S', 'M', 'T', 'W', 'T', 'F', 'S']
-            },
-            {
-                locale: 'en',
-                startDayOfWeek: 21,
-                expectedOutput: ['S', 'M', 'T', 'W', 'T', 'F', 'S']
-            }
-        ].forEach(({ locale, startDayOfWeek, expectedOutput }) => {
-            it(`should work as expected for ${locale} and ${startDayOfWeek}`, () => {
-                expect(getWeekdays(locale, startDayOfWeek)).toEqual(expectedOutput);
-            });
-        });
-    });
-    describe('getOffsetMonthDate', () => {
-        [
-            {
-                baseDate: new Date(2022, 0, 1),
-                monthDelta: 0,
-                expectedOutput: new Date(2022, 0, 1)
-            },
-            {
-                baseDate: new Date(2022, 0, 1),
-                monthDelta: 1,
-                expectedOutput: new Date(2022, 1, 1)
-            },
-            {
-                baseDate: new Date(2022, 0, 1),
-                monthDelta: 2,
-                expectedOutput: new Date(2022, 2, 1)
-            },
-            {
-                baseDate: new Date(2022, 1, 1),
-                monthDelta: 0,
-                expectedOutput: new Date(2022, 1, 1)
-            },
-            {
-                baseDate: new Date(2022, 0, 30),
-                monthDelta: 0,
-                expectedOutput: new Date(2022, 0, 1)
-            },
-            {
-                baseDate: new Date(2022, 0, 30),
-                monthDelta: 1,
-                expectedOutput: new Date(2022, 1, 1)
-            },
-            {
-                baseDate: new Date(2022, 0, 30),
-                monthDelta: 2,
-                expectedOutput: new Date(2022, 2, 1)
-            },
-            {
-                baseDate: new Date(2022, 11, 1),
-                monthDelta: 0,
-                expectedOutput: new Date(2022, 11, 1)
-            },
-            {
-                baseDate: new Date(2022, 11, 1),
-                monthDelta: 1,
-                expectedOutput: new Date(2023, 0, 1)
-            },
-            {
-                baseDate: new Date(2022, 11, 1),
-                monthDelta: 2,
-                expectedOutput: new Date(2023, 1, 1)
-            }
-        ].forEach(({ baseDate, monthDelta, expectedOutput }) => {
-            it(`should work as expected for ${baseDate.toISOString()} and monthDelta ${monthDelta}`, () => {
-                expect(getOffsetMonthDate(baseDate, monthDelta)).toEqual(expectedOutput);
-            });
-        });
-    });
-    describe('getDateMonthAndYearString', () => {
-        [
-            { locale: 'ar', expectedOutput: 'ديسمبر ٢٠٢٢' },
-            { locale: 'cs', expectedOutput: 'Prosinec 2022' },
-            { locale: 'da', expectedOutput: 'December 2022' },
-            { locale: 'de', expectedOutput: 'Dezember 2022' },
-            { locale: 'en', expectedOutput: 'December 2022' },
-            { locale: 'es', expectedOutput: 'Diciembre de 2022' },
-            { locale: 'es-es', expectedOutput: 'Diciembre de 2022' },
-            { locale: 'fi', expectedOutput: 'Joulukuu 2022' },
-            { locale: 'fr', expectedOutput: 'Décembre 2022' },
-            { locale: 'fr-ca', expectedOutput: 'Décembre 2022' },
-            { locale: 'he', expectedOutput: 'דצמבר 2022' },
-            { locale: 'it', expectedOutput: 'Dicembre 2022' },
-            { locale: 'ja', expectedOutput: '2022年12月' },
-            { locale: 'ko', expectedOutput: '2022년 12월' },
-            { locale: 'nl', expectedOutput: 'December 2022' },
-            { locale: 'no', expectedOutput: 'Desember 2022' },
-            { locale: 'pl', expectedOutput: 'Grudzień 2022' },
-            { locale: 'pt-br', expectedOutput: 'Dezembro de 2022' },
-            { locale: 'pt-pt', expectedOutput: 'Dezembro de 2022' },
-            { locale: 'ru', expectedOutput: 'Декабрь 2022 г.' },
-            { locale: 'sv', expectedOutput: 'December 2022' },
-            { locale: 'th', expectedOutput: 'ธันวาคม 2565' },
-            { locale: 'tr', expectedOutput: 'Aralık 2022' },
-            { locale: 'uk', expectedOutput: 'Грудень 2022 р.' },
-            { locale: 'zh-cn', expectedOutput: '2022年12月' },
-            { locale: 'zh-tw', expectedOutput: '2022年12月' }
-        ].forEach(({ locale, expectedOutput }) => {
-            it(`should work as expected for ${locale}`, () => {
-                expect(getDateMonthAndYearString(new Date(2022, 11, 31), locale)).toEqual(expectedOutput);
-            });
-        });
-    });
-});

package/dist/collection/components/stable/gux-calendar/tests/gux-calendar.spec.js

@@ -1,62 +0,0 @@
-const useRegionalDates = jest.fn().mockReturnValue(false);
-jest.mock('i18n/use-regional-dates', () => ({
-    __esModule: true,
-    useRegionalDates
-}));
-import { newSpecPage } from "../../../../test/specTestUtils";
-import { GuxCalendar } from "../gux-calendar";
-import { languageList } from "../../../../i18n/languageList";
-const components = [GuxCalendar];
-const language = 'en';
-const testCases = [
-    `<gux-calendar mode="single" value="1997-08-29"></gux-calendar>`,
-    `<gux-calendar mode="range" number-of-months="2" value="2019-11-25/2019-12-02"></gux-calendar>`,
-    `<gux-calendar mode="single" value="1997-08-29" start-day-of-week="6"></gux-calendar>`,
-    `<gux-calendar mode="single" value="1997-08-29" lang="ar"></gux-calendar>`
-];
-describe('gux-datepicker', () => {
-    it('should build', async () => {
-        const page = await newSpecPage({
-            components,
-            html: `<gux-calendar></gux-calendar>`,
-            language
-        });
-        expect(page.rootInstance).toBeInstanceOf(GuxCalendar);
-    });
-    describe('#render', () => {
-        describe('#render using non regional dates', () => {
-            beforeAll(() => {
-                useRegionalDates.mockReturnValue(false);
-            });
-            languageList.forEach(language => {
-                testCases.forEach((input, index) => {
-                    it(`should render component as expected (${index + 1})`, async () => {
-                        const page = await newSpecPage({
-                            components,
-                            html: input,
-                            language
-                        });
-                        expect(page.root).toMatchSnapshot();
-                    });
-                });
-            });
-        });
-        describe('#render using regional dates', () => {
-            beforeAll(() => {
-                useRegionalDates.mockReturnValue(true);
-            });
-            languageList.forEach(language => {
-                testCases.forEach((input, index) => {
-                    it(`should render component as expected (${index + 1})`, async () => {
-                        const page = await newSpecPage({
-                            components,
-                            html: input,
-                            language
-                        });
-                        expect(page.root).toMatchSnapshot();
-                    });
-                });
-            });
-        });
-    });
-});

package/dist/collection/components/stable/gux-card/tests/gux-card.e2e.js

@@ -1,16 +0,0 @@
-import { newSparkE2EPage, a11yCheck } from "../../../../test/e2eTestUtils";
-describe('#render different card accents', () => {
-    [
-        '<gux-card><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="bordered"><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="raised"><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="borderless"><span>This is a content slot</span></gux-card>'
-    ].forEach((html, index) => {
-        it(`should render component as expected (${index + 1})`, async () => {
-            const page = await newSparkE2EPage({ html });
-            const element = await page.find('gux-card');
-            await a11yCheck(page);
-            expect(element.outerHTML).toMatchSnapshot();
-        });
-    });
-});

package/dist/collection/components/stable/gux-card/tests/gux-card.spec.js

@@ -1,17 +0,0 @@
-import { newSpecPage } from "../../../../test/specTestUtils";
-import { GuxCard } from "../gux-card";
-const components = [GuxCard];
-const language = 'en';
-describe('#render different card accents', () => {
-    [
-        '<gux-card><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="bordered"><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="raised"><span>This is a content slot</span></gux-card>',
-        '<gux-card accent="borderless"><span>This is a content slot</span></gux-card>'
-    ].forEach((html, index) => {
-        it(`should render component as expected (${index + 1})`, async () => {
-            const page = await newSpecPage({ components, html, language });
-            expect(page.root).toMatchSnapshot();
-        });
-    });
-});

package/dist/collection/components/stable/gux-column-manager/gux-column-manager-item/tests/gux-column-manager-item.service.spec.js

@@ -1,35 +0,0 @@
-import { getNewIndex } from "../gux-column-manager-item.service";
-describe('gux-column-manager-item.service', () => {
-    describe('#getOrderChange', () => {
-        [
-            {
-                oldIndex: 0,
-                dropIndex: 5,
-                mouseOnTopHalfOfDropElement: true,
-                expectedOutput: 4
-            },
-            {
-                oldIndex: 0,
-                dropIndex: 5,
-                mouseOnTopHalfOfDropElement: false,
-                expectedOutput: 5
-            },
-            {
-                oldIndex: 5,
-                dropIndex: 0,
-                mouseOnTopHalfOfDropElement: true,
-                expectedOutput: 0
-            },
-            {
-                oldIndex: 5,
-                dropIndex: 0,
-                mouseOnTopHalfOfDropElement: false,
-                expectedOutput: 1
-            }
-        ].forEach(({ oldIndex, dropIndex, mouseOnTopHalfOfDropElement, expectedOutput }, index) => {
-            it(`should work as expected ${index + 1}`, async () => {
-                expect(getNewIndex(oldIndex, dropIndex, mouseOnTopHalfOfDropElement)).toBe(expectedOutput);
-            });
-        });
-    });
-});