cronofy-elements 1.48.1 → 1.49.1

package/src/js/helpers/connections.js

@@ -1,370 +0,0 @@
-import * as mocks from "./mocks";
-import packageDetails from "../../../package";
-import { errorMessages } from "./logging";
-import { parseFreeBusyEvents } from "./events";
-
-const handle422Responses = res => {
-    if (res.errors) {
-        throw {
-            type: 422,
-            message: errorMessages[422].message,
-            body: res.errors,
-            docsSlug: errorMessages[422].docsSlug,
-        };
-    }
-    return res;
-};
-
-const handleInvalidResponses = res => {
-    // All 2** status are valid.
-    // 422 is included because we want to handle those in
-    // handle422Responses *after* res.body.json() has completed
-    // (res.body is a ReadableStream until then)
-    const okStatuses = [200, 201, 202, 422];
-
-    if (okStatuses.includes(res.status)) {
-        return res;
-    }
-
-    throw {
-        type: res.status,
-        message: errorMessages[res.status].message,
-    };
-};
-
-const handleInvalidRulesResponse = res => {
-    if (res.status === 404) {
-        // Rules treats a 404 as a valid response
-        return res;
-    }
-
-    return handleInvalidResponses(res);
-};
-
-const catchAndRethrowErrors = error => {
-    if (error.type) {
-        throw error;
-    }
-    throw {
-        type: 401,
-        message: errorMessages[401].message,
-        docsSlug: errorMessages[401].docsSlug,
-    };
-};
-
-export const parseCalendars = response =>
-    response.calendars.map((cal, i) => ({
-        name: cal.calendar_name,
-        id: cal.calendar_id,
-        color: i,
-    }));
-
-export const getUserInfo = (token, api_domain, mock = false) => {
-    if (mock) return mocks.userinfo;
-
-    const url = new URL(`${api_domain}/v1/userinfo`);
-    url.searchParams.append("et", token);
-
-    return fetch(url.href, {
-        method: "GET",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, agenda`,
-        },
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .catch(catchAndRethrowErrors);
-};
-
-export const parseUserInfoCalendars = response => {
-    const fullCalendars = response["cronofy.data"].profiles
-        .map(profile => profile.profile_calendars)
-        .reduce((acc, curr) => [...acc, ...curr], []);
-
-    const parsedCalendars = fullCalendars.map((cal, i) => ({
-        name: cal.calendar_name,
-        id: cal.calendar_id,
-        color: i,
-    }));
-    return parsedCalendars;
-};
-
-export const parseRulesCalendars = response => {
-    // Filter deleted calendars
-    const profiles = response["cronofy.data"].profiles.map(profile => {
-        const profile_calendars = profile.profile_calendars.filter(cal => !cal.calendar_deleted);
-        return { ...profile, profile_calendars };
-    });
-
-    // Format and flatten calendars into 1D array
-    const calendars = profiles
-        .map(profile =>
-            profile.profile_calendars.map(cal => ({
-                name: cal.calendar_name,
-                id: cal.calendar_id,
-                profile_name: profile.profile_name,
-                provider_name: profile.provider_name,
-            }))
-        )
-        .reduce((acc, curr) => [...acc, ...curr], []);
-
-    return {
-        calendars,
-        profiles,
-    };
-};
-
-export const parseEventsArgs = (args, token) => {
-    const parsedArgs = {
-        et: token,
-        from: args.from,
-        include_geo: true,
-        include_userinfo: true,
-        to: args.to,
-        tzid: args.tzid,
-    };
-
-    if (args.only_managed) {
-        parsedArgs.only_managed = true;
-    } else {
-        parsedArgs.include_managed = true;
-    }
-
-    return parsedArgs;
-};
-
-export const parseFreeBusyArgs = (args, token) => {
-    const parsedArgs = {
-        et: token,
-        from: args.from,
-        include_geo: true,
-        include_userinfo: true,
-        to: args.to,
-        tzid: args.tzid,
-    };
-
-    // If only_managed is true, then we're request
-    // managed events in the regular `events` call
-    // so want to filter them out here.
-    if (args.only_managed) {
-        parsedArgs.include_managed = false;
-    } else {
-        parsedArgs.include_managed = true;
-    }
-
-    return parsedArgs;
-};
-
-export const createEventsUrl = (api_domain, data, slug = "events") => {
-    const url = new URL(`${api_domain}/v1/${slug}`);
-    Object.keys(data).forEach(key => url.searchParams.append(key, data[key]));
-    return url.href;
-};
-
-export const getEvents = ({
-    token,
-    api_domain,
-    args,
-    next = loadNextPage,
-    freeBusy = false,
-    mock = false,
-}) => {
-    if (mock) return mocks.eventsWithUserinfo;
-
-    const data = freeBusy ? parseFreeBusyArgs(args, token) : parseEventsArgs(args, token);
-
-    const url = createEventsUrl(api_domain, data, freeBusy ? "free_busy" : "events");
-
-    let events = [];
-
-    return fetch(url, {
-        method: "GET",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, agenda`,
-        },
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .then(json => {
-            const userinfo = json.userinfo;
-            if (json.events && json.events.length > 0) {
-                events.push(...json.events);
-            }
-            if (json.free_busy && json.free_busy.length > 0) {
-                const parsedEvents = parseFreeBusyEvents(json.free_busy);
-                events.push(...parsedEvents);
-            }
-            if (json.pages && json.pages.next_page) {
-                return next(token, json.pages.next_page, events, userinfo);
-            }
-            return { events, userinfo };
-        })
-        .catch(catchAndRethrowErrors);
-};
-
-export const loadNextPage = (token, pageUrl, eventsArray, userinfo, callback = loadNextPage) => {
-    const newurl = new URL(pageUrl);
-    newurl.searchParams.append("et", token);
-    return fetch(newurl.href, {
-        method: "GET",
-        headers: {
-            "Content-Type": "application/json; charset=utf-8",
-            "Cronofy-Element": `v${packageDetails.version}, agenda`,
-        },
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .then(json => {
-            if (json.events && json.events.length > 0) {
-                eventsArray.push(...json.events);
-            }
-            if (json.free_busy && json.free_busy.length > 0) {
-                const parsedEvents = parseFreeBusyEvents(json.free_busy);
-                eventsArray.push(...parsedEvents);
-            }
-            if (json.pages && json.pages.next_page) {
-                return callback(token, json.pages.next_page, eventsArray, userinfo);
-            }
-            return { events: eventsArray, userinfo };
-        })
-        .catch(catchAndRethrowErrors);
-};
-
-export const getAvailability = (
-    token,
-    api_domain,
-    params = {},
-    element = "availability",
-    tzid = "Etc/UTC",
-    mock = false
-) => {
-    if (
-        (mock && params.response_format === "slots") ||
-        (mock && typeof params.start_interval === "undefined")
-    ) {
-        return mocks.availabilitySlots;
-    }
-    if (mock && params.response_format === "overlapping_slots") {
-        return mocks.availabilityOverlappingSlots(
-            params.start_interval.minutes,
-            params.required_duration.minutes,
-            params.query_periods,
-            tzid
-        );
-    }
-    if (mock) return mocks.availability;
-
-    return fetch(`${api_domain}/v1/availability?et=${token}`, {
-        method: "POST",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, ${element}`,
-            "Content-Type": "application/json; charset=utf-8",
-        },
-        body: JSON.stringify(params),
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .then(handle422Responses)
-        .catch(catchAndRethrowErrors);
-};
-
-export const getSequencedAvailability = (
-    token,
-    api_domain,
-    params = {},
-    element = "sequenced-availability",
-    tzid = "Etc/UTC",
-    mock = false
-) => {
-    if (mock) return mocks.sequencedAvailabilitySlots;
-
-    return fetch(`${api_domain}/v1/sequenced_availability?et=${token}`, {
-        method: "POST",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, ${element}`,
-            "Content-Type": "application/json; charset=utf-8",
-        },
-        body: JSON.stringify(params),
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .then(handle422Responses)
-        .catch(catchAndRethrowErrors);
-};
-
-export const getAvailabilityRules = ({
-    token,
-    api_domain,
-    availability_rule_id = false,
-    element = "rules",
-    mock = false,
-    tzid = false,
-}) => {
-    if (mock) return mocks.availability_rules(tzid);
-
-    const url = new URL(`${api_domain}/v1/availability_rules/${availability_rule_id}`);
-    url.searchParams.append("et", token);
-
-    return fetch(url.href, {
-        method: "GET",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, ${element}`,
-        },
-    })
-        .then(handleInvalidRulesResponse)
-        .then(res => {
-            if (res.status === 404) {
-                return { type: 404 };
-            }
-            return res.json();
-        })
-        .catch(catchAndRethrowErrors);
-};
-
-export const setAvailabilityRules = ({
-    token,
-    api_domain,
-    params = {},
-    element = "rules",
-    mock = false,
-    tzid = false,
-}) => {
-    if (mock) return mocks.availability_rules(tzid);
-
-    return fetch(`${api_domain}/v1/availability_rules?et=${token}`, {
-        method: "POST",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, ${element}`,
-            "Content-Type": "application/json; charset=utf-8",
-        },
-        body: JSON.stringify(params),
-    })
-        .then(handleInvalidResponses)
-        .then(res => res.json())
-        .catch(catchAndRethrowErrors);
-};
-
-export const revokeProfile = (
-    token,
-    api_domain,
-    profile_id,
-    element = "calendar-sync",
-    mock = false
-) => {
-    if (mock) return mocks.revokeProfile();
-
-    return fetch(`${api_domain}/v1/profiles/${profile_id}/revoke?et=${token}`, {
-        method: "POST",
-        headers: {
-            "Cronofy-Element": `v${packageDetails.version}, ${element}`,
-            "Content-Type": "application/json; charset=utf-8",
-        },
-    })
-        .then(handleInvalidResponses)
-        .catch(catchAndRethrowErrors);
-};
-
-export const getCalendars = (token, apiDomain, demo) =>
-    getUserInfo(token, apiDomain, demo)
-        .then(res => parseRulesCalendars(res))
-        .catch(catchAndRethrowErrors);

package/src/js/helpers/events.js

@@ -1,166 +0,0 @@
-import moment from "moment-timezone";
-import merge from "deepmerge";
-import { uniqueItems } from "./utils";
-
-export const isAllDayEvent = (start, end) => checkISO8601(start) && checkISO8601(end);
-
-export const checkISO8601 = string => /^\d{4}-\d{2}-\d{2}$/.test(string);
-
-export const dayNumbersString = (startObj, endObj, currentDay) => {
-    const days = dayNumbers(startObj, endObj, currentDay);
-    const multi = days.days > 1 ? ` - ${days.day}/${days.days}` : ``;
-    return multi;
-};
-
-export const dayNumbers = (startObj, endObj, currentDay) => {
-    const days = endObj.diff(startObj, "days");
-    const dayDiff = endObj.diff(moment(currentDay), "days");
-    const day = days - dayDiff + 1;
-    return { days, day };
-};
-
-export const getMultiDayStatus = (start, end, current) => {
-    const allDay = isAllDayEvent(start, end);
-    if (!allDay) return 0;
-    const days = dayNumbers(moment(start), moment(end), current);
-    if (days.days <= 1) return 0;
-    if (days.day === 1) return 1;
-    if (days.day === days.days) return 2;
-    return 3;
-};
-
-export const checkDirection = (target, current) => {
-    const dayDiff = target.diff(current, "days");
-    const result = dayDiff > 0 ? "forwards" : "backwards";
-    return result;
-};
-
-// Add the uid for an event to every day that the event covers
-export const eventDates = event => {
-    const first = moment(event.start);
-    const last = moment(event.end);
-    const dayCount = last.diff(first, "days");
-    const dates = {};
-    dates[first.format(`YYYY-MM-DD`)] = {
-        [event.event_uid]: true,
-    };
-    for (let i = 1; i < dayCount; i++) {
-        let current = first;
-        current.add(1, "days");
-        dates[current.format(`YYYY-MM-DD`)] = {
-            [event.event_uid]: true,
-        };
-    }
-    return dates;
-};
-
-// Add a date object for each date in the selected range (targetDate +- offset)
-export const getDayRange = (targetDate, offset, existingDays = {}) => {
-    const days = existingDays;
-    for (let i = 0 - offset; i <= offset; i++) {
-        const day = moment(targetDate).add(i, "days").format(`YYYY-MM-DD`);
-        days[day] = {};
-    }
-    return days;
-};
-
-export const setEventDayIDs = (events, daysObject, eventDatesFunc = eventDates) => {
-    let output = daysObject;
-    events.map(event => {
-        const days = { ...output };
-        const thisEventDays = eventDatesFunc(event);
-        output = merge(days, thisEventDays);
-    });
-    return output;
-};
-
-export const parseEventsByID = (events, existingEvents = {}) => {
-    const eventsOutput = existingEvents;
-    // for each event, add the event to the output, using its uid as a key
-    events.map(event => {
-        eventsOutput[event.event_uid] = event;
-    });
-    return eventsOutput;
-};
-
-// calculateLimit returns:
-//  0 = not at limit
-// -1 = at backward limit
-//  1 = at forward limit
-export const calculateLimit = (current, anchor) => {
-    const today = moment(anchor);
-    const target = moment(current);
-    const limits = [-14, 90]; // 2 weeks behind | 3 months ahead
-    const diff = target.diff(today, "days");
-    let limit = 0;
-    if (diff > limits[1]) limit = 1;
-    if (diff < limits[0]) limit = -1;
-    return limit;
-};
-
-export const sortEventsByType = events => {
-    const allDayEvents = events.filter(event => isAllDayEvent(event.start, event.end));
-    const timedEvents = events
-        .filter(event => !isAllDayEvent(event.start, event.end))
-        .sort((a, b) => {
-            if (moment(a.start) < moment(b.start)) {
-                return -1;
-            }
-            if (moment(a.start) > moment(b.start)) {
-                return 1;
-            }
-            return 0;
-        });
-    return { allDay: allDayEvents, timed: timedEvents };
-};
-
-export const getEventByID = (id, events) => events.find(event => event.event_uid === id);
-
-export const getCalColor = (id, cals) =>
-    cals.filter(cal => cal.id == id).reduce((acc, curr) => curr.color, 0);
-
-export const parseDirection = directionInput => {
-    let direction;
-    switch (directionInput) {
-        case "backwards":
-        case "backward":
-        case "back":
-            direction = "backwards";
-            break;
-        case "upwards":
-        case "upward":
-        case "up":
-            direction = "upwards";
-            break;
-        case "downwards":
-        case "downward":
-        case "down":
-            direction = "downwards";
-            break;
-        default:
-            direction = "forwards";
-            break;
-    }
-    return direction;
-};
-
-export const getCalendarsFromEvents = events => {
-    const allCalendarIDs = events.map(event => event.calendar_id);
-    const uniqueIDs = uniqueItems(allCalendarIDs);
-    const calendars = uniqueIDs.map((ID, index) => ({ id: ID, color: index }));
-    return calendars;
-};
-
-// Check crucial event properties to make sure they exist (and apply fallback if needed)
-export const parseEvents = events =>
-    events.map(event => ({
-        ...event,
-        summary: event.summary || "–",
-    }));
-
-export const parseFreeBusyEvents = events =>
-    events.map(event => ({
-        ...event,
-        summary: event.summary || event.free_busy_status,
-        event_uid: event.event_uid || `${event.free_busy_status}_${event.start}`,
-    }));

package/src/js/helpers/functional.js

@@ -1,4 +0,0 @@
-export const compose = (...functions) => data =>
-    functions.reduceRight((value, func) => func(value), data);
-
-export const pipe = (...functions) => data => functions.reduce((value, func) => func(value), data);

package/src/js/helpers/generator.js

@@ -1,107 +0,0 @@
-// import React from "react";
-import ReactDOM from "react-dom";
-
-import Error from "../components/generic/Error";
-import { logConstructor } from "./logging";
-import { deepCopy } from "./utils";
-
-const renderError = targetId => {
-    const target = document.getElementById(targetId);
-    if (!target) return false;
-
-    ReactDOM.render(
-        <div className="error__wrapper" style={{ position: "relative", minHeight: "200px" }}>
-            <Error
-                message={
-                    "There was a problem with the UI Elements configuration settings. See the developer console for more detail."
-                }
-                theme={{ colors: { black: "#4D4D4D" } }}
-            />
-        </div>,
-        target
-    );
-};
-
-/**
- * This is a wrapper to handle re-rendering logic when `options` are
- * changed.
- */
-export const generateElementAPI = (Renderer, options, optionsFormatter, elementName) => {
-    let config = typeof options.config === "undefined" ? {} : options.config;
-    const logs = typeof config.logs === "undefined" ? "warn" : config.logs;
-    const log = logConstructor(logs, elementName);
-
-    let currentOptions = deepCopy(options);
-    currentOptions.callback = options.callback;
-    const renderElement = (key, options, target) => {
-        ReactDOM.render(Renderer(key, options), target);
-    };
-
-    // We need to change the key every time we reload the Element (to trigger)
-    let key = 1;
-
-    const parsedOptions = optionsFormatter(options);
-    if (!parsedOptions) {
-        renderError(options.target_id);
-        return false;
-    }
-    const target = document.getElementById(parsedOptions.target);
-
-    if (!target) {
-        log.error(`${parsedOptions.target} is not a valid DOM element`);
-        return false;
-    }
-
-    const context = () => {
-        return { tzid: parsedOptions.tzid };
-    };
-
-    renderElement(key, parsedOptions, target);
-
-    const reload = newRawOptions => {
-        // Increment the key - this will ensure the React
-        // component re-renders when the `options` change.
-        key++;
-        // Check our options for error/omissions
-        currentOptions = deepCopy(newRawOptions);
-        currentOptions.callback = newRawOptions.callback;
-        const newOptions = optionsFormatter(newRawOptions);
-        newOptions.callback = currentOptions.callback;
-        // Start the re-render
-        renderElement(key, newOptions, target);
-    };
-
-    return {
-        context: context(),
-        refresh: () => reload(currentOptions),
-        update: newOptions => {
-            if (typeof newOptions === "undefined") {
-                log.warn(`The update() method expects to recieve an options object`);
-                return;
-            }
-            let updatedOptions = {
-                ...currentOptions,
-                ...newOptions,
-            };
-            if (newOptions.config) {
-                updatedOptions.config = {
-                    ...currentOptions.config,
-                    ...newOptions.config,
-                };
-            }
-            if (newOptions.availability_query) {
-                updatedOptions.availability_query = {
-                    ...currentOptions.availability_query,
-                    ...newOptions.availability_query,
-                };
-            }
-            if (newOptions.styles) {
-                updatedOptions.styles = {
-                    ...currentOptions.styles,
-                    ...newOptions.styles,
-                };
-            }
-            return reload(updatedOptions);
-        },
-    };
-};