cronofy-elements 1.48.2 → 1.49.2

package/tests/DateTimePicker/utils.test.js

@@ -1,515 +0,0 @@
-import * as utils from "../../src/js/components/DateTimePicker/utils/slots";
-import {
-    rawSlots,
-    testSequencedSlotsObject,
-    testSequencedSlotsObjectWithTitle,
-    testSequencedSlotsArray,
-    testSequencedQuery,
-    testSequencedQueryWithTitle,
-} from "./dummy-data";
-import moment from "moment-timezone";
-
-describe("DateTimePicker utils", () => {
-    it("Gets months from single period", () => {
-        const singleMonthPeriod = {
-            start: "2021-06-11T00:00:00Z",
-            end: "2021-06-12T23:00:00Z",
-        };
-        const singleMonthPeriodResult = utils.getMonthsCoveredByPeriod(
-            singleMonthPeriod,
-            "Etc/UTC"
-        );
-        expect(singleMonthPeriodResult.length).toBe(1);
-        expect(singleMonthPeriodResult[0]).toBe("2021-06");
-
-        const twoMonthPeriod = {
-            start: "2021-06-11T00:00:00Z",
-            end: "2021-07-12T23:00:00Z",
-        };
-        const twoMonthPeriodResult = utils.getMonthsCoveredByPeriod(twoMonthPeriod, "Etc/UTC");
-        expect(twoMonthPeriodResult.length).toBe(2);
-        expect(twoMonthPeriodResult[0]).toBe("2021-06");
-        expect(twoMonthPeriodResult[1]).toBe("2021-07");
-
-        const multiMonthPeriod = {
-            start: "2021-06-11T00:00:00Z",
-            end: "2021-10-12T23:00:00Z",
-        };
-        const multiMonthPeriodResult = utils.getMonthsCoveredByPeriod(multiMonthPeriod, "Etc/UTC");
-        expect(multiMonthPeriodResult.length).toBe(5);
-        expect(multiMonthPeriodResult[0]).toBe("2021-06");
-        expect(multiMonthPeriodResult[1]).toBe("2021-07");
-        expect(multiMonthPeriodResult[2]).toBe("2021-08");
-        expect(multiMonthPeriodResult[3]).toBe("2021-09");
-        expect(multiMonthPeriodResult[4]).toBe("2021-10");
-    });
-
-    it("Gets months from full query_period", () => {
-        const periods = [
-            {
-                start: "2021-06-11T00:00:00Z",
-                end: "2021-06-12T23:00:00Z",
-            },
-            {
-                start: "2021-06-13T00:00:00Z",
-                end: "2021-07-14T23:00:00Z",
-            },
-        ];
-
-        const result = utils.getMonthsFromQuery(periods, "Etc/UTC");
-        expect(result.length).toBe(2);
-        expect(result[0]).toBe("2021-06");
-        expect(result[1]).toBe("2021-07");
-    });
-
-    it("Trims a period to be within a specific start and end time", () => {
-        const startLimit = "2021-06-01T00:00:00Z";
-        const endLimit = "2021-06-30T23:59:00Z";
-
-        // Trims both ends if both overlap
-        const fullyOverlappingPeriod = {
-            start: "2021-05-11T00:00:00Z",
-            end: "2021-07-14T23:00:00Z",
-        };
-        const trimmedFullyOverlappingPeriod = utils.trimPeriod(
-            fullyOverlappingPeriod,
-            startLimit,
-            endLimit
-        );
-        expect(trimmedFullyOverlappingPeriod.start).toBe(startLimit);
-        expect(trimmedFullyOverlappingPeriod.end).toBe(endLimit);
-
-        // Only trims end if only end overlaps
-        const partOverlappingPeriod_1 = {
-            start: "2021-06-11T00:00:00Z",
-            end: "2021-07-14T23:00:00Z",
-        };
-        const trimmedPartOverlappingPeriod_1 = utils.trimPeriod(
-            partOverlappingPeriod_1,
-            startLimit,
-            endLimit
-        );
-        expect(trimmedPartOverlappingPeriod_1.start).toBe(partOverlappingPeriod_1.start);
-        expect(trimmedPartOverlappingPeriod_1.end).toBe(endLimit);
-
-        // Only trims start if only start overlaps
-        const partOverlappingPeriod_2 = {
-            start: "2021-05-11T00:00:00Z",
-            end: "2021-06-14T23:00:00Z",
-        };
-        const trimmedPartOverlappingPeriod_2 = utils.trimPeriod(
-            partOverlappingPeriod_2,
-            startLimit,
-            endLimit
-        );
-        expect(trimmedPartOverlappingPeriod_2.start).toBe(startLimit);
-        expect(trimmedPartOverlappingPeriod_2.end).toBe(partOverlappingPeriod_2.end);
-
-        // Does no trimming if there is no overlap
-        const nonOverlappingPeriod = {
-            start: "2021-06-11T00:00:00Z",
-            end: "2021-06-14T23:00:00Z",
-        };
-        const trimmedNonOverlappingPeriod = utils.trimPeriod(
-            nonOverlappingPeriod,
-            startLimit,
-            endLimit
-        );
-        expect(trimmedNonOverlappingPeriod.start).toBe(nonOverlappingPeriod.start);
-        expect(trimmedNonOverlappingPeriod.end).toBe(nonOverlappingPeriod.end);
-    });
-
-    it("gets tz-aware start and end times for a given month", () => {
-        const month__UTC = utils.getMonthBounds("2021-07", "Etc/UTC");
-        expect(month__UTC.start).toBe("2021-07-01T00:00:00Z");
-        expect(month__UTC.end).toBe("2021-07-31T23:59:00Z");
-
-        const month__London = utils.getMonthBounds("2021-07", "Europe/London");
-        expect(month__London.start).toBe("2021-06-30T23:00:00Z");
-        expect(month__London.end).toBe("2021-07-31T22:59:00Z");
-
-        const month__Fiji = utils.getMonthBounds("2021-07", "Pacific/Fiji");
-        expect(month__Fiji.start).toBe("2021-06-30T12:00:00Z");
-        expect(month__Fiji.end).toBe("2021-07-31T11:59:00Z");
-
-        const month__New_Salem = utils.getMonthBounds("2021-07", "America/North_Dakota/New_Salem");
-        expect(month__New_Salem.start).toBe("2021-07-01T05:00:00Z");
-        expect(month__New_Salem.end).toBe("2021-08-01T04:59:00Z");
-    });
-
-    it("gets slots for a single day", () => {
-        const exampleSlots = { ...rawSlots };
-        const slotsByDay = utils.getSlotsByDay(exampleSlots, "2021-06-18", "Europe/London");
-        expect(slotsByDay.length).toBe(3);
-    });
-
-    it("adds sequenced slots to object", () => {
-        const exampleSlots = [...testSequencedSlotsArray];
-        const slotsObject = utils.addSequencedSlotsToObject(
-            {},
-            exampleSlots,
-            testSequencedQuery.sequence
-        );
-        expect(slotsObject).toStrictEqual(testSequencedSlotsObject);
-    });
-
-    it("adds sequenced slots to object with sequence title", () => {
-        const exampleSlots = [...testSequencedSlotsArray];
-        const slotsObject = utils.addSequencedSlotsToObject(
-            {},
-            exampleSlots,
-            testSequencedQueryWithTitle.sequence
-        );
-        expect(slotsObject).toStrictEqual(testSequencedSlotsObjectWithTitle);
-    });
-
-    describe("Parses the timezone list correctly", () => {
-        it("gets timezone list", () => {
-            const timezones = ["Europe/London", "Asia/Kathmandu", "Pacific/Fiji"];
-
-            const result = [
-                {
-                    tzid: "Europe/London",
-                    offset: moment.tz("Europe/London").format("Z"),
-                    offsetMins: moment.tz("Europe/London").utcOffset(),
-                    name: "London",
-                    abbr: moment.tz("Europe/London").zoneAbbr(),
-                },
-                {
-                    tzid: "Asia/Kathmandu",
-                    offset: moment.tz("Asia/Kathmandu").format("Z"),
-                    offsetMins: moment.tz("Asia/Kathmandu").utcOffset(),
-                    name: "Kathmandu",
-                    abbr: moment.tz("Asia/Kathmandu").zoneAbbr(),
-                },
-                {
-                    tzid: "Pacific/Fiji",
-                    offset: moment.tz("Pacific/Fiji").format("Z"),
-                    offsetMins: moment.tz("Pacific/Fiji").utcOffset(),
-                    name: "Fiji",
-                    abbr: moment.tz("Pacific/Fiji").zoneAbbr(),
-                },
-            ];
-            result.sort((tzA, tzB) => tzA.offsetMins - tzB.offsetMins);
-
-            const tzid = "Europe/London";
-
-            const tzList = utils.parseTzList(timezones, tzid);
-
-            expect(tzList.length).toBe(3);
-            expect(tzList).toEqual(result);
-        });
-
-        it("gets timezone list with a tzid that isn't in the list", () => {
-            const timezones = [
-                "Europe/London",
-                "Asia/Kathmandu",
-                "Pacific/Fiji",
-                "Africa/Dar_es_Salaam",
-            ];
-
-            const result = [
-                {
-                    tzid: "Europe/London",
-                    offset: moment.tz("Europe/London").format("Z"),
-                    offsetMins: moment.tz("Europe/London").utcOffset(),
-                    name: "London",
-                    abbr: moment.tz("Europe/London").zoneAbbr(),
-                },
-                {
-                    tzid: "Asia/Kathmandu",
-                    offset: moment.tz("Asia/Kathmandu").format("Z"),
-                    offsetMins: moment.tz("Asia/Kathmandu").utcOffset(),
-                    name: "Kathmandu",
-                    abbr: moment.tz("Asia/Kathmandu").zoneAbbr(),
-                },
-                {
-                    tzid: "Africa/Libreville",
-                    offset: moment.tz("Africa/Libreville").format("Z"),
-                    offsetMins: moment.tz("Africa/Libreville").utcOffset(),
-                    name: "Libreville",
-                    abbr: moment.tz("Africa/Libreville").zoneAbbr(),
-                },
-                {
-                    tzid: "Pacific/Fiji",
-                    offset: moment.tz("Pacific/Fiji").format("Z"),
-                    offsetMins: moment.tz("Pacific/Fiji").utcOffset(),
-                    name: "Fiji",
-                    abbr: moment.tz("Pacific/Fiji").zoneAbbr(),
-                },
-                {
-                    tzid: "Africa/Dar_es_Salaam",
-                    offset: moment.tz("Africa/Dar_es_Salaam").format("Z"),
-                    offsetMins: moment.tz("Africa/Dar_es_Salaam").utcOffset(),
-                    name: "Dar es Salaam",
-                    abbr: moment.tz("Africa/Dar_es_Salaam").zoneAbbr(),
-                },
-            ];
-            result.sort((tzA, tzB) => tzA.offsetMins - tzB.offsetMins);
-
-            const tzid = "Africa/Libreville";
-
-            const tzList = utils.parseTzList(timezones, tzid);
-
-            expect(tzList.length).toBe(5);
-            expect(tzList).toEqual(result);
-        });
-
-        it("gets initial selected tzid", () => {
-            const tzList = [
-                {
-                    tzid: "Europe/London",
-                    offset: moment.tz("Europe/London").format("Z"),
-                    offsetMins: moment.tz("Europe/London").utcOffset(),
-                    name: "London",
-                    abbr: moment.tz("Europe/London").zoneAbbr(),
-                },
-                {
-                    tzid: "Asia/Kathmandu",
-                    offset: moment.tz("Asia/Kathmandu").format("Z"),
-                    offsetMins: moment.tz("Asia/Kathmandu").utcOffset(),
-                    name: "Kathmandu",
-                    abbr: moment.tz("Asia/Kathmandu").zoneAbbr(),
-                },
-                {
-                    tzid: "Pacific/Fiji",
-                    offset: moment.tz("Pacific/Fiji").format("Z"),
-                    offsetMins: moment.tz("Pacific/Fiji").utcOffset(),
-                    name: "Fiji",
-                    abbr: moment.tz("Pacific/Fiji").zoneAbbr(),
-                },
-            ];
-            const tzid = "Europe/London";
-
-            const result = {
-                tzid: "Europe/London",
-                offset: moment.tz("Europe/London").format("Z"),
-                offsetMins: moment.tz("Europe/London").utcOffset(),
-                name: "London",
-                abbr: moment.tz("Europe/London").zoneAbbr(),
-            };
-            const selectedTzid = utils.getInitialSelectedTzid(tzList, tzid);
-
-            expect(selectedTzid).toEqual(result);
-        });
-    });
-
-    describe("getMonthObjectsFromQuery", () => {
-        const tzid = "Etc/UTC";
-
-        it("returns the currentMonth when query_periods is empty", () => {
-            const query_periods = [];
-
-            const query = {
-                query_periods,
-            };
-
-            const expected = [
-                {
-                    month: moment.tz().format("YYYY-MM"),
-                    current: true,
-                },
-            ];
-
-            const actual = utils.getMonthObjectsFromQuery(query, tzid);
-
-            expect(actual).toEqual(expected);
-        });
-
-        describe("when query_periods is populated", () => {
-            const query_periods = [
-                {
-                    start: "2021-06-11T00:00:00Z",
-                    end: "2021-06-12T23:00:00Z",
-                },
-                {
-                    start: "2021-06-13T00:00:00Z",
-                    end: "2021-07-14T23:00:00Z",
-                },
-            ];
-
-            it("returns list based on query_periods", () => {
-                const query = {
-                    query_periods,
-                };
-
-                const expected = [
-                    {
-                        month: "2021-06",
-                        current: true,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-06-12T23:00:00Z",
-                                    start: "2021-06-11T00:00:00Z",
-                                },
-                                {
-                                    end: "2021-06-30T23:59:00Z",
-                                    start: "2021-06-13T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                    {
-                        month: "2021-07",
-                        current: false,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-07-14T23:00:00Z",
-                                    start: "2021-07-01T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                ];
-
-                const actual = utils.getMonthObjectsFromQuery(query, tzid);
-
-                expect(actual).toEqual(expected);
-            });
-
-            it("correctly sets max_results", () => {
-                const query = {
-                    query_periods,
-                    max_results: 15,
-                };
-
-                const expected = [
-                    {
-                        month: "2021-06",
-                        current: true,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-06-12T23:00:00Z",
-                                    start: "2021-06-11T00:00:00Z",
-                                },
-                                {
-                                    end: "2021-06-30T23:59:00Z",
-                                    start: "2021-06-13T00:00:00Z",
-                                },
-                            ],
-                            max_results: 15,
-                        },
-                    },
-                    {
-                        month: "2021-07",
-                        current: false,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-07-14T23:00:00Z",
-                                    start: "2021-07-01T00:00:00Z",
-                                },
-                            ],
-                            max_results: 15,
-                        },
-                    },
-                ];
-
-                const actual = utils.getMonthObjectsFromQuery(query, tzid);
-
-                expect(actual).toEqual(expected);
-            });
-
-            it("defaults max_results to 512", () => {
-                const query = {
-                    query_periods,
-                };
-
-                const expected = [
-                    {
-                        month: "2021-06",
-                        current: true,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-06-12T23:00:00Z",
-                                    start: "2021-06-11T00:00:00Z",
-                                },
-                                {
-                                    end: "2021-06-30T23:59:00Z",
-                                    start: "2021-06-13T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                    {
-                        month: "2021-07",
-                        current: false,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-07-14T23:00:00Z",
-                                    start: "2021-07-01T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                ];
-
-                const actual = utils.getMonthObjectsFromQuery(query, tzid);
-
-                expect(actual).toEqual(expected);
-            });
-
-            it("returns with the correct month set to current when selectedDay is set", () => {
-                const selectedDay = "2021-07";
-
-                const query = {
-                    query_periods,
-                };
-
-                const expected = [
-                    {
-                        month: "2021-06",
-                        current: false,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-06-12T23:00:00Z",
-                                    start: "2021-06-11T00:00:00Z",
-                                },
-                                {
-                                    end: "2021-06-30T23:59:00Z",
-                                    start: "2021-06-13T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                    {
-                        month: "2021-07",
-                        current: true,
-                        loading: true,
-                        query: {
-                            query_periods: [
-                                {
-                                    end: "2021-07-14T23:00:00Z",
-                                    start: "2021-07-01T00:00:00Z",
-                                },
-                            ],
-                            max_results: 512,
-                        },
-                    },
-                ];
-
-                const actual = utils.getMonthObjectsFromQuery(query, tzid, selectedDay);
-
-                expect(actual).toEqual(expected);
-            });
-        });
-    });
-});

package/tests/colors.test.js

@@ -1,70 +0,0 @@
-import * as colors from "../src/js/helpers/colors";
-
-describe("Colors", () => {
-    // hexToRGB
-    it("converts a hex code into an RGB value", () => {
-        expect(colors.hexToRGB("ff00ee")).toEqual([255, 0, 238]);
-        expect(colors.hexToRGB("000000")).toEqual([0, 0, 0]);
-        expect(colors.hexToRGB("ffffff")).toEqual([255, 255, 255]);
-    });
-
-    // normalize
-    it("normalizes values to within 0 and 255", () => {
-        expect(colors.normalize(-24)).toEqual(0);
-        expect(colors.normalize(24)).toEqual(24);
-        expect(colors.normalize(260)).toEqual(255);
-        expect(colors.normalize(1)).toEqual(1);
-        expect(colors.normalize(255)).toEqual(255);
-    });
-
-    // shift
-    it("shifts a color by a given amount", () => {
-        expect(colors.shift("aaaaaa", 10)).toEqual("#b4b4b4");
-        expect(colors.shift("#aabbcc", 10)).toEqual("#b4c5d6");
-        expect(colors.shift("#aabbcc", 255)).toEqual("#ffffff");
-        expect(colors.shift("aabbcc", -255)).toEqual("#000000");
-    });
-
-    // getCalendarColors
-    it("gets the colors for a calendar when no calendar-colors have been set", () => {
-        const themeColors = {
-            black: "#4d4d4d",
-            greyLight: "#e4ebf2",
-            white: "#FFFFFF",
-        };
-        const calendarColors = {
-            ...themeColors,
-            calendars: [],
-            dark: "#7d9ec0",
-            main: "#e4ebf2",
-            mid: "#c2d2e1",
-            text: "#4d4d4d",
-        };
-        expect(colors.getCalendarColors(themeColors, 1)).toEqual(calendarColors);
-    });
-    // getCalendarColors
-    it("gets the colors for a calendar when calendar-colors are provided", () => {
-        const themeColors = {
-            black: "#4d4d4d",
-            calendars: ["#ff0000", "#00ff00"],
-            greyLight: "#e4ebf2",
-            white: "#ffffff",
-        };
-        const calendarColors_0 = {
-            ...themeColors,
-            dark: "#600",
-            main: "#ff0000",
-            mid: "#c00",
-            text: "#ffffff",
-        };
-        const calendarColors_1 = {
-            ...themeColors,
-            dark: "#060",
-            main: "#00ff00",
-            mid: "#0c0",
-            text: "#4d4d4d",
-        };
-        expect(colors.getCalendarColors(themeColors, 0)).toEqual(calendarColors_0);
-        expect(colors.getCalendarColors(themeColors, 1)).toEqual(calendarColors_1);
-    });
-});