cronofy-elements 1.48.1 → 1.49.1

package/tests/slots.rules.test.js

@@ -1,195 +0,0 @@
-import * as slotsRulesHelpers from "../src/js/helpers/slots.rules";
-
-describe("Slots Rules helpers", () => {
-    // getWeekDays
-    it("returns array of week days", () => {
-        const result = slotsRulesHelpers.getWeekDays();
-        const expectedResult = [
-            "sunday",
-            "monday",
-            "tuesday",
-            "wednesday",
-            "thursday",
-            "friday",
-            "saturday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a monday", () => {
-        const result = slotsRulesHelpers.getWeekDays("monday");
-        const expectedResult = [
-            "monday",
-            "tuesday",
-            "wednesday",
-            "thursday",
-            "friday",
-            "saturday",
-            "sunday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a tuesday", () => {
-        const result = slotsRulesHelpers.getWeekDays("tuesday");
-        const expectedResult = [
-            "tuesday",
-            "wednesday",
-            "thursday",
-            "friday",
-            "saturday",
-            "sunday",
-            "monday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a wednesday", () => {
-        const result = slotsRulesHelpers.getWeekDays("wednesday");
-        const expectedResult = [
-            "wednesday",
-            "thursday",
-            "friday",
-            "saturday",
-            "sunday",
-            "monday",
-            "tuesday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a thursday", () => {
-        const result = slotsRulesHelpers.getWeekDays("thursday");
-        const expectedResult = [
-            "thursday",
-            "friday",
-            "saturday",
-            "sunday",
-            "monday",
-            "tuesday",
-            "wednesday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a friday", () => {
-        const result = slotsRulesHelpers.getWeekDays("friday");
-        const expectedResult = [
-            "friday",
-            "saturday",
-            "sunday",
-            "monday",
-            "tuesday",
-            "wednesday",
-            "thursday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a saturday", () => {
-        const result = slotsRulesHelpers.getWeekDays("saturday");
-        const expectedResult = [
-            "saturday",
-            "sunday",
-            "monday",
-            "tuesday",
-            "wednesday",
-            "thursday",
-            "friday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-    it("returns array of week days, starting on a sunday", () => {
-        const result = slotsRulesHelpers.getWeekDays("sunday");
-        const expectedResult = [
-            "sunday",
-            "monday",
-            "tuesday",
-            "wednesday",
-            "thursday",
-            "friday",
-            "saturday",
-        ];
-        expect(result).toEqual(expectedResult);
-    });
-
-    it("Generates blank slots (60 mins)", () => {
-        const options = [60, "sunday", { f: jest.fn() }];
-        const result = slotsRulesHelpers.generateEmptyRulesSlots(...options);
-
-        const resultKeys = Object.keys(result);
-        const firstKey = resultKeys[0];
-        const lastKey = resultKeys[resultKeys.length - 1];
-
-        expect(resultKeys.length).toEqual(168);
-
-        expect(firstKey).toEqual("00_00");
-        expect(lastKey).toEqual("06_23");
-
-        expect(result[firstKey].start).toEqual("00:00");
-        expect(result[firstKey].end).toEqual("01:00");
-        expect(result[firstKey].day).toEqual("sunday");
-
-        expect(result[lastKey].start).toEqual("23:00");
-        expect(result[lastKey].end).toEqual("24:00");
-        expect(result[lastKey].day).toEqual("saturday");
-    });
-
-    it("Generates blank slots (30 mins)", () => {
-        const options = [30, "sunday", { f: jest.fn() }];
-        const result = slotsRulesHelpers.generateEmptyRulesSlots(...options);
-
-        const resultKeys = Object.keys(result);
-        const firstKey = resultKeys[0];
-        const lastKey = resultKeys[resultKeys.length - 1];
-
-        expect(resultKeys.length).toEqual(336);
-
-        expect(firstKey).toEqual("00_00");
-        expect(lastKey).toEqual("06_47");
-
-        expect(result[firstKey].start).toEqual("00:00");
-        expect(result[firstKey].end).toEqual("00:30");
-        expect(result[firstKey].day).toEqual("sunday");
-
-        expect(result[lastKey].start).toEqual("23:30");
-        expect(result[lastKey].end).toEqual("24:00");
-        expect(result[lastKey].day).toEqual("saturday");
-    });
-
-    it("Generates blank slots (15 mins)", () => {
-        const options = [15, "sunday", { f: jest.fn() }];
-        const result = slotsRulesHelpers.generateEmptyRulesSlots(...options);
-
-        const resultKeys = Object.keys(result);
-        const firstKey = resultKeys[0];
-        const lastKey = resultKeys[resultKeys.length - 1];
-
-        expect(resultKeys.length).toEqual(672);
-
-        expect(firstKey).toEqual("00_00");
-        expect(lastKey).toEqual("06_95");
-
-        expect(result[firstKey].start).toEqual("00:00");
-        expect(result[firstKey].end).toEqual("00:15");
-        expect(result[firstKey].day).toEqual("sunday");
-
-        expect(result[lastKey].start).toEqual("23:45");
-        expect(result[lastKey].end).toEqual("24:00");
-        expect(result[lastKey].day).toEqual("saturday");
-    });
-
-    it("Generates blank slots (for non-sunday week-starts)", () => {
-        const options_1 = [60, "monday", { f: jest.fn() }];
-        const result_1 = slotsRulesHelpers.generateEmptyRulesSlots(...options_1);
-
-        expect(result_1["00_00"].day).toEqual("monday");
-        expect(result_1["06_23"].day).toEqual("sunday");
-
-        const options_2 = [60, "tuesday", { f: jest.fn() }];
-        const result_2 = slotsRulesHelpers.generateEmptyRulesSlots(...options_2);
-
-        expect(result_2["00_00"].day).toEqual("tuesday");
-        expect(result_2["06_23"].day).toEqual("monday");
-
-        const options_3 = [60, "wednesday", { f: jest.fn() }];
-        const result_3 = slotsRulesHelpers.generateEmptyRulesSlots(...options_3);
-
-        expect(result_3["00_00"].day).toEqual("wednesday");
-        expect(result_3["06_23"].day).toEqual("tuesday");
-    });
-});

package/tests/slots.test.js

@@ -1,278 +0,0 @@
-import * as slotsHelpers from "../src/js/helpers/slots";
-import moment from "moment-timezone";
-
-describe("Slots helpers", () => {
-    // getDaysFromAvailablePeriods
-    it("returns a map of days to query_periods", () => {
-        const mockData = [
-            {
-                start: "2018-11-08T15:40:00Z",
-                end: "2018-11-08T17:00:00Z",
-            },
-            {
-                start: "2018-11-09T09:00:00Z",
-                end: "2018-11-09T10:00:00Z",
-            },
-            {
-                start: "2018-11-09T10:30:00Z",
-                end: "2018-11-09T11:30:00Z",
-            },
-            {
-                start: "2018-11-10T09:00:00Z",
-                end: "2018-11-10T10:00:00Z",
-            },
-            {
-                start: "2018-11-10T10:30:00Z",
-                end: "2018-11-10T11:30:00Z",
-            },
-            {
-                start: "2018-11-10T12:00:00Z",
-                end: "2018-11-10T14:30:00Z",
-            },
-        ];
-
-        // Timezone labels should be shown native to the given TZID
-        const expectedResult = {
-            "2018-11-08": {
-                label: "Thursday 8th November",
-                value: "2018-11-08",
-                slots: [
-                    {
-                        label: "10:40AM - 12:00PM",
-                        value: {
-                            end: "2018-11-08T17:00:00Z",
-                            start: "2018-11-08T15:40:00Z",
-                        },
-                    },
-                ],
-            },
-            "2018-11-09": {
-                label: "Friday 9th November",
-                value: "2018-11-09",
-                slots: [
-                    {
-                        label: "4:00AM - 5:00AM",
-                        value: {
-                            start: "2018-11-09T09:00:00Z",
-                            end: "2018-11-09T10:00:00Z",
-                        },
-                    },
-                    {
-                        label: "5:30AM - 6:30AM",
-                        value: {
-                            start: "2018-11-09T10:30:00Z",
-                            end: "2018-11-09T11:30:00Z",
-                        },
-                    },
-                ],
-            },
-            "2018-11-10": {
-                label: "Saturday 10th November",
-                value: "2018-11-10",
-                slots: [
-                    {
-                        label: "4:00AM - 5:00AM",
-                        value: {
-                            start: "2018-11-10T09:00:00Z",
-                            end: "2018-11-10T10:00:00Z",
-                        },
-                    },
-                    {
-                        label: "5:30AM - 6:30AM",
-                        value: {
-                            start: "2018-11-10T10:30:00Z",
-                            end: "2018-11-10T11:30:00Z",
-                        },
-                    },
-                    {
-                        label: "7:00AM - 9:30AM",
-                        value: {
-                            start: "2018-11-10T12:00:00Z",
-                            end: "2018-11-10T14:30:00Z",
-                        },
-                    },
-                ],
-            },
-        };
-
-        const days = slotsHelpers.getDaysFromAvailablePeriods(
-            mockData,
-            "en-US",
-            "America/New_York"
-        );
-
-        expect(days).toEqual(expectedResult);
-    });
-
-    // slotsFromPeriod
-    it("returns slots in a given period", () => {
-        const mockData = {
-            start: "2018-11-08T15:40:00Z",
-            end: "2018-11-08T17:00:00Z",
-        };
-        const expectedResult = [
-            {
-                end: "2018-11-08T15:55:00Z",
-                participants: [],
-                start: "2018-11-08T15:40:00Z",
-            },
-            {
-                end: "2018-11-08T16:10:00Z",
-                participants: [],
-                start: "2018-11-08T15:55:00Z",
-            },
-            {
-                end: "2018-11-08T16:25:00Z",
-                participants: [],
-                start: "2018-11-08T16:10:00Z",
-            },
-            {
-                end: "2018-11-08T16:40:00Z",
-                participants: [],
-                start: "2018-11-08T16:25:00Z",
-            },
-            {
-                end: "2018-11-08T16:55:00Z",
-                participants: [],
-                start: "2018-11-08T16:40:00Z",
-            },
-        ];
-
-        const slots = slotsHelpers.slotsFromPeriod(mockData, 15);
-
-        expect(slots).toEqual(expectedResult);
-    });
-
-    // roundToNextHour
-    it("rounds up to next hour", () => {
-        // rounds up
-        expect(
-            slotsHelpers
-                .roundToNextHour(moment("2018-11-08T15:40:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T16:00:00");
-        // ...but only if it needs to
-        expect(
-            slotsHelpers
-                .roundToNextHour(moment("2018-11-08T15:00:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:00:00");
-    });
-
-    // roundToNextHalfHour
-    it("rounds up to next half-hour", () => {
-        // rounds up
-        expect(
-            slotsHelpers
-                .roundToNextHalfHour(moment("2018-11-08T15:40:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T16:00:00");
-        expect(
-            slotsHelpers
-                .roundToNextHalfHour(moment("2018-11-08T15:12:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:30:00");
-        expect(
-            slotsHelpers
-                .roundToNextHalfHour(moment("2018-11-08T15:34:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T16:00:00");
-        // ...but only if it needs to
-        expect(
-            slotsHelpers
-                .roundToNextHalfHour(moment("2018-11-08T15:00:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:00:00");
-        expect(
-            slotsHelpers
-                .roundToNextHalfHour(moment("2018-11-08T15:30:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:30:00");
-    });
-
-    // roundToNextQuarterHour
-    it("rounds up to next quarter-hour", () => {
-        // rounds up
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:40:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:45:00");
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:12:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:15:00");
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:34:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:45:00");
-        // ...but only if it needs to
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:00:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:00:00");
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:30:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:30:00");
-        expect(
-            slotsHelpers
-                .roundToNextQuarterHour(moment("2018-11-08T15:45:00"))
-                .format(`YYYY-MM-DDTHH:mm[:00]`)
-        ).toEqual("2018-11-08T15:45:00");
-    });
-
-    // roundPeriod
-    it("rounds to the correct duration", () => {
-        const mockData = {
-            start: "2018-11-08T15:10:00Z",
-            end: "2018-11-08T17:00:00Z",
-        };
-
-        const hour = jest.fn();
-        hour.mockReturnValue(moment("2018-11-08T16:00:00Z"));
-        const half = jest.fn();
-        half.mockReturnValue(moment("2018-11-08T15:30:00Z"));
-        const quarter = jest.fn();
-        quarter.mockReturnValue(moment("2018-11-08T15:15:00Z"));
-
-        slotsHelpers.roundPeriod(mockData, 15, hour, half, quarter);
-        expect(hour).toHaveBeenCalledTimes(0);
-        expect(half).toHaveBeenCalledTimes(0);
-        expect(quarter).toHaveBeenCalledTimes(1);
-
-        slotsHelpers.roundPeriod(mockData, 30, hour, half, quarter);
-        expect(hour).toHaveBeenCalledTimes(0);
-        expect(half).toHaveBeenCalledTimes(1);
-        expect(quarter).toHaveBeenCalledTimes(1);
-
-        slotsHelpers.roundPeriod(mockData, 60, hour, half, quarter);
-        expect(hour).toHaveBeenCalledTimes(1);
-        expect(half).toHaveBeenCalledTimes(1);
-        expect(quarter).toHaveBeenCalledTimes(1);
-    });
-
-    // parsePeriodsIntoSlots
-    it("parses periods into slots", () => {
-        const periods = [
-            {
-                start: "2018-11-08T15:40:00Z",
-                end: "2018-11-08T17:00:00Z",
-            },
-            {
-                start: "2018-11-09T09:00:00Z",
-                end: "2018-11-09T10:00:00Z",
-            },
-        ];
-        const slots = slotsHelpers.parsePeriodsIntoSlots(periods, 30);
-        expect(slots.length).toEqual(4);
-        expect(slots[0].start).toEqual("2018-11-08T16:00:00Z");
-        expect(slots[0].end).toEqual("2018-11-08T16:30:00Z");
-        expect(slots[1].start).toEqual("2018-11-08T16:30:00Z");
-        expect(slots[1].end).toEqual("2018-11-08T17:00:00Z");
-    });
-});

package/tests/utils.AvailabilityRules.test.js

@@ -1,221 +0,0 @@
-import * as utils from "../src/js/helpers/utils.AvailabilityRules";
-
-describe("Utilities: AvailabilityRules", () => {
-    // buildSlotID
-    it("builds a correct slot ID", () => {
-        // Correctly pads single-digit numbers
-        expect(utils.buildSlotID(1, 2)).toEqual("01_02");
-        // Correctly pads (or doesn't pad) double-digit numbers
-        expect(utils.buildSlotID(12, 42)).toEqual("12_42");
-        // Works with strings
-        expect(utils.buildSlotID("1", "02")).toEqual("01_02");
-    });
-
-    // calculateSlotsPerDay
-    it("correctly calculates slots per day", () => {
-        // Handles normal results
-        expect(utils.calculateSlotsPerDay(60, "18:00", "20:00")).toEqual(2);
-        // Correctly rounds (down) potential floating-point issues
-        expect(utils.calculateSlotsPerDay(60, "18:30", "20:00")).toEqual(1);
-        // Never returns negative values
-        expect(utils.calculateSlotsPerDay(60, "20:00", "18:00")).toEqual(2);
-    });
-
-    // parseExtras
-    it("correctly returns extras when none are explicitly set", () => {
-        const expectedOutput = {
-            limits: {
-                duration: 60,
-                end: "17:30",
-                slotsOffset: 9,
-                start: "09:00",
-                tzid: moment.tz.guess(),
-                slotsPerDay: 8,
-            },
-            slotHeight: { height: 40 },
-            keyboardSupport: false,
-        };
-        expect(utils.parseExtras()).toEqual(expectedOutput);
-    });
-
-    // parseExtras
-    it("correctly parses extras", () => {
-        const input = {
-            config: {
-                duration: 30,
-                start_time: "08:00",
-                keyboardSupport: "basic",
-            },
-            tzid: "America/Chicago",
-        };
-        const expectedOutput = {
-            limits: {
-                duration: 30,
-                end: "17:30",
-                slotsOffset: 16,
-                start: "08:00",
-                tzid: "America/Chicago",
-                slotsPerDay: 19,
-            },
-            slotHeight: { height: 26 },
-            keyboardSupport: "basic",
-        };
-        expect(utils.parseExtras(input)).toEqual(expectedOutput);
-    });
-
-    // parseAccountOptions
-    it("correctly returns default account options", () => {
-        const explicit_rule_id = { availability_rule_id: "DEFAULT" };
-        const expectedOutput = {
-            availability_rule_id: "DEFAULT",
-            tzid: "Etc/UTC",
-        };
-        expect(utils.parseAccountOptions(explicit_rule_id)).toEqual(expectedOutput);
-    });
-
-    // parseAccountOptions
-    it("correctly parses account options", () => {
-        const input = {
-            availability_rule_id: "RULE_ID",
-            unused_option: "UNUSED",
-        };
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            tzid: "Etc/UTC",
-        };
-        expect(utils.parseAccountOptions(input)).toEqual(expectedOutput);
-    });
-
-    // buildRuleTemplate
-    it("builds a rules template", () => {
-        const tzid = "TEST_TIMEZONE";
-        const default_weekly_periods = [
-            {
-                day: "monday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "tuesday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "wednesday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "thursday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "friday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-        ];
-        const expectedOutput = {
-            availability_rule: {
-                availability_rule_id: "default",
-                calendar_ids: [],
-                tzid: "TEST_TIMEZONE",
-                weekly_periods: [
-                    {
-                        day: "monday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "tuesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "wednesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "thursday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "friday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                ],
-            },
-        };
-        expect(utils.buildRuleTemplate(default_weekly_periods, tzid)).toEqual(expectedOutput);
-    });
-
-    // buildRuleTemplate
-    it("builds a rules template when no tzid is provided", () => {
-        const default_weekly_periods = [
-            {
-                day: "monday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "tuesday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "wednesday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "thursday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-            {
-                day: "friday",
-                end_time: "17:00",
-                start_time: "09:00",
-            },
-        ];
-        const expectedOutput = {
-            availability_rule: {
-                availability_rule_id: "default",
-                calendar_ids: [],
-                tzid: moment.tz.guess(),
-                weekly_periods: [
-                    {
-                        day: "monday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "tuesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "wednesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "thursday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "friday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                ],
-            },
-        };
-        expect(utils.buildRuleTemplate(default_weekly_periods)).toEqual(expectedOutput);
-    });
-});