cronofy-elements 1.48.1 → 1.49.1

package/src/js/helpers/utils.AvailabilityViewer.js

@@ -1,789 +0,0 @@
-import moment from "moment-timezone";
-import {
-    createEmptySlotsForPeriod,
-    getMonthsDescription,
-    roundPeriod,
-    keyFormat,
-    shortKeyFormat,
-} from "./slots";
-import { objectToArray } from "./utils";
-import { timeLabels } from "./slots";
-
-// Use the slot's "start" time-string as the
-// key (for quicker/simpler look-up later)
-export const addKeysToSlots = rawSlots => {
-    if (rawSlots) {
-        return rawSlots.reduce((acc, curr) => {
-            acc[curr.start] = curr;
-            return acc;
-        }, {});
-    } else {
-        return {};
-    }
-};
-
-export const sortKeys = keys =>
-    keys.sort((a, b) => {
-        if (moment.utc(a) < moment.utc(b)) {
-            return -1;
-        }
-        if (moment.utc(a) > moment.utc(b)) {
-            return 1;
-        }
-        return 0;
-    });
-
-export const getMinMaxDates = (queryPeriods = false) => {
-    if (!queryPeriods || Object.keys(queryPeriods).length < 1) {
-        return {
-            min: moment.utc().format("YYYY-MM-DD"),
-            max: moment.utc().add(1, "days").format("YYYY-MM-DD"),
-        };
-    }
-
-    const startDates = sortKeys(Object.keys(queryPeriods));
-
-    return {
-        min: moment
-            .utc(queryPeriods[startDates[0]].start, "YYYY-MM-DDTHH:mm:00Z")
-            .local()
-            .format("YYYY-MM-DD"),
-        max: moment
-            .utc(queryPeriods[startDates[startDates.length - 1]].end, "YYYY-MM-DDTHH:mm:00Z")
-            .local()
-            .format("YYYY-MM-DD"),
-    };
-};
-
-export const buildDayPeriod = (startTime, endTime, day, tzid) => {
-    const localStart = `${day}T${startTime}`;
-    const localEnd = `${day}T${endTime}`;
-    const UTCStart = moment.tz(localStart, "YYYY-MM-DDTHH:mm", tzid).utc();
-    const UTCEnd = moment.tz(localEnd, "YYYY-MM-DDTHH:mm", tzid).utc();
-
-    const is24Hours = startTime === endTime;
-    if (is24Hours) {
-        UTCEnd.add(1, "days");
-    }
-
-    // An end-time of midnight will always be at the *end* of our
-    // target day (a.k.a. the very start of the following day)
-    const localMidnight = moment(`${day}T00:00`, "YYYY-MM-DDTHH:mm");
-    if (UTCEnd.diff(localMidnight, "minutes") === 0) {
-        UTCEnd.add(1, "days");
-    }
-
-    const start = UTCStart.format("YYYY-MM-DDTHH:mm[:00Z]");
-    const end = UTCEnd.format("YYYY-MM-DDTHH:mm[:00Z]");
-
-    return {
-        start,
-        end,
-    };
-};
-
-export const getDaysForWeek = startDate => {
-    const start = startDate.clone();
-    return [
-        start.format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-        start.add(1, "days").format("YYYY-MM-DD"),
-    ];
-};
-
-export const getDayOffset = (day, target = "sunday") => {
-    const dayNumbers = {
-        sunday: 0,
-        monday: 1,
-        tuesday: 2,
-        wednesday: 3,
-        thursday: 4,
-        friday: 5,
-        saturday: 6,
-    };
-    const diff = dayNumbers[day] - dayNumbers[target];
-    const adjustedDiff = diff < 0 ? diff + 7 : diff;
-    return adjustedDiff;
-};
-
-export const getStartDate = (dateObject, targetDayName) => {
-    // Belt and braces: we *need* this value to be a lowercase day-name in English
-    // regardless of whatever locale or format moment might try to give us if left
-    // to its own devices.
-    const dateDayName = dateObject.clone().locale("en").format("dddd").toLowerCase();
-
-    const offset = getDayOffset(dateDayName, targetDayName);
-    return dateObject.subtract(offset, "days");
-};
-
-export const getPageCount = (weekStartDate, end, count = 1) => {
-    const weekEndDate = weekStartDate.clone().add(7, "days");
-    const endDiff = end.diff(weekEndDate, "days");
-    if (endDiff < 0) {
-        return count;
-    }
-    return getPageCount(weekEndDate, end, count + 1);
-};
-
-export const getAllWeekDays = ({ startDate, endDate, startDay = "sunday", tzid }) => {
-    const start = moment.tz(startDate, "YYYY-MM-DD", tzid);
-    const end = moment.tz(endDate, "YYYY-MM-DD", tzid);
-
-    const weekStartDate = getStartDate(start, startDay);
-
-    const weekCount = getPageCount(weekStartDate, end);
-
-    let weeks = [];
-    for (let i = 0; i < weekCount; i++) {
-        weeks.push(...getDaysForWeek(weekStartDate.clone().add(i * 7, "days")));
-    }
-    return weeks;
-};
-
-export const getWeeksInfo = weekdays => {
-    const current = 1;
-    const total = Math.ceil(weekdays.length / 7);
-
-    return {
-        set: true,
-        days: weekdays,
-        total,
-        current,
-        hasNext: current < total,
-        hasPrev: false,
-    };
-};
-
-export const checkWeekdaysSlotAvailability = (
-    weekdaysEmpties,
-    availablePeriods,
-    selectedSlots,
-    duration,
-    interval,
-    unrestricted
-) => {
-    const slotsPerSelection = duration / interval;
-
-    const relativeSlot = (slot, offset) => slot.clone().add(offset * interval, "minutes");
-
-    const slotKey = slot => slot.format(shortKeyFormat);
-
-    const allAvailableSlots = {};
-    Object.values(availablePeriods).forEach(ap => {
-        let slotStart = moment.utc(ap.start);
-        const apEnd = moment.utc(ap.end);
-
-        while (slotStart < apEnd) {
-            allAvailableSlots[slotKey(slotStart)] = ap;
-            slotStart = relativeSlot(slotStart, 1);
-        }
-    });
-
-    const allSlotsInSelections = {};
-    Object.keys(selectedSlots).forEach(selected => {
-        const selectedSlot = moment.utc(selected, keyFormat);
-        for (let i = 0; i < slotsPerSelection; i++) {
-            const slot = relativeSlot(selectedSlot, i);
-            allSlotsInSelections[slotKey(slot)] = slot;
-        }
-    });
-
-    const slotSelectable = slot => {
-        if (allSlotsInSelections[slot.start]) {
-            return false;
-        } else if (unrestricted) {
-            return true;
-        } else {
-            return !!allAvailableSlots[slot.start];
-        }
-    };
-
-    const newParsedSlot = (start, lastSelectableMoment) => {
-        const startKey = slotKey(start);
-        const slotEnd = start.clone().add(duration, "minutes");
-        const endKey = slotKey(slotEnd);
-        const availableSlot = allAvailableSlots[startKey];
-        const visiblyAvailable = !!availableSlot && startKey <= lastSelectableMoment;
-        const participants = !!availableSlot ? availableSlot.participants : [];
-
-        return {
-            startMoment: start,
-            start: startKey,
-            end: endKey,
-            available: false, // Can it actually be selected?
-            visiblyAvailable: visiblyAvailable, // is it availble in the calendar
-            blocked: false,
-            selected: false,
-            target: false,
-            targetOffset: 0,
-            participants: participants,
-        };
-    };
-
-    // If a slot is `available` then it can be selected by a user.
-    //
-    // If a slot is `visiblyAvailable`, it cannot be directly selected, but
-    // should be displayed as "available" (because it falls in the duration
-    // overflow)
-    //
-    // If a slot is `blocked` it would normally be available, but is currently
-    // unselectable becasue of an existing user selection (this is a dynamic
-    // effect, and not set here).
-
-    return weekdaysEmpties.map(day => {
-        const parsedSlots = {};
-        const lastSlotOfTheDay = day.slots[day.slots.length - 1];
-        const lastSelectableMoment = lastSlotOfTheDay.end;
-
-        // Pre-generate all the slot objects for the day
-        day.slots.forEach(slot => {
-            const slotStart = moment.utc(slot.start, keyFormat);
-            const newSlot = newParsedSlot(slotStart, lastSelectableMoment);
-            parsedSlots[slot.start] = newSlot;
-        });
-
-        // March foward through each slot, seeing if the window of slots ahead of it can be selected
-        day.slots.forEach(slot => {
-            const parsedSlot = parsedSlots[slot.start];
-
-            // Even if this one is available, the slot would overun the end of the element
-            if (parsedSlot.end > lastSelectableMoment) return;
-
-            // If we click this Slot, which other slots will need to be selected?
-            const additionalSlotsForSelection = [];
-            for (let i = 0; i < slotsPerSelection; i++) {
-                const windowSlot = relativeSlot(parsedSlot.startMoment, i);
-                const windowParsedSlot = parsedSlots[slotKey(windowSlot)];
-                if (windowParsedSlot) additionalSlotsForSelection.push(windowParsedSlot);
-            }
-
-            // Are all of the slots we need selectable?
-            if (additionalSlotsForSelection.every(slotSelectable)) {
-                // Yes, set all of the slots in the window to use the current slot as their parent
-                additionalSlotsForSelection.forEach((windowParsedSlot, offset) => {
-                    if (offset === 0) {
-                        // Slot is the start of a selectable group
-                        windowParsedSlot.available = true;
-                        windowParsedSlot.target = false;
-                        windowParsedSlot.targetOffset = false;
-                    } else {
-                        // Slot is the part of a selectable group
-                        windowParsedSlot.target = slot.start;
-                        windowParsedSlot.targetOffset = slotsPerSelection - offset;
-                    }
-                    parsedSlots[windowParsedSlot.start] = windowParsedSlot;
-                });
-            }
-        });
-
-        const daySlots = Object.values(parsedSlots);
-        return {
-            day: day.day,
-            slots: daySlots,
-        };
-    });
-};
-
-export const checkWeekdaysSlotAvailabilityFreeSelect = (weekdaysEmpties, availablePeriods) => {
-    return weekdaysEmpties.map(day => ({
-        ...day,
-        slots: day.slots.map(slot => {
-            const withinPeriod = Object.keys(availablePeriods).map(periodKey => {
-                const period = availablePeriods[periodKey];
-                return slot.start >= period.start && slot.end <= period.end;
-            });
-            const result = withinPeriod.reduce((bool, acc) => {
-                if (bool) {
-                    return true;
-                } else {
-                    return acc;
-                }
-            }, false);
-            return { ...slot, visiblyAvailable: result };
-        }),
-    }));
-};
-
-export const generatePageSlots = (
-    { availablePeriods, selectedSlots, limits, pages, tzid, unrestricted, freeSelect = false },
-    getEmpties = createEmptySlotsForPeriod,
-    buildPeriod = buildDayPeriod
-) => {
-    const weekdaysEmpties = pages.days.reduce((acc, day) => {
-        const dayPeriod = buildPeriod(limits.start, limits.end, day, tzid);
-
-        // Make sure the period starts on a round value (according to the duration)
-        const roundedPeriod = roundPeriod(dayPeriod, limits.duration);
-
-        acc.push({
-            day: day,
-            slots: getEmpties(roundedPeriod, limits.interval, tzid),
-        });
-        return acc;
-    }, []);
-
-    let allSlots = [];
-    if (freeSelect) {
-        allSlots = checkWeekdaysSlotAvailabilityFreeSelect(weekdaysEmpties, availablePeriods);
-    } else {
-        const currentPage = pages.current || 1;
-        const day0 = (currentPage - 1) * 7;
-        const day7 = currentPage * 7;
-        const daysToProcess = weekdaysEmpties.slice(day0, day7);
-        allSlots = checkWeekdaysSlotAvailability(
-            daysToProcess,
-            availablePeriods,
-            selectedSlots,
-            limits.duration,
-            limits.interval,
-            unrestricted
-        );
-    }
-
-    return {
-        pages,
-        slots: allSlots,
-    };
-};
-
-export const createExportableSelection = slots => objectToArray(slots).map(item => item.value.slot);
-
-export const checkBlockedSlots = ({ slots, selected, duration = 60, interval = 60 }) => {
-    const intervalsPerSlot = duration / interval;
-
-    let precedingBlocks = [];
-    let selectedBlocks = [];
-
-    // We just need the `start` string values (used as the keys for the selected
-    // slots object).
-    const selectedKeys = Object.keys(selected);
-
-    selectedKeys.map(key => {
-        const blockSource = moment(key, "YYYY-MM-DDTHH:mm:00Z");
-        for (let i = 1; i < intervalsPerSlot; i++) {
-            // Get the `start` string for any slots directly covered
-            // by the current selection.
-            const selectedKey = blockSource
-                .clone()
-                .utc()
-                .add(i * interval, "minutes")
-                .format("YYYY-MM-DDTHH:mm[:00Z]");
-            selectedBlocks.push(selectedKey);
-
-            // Get the `start` string for any preceding slots that would
-            // overlap the selected slot.
-            const precedingOverlapKey = blockSource
-                .clone()
-                .utc()
-                .subtract(i * interval, "minutes")
-                .format("YYYY-MM-DDTHH:mm[:00Z]");
-            precedingBlocks.push(precedingOverlapKey);
-        }
-    });
-
-    const blockedSlots = slots.map(day => ({
-        ...day,
-        slots: day.slots.map(slot => {
-            // Is this slot a `preceding` slot? (if so, it should be blocked).
-            const precedingBlockStatus = precedingBlocks.includes(slot.start);
-
-            // Is this slot at the end of an available period *and* with the overlap
-            // region of a selected slot? (if so, it should be blocked).
-            const followingBlockStatus = slot.target && selectedBlocks.includes(slot.target);
-
-            const blockStatus = precedingBlockStatus || followingBlockStatus || false;
-            return {
-                ...slot,
-                blocked: blockStatus,
-            };
-        }),
-    }));
-    return blockedSlots;
-};
-
-export const generateStaticPages = (queryPeriods, startDay, tzid) => {
-    const periodsWithKeys = addKeysToSlots(queryPeriods);
-    const minMax = getMinMaxDates(periodsWithKeys);
-    const weekdays = getAllWeekDays({
-        startDate: minMax.min,
-        endDate: minMax.max,
-        startDay: startDay,
-        tzid: tzid,
-    });
-
-    const weeks = getWeeksInfo(weekdays);
-    return weeks;
-};
-
-export const divideDaysIntoWeeks = (days, currentPage) =>
-    [...days].slice((currentPage - 1) * 7, currentPage * 7);
-
-// compare 2 periods (objects with start/end as moment instances).
-// If they overlap, return that overlapping period as an object
-// with start/end as "YYYY-MM-DDTHH:mm:00Z" strings.
-// If they don't, return false.
-export const periodOverlap = (testPeriod, wrapper) => {
-    // If `testPeriod` ends before `wrapper` starts, then there's no overlap
-    const endsBefore = testPeriod.end.diff(wrapper.start, "hours");
-    if (endsBefore <= 0) return false;
-
-    // If `wrapper` starts after `testPeriod` ends, then there's no overlap
-    const startsAfter = testPeriod.start.diff(wrapper.end, "hours");
-    if (startsAfter >= 0) return false;
-
-    const startDiff = wrapper.start.diff(testPeriod.start, "minutes");
-    const endDiff = testPeriod.end.diff(wrapper.end, "minutes");
-
-    const newStart =
-        startDiff < 0
-            ? testPeriod.start.format("YYYY-MM-DDTHH:mm[:00Z]")
-            : wrapper.start.format("YYYY-MM-DDTHH:mm[:00Z]");
-    const newEnd =
-        endDiff < 0
-            ? testPeriod.end.format("YYYY-MM-DDTHH:mm[:00Z]")
-            : wrapper.end.format("YYYY-MM-DDTHH:mm[:00Z]");
-    const newPeriod = { start: newStart, end: newEnd };
-    return newPeriod;
-};
-
-export const cropQuery = (query, extent, ignoreWeeks = false) => {
-    let days;
-    if (ignoreWeeks) {
-        days = extent.days;
-    } else {
-        days = divideDaysIntoWeeks(extent.days, extent.currentPage);
-    }
-
-    // These are the bounds within which our query should live:
-    const bounds = days.map(day => {
-        const localStart = extent.startTime;
-        const localEnd = extent.endTime;
-
-        const startTime = moment.tz(`${day}T${localStart}`, "YYYY-MM-DDTHH:mm", extent.tzid).utc();
-
-        const endTimeRaw = moment.tz(`${day}T${localEnd}`, "YYYY-MM-DDTHH:mm", extent.tzid).utc();
-
-        // If the endTime is an earlier hour than the startTime, that means
-        // the period overflows a day boundary.
-        const isEndBeforeStart = startTime.diff(endTimeRaw, "minutes") > 0;
-
-        const endTime =
-            isEndBeforeStart || extent.startTime === extent.endTime
-                ? endTimeRaw.add(1, "days")
-                : endTimeRaw;
-
-        return {
-            start: startTime,
-            end: endTime,
-        };
-    });
-
-    const croppedPeriods = bounds.reduce((periodsAccumulator, day) => {
-        const newPeriods = query.query_periods
-            .map(period => {
-                const periodStart = moment.utc(period.start, "YYYY-MM-DDTHH:mm:00Z");
-                const periodEnd = moment.utc(period.end, "YYYY-MM-DDTHH:mm:00Z");
-                const overlap = periodOverlap({ start: periodStart, end: periodEnd }, day);
-
-                return overlap;
-            })
-            .filter(period => period);
-
-        return [...periodsAccumulator, ...newPeriods];
-    }, []);
-
-    return { ...query, query_periods: croppedPeriods };
-};
-
-export const calculateDisplayText = (i18n, slot, status) => {
-    const startObject = moment.tz(slot.start, "YYYY-MM-DDTHH:mm:00Z", status.tzid);
-    const endObject = moment.tz(slot.end, "YYYY-MM-DDTHH:mm:00Z", status.tzid);
-    const startTime = i18n.f(startObject, "LT").replace(" ", "");
-    const endTime = i18n.f(endObject, "LT").replace(" ", "");
-
-    let text;
-    switch (status.mode) {
-        case "multi_select":
-        case "no_confirm":
-            text = `${startTime} - ${endTime}`;
-            break;
-        case "free_select":
-            text = "";
-            break;
-        default:
-            text = i18n.t("confirm");
-    }
-    return {
-        time: `${startTime} - ${endTime}`,
-        text,
-    };
-};
-
-export const buildPeriodsFromSlots = slots => {
-    const sortedSlots = slots.sort((a, b) => {
-        if (a.start < b.start) {
-            return -1;
-        }
-        if (a.start > b.start) {
-            return 1;
-        }
-        return 0;
-    });
-
-    const periods = sortedSlots.reduce((acc, curr, i) => {
-        const prev = slots[i - 1];
-
-        if (!prev) {
-            // This is the last slot, so just add it to the array
-            return [
-                ...acc,
-                {
-                    start: curr.start,
-                    end: curr.end,
-                },
-            ];
-        }
-
-        if (curr.start === prev.end) {
-            // This slot abuts the one that came before, so
-            // let's remove the previous one and combine it with
-            // the current one.
-            const lastItem = acc.pop(); // Note: we're relying on pop() mutating acc here
-            const combo = {
-                start: lastItem.start,
-                end: curr.end,
-            };
-            return [...acc, combo];
-        }
-        // The slots don't abut, so just add this one
-        return [
-            ...acc,
-            {
-                start: curr.start,
-                end: curr.end,
-            },
-        ];
-    }, []);
-
-    return periods;
-};
-
-export const addSlotStarts = (start, interval, count) => {
-    const times = [];
-    for (let i = 0; i <= count; i++) {
-        const time = start.clone().add(i * interval, "minutes");
-        times.push(time.format("YYYY-MM-DDTHH:mm[:00Z]"));
-    }
-    return times;
-};
-
-// Given a start and end slot-time, caluculate the start-times
-// of all slots that fall between those times
-export const tweenSlots = ({ start, end, tzid, interval }) => {
-    const first = start < end ? start : end;
-    const last = start > end ? start : end;
-
-    const startTime = moment.utc(first, "YYYY-MM-DDTHH:mm:00Z");
-    const endTime = moment.utc(last, "YYYY-MM-DDTHH:mm:00Z");
-    const diff = endTime.diff(startTime, "minutes");
-
-    const firstDate = startTime.clone().tz(tzid);
-    const lastDate = endTime.clone().tz(tzid);
-    if (firstDate.format("YYYY-MM-DD") !== lastDate.format("YYYY-MM-DD")) {
-        // The selection spans mulitple days
-        const localFirstTime = startTime.clone().tz(tzid).format("HH:mm");
-        const localLastTime = endTime.clone().tz(tzid).format("HH:mm");
-        const sortedLocalFirstTime =
-            localFirstTime < localLastTime ? localFirstTime : localLastTime;
-        const sortedLocalLastTime = localFirstTime > localLastTime ? localFirstTime : localLastTime;
-
-        const timeDiff = moment(sortedLocalLastTime, "HH:mm").diff(
-            moment(sortedLocalFirstTime, "HH:mm"),
-            "minutes"
-        );
-        const dayTweenCount = timeDiff / interval;
-
-        const dayDiff = lastDate
-            .clone()
-            .endOf("day")
-            .diff(firstDate.clone().startOf("day"), "hours");
-        const dayCount = Math.floor(dayDiff / 24);
-        const dates = [firstDate.format("YYYY-MM-DD")];
-        for (let i = 1; i < dayCount; i++) {
-            const tweenDay = firstDate.clone().add(i, "days");
-            dates.push(tweenDay.format("YYYY-MM-DD"));
-        }
-        dates.push(lastDate.format("YYYY-MM-DD"));
-
-        const daysTweens = dates.map(day => {
-            const dayStart = moment
-                .tz(`${day} ${sortedLocalFirstTime}`, "YYYY-MM-DD HH:mm", tzid)
-                .utc();
-
-            const dayTweens = addSlotStarts(dayStart, interval, dayTweenCount);
-
-            return dayTweens;
-        });
-
-        const flattenedTweens = [].concat.apply([], daysTweens);
-
-        return flattenedTweens;
-    }
-
-    const tweenCount = diff / interval;
-    const tweens = addSlotStarts(startTime, interval, tweenCount);
-    return tweens;
-};
-
-export const calculateTimeString = (slot, i18n, tzid) => {
-    const startTimeString = i18n
-        .f(moment(slot.start, "YYYY-MM-DDTHH:mm:00Z").tz(tzid), "LT")
-        .replace(" ", "");
-    const endTimeString = i18n
-        .f(moment(slot.end, "YYYY-MM-DDTHH:mm:00Z").tz(tzid), "LT")
-        .replace(" ", "");
-    const timeString = `${startTimeString} - ${endTimeString}`;
-    return timeString;
-};
-
-export const getSelectedSlots = slots => {
-    const flattenedSlots = [].concat.apply(
-        [],
-        slots.map(day => day.slots)
-    );
-    const selectedSlotsByDay = flattenedSlots.filter(slot => slot.selected);
-    return selectedSlotsByDay;
-};
-
-export const checkSelectedState = (newSlots, oldSlots) => {
-    let selectedTimes = [];
-    oldSlots.map(day =>
-        day.slots.map(slot => {
-            if (slot.selected) {
-                selectedTimes.push(slot.start);
-            }
-        })
-    );
-    const mergedSlots = newSlots.map(day => ({
-        ...day,
-        slots: day.slots.map(slot => {
-            if (selectedTimes.includes(slot.start)) {
-                return {
-                    ...slot,
-                    selected: true,
-                };
-            }
-            return slot;
-        }),
-    }));
-    return mergedSlots;
-};
-
-export const condenseTimeLabel = label =>
-    label
-        .replace(/[^0-9][0-9]{2} ?/g, "")
-        .replace(/m/i, "")
-        .replace(" ", "");
-
-export const cropDaysToWindow = (rawDays, windowSize = 34) => {
-    const days = rawDays.slice(0, windowSize);
-    const overflow = rawDays.slice(windowSize - 1, rawDays.length);
-
-    return { days, overflow };
-};
-
-export const getAllLabels = ({ days, limits, tzid, i18n, locale }) => {
-    // For each week that the AV could potentially show we
-    // want to calculate:
-    // 1. An array of days in that week
-    // 2. An array of time label info (start-time | end-time | is-hour?)
-    // 3. The appropriate month label for the week
-
-    // Generate an array with one empty item for each week.
-    const emptyWeeks = Array.from(new Array(Math.ceil(days.length / 7)));
-
-    // Add the days to each week.
-    const weeksWithDays = emptyWeeks.map((_, i) => {
-        const start = i * 7;
-        const end = start + 7;
-        const weeklyDays = days.slice(start, end);
-        const dayObjects = weeklyDays.map(day => {
-            const dayObject = moment.tz(day, "YYYY-MM-DD", tzid);
-            return {
-                date: day,
-                number: i18n.f(dayObject, "D"),
-                name: i18n.f(dayObject, "ddd"),
-            };
-        });
-        return { days: dayObjects };
-    });
-
-    // Add the time labels to each week.
-    const weeksWithTimes = weeksWithDays.map(week => {
-        // `days[1]` is the second day in the week (Monday) so that even on
-        // weeks where there is a DST transition on a Sunday, the labels are
-        // accurate for the main bulk of the days shown.
-        return {
-            ...week,
-            times: timeLabels(limits, week.days[1].date, tzid),
-        };
-    });
-
-    // Add a month label to each week [TODO]
-    const weeksWithMonths = weeksWithTimes.map(week => {
-        const simpleDaysArray = week.days.map(day => day.date);
-        return {
-            ...week,
-            month: getMonthsDescription(simpleDaysArray, locale),
-        };
-    });
-
-    return weeksWithMonths;
-};
-
-// Do the days stored in our `allLabels` state match the days
-// in our `pages` context?
-export const checkIfDaysMatch = (days, allLabels) => {
-    if (typeof allLabels !== "object" || allLabels.length <= 0) {
-        // We have no saved days, so they definitely do not match
-        return false;
-    }
-
-    // First and last days from `pages`
-    const firstDay = days[0];
-    const lastDay = days[days.length - 1];
-
-    // First and last days from `allLabels`
-    const firstSavedDay = allLabels[0].days[0].date;
-    const lastSavedWeek = allLabels[allLabels.length - 1].days;
-    const lastSavedDay = lastSavedWeek[lastSavedWeek.length - 1].date;
-
-    return firstDay === firstSavedDay && lastDay === lastSavedDay;
-};
-
-export const checkIfLimitsMatch = ({ start, end }, times, tzid = "Etc/UTC") => {
-    // Get the first start time in `HH:mm` format
-    const startTime = moment
-        .tz(times[0].start, "YYYY-MM-DDTHH:mm:00Z", tzid)
-        .local()
-        .format("HH:mm");
-
-    // Get the last end time in `HH:mm` format
-    const rawEndTime = moment
-        .tz(times[times.length - 1].end, "YYYY-MM-DDTHH:mm:00Z", tzid)
-        .local()
-        .format("HH:mm");
-
-    // Account for limits.end being "24:00"
-    const endTime = rawEndTime === "00:00" ? "24:00" : rawEndTime;
-
-    const startMatches = startTime === start;
-    const endMatches = endTime === end;
-
-    // The limits match the time-labels if *both* start and end match.
-    return startMatches && endMatches;
-};