cronofy-elements 1.48.2 → 1.49.2

package/tests/utils.AvailabilityViewer.test.js

@@ -1,1800 +0,0 @@
-import * as utils from "../src/js/helpers/utils.AvailabilityViewer";
-
-describe("Utilities: AvailabilityViewer", () => {
-    // addKeysToSlots
-    it("turns an array of slots into an object, using the start date as a key", () => {
-        const input = [
-            {
-                end: "2019-04-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-04-06T08:00:00Z",
-            },
-            {
-                end: "2019-05-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-05-06T08:00:00Z",
-            },
-            {
-                end: "2019-05-07T09:00:00Z",
-                start: "2019-05-07T08:00:00Z",
-            },
-        ];
-
-        const expectedOutput = {
-            "2019-04-06T08:00:00Z": {
-                end: "2019-04-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-04-06T08:00:00Z",
-            },
-            "2019-05-06T08:00:00Z": {
-                end: "2019-05-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-05-06T08:00:00Z",
-            },
-            "2019-05-07T08:00:00Z": {
-                end: "2019-05-07T09:00:00Z",
-                start: "2019-05-07T08:00:00Z",
-            },
-        };
-
-        expect(utils.addKeysToSlots(input)).toEqual(expectedOutput);
-    });
-
-    // sortKeys
-    it("sorts array of date-keys into ascending order", () => {
-        const input = [
-            "2019-05-06T08:00:00Z",
-            "2019-04-06T08:00:00Z",
-            "2019-05-07T08:00:00Z",
-            "2018-05-07T08:00:00Z",
-            "2018-05-07T10:00:00Z",
-            "2018-05-07T09:00:00Z",
-            "2020-05-07T08:00:00Z",
-        ];
-
-        const expectedOutput = [
-            "2018-05-07T08:00:00Z",
-            "2018-05-07T09:00:00Z",
-            "2018-05-07T10:00:00Z",
-            "2019-04-06T08:00:00Z",
-            "2019-05-06T08:00:00Z",
-            "2019-05-07T08:00:00Z",
-            "2020-05-07T08:00:00Z",
-        ];
-
-        expect(utils.sortKeys(input)).toEqual(expectedOutput);
-    });
-
-    // getMinMaxDates
-    it("gets the first and last start-dates for a given set of slots", () => {
-        const input = {
-            "2019-04-06T08:00:00Z": {
-                end: "2019-04-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-04-06T08:00:00Z",
-            },
-            "2019-05-06T08:00:00Z": {
-                end: "2019-05-06T09:00:00Z",
-                participants: [{ sub: "EXAMPLE_SUB" }],
-                start: "2019-05-06T08:00:00Z",
-            },
-            "2019-05-07T08:00:00Z": {
-                end: "2019-05-07T09:00:00Z",
-                start: "2019-05-07T08:00:00Z",
-            },
-        };
-
-        const expectedOutput = {
-            max: moment
-                .utc("2019-05-07T08:00:00Z", "YYYY-MM-DDTHH:mm:00Z")
-                .local()
-                .format("YYYY-MM-DD"),
-            min: moment
-                .utc("2019-04-06T08:00:00Z", "YYYY-MM-DDTHH:mm:00Z")
-                .local()
-                .format("YYYY-MM-DD"),
-        };
-
-        expect(utils.getMinMaxDates(input)).toEqual(expectedOutput);
-    });
-
-    it("provides sensible fallbacks for min/max when there's no data", () => {
-        const expectedOutput = {
-            min: moment.utc().format("YYYY-MM-DD"),
-            max: moment.utc().add(1, "days").format("YYYY-MM-DD"),
-        };
-        expect(utils.getMinMaxDates()).toEqual(expectedOutput);
-    });
-
-    describe("getAllWeekDays", () => {
-        it("gets all the week days for a given period", () => {
-            const input = {
-                startDate: "2019-04-02", // Tue
-                endDate: "2019-04-04", // Thu
-            };
-
-            const out = [
-                "2019-03-31", // Sun
-                "2019-04-01", // Mon
-                "2019-04-02", // Tue
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-            ];
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period with a specific start day", () => {
-            const input = {
-                startDate: "2019-04-02", // Tue
-                endDate: "2019-04-04", // Thu
-                startDay: "wednesday",
-            };
-
-            const out = [
-                "2019-03-27", // Wed
-                "2019-03-28", // Thu
-                "2019-03-29", // Fri
-                "2019-03-30", // Sat
-                "2019-03-31", // Sun
-                "2019-04-01", // Mon
-                "2019-04-02", // Tue
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-                "2019-04-07", // Sun
-                "2019-04-08", // Mon
-                "2019-04-09", // Tue
-            ];
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that spans two weeks", () => {
-            const input = {
-                startDate: "2019-04-02", // Tue 1
-                endDate: "2019-04-10", // Wed 2
-            };
-
-            const out = [
-                "2019-03-31", // Sun
-                "2019-04-01", // Mon
-                "2019-04-02", // Tue
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-                "2019-04-07", // Sun 2
-                "2019-04-08", // Mon 2
-                "2019-04-09", // Tue 2
-                "2019-04-10", // Wed 2
-                "2019-04-11", // Thu 2
-                "2019-04-12", // Fri 2
-                "2019-04-13", // Sat 2
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that spans two weeks with a specific start day", () => {
-            const input = {
-                startDate: "2019-04-04", // Thu 1
-                endDate: "2019-04-10", // Wed 2
-                startDay: "wednesday",
-            };
-
-            const out = [
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-                "2019-04-07", // Sun
-                "2019-04-08", // Mon
-                "2019-04-09", // Tue
-                "2019-04-10", // Wed 2
-                "2019-04-11", // Thu 2
-                "2019-04-12", // Fri 2
-                "2019-04-13", // Sat 2
-                "2019-04-14", // Sun 2
-                "2019-04-15", // Mon 2
-                "2019-04-16", // Tue 2
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that spans three weeks", () => {
-            const input = {
-                startDate: "2019-04-02", // Tue 1
-                endDate: "2019-04-16", // Tue 3
-            };
-
-            const out = [
-                "2019-03-31", // Sun
-                "2019-04-01", // Mon
-                "2019-04-02", // Tue
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-                "2019-04-07", // Sun 2
-                "2019-04-08", // Mon 2
-                "2019-04-09", // Tue 2
-                "2019-04-10", // Wed 2
-                "2019-04-11", // Thu 2
-                "2019-04-12", // Fri 2
-                "2019-04-13", // Sat 2
-                "2019-04-14", // Sun 3
-                "2019-04-15", // Mon 3
-                "2019-04-16", // Tue 3
-                "2019-04-17", // Wed 3
-                "2019-04-18", // Thu 3
-                "2019-04-19", // Fri 3
-                "2019-04-20", // Sat 3
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that spans three weeks with a specific start day", () => {
-            const input = {
-                startDate: "2019-04-04", // Thu 1
-                endDate: "2019-04-18", // Thu 3
-                startDay: "wednesday",
-            };
-
-            const out = [
-                "2019-04-03", // Wed
-                "2019-04-04", // Thu
-                "2019-04-05", // Fri
-                "2019-04-06", // Sat
-                "2019-04-07", // Sun
-                "2019-04-08", // Mon
-                "2019-04-09", // Tue
-                "2019-04-10", // Wed 2
-                "2019-04-11", // Thu 2
-                "2019-04-12", // Fri 2
-                "2019-04-13", // Sat 2
-                "2019-04-14", // Sun 2
-                "2019-04-15", // Mon 2
-                "2019-04-16", // Tue 2
-                "2019-04-17", // Wed 3
-                "2019-04-18", // Thu 3
-                "2019-04-19", // Fri 3
-                "2019-04-20", // Sat 3
-                "2019-04-21", // Sun 3
-                "2019-04-22", // Mon 3
-                "2019-04-23", // Tue 3
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that starts on a Sunday", () => {
-            const input = {
-                startDate: "2020-06-07", // Sun
-                endDate: "2020-06-10", // Wed
-            };
-
-            const out = [
-                "2020-06-07", // Sun
-                "2020-06-08", // Mon
-                "2020-06-09", // Tue
-                "2020-06-10", // Wed
-                "2020-06-11", // Thu
-                "2020-06-12", // Fri
-                "2020-06-13", // Sat
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that starts on a Saturday", () => {
-            const input = {
-                startDate: "2020-06-06", // Sat
-                endDate: "2020-06-10", // Wed
-            };
-
-            const out = [
-                "2020-05-31", // Sun
-                "2020-06-01", // Mon
-                "2020-06-02", // Tue
-                "2020-06-03", // Wed
-                "2020-06-04", // Thu
-                "2020-06-05", // Fri
-                "2020-06-06", // Sat
-                "2020-06-07", // Sun
-                "2020-06-08", // Mon
-                "2020-06-09", // Tue
-                "2020-06-10", // Wed
-                "2020-06-11", // Thu
-                "2020-06-12", // Fri
-                "2020-06-13", // Sat
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-
-        it("gets all the week days for a given period that starts on the same day as provided as a week_start_day", () => {
-            const input = {
-                startDate: "2020-06-09", // Tue
-                endDate: "2020-06-12", // Fri
-                startDay: "tuesday",
-            };
-
-            const out = [
-                "2020-06-09", // Tue
-                "2020-06-10", // Wed
-                "2020-06-11", // Thu
-                "2020-06-12", // Fri
-                "2020-06-13", // Sat
-                "2020-06-14", // Sun
-                "2020-06-15", // Mon
-            ];
-
-            expect(utils.getAllWeekDays(input)).toEqual(out);
-        });
-    });
-
-    describe("cropQuery", () => {
-        const cropExtent = {
-            startTime: "09:00",
-            endTime: "17:00",
-            days: [
-                "2020-11-06",
-                "2020-11-07",
-                "2020-11-08",
-                "2020-11-09",
-                "2020-11-10",
-                "2020-11-11",
-                "2020-11-12",
-            ],
-            currentPage: 1,
-        };
-
-        const query = {
-            participants: [
-                {
-                    required: "all",
-                    members: [{ sub: "SUB" }],
-                },
-            ],
-            required_duration: { minutes: 60 },
-        };
-
-        it("correctly crops a single overlapping period", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-09T06:00:00Z",
-                        end: "2020-11-09T19:00:00Z",
-                    },
-                ],
-            };
-            const out = [{ start: "2020-11-09T09:00:00Z", end: "2020-11-09T17:00:00Z" }];
-            expect(utils.cropQuery(input, cropExtent).query_periods).toEqual(out);
-        });
-
-        it("correctly crops multiple overlapping periods", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-09T06:00:00Z",
-                        end: "2020-11-09T19:00:00Z",
-                    },
-                    {
-                        start: "2020-11-10T06:00:00Z",
-                        end: "2020-11-10T12:00:00Z",
-                    },
-                    {
-                        start: "2020-11-11T06:00:00Z",
-                        end: "2020-11-11T19:00:00Z",
-                    },
-                ],
-            };
-            const out = [
-                { start: "2020-11-09T09:00:00Z", end: "2020-11-09T17:00:00Z" },
-                { start: "2020-11-10T09:00:00Z", end: "2020-11-10T12:00:00Z" },
-                { start: "2020-11-11T09:00:00Z", end: "2020-11-11T17:00:00Z" },
-            ];
-            expect(utils.cropQuery(input, cropExtent).query_periods).toEqual(out);
-        });
-
-        it("correctly crops huge overlapping periods", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-10-09T06:00:00Z",
-                        end: "2020-12-09T19:00:00Z",
-                    },
-                ],
-            };
-            const out = [
-                { start: "2020-11-06T09:00:00Z", end: "2020-11-06T17:00:00Z" },
-                { start: "2020-11-07T09:00:00Z", end: "2020-11-07T17:00:00Z" },
-                { start: "2020-11-08T09:00:00Z", end: "2020-11-08T17:00:00Z" },
-                { start: "2020-11-09T09:00:00Z", end: "2020-11-09T17:00:00Z" },
-                { start: "2020-11-10T09:00:00Z", end: "2020-11-10T17:00:00Z" },
-                { start: "2020-11-11T09:00:00Z", end: "2020-11-11T17:00:00Z" },
-                { start: "2020-11-12T09:00:00Z", end: "2020-11-12T17:00:00Z" },
-            ];
-            expect(utils.cropQuery(input, cropExtent).query_periods).toEqual(out);
-        });
-
-        it("correctly crops tiny overlapping periods", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-09T07:00:00Z",
-                        end: "2020-11-09T10:00:00Z",
-                    },
-                    {
-                        start: "2020-11-09T12:00:00Z",
-                        end: "2020-11-09T14:00:00Z",
-                    },
-                    {
-                        start: "2020-11-09T16:00:00Z",
-                        end: "2020-11-09T22:00:00Z",
-                    },
-                ],
-            };
-            const out = [
-                { start: "2020-11-09T09:00:00Z", end: "2020-11-09T10:00:00Z" },
-                { start: "2020-11-09T12:00:00Z", end: "2020-11-09T14:00:00Z" },
-                { start: "2020-11-09T16:00:00Z", end: "2020-11-09T17:00:00Z" },
-            ];
-            expect(utils.cropQuery(input, cropExtent).query_periods).toEqual(out);
-        });
-
-        it("correctly crops non-overlapping periods", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-09T07:00:00Z",
-                        end: "2020-11-09T12:00:00Z",
-                    },
-                    {
-                        start: "2020-11-10T12:00:00Z",
-                        end: "2020-11-10T14:00:00Z",
-                    },
-                    {
-                        start: "2020-11-11T16:00:00Z",
-                        end: "2020-11-11T13:00:00Z",
-                    },
-                ],
-            };
-            const offsetCropExtent = {
-                ...cropExtent,
-                startTime: "15:00",
-                endTime: "17:00",
-            };
-            expect(utils.cropQuery(input, offsetCropExtent).query_periods).toEqual([]);
-        });
-
-        it("correctly crops non-overlapping but abutting periods", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-09T07:00:00Z",
-                        end: "2020-11-09T15:00:00Z",
-                    },
-                ],
-            };
-            const offsetCropExtent = {
-                ...cropExtent,
-                startTime: "15:00",
-                endTime: "17:00",
-            };
-            expect(utils.cropQuery(input, offsetCropExtent).query_periods).toEqual([]);
-        });
-
-        //TODO: Correctly test this scenario - has to be a 26 day query with no available slots and the query end time for the last day needs to be before the startTime
-        it.skip("correctly crops 26 day query that has no availability at all", () => {
-            const input = {
-                ...query,
-                query_periods: [
-                    {
-                        start: "2020-11-26T07:00:00Z",
-                        end: "2020-12-01T15:00:00Z",
-                    },
-                ],
-            };
-            const offsetCropExtent = {
-                ...cropExtent,
-                days: [
-                    "2020-11-06",
-                    "2020-11-07",
-                    "2020-11-08",
-                    "2020-11-09",
-                    "2020-11-10",
-                    "2020-11-11",
-                    "2020-11-12",
-                    "2020-11-13",
-                    "2020-11-14",
-                    "2020-11-15",
-                    "2020-11-16",
-                    "2020-11-17",
-                    "2020-11-18",
-                    "2020-11-19",
-                    "2020-11-20",
-                    "2020-11-21",
-                    "2020-11-22",
-                    "2020-11-23",
-                    "2020-11-24",
-                    "2020-11-25",
-                    "2020-11-26",
-                    "2020-11-27",
-                    "2020-11-28",
-                    "2020-11-29",
-                    "2020-11-30",
-                    "2020-12-01",
-                ],
-                startTime: "08:00",
-                endTime: "17:00",
-            };
-            expect(utils.cropQuery(input, offsetCropExtent).query_periods).toEqual([]);
-        });
-    });
-
-    // periodOverlap
-    it("correctly detects overlaps", () => {
-        const period_1 = {
-            start: moment.utc("2020-11-09T09:00:00Z"),
-            end: moment.utc("2020-11-09T12:00:00Z"),
-        };
-        const period_2 = {
-            start: moment.utc("2020-11-09T11:00:00Z"),
-            end: moment.utc("2020-11-09T17:00:00Z"),
-        };
-        const out = {
-            start: "2020-11-09T11:00:00Z",
-            end: "2020-11-09T12:00:00Z",
-        };
-        expect(utils.periodOverlap(period_1, period_2)).toEqual(out);
-    });
-
-    it("correctly detects internal overlaps", () => {
-        const period_1 = {
-            start: moment.utc("2020-11-09T09:00:00Z"),
-            end: moment.utc("2020-11-09T17:00:00Z"),
-        };
-        const period_2 = {
-            start: moment.utc("2020-11-09T11:00:00Z"),
-            end: moment.utc("2020-11-09T13:00:00Z"),
-        };
-        const out = {
-            start: "2020-11-09T11:00:00Z",
-            end: "2020-11-09T13:00:00Z",
-        };
-        expect(utils.periodOverlap(period_1, period_2)).toEqual(out);
-    });
-
-    // divideDaysIntoWeeks
-    it("correctly divides days into weeks", () => {
-        const days = [
-            "2020-11-06",
-            "2020-11-07",
-            "2020-11-08",
-            "2020-11-09",
-            "2020-11-10",
-            "2020-11-11",
-            "2020-11-12",
-            "2020-11-13",
-            "2020-11-14",
-            "2020-11-15",
-            "2020-11-16",
-            "2020-11-17",
-            "2020-11-18",
-            "2020-11-19",
-            "2020-11-20",
-            "2020-11-21",
-            "2020-11-22",
-            "2020-11-23",
-            "2020-11-24",
-            "2020-11-25",
-            "2020-11-26",
-        ];
-        const week_1 = [
-            "2020-11-06",
-            "2020-11-07",
-            "2020-11-08",
-            "2020-11-09",
-            "2020-11-10",
-            "2020-11-11",
-            "2020-11-12",
-        ];
-        const week_2 = [
-            "2020-11-13",
-            "2020-11-14",
-            "2020-11-15",
-            "2020-11-16",
-            "2020-11-17",
-            "2020-11-18",
-            "2020-11-19",
-        ];
-        const week_3 = [
-            "2020-11-20",
-            "2020-11-21",
-            "2020-11-22",
-            "2020-11-23",
-            "2020-11-24",
-            "2020-11-25",
-            "2020-11-26",
-        ];
-        expect(utils.divideDaysIntoWeeks(days, 1)).toEqual(week_1);
-        expect(utils.divideDaysIntoWeeks(days, 2)).toEqual(week_2);
-        expect(utils.divideDaysIntoWeeks(days, 3)).toEqual(week_3);
-    });
-
-    // generateStaticPages
-    it("correctly generates static weeks", () => {
-        const input = [
-            { start: "2020-11-09T06:00:00Z", end: "2020-11-09T19:00:00Z" },
-            { start: "2020-11-10T06:00:00Z", end: "2020-11-10T12:00:00Z" },
-            { start: "2020-11-11T06:00:00Z", end: "2020-11-11T19:00:00Z" },
-        ];
-        const out = {
-            current: 1,
-            days: [
-                "2020-11-08",
-                "2020-11-09",
-                "2020-11-10",
-                "2020-11-11",
-                "2020-11-12",
-                "2020-11-13",
-                "2020-11-14",
-            ],
-            set: true,
-            total: 1,
-            hasNext: false,
-            hasPrev: false,
-        };
-        expect(utils.generateStaticPages(input)).toEqual(out);
-    });
-
-    it("correctly generates multiple static weeks", () => {
-        const input = [
-            { start: "2020-11-09T06:00:00Z", end: "2020-11-09T19:00:00Z" },
-            { start: "2020-11-10T06:00:00Z", end: "2020-11-10T12:00:00Z" },
-            { start: "2020-11-11T06:00:00Z", end: "2020-11-11T19:00:00Z" },
-            { start: "2020-11-22T06:00:00Z", end: "2020-11-23T19:00:00Z" },
-        ];
-        const out = {
-            current: 1,
-            days: [
-                "2020-11-08",
-                "2020-11-09",
-                "2020-11-10",
-                "2020-11-11",
-                "2020-11-12",
-                "2020-11-13",
-                "2020-11-14",
-                "2020-11-15",
-                "2020-11-16",
-                "2020-11-17",
-                "2020-11-18",
-                "2020-11-19",
-                "2020-11-20",
-                "2020-11-21",
-                "2020-11-22",
-                "2020-11-23",
-                "2020-11-24",
-                "2020-11-25",
-                "2020-11-26",
-                "2020-11-27",
-                "2020-11-28",
-            ],
-            set: true,
-            total: 3,
-            hasNext: true,
-            hasPrev: false,
-        };
-        expect(utils.generateStaticPages(input)).toEqual(out);
-    });
-
-    it("correctly generates static week from same-day start", () => {
-        const input = [
-            { start: "2019-11-11T06:00:00Z", end: "2019-11-11T19:00:00Z" },
-            { start: "2019-11-12T06:00:00Z", end: "2019-11-12T19:00:00Z" },
-            { start: "2019-11-13T06:00:00Z", end: "2019-11-13T19:00:00Z" },
-            { start: "2019-11-14T06:00:00Z", end: "2019-11-14T19:00:00Z" },
-        ];
-        const out = {
-            current: 1,
-            days: [
-                "2019-11-10",
-                "2019-11-11",
-                "2019-11-12",
-                "2019-11-13",
-                "2019-11-14",
-                "2019-11-15",
-                "2019-11-16",
-            ],
-            set: true,
-            total: 1,
-            hasNext: false,
-            hasPrev: false,
-        };
-        expect(moment().utcOffset()).toEqual(0);
-        expect(utils.generateStaticPages(input)).toEqual(out);
-    });
-
-    // getAllWeekDays
-    it("gets all days between 2 dates", () => {
-        const out = [
-            "2020-03-01",
-            "2020-03-02",
-            "2020-03-03",
-            "2020-03-04",
-            "2020-03-05",
-            "2020-03-06",
-            "2020-03-07",
-        ];
-        expect(
-            utils.getAllWeekDays({
-                startDate: "2020-03-01",
-                endDate: "2020-03-05",
-            })
-        ).toEqual(out);
-    });
-
-    // getWeeksInfo
-    it("gets week's info", () => {
-        const input = [
-            "2020-03-01",
-            "2020-03-02",
-            "2020-03-03",
-            "2020-03-04",
-            "2020-03-05",
-            "2020-03-06",
-            "2020-03-07",
-        ];
-        const out = {
-            current: 1,
-            days: [
-                "2020-03-01",
-                "2020-03-02",
-                "2020-03-03",
-                "2020-03-04",
-                "2020-03-05",
-                "2020-03-06",
-                "2020-03-07",
-            ],
-            set: true,
-            total: 1,
-            hasNext: false,
-            hasPrev: false,
-        };
-        expect(utils.getWeeksInfo(input)).toEqual(out);
-    });
-
-    // getDaysForWeek
-    it("correctly generates a week of days from a single date", () => {
-        const input = moment.utc("2020-05-12");
-        const out = [
-            "2020-05-12",
-            "2020-05-13",
-            "2020-05-14",
-            "2020-05-15",
-            "2020-05-16",
-            "2020-05-17",
-            "2020-05-18",
-        ];
-        expect(utils.getDaysForWeek(input)).toEqual(out);
-    });
-
-    // buildDayPeriod = (startTime, endTime, day)
-    it("builds a day period", () => {
-        const input = ["09:00", "17:00", "2020-03-20", "Etc/UTC"];
-        const out = {
-            start: "2020-03-20T09:00:00Z",
-            end: "2020-03-20T17:00:00Z",
-        };
-        expect(moment().utcOffset()).toEqual(0);
-        expect(utils.buildDayPeriod(...input)).toEqual(out);
-    });
-
-    // getMinMaxDates
-    it("gets min/max dates from a query", () => {
-        const input = {
-            "2020-11-06T09:00:00Z": {
-                start: "2020-11-06T09:00:00Z",
-                end: "2020-11-06T17:00:00Z",
-            },
-            "2020-11-07T09:00:00Z": {
-                start: "2020-11-07T09:00:00Z",
-                end: "2020-11-07T17:00:00Z",
-            },
-            "2020-11-08T09:00:00Z": {
-                start: "2020-11-08T09:00:00Z",
-                end: "2020-11-08T17:00:00Z",
-            },
-            "2020-11-09T09:00:00Z": {
-                start: "2020-11-09T09:00:00Z",
-                end: "2020-11-09T17:00:00Z",
-            },
-            "2020-11-10T09:00:00Z": {
-                start: "2020-11-10T09:00:00Z",
-                end: "2020-11-10T17:00:00Z",
-            },
-            "2020-11-11T09:00:00Z": {
-                start: "2020-11-11T09:00:00Z",
-                end: "2020-11-11T17:00:00Z",
-            },
-            "2020-11-12T09:00:00Z": {
-                start: "2020-11-12T09:00:00Z",
-                end: "2020-11-12T17:00:00Z",
-            },
-        };
-        const out = {
-            min: moment.utc("2020-11-06T09:00:00Z").local().format("YYYY-MM-DD"),
-            max: moment.utc("2020-11-12T17:00:00Z").local().format("YYYY-MM-DD"),
-        };
-        expect(utils.getMinMaxDates(input)).toEqual(out);
-    });
-
-    it("gets min/max dates from an empty query", () => {
-        const out = {
-            min: moment().format("YYYY-MM-DD"),
-            max: moment().add(1, "days").format("YYYY-MM-DD"),
-        };
-        expect(utils.getMinMaxDates()).toEqual(out);
-    });
-
-    // checkWeekdaysSlotAvailability
-    it("checks visibility status", () => {
-        const emptySlots = [
-            {
-                day: "2019-09-29",
-                slots: [
-                    {
-                        start: "2019-09-29T09:00:00Z",
-                        end: "2019-09-29T09:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:15:00Z",
-                        end: "2019-09-29T09:30:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:30:00Z",
-                        end: "2019-09-29T09:45:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:45:00Z",
-                        end: "2019-09-29T10:00:00Z",
-                    },
-                ],
-            },
-        ];
-
-        const availablePeriods = {
-            "2019-09-29T09:30:00Z": {
-                start: "2019-09-29T09:30:00Z",
-                end: "2019-09-29T10:30:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-            "2019-09-29T09:45:00Z": {
-                start: "2019-09-29T09:45:00Z",
-                end: "2019-09-29T10:45:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-            "2019-09-29T10:00:00Z": {
-                start: "2019-09-29T10:00:00Z",
-                end: "2019-09-29T11:00:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-        };
-
-        const selectedSlots = {};
-        const input = [emptySlots, availablePeriods, selectedSlots, 30, 15, false];
-        const checkedSlots = utils.checkWeekdaysSlotAvailability(...input);
-
-        expect(checkedSlots[0].day).toEqual("2019-09-29");
-        expect(checkedSlots[0].slots.length).toEqual(4);
-        expect(checkedSlots[0].slots[0].available).toEqual(false); // before period starts
-        expect(checkedSlots[0].slots[1].available).toEqual(false); // before period starts
-        expect(checkedSlots[0].slots[2].available).toEqual(true); // 09:30-10:00 Selectable
-        expect(checkedSlots[0].slots[3].available).toEqual(false); // 09:45 overruns the window of empty slots
-    });
-
-    it("checks visibility status with overlap", () => {
-        const emptySlots = [
-            {
-                day: "2019-09-29",
-                slots: [
-                    {
-                        start: "2019-09-29T09:00:00Z",
-                        end: "2019-09-29T09:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:15:00Z",
-                        end: "2019-09-29T09:30:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:30:00Z",
-                        end: "2019-09-29T09:45:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:45:00Z",
-                        end: "2019-09-29T10:00:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:00:00Z",
-                        end: "2019-09-29T10:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:15:00Z",
-                        end: "2019-09-29T10:30:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:30:00Z",
-                        end: "2019-09-29T10:45:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:45:00Z",
-                        end: "2019-09-29T11:00:00Z",
-                    },
-                ],
-            },
-        ];
-
-        const availablePeriods = {
-            "2019-09-29T09:30:00Z": {
-                start: "2019-09-29T09:30:00Z",
-                end: "2019-09-29T10:30:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-        };
-
-        const selectedSlots = {};
-        const input = [emptySlots, availablePeriods, selectedSlots, 60, 15, false];
-        const checkedSlots = utils.checkWeekdaysSlotAvailability(...input);
-
-        expect(checkedSlots[0].day).toEqual("2019-09-29");
-
-        const daySlots = checkedSlots[0].slots;
-        expect(daySlots.length).toEqual(8);
-
-        // Before start of the period
-        expect(daySlots[0].start).toEqual("2019-09-29T09:00:00Z");
-        expect(daySlots[0].available).toEqual(false);
-        expect(daySlots[0].visiblyAvailable).toEqual(false);
-        expect(daySlots[0].target).toEqual(false);
-
-        // Before start of the period
-        expect(daySlots[1].start).toEqual("2019-09-29T09:15:00Z");
-        expect(daySlots[1].available).toEqual(false);
-        expect(daySlots[1].visiblyAvailable).toEqual(false);
-        expect(daySlots[1].target).toEqual(false);
-
-        // 9:30 - 10:30 is available and in period
-        expect(daySlots[2].start).toEqual("2019-09-29T09:30:00Z");
-        expect(daySlots[2].available).toEqual(true);
-        expect(daySlots[2].visiblyAvailable).toEqual(true);
-        expect(daySlots[2].target).toEqual(false);
-        expect(daySlots[2].targetOffset).toEqual(false);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[3].start).toEqual("2019-09-29T09:45:00Z");
-        expect(daySlots[3].available).toEqual(false);
-        expect(daySlots[3].visiblyAvailable).toEqual(true);
-        expect(daySlots[3].target).toEqual(daySlots[2].start);
-        expect(daySlots[3].targetOffset).toEqual(3);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[4].start).toEqual("2019-09-29T10:00:00Z");
-        expect(daySlots[4].available).toEqual(false);
-        expect(daySlots[4].visiblyAvailable).toEqual(true);
-        expect(daySlots[4].target).toEqual(daySlots[2].start);
-        expect(daySlots[4].targetOffset).toEqual(2);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[5].start).toEqual("2019-09-29T10:15:00Z");
-        expect(daySlots[5].available).toEqual(false);
-        expect(daySlots[5].visiblyAvailable).toEqual(true);
-        expect(daySlots[5].target).toEqual(daySlots[2].start);
-        expect(daySlots[5].targetOffset).toEqual(1);
-
-        // After the period
-        expect(daySlots[6].start).toEqual("2019-09-29T10:30:00Z");
-        expect(daySlots[6].available).toEqual(false);
-        expect(daySlots[6].visiblyAvailable).toEqual(false);
-        expect(daySlots[6].target).toEqual(false);
-        //
-        // After the period
-        expect(daySlots[7].start).toEqual("2019-09-29T10:45:00Z");
-        expect(daySlots[7].available).toEqual(false);
-        expect(daySlots[7].visiblyAvailable).toEqual(false);
-        expect(daySlots[7].target).toEqual(false);
-    });
-
-    it("checks visibility status with overlap including a selected slot", () => {
-        const emptySlots = [
-            {
-                day: "2019-09-29",
-                slots: [
-                    {
-                        start: "2019-09-29T09:00:00Z",
-                        end: "2019-09-29T09:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:15:00Z",
-                        end: "2019-09-29T09:30:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:30:00Z",
-                        end: "2019-09-29T09:45:00Z",
-                    },
-                    {
-                        start: "2019-09-29T09:45:00Z",
-                        end: "2019-09-29T10:00:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:00:00Z",
-                        end: "2019-09-29T10:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:15:00Z",
-                        end: "2019-09-29T10:30:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:30:00Z",
-                        end: "2019-09-29T10:45:00Z",
-                    },
-                    {
-                        start: "2019-09-29T10:45:00Z",
-                        end: "2019-09-29T11:00:00Z",
-                    },
-                    {
-                        start: "2019-09-29T11:00:00Z",
-                        end: "2019-09-29T11:15:00Z",
-                    },
-                    {
-                        start: "2019-09-29T11:15:00Z",
-                        end: "2019-09-29T11:30:00Z",
-                    },
-                ],
-            },
-        ];
-
-        const availablePeriods = {
-            "2019-09-29T09:30:00Z": {
-                start: "2019-09-29T09:30:00Z",
-                end: "2019-09-29T11:30:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-        };
-
-        const selectedSlots = {
-            "2019-09-29T10:30:00Z": {
-                start: "2019-09-29T10:30:00Z",
-                end: "2019-09-29T11:30:00Z",
-                participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-            },
-        };
-        const input = [emptySlots, availablePeriods, selectedSlots, 60, 15, false];
-        const checkedSlots = utils.checkWeekdaysSlotAvailability(...input);
-
-        expect(checkedSlots[0].day).toEqual("2019-09-29");
-
-        const daySlots = checkedSlots[0].slots;
-        expect(daySlots.length).toEqual(10);
-
-        // Before start of the period
-        expect(daySlots[0].start).toEqual("2019-09-29T09:00:00Z");
-        expect(daySlots[0].available).toEqual(false);
-        expect(daySlots[0].visiblyAvailable).toEqual(false);
-        expect(daySlots[0].target).toEqual(false);
-
-        // Before start of the period
-        expect(daySlots[1].start).toEqual("2019-09-29T09:15:00Z");
-        expect(daySlots[1].available).toEqual(false);
-        expect(daySlots[1].visiblyAvailable).toEqual(false);
-        expect(daySlots[1].target).toEqual(false);
-
-        // 9:30 - 10:30 is available and in period
-        expect(daySlots[2].start).toEqual("2019-09-29T09:30:00Z");
-        expect(daySlots[2].available).toEqual(true);
-        expect(daySlots[2].visiblyAvailable).toEqual(true);
-        expect(daySlots[2].target).toEqual(false);
-        expect(daySlots[2].targetOffset).toEqual(false);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[3].start).toEqual("2019-09-29T09:45:00Z");
-        expect(daySlots[3].available).toEqual(false);
-        expect(daySlots[3].visiblyAvailable).toEqual(true);
-        expect(daySlots[3].target).toEqual(daySlots[2].start);
-        expect(daySlots[3].targetOffset).toEqual(3);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[4].start).toEqual("2019-09-29T10:00:00Z");
-        expect(daySlots[4].available).toEqual(false);
-        expect(daySlots[4].visiblyAvailable).toEqual(true);
-        expect(daySlots[4].target).toEqual(daySlots[2].start);
-        expect(daySlots[4].targetOffset).toEqual(2);
-
-        // Not enough time but can be part of the 9:30 - 10:30 slot
-        expect(daySlots[5].start).toEqual("2019-09-29T10:15:00Z");
-        expect(daySlots[5].available).toEqual(false);
-        expect(daySlots[5].visiblyAvailable).toEqual(true);
-        expect(daySlots[5].target).toEqual(daySlots[2].start);
-        expect(daySlots[5].targetOffset).toEqual(1);
-
-        // Start of selected period - 10:30 - 11: 30
-        expect(daySlots[6].start).toEqual("2019-09-29T10:30:00Z");
-        expect(daySlots[6].available).toEqual(false);
-        expect(daySlots[6].visiblyAvailable).toEqual(true);
-        expect(daySlots[6].target).toEqual(false);
-
-        // part of selected period - 10:30 - 11: 30
-        expect(daySlots[7].start).toEqual("2019-09-29T10:45:00Z");
-        expect(daySlots[7].available).toEqual(false);
-        expect(daySlots[7].visiblyAvailable).toEqual(true);
-        expect(daySlots[7].target).toEqual(false);
-    });
-
-    describe("when running in an environment with a different timezone", () => {
-        beforeEach(() => moment.tz.setDefault("Asia/Yekaterinburg"));
-        afterEach(() => moment.tz.setDefault("UTC"));
-
-        it("checks visibility status with overlap including a selected slot in another timezone", () => {
-            const emptySlots = [
-                {
-                    day: "2019-09-29",
-                    slots: [
-                        {
-                            start: "2019-09-29T09:00:00Z",
-                            end: "2019-09-29T09:15:00Z",
-                        },
-                        {
-                            start: "2019-09-29T09:15:00Z",
-                            end: "2019-09-29T09:30:00Z",
-                        },
-                        {
-                            start: "2019-09-29T09:30:00Z",
-                            end: "2019-09-29T09:45:00Z",
-                        },
-                        {
-                            start: "2019-09-29T09:45:00Z",
-                            end: "2019-09-29T10:00:00Z",
-                        },
-                        {
-                            start: "2019-09-29T10:00:00Z",
-                            end: "2019-09-29T10:15:00Z",
-                        },
-                        {
-                            start: "2019-09-29T10:15:00Z",
-                            end: "2019-09-29T10:30:00Z",
-                        },
-                        {
-                            start: "2019-09-29T10:30:00Z",
-                            end: "2019-09-29T10:45:00Z",
-                        },
-                        {
-                            start: "2019-09-29T10:45:00Z",
-                            end: "2019-09-29T11:00:00Z",
-                        },
-                        {
-                            start: "2019-09-29T11:00:00Z",
-                            end: "2019-09-29T11:15:00Z",
-                        },
-                        {
-                            start: "2019-09-29T11:15:00Z",
-                            end: "2019-09-29T11:30:00Z",
-                        },
-                    ],
-                },
-            ];
-
-            const availablePeriods = {
-                "2019-09-29T09:30:00Z": {
-                    start: "2019-09-29T09:30:00Z",
-                    end: "2019-09-29T11:30:00Z",
-                    participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-                },
-            };
-
-            const selectedSlots = {
-                "2019-09-29T10:30:00Z": {
-                    start: "2019-09-29T10:30:00Z",
-                    end: "2019-09-29T11:30:00Z",
-                    participants: ["PARTICIPANT_1", "PARTICIPANT_2"],
-                },
-            };
-
-            const input = [emptySlots, availablePeriods, selectedSlots, 60, 15, false];
-            const checkedSlots = utils.checkWeekdaysSlotAvailability(...input);
-
-            expect(checkedSlots[0].day).toEqual("2019-09-29");
-
-            const daySlots = checkedSlots[0].slots;
-            expect(daySlots.length).toEqual(10);
-
-            // Before start of the period
-            expect(daySlots[0].start).toEqual("2019-09-29T09:00:00Z");
-            expect(daySlots[0].available).toEqual(false);
-            expect(daySlots[0].visiblyAvailable).toEqual(false);
-            expect(daySlots[0].target).toEqual(false);
-
-            // Before start of the period
-            expect(daySlots[1].start).toEqual("2019-09-29T09:15:00Z");
-            expect(daySlots[1].available).toEqual(false);
-            expect(daySlots[1].visiblyAvailable).toEqual(false);
-            expect(daySlots[1].target).toEqual(false);
-
-            // 9:30 - 10:30 is available and in period
-            expect(daySlots[2].start).toEqual("2019-09-29T09:30:00Z");
-            expect(daySlots[2].available).toEqual(true);
-            expect(daySlots[2].visiblyAvailable).toEqual(true);
-            expect(daySlots[2].target).toEqual(false);
-            expect(daySlots[2].targetOffset).toEqual(false);
-
-            // Not enough time but can be part of the 9:30 - 10:30 slot
-            expect(daySlots[3].start).toEqual("2019-09-29T09:45:00Z");
-            expect(daySlots[3].available).toEqual(false);
-            expect(daySlots[3].visiblyAvailable).toEqual(true);
-            expect(daySlots[3].target).toEqual(daySlots[2].start);
-            expect(daySlots[3].targetOffset).toEqual(3);
-
-            // Not enough time but can be part of the 9:30 - 10:30 slot
-            expect(daySlots[4].start).toEqual("2019-09-29T10:00:00Z");
-            expect(daySlots[4].available).toEqual(false);
-            expect(daySlots[4].visiblyAvailable).toEqual(true);
-            expect(daySlots[4].target).toEqual(daySlots[2].start);
-            expect(daySlots[4].targetOffset).toEqual(2);
-
-            // Not enough time but can be part of the 9:30 - 10:30 slot
-            expect(daySlots[5].start).toEqual("2019-09-29T10:15:00Z");
-            expect(daySlots[5].available).toEqual(false);
-            expect(daySlots[5].visiblyAvailable).toEqual(true);
-            expect(daySlots[5].target).toEqual(daySlots[2].start);
-            expect(daySlots[5].targetOffset).toEqual(1);
-
-            // Start of selected period - 10:30 - 11: 30
-            expect(daySlots[6].start).toEqual("2019-09-29T10:30:00Z");
-            expect(daySlots[6].available).toEqual(false);
-            expect(daySlots[6].visiblyAvailable).toEqual(true);
-            expect(daySlots[6].target).toEqual(false);
-
-            // part of selected period - 10:30 - 11: 30
-            expect(daySlots[7].start).toEqual("2019-09-29T10:45:00Z");
-            expect(daySlots[7].available).toEqual(false);
-            expect(daySlots[7].visiblyAvailable).toEqual(true);
-            expect(daySlots[7].target).toEqual(false);
-        });
-    });
-
-    describe("buildPeriodsFromSlots", () => {
-        it("combines abutting slots into periods", () => {
-            const slots = [
-                {
-                    start: "2020-06-16T08:00:00Z",
-                    end: "2020-06-16T08:30:00Z",
-                },
-                {
-                    start: "2020-06-16T08:30:00Z",
-                    end: "2020-06-16T09:00:00Z",
-                },
-                {
-                    start: "2020-06-16T10:00:00Z",
-                    end: "2020-06-16T10:30:00Z",
-                },
-                {
-                    start: "2020-06-16T10:30:00Z",
-                    end: "2020-06-16T11:00:00Z",
-                },
-                {
-                    start: "2020-06-16T11:00:00Z",
-                    end: "2020-06-16T11:30:00Z",
-                },
-            ];
-            const expectedPeriods = [
-                {
-                    start: "2020-06-16T08:00:00Z",
-                    end: "2020-06-16T09:00:00Z",
-                },
-                {
-                    start: "2020-06-16T10:00:00Z",
-                    end: "2020-06-16T11:30:00Z",
-                },
-            ];
-            const periods = utils.buildPeriodsFromSlots(slots);
-            expect(periods.length).toEqual(2);
-            expect(periods[0]).toEqual(expectedPeriods[0]);
-        });
-
-        it("warns when slots are negative length", () => {
-            const slots = [
-                {
-                    start: "2020-10-23T09:00:00Z",
-                    end: "2020-10-22T09:00:00Z",
-                },
-            ];
-            const expectedPeriods = [];
-            const periods = utils.buildPeriodsFromSlots(slots);
-        });
-
-        it("combines unsorted abutting slots into periods", () => {
-            const slots = [
-                {
-                    start: "2020-06-16T08:30:00Z",
-                    end: "2020-06-16T09:00:00Z",
-                },
-                {
-                    start: "2020-06-16T08:00:00Z",
-                    end: "2020-06-16T08:30:00Z",
-                },
-                {
-                    start: "2020-06-16T10:30:00Z",
-                    end: "2020-06-16T11:00:00Z",
-                },
-                {
-                    start: "2020-06-17T10:30:00Z",
-                    end: "2020-06-17T11:00:00Z",
-                },
-                {
-                    start: "2020-06-16T11:00:00Z",
-                    end: "2020-06-16T11:30:00Z",
-                },
-                {
-                    start: "2020-06-16T10:00:00Z",
-                    end: "2020-06-16T10:30:00Z",
-                },
-            ];
-            const expectedPeriods = [
-                {
-                    start: "2020-06-16T08:00:00Z",
-                    end: "2020-06-16T09:00:00Z",
-                },
-                {
-                    start: "2020-06-16T10:00:00Z",
-                    end: "2020-06-16T11:30:00Z",
-                },
-                {
-                    start: "2020-06-17T10:30:00Z",
-                    end: "2020-06-17T11:00:00Z",
-                },
-            ];
-            const periods = utils.buildPeriodsFromSlots(slots);
-            expect(periods.length).toEqual(3);
-            expect(periods[0]).toEqual(expectedPeriods[0]);
-            expect(periods[1]).toEqual(expectedPeriods[1]);
-            expect(periods[2]).toEqual(expectedPeriods[2]);
-        });
-    });
-
-    describe("tweenSlots", () => {
-        it("calculates tweens for slot-starts", () => {
-            const options = {
-                start: "2020-06-16T08:00:00Z",
-                end: "2020-06-16T11:30:00Z",
-                tzid: "Europe/London",
-                interval: 30,
-            };
-            const expected = [
-                "2020-06-16T08:00:00Z",
-                "2020-06-16T08:30:00Z",
-                "2020-06-16T09:00:00Z",
-                "2020-06-16T09:30:00Z",
-                "2020-06-16T10:00:00Z",
-                "2020-06-16T10:30:00Z",
-                "2020-06-16T11:00:00Z",
-                "2020-06-16T11:30:00Z",
-            ];
-
-            const result = utils.tweenSlots(options);
-            expect(result).toEqual(expected);
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(expected.length);
-        });
-        it("calculates tweens for cross-day slot-starts", () => {
-            const options = {
-                start: "2020-06-16T08:00:00Z",
-                end: "2020-06-17T10:00:00Z",
-                tzid: "America/Toronto",
-                interval: 60,
-            };
-            const expected = [
-                "2020-06-16T08:00:00Z",
-                "2020-06-16T09:00:00Z",
-                "2020-06-16T10:00:00Z",
-                "2020-06-17T08:00:00Z",
-                "2020-06-17T09:00:00Z",
-                "2020-06-17T10:00:00Z",
-            ];
-
-            const result = utils.tweenSlots(options);
-            expect(result).toEqual(expected);
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(expected.length);
-        });
-
-        it("calculates tweens for cross-day slot-starts over timezone boundaries", () => {
-            const options = {
-                // In America/Toronto, these times cross midnight
-                // so there should be blocks for FOUR days (not
-                // just the three that 23rd - 25th would suggest)
-                start: "2020-06-23T02:00:00Z",
-                end: "2020-06-25T21:00:00Z",
-                tzid: "America/Toronto",
-                interval: 60,
-            };
-            const expected = [
-                // Block 1
-                "2020-06-22T21:00:00Z",
-                "2020-06-22T22:00:00Z",
-                "2020-06-22T23:00:00Z",
-                "2020-06-23T00:00:00Z",
-                "2020-06-23T01:00:00Z",
-                "2020-06-23T02:00:00Z",
-                // Block 2
-                "2020-06-23T21:00:00Z",
-                "2020-06-23T22:00:00Z",
-                "2020-06-23T23:00:00Z",
-                "2020-06-24T00:00:00Z",
-                "2020-06-24T01:00:00Z",
-                "2020-06-24T02:00:00Z",
-                // Block 3
-                "2020-06-24T21:00:00Z",
-                "2020-06-24T22:00:00Z",
-                "2020-06-24T23:00:00Z",
-                "2020-06-25T00:00:00Z",
-                "2020-06-25T01:00:00Z",
-                "2020-06-25T02:00:00Z",
-                // Block 4
-                "2020-06-25T21:00:00Z",
-                "2020-06-25T22:00:00Z",
-                "2020-06-25T23:00:00Z",
-                "2020-06-26T00:00:00Z",
-                "2020-06-26T01:00:00Z",
-                "2020-06-26T02:00:00Z",
-            ];
-
-            const result = utils.tweenSlots(options);
-            expect(result).toEqual(expected);
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(expected.length);
-        });
-    });
-
-    // addSlotStarts
-    it("adds N slot start times", () => {
-        const options = [moment("2020-06-16T08:00:00Z", "YYYY-MM-DDTHH:mm:00Z"), 30, 4];
-        const expected = [
-            "2020-06-16T08:00:00Z",
-            "2020-06-16T08:30:00Z",
-            "2020-06-16T09:00:00Z",
-            "2020-06-16T09:30:00Z",
-            "2020-06-16T10:00:00Z",
-        ];
-        const result = utils.addSlotStarts(...options);
-        expect(result).toEqual(expected);
-    });
-
-    // getDayOffset
-    it("calculates the numerical difference between two day strings", () => {
-        const tueSun = utils.getDayOffset("tuesday", "sunday");
-        expect(tueSun).toEqual(2);
-
-        const sunTue = utils.getDayOffset("sunday", "tuesday");
-        expect(sunTue).toEqual(5);
-
-        const sunSun = utils.getDayOffset("sunday", "sunday");
-        expect(sunSun).toEqual(0);
-
-        const monMon = utils.getDayOffset("monday", "monday");
-        expect(monMon).toEqual(0);
-
-        const tueTue = utils.getDayOffset("tuesday", "tuesday");
-        expect(tueTue).toEqual(0);
-
-        const sunMon = utils.getDayOffset("sunday", "monday");
-        expect(sunMon).toEqual(6);
-
-        const monSun = utils.getDayOffset("monday", "sunday");
-        expect(monSun).toEqual(1);
-
-        const friWed = utils.getDayOffset("friday", "wednesday");
-        expect(friWed).toEqual(2);
-
-        const wedFri = utils.getDayOffset("wednesday", "friday");
-        expect(wedFri).toEqual(5);
-    });
-
-    // condenseTimeLabel
-    it("correctly truncates time string based on locale", () => {
-        const enTimes = ["09:00", "10:00", "13:00", "23:00"];
-        const usTimes = ["9:00 am", "10:00 am", "1:00 pm", "11 pm"];
-        const weirds = ["9:00am", "1:00 PM", "11pm", "02pm", "02 pm"];
-
-        expect(utils.condenseTimeLabel(enTimes[0])).toEqual("09");
-        expect(utils.condenseTimeLabel(enTimes[1])).toEqual("10");
-        expect(utils.condenseTimeLabel(enTimes[2])).toEqual("13");
-        expect(utils.condenseTimeLabel(enTimes[3])).toEqual("23");
-
-        expect(utils.condenseTimeLabel(usTimes[0])).toEqual("9a");
-        expect(utils.condenseTimeLabel(usTimes[1])).toEqual("10a");
-        expect(utils.condenseTimeLabel(usTimes[2])).toEqual("1p");
-        expect(utils.condenseTimeLabel(usTimes[3])).toEqual("11p");
-
-        expect(utils.condenseTimeLabel(weirds[0])).toEqual("9a");
-        expect(utils.condenseTimeLabel(weirds[1])).toEqual("1P");
-        expect(utils.condenseTimeLabel(weirds[2])).toEqual("11p");
-        expect(utils.condenseTimeLabel(weirds[3])).toEqual("02p");
-        expect(utils.condenseTimeLabel(weirds[4])).toEqual("02p");
-    });
-
-    describe("cropDaysToWindow", () => {
-        it("crops an array of days into a defined window", () => {
-            const rawDays = [
-                "2021-03-25",
-                "2021-03-26",
-                "2021-03-27",
-                "2021-03-28",
-                "2021-03-29",
-                "2021-03-30",
-                "2021-03-31",
-                "2021-04-01",
-                "2021-04-02",
-                "2021-04-03",
-                "2021-04-04",
-                "2021-04-05",
-                "2021-04-06",
-            ];
-            const windowSize = 8;
-
-            const { days, overflow } = utils.cropDaysToWindow(rawDays, windowSize);
-
-            expect(days.length).toBe(8);
-            expect(overflow.length).toBe(6);
-            expect(days[0]).toEqual("2021-03-25");
-            expect(days[days.length - 1]).toEqual("2021-04-01");
-        });
-
-        it("works when window is longer than array", () => {
-            const rawDays = ["2021-03-25", "2021-03-26", "2021-03-27", "2021-03-28"];
-            const windowSize = 8;
-
-            const { days, overflow } = utils.cropDaysToWindow(rawDays, windowSize);
-
-            expect(days.length).toBe(4);
-            expect(overflow.length).toBe(0);
-            expect(days[0]).toEqual("2021-03-25");
-            expect(days[days.length - 1]).toEqual("2021-03-28");
-        });
-
-        it("provides an array of overflow days (with a 1 day overlap)", () => {
-            const rawDays = [
-                "2021-03-25",
-                "2021-03-26",
-                "2021-03-27",
-                "2021-03-28",
-                "2021-03-29",
-                "2021-03-30",
-                "2021-03-31",
-                "2021-04-01",
-                "2021-04-02",
-                "2021-04-03",
-                "2021-04-04",
-                "2021-04-05",
-                "2021-04-06",
-            ];
-            const windowSize = 8;
-
-            const { days, overflow } = utils.cropDaysToWindow(rawDays, windowSize);
-
-            expect(days.length).toBe(8);
-            expect(overflow.length).toBe(6);
-            expect(days[0]).toEqual("2021-03-25");
-            expect(days[days.length - 1]).toEqual("2021-04-01");
-
-            expect(overflow[0]).toEqual("2021-04-01");
-            expect(overflow[overflow.length - 1]).toEqual("2021-04-06");
-        });
-    });
-
-    describe("generate labels", () => {
-        it("gets all labels", () => {
-            const options = {
-                days: [
-                    "2021-01-17",
-                    "2021-01-18",
-                    "2021-01-19",
-                    "2021-01-20",
-                    "2021-01-21",
-                    "2021-01-22",
-                    "2021-01-23",
-                ],
-                limits: {
-                    duration: 60,
-                    start: "10:00",
-                    end: "14:00",
-                    interval: 30,
-                },
-                tzid: "Europe/London",
-                i18n: {
-                    f: jest.fn(() => "STRING"),
-                },
-                locale: "en",
-            };
-            const allLabels = utils.getAllLabels(options);
-            expect(allLabels.length).toBe(1);
-            expect(allLabels[0].days.length).toBe(7);
-            expect(allLabels[0].days[0].date).toBe(options.days[0]);
-            expect(allLabels[0].days[0].number).toBe("STRING");
-            expect(allLabels[0].days[0].name).toBe("STRING");
-            expect(allLabels[0].days[6].date).toBe(options.days[6]);
-            expect(allLabels[0].month).toBe("Jan 2021");
-            expect(allLabels[0].times.length).toBe(8);
-            expect(allLabels[0].times[0].start).toBe("2021-01-18T10:00:00Z");
-            expect(allLabels[0].times[0].hour).toBe(true);
-            expect(allLabels[0].times[1].start).toBe("2021-01-18T10:30:00Z");
-            expect(allLabels[0].times[1].hour).toBe(false);
-        });
-
-        it("detects when days match", () => {
-            const days = ["2021-01-30", "2021-01-31", "2021-02-01", "2021-02-02"];
-            const fullList = [
-                {
-                    days: [
-                        { date: "2021-01-30" },
-                        { date: "2021-01-31" },
-                        { date: "2021-02-01" },
-                        { date: "2021-02-02" },
-                    ],
-                },
-            ];
-
-            const justKeyDates = [
-                {
-                    days: [{ date: "2021-01-30" }, { date: "2021-02-02" }],
-                },
-            ];
-
-            const matchFull = utils.checkIfDaysMatch(days, fullList);
-            expect(matchFull).toBe(true);
-
-            const matchKeyDates = utils.checkIfDaysMatch(days, justKeyDates);
-            expect(matchKeyDates).toBe(true);
-        });
-
-        it("detects when days differ", () => {
-            const days = ["2021-01-30", "2021-01-31", "2021-02-01", "2021-02-02"];
-
-            const inclusiveMore = [
-                {
-                    days: [
-                        { date: "2021-01-29" },
-                        { date: "2021-01-30" },
-                        { date: "2021-01-31" },
-                        { date: "2021-02-01" },
-                        { date: "2021-02-02" },
-                        { date: "2021-02-03" },
-                    ],
-                },
-            ];
-            const matchInclusiveMore = utils.checkIfDaysMatch(days, inclusiveMore);
-            expect(matchInclusiveMore).toBe(false);
-
-            const inclusiveFewer = [
-                {
-                    days: [{ date: "2021-01-31" }, { date: "2021-02-01" }],
-                },
-            ];
-            const matchInclusiveFewer = utils.checkIfDaysMatch(days, inclusiveFewer);
-            expect(matchInclusiveFewer).toBe(false);
-
-            const overlapPre = [
-                {
-                    days: [{ date: "2021-01-29" }, { date: "2021-01-30" }, { date: "2021-01-31" }],
-                },
-            ];
-            const matchOverlapPre = utils.checkIfDaysMatch(days, overlapPre);
-            expect(matchOverlapPre).toBe(false);
-
-            const overlapPost = [
-                {
-                    days: [{ date: "2021-02-01" }, { date: "2021-02-02" }, { date: "2021-02-03" }],
-                },
-            ];
-            const matchOverlapPost = utils.checkIfDaysMatch(days, overlapPost);
-            expect(matchOverlapPost).toBe(false);
-        });
-
-        it("detects missmatch with empty option", () => {
-            const days = ["2021-01-30", "2021-01-31", "2021-02-01", "2021-02-02"];
-            const matchEmpty = utils.checkIfDaysMatch(days, []);
-
-            expect(matchEmpty).toBe(false);
-
-            const matchMissing = utils.checkIfDaysMatch(days);
-
-            expect(matchMissing).toBe(false);
-        });
-
-        it("detects when limits match", () => {
-            const limits = { start: "08:00", end: "17:30" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-18T17:30:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(true);
-        });
-
-        it("detects when start limit does not match", () => {
-            const limits = { start: "00:00", end: "17:30" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-18T17:30:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(false);
-        });
-
-        it("detects when end limit does not match", () => {
-            const limits = { start: "08:00", end: "17:00" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-18T17:30:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(false);
-        });
-
-        it("detects when both limits do not match", () => {
-            const limits = { start: "07:00", end: "17:00" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-18T17:30:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(false);
-        });
-
-        it("detects when both limits do not match", () => {
-            const limits = { start: "07:00", end: "17:00" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-18T17:30:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(false);
-        });
-
-        it("handles matching limits when end is midnight", () => {
-            const limits = { start: "08:00", end: "24:00" };
-            const times = [
-                {
-                    start: "2021-01-18T08:00:00Z",
-                    end: "2021-01-19T00:00:00Z",
-                },
-            ];
-            const matchEmpty = utils.checkIfLimitsMatch(limits, times);
-
-            expect(matchEmpty).toBe(true);
-        });
-    });
-});