cronofy-elements 1.48.2 → 1.49.2

package/demo/server.js

@@ -1,425 +0,0 @@
-require("@babel/polyfill");
-const fetch = require("node-fetch");
-const express = require("express");
-const app = express();
-const path = require("path");
-const moment = require("moment");
-
-const url = require("url");
-const querystring = require("querystring");
-
-const env = require("../src/js/env");
-let apiDomain = env.API_DOMAIN || "https://api.cronofy.com";
-let rawApiDomain = apiDomain;
-const appDomain = env.APP_DOMAIN || "https://app.cronofy.com";
-
-if (env.API_DOMAIN) {
-    // The the "domain" starts with a protocol, we can assume it is
-    // a full path. Otherwise assume it is a pure domain, so add our
-    // protocol (everyone should be using HTTPS)
-    apiDomain = env.API_DOMAIN.startsWith("http")
-        ? env.API_DOMAIN
-        : `https://${env.API_DOMAIN}`;
-    rawApiDomain = env.API_DOMAIN;
-}
-
-console.log("Firing up server...");
-
-const getData = async (url, options) =>
-    await fetch(url, options)
-        .then(async res => await res.json())
-        .catch(err => {
-            console.log(err);
-            console.error(
-                "\x1b[31m",
-                "\n┌───────────────────────────────────────────────────┐\n│ ERROR:                                            │\n│ There was a problem generating the element token. │\n│ Check that your CLIENT_ID, CLIENT_SECRET, and SUB │\n│ environment variables are correct.                │\n└───────────────────────────────────────────────────┘\n",
-                "\x1b[0m"
-            );
-            return { element_token: { token: "invalid" } };
-        });
-
-const baseUrl = `${apiDomain}/v1/element_tokens`;
-
-const singleTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: [
-            "agenda",
-            "availability",
-            "managed_availability",
-            "account_management"
-        ],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const calendarSyncTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: ["account_management"],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const rulesTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: ["managed_availability"],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const agendaTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: ["agenda"],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const availabilityViewerTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: ["availability"],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const slotPickerTokenOptions = {
-    method: "POST",
-    headers: {
-        "Content-Type": "application/json; charset=utf-8",
-        Authorization: `Bearer ${env.CLIENT_SECRET}`
-    },
-    body: JSON.stringify({
-        version: "1",
-        permissions: ["availability"],
-        subs: [env.SUB],
-        origin: "http://localhost:8080"
-    })
-};
-
-const dateTimePickerTokenOptions = {
-  method: "POST",
-  headers: {
-      "Content-Type": "application/json; charset=utf-8",
-      Authorization: `Bearer ${env.CLIENT_SECRET}`
-  },
-  body: JSON.stringify({
-      version: "1",
-      permissions: ["availability"],
-      subs: [env.SUB],
-      origin: "http://localhost:8080"
-  })
-};
-
-function localMiddleware (req, res, next) {
-    if (req.query.locale !== undefined) { 
-        req.locale = req.query.locale;
-    } else {
-        req.locale = 'en';
-    }
-    // keep executing the router middleware
-    next()
-}
-
-app.set("query parser", "extended");
-app.use(express.static(__dirname + "/../"));
-app.use(localMiddleware)
-app.set("view engine", "ejs");
-app.set("views", path.join(__dirname, "/../demo"));
-
-app.get("/", async (req, res) => {
-    const codeQuery = req.query.code;
-
-    if (codeQuery) {
-        console.log("there is a `code` query:", codeQuery);
-        const codeResponse = await getData(`${apiDomain}/oauth/token`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json; charset=utf-8"
-            },
-            body: JSON.stringify({
-                client_id: env.CLIENT_ID,
-                client_secret: env.CLIENT_SECRET,
-                grant_type: "authorization_code",
-                code: codeQuery,
-                redirect_uri: "http://localhost:8080/"
-            })
-        });
-        console.log("codeResponse", codeResponse);
-        return res.redirect("/");
-    }
-
-    const single_token = await getData(baseUrl, singleTokenOptions);
-
-    return res.render("index", {
-        single_token: single_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/availability-viewer", async (req, res) => {
-    const availability_token = await getData(
-        baseUrl,
-        availabilityViewerTokenOptions
-    );
-    console.log("Rendering with " + req.locale);
-    return res.render("availability-viewer", {
-        availability_token: availability_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/rules", async (req, res) => {
-    const rules_token = await getData(baseUrl, rulesTokenOptions);
-    return res.render("rules", {
-        rules_token: rules_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/agenda", async (req, res) => {
-    const agenda_token = await getData(baseUrl, agendaTokenOptions);
-    return res.render("agenda", {
-        agenda_token: agenda_token.element_token.token,
-        locale: req.locale,
-        api_domain: rawApiDomain
-    });
-});
-
-app.get("/integration", async (req, res) => {
-    const availability_token = await getData(
-        baseUrl,
-        availabilityViewerTokenOptions
-    );
-    const agenda_token = await getData(baseUrl, agendaTokenOptions);
-    const rules_token = await getData(baseUrl, rulesTokenOptions);
-    const slot_picker_token = await getData(baseUrl, slotPickerTokenOptions);
-    const cal_sync_token = await getData(baseUrl, calendarSyncTokenOptions);
-    return res.render("integration", {
-        agenda_token: agenda_token.element_token.token,
-        availability_token: availability_token.element_token.token,
-        rules_token: rules_token.element_token.token,
-        slot_picker_token: slot_picker_token.element_token.token,
-        cal_sync_token: cal_sync_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/crossbrowser", async (req, res) => {
-    const availability_token = await getData(
-        baseUrl,
-        availabilityViewerTokenOptions
-    );
-    const agenda_token = await getData(baseUrl, agendaTokenOptions);
-    const rules_token = await getData(baseUrl, rulesTokenOptions);
-    const slot_picker_token = await getData(baseUrl, slotPickerTokenOptions);
-    const cal_sync_token = await getData(baseUrl, calendarSyncTokenOptions);
-    return res.render("crossbrowser", {
-        agenda_token: agenda_token.element_token.token,
-        availability_token: availability_token.element_token.token,
-        rules_token: rules_token.element_token.token,
-        slot_picker_token: slot_picker_token.element_token.token,
-        cal_sync_token: cal_sync_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-const slotTimes = function(days, time) {
-    const timeString = `${moment().utc().format("YYYY-MM-DD")}T${time}:00Z`;
-    const output = moment(timeString)
-        .add(days, "days");
-    return output.utc().format();
-};
-
-app.get("/slot-picker", async (req, res) => {
-    let bookable_event_ids = [];
-
-    const createBookableEvents = req.query.bookable_events;
-
-    if (createBookableEvents) {
-        const example_bookable_events = [
-            {
-                "bookable_event_id": "BOOKABLE_EVENT_1",
-                "start": slotTimes(1,"10:00"),
-                "end": slotTimes(1,"11:00"),
-                "status": "confirmed",
-                "registration": {
-                    "capacity": 5
-                }
-            },
-            {
-                "bookable_event_id": "BOOKABLE_EVENT_2",
-                "start": slotTimes(1,"12:00"),
-                "end": slotTimes(1,"13:30"),
-                "status": "confirmed",
-                "registration": {
-                    "capacity": 5
-                }
-            },
-            {
-                "bookable_event_id": "BOOKABLE_EVENT_3",
-                "start": slotTimes(1,"15:00"),
-                "end": slotTimes(1,"17:00"),
-                "status": "confirmed",
-                "registration": {
-                    "capacity": 5
-                }
-            },
-            {
-                "bookable_event_id": "BOOKABLE_EVENT_4",
-                "start": slotTimes(2,"12:00"),
-                "end": slotTimes(2,"13:30"),
-                "status": "confirmed",
-                "registration": {
-                    "capacity": 5
-                }
-            }
-        ];
-
-        const bookableEventsUrl = `${apiDomain}/v1/bookable_events`;
-        const eventCreationOptions = {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json; charset=utf-8",
-                Authorization: `Bearer ${env.CLIENT_SECRET}`
-            }
-        };
-
-        bookable_event_ids = await Promise.all(example_bookable_events.map(async event => {
-            const options = {
-                ...eventCreationOptions,
-                body: JSON.stringify(event)
-            };
-    
-            const bookable_event = await getData(bookableEventsUrl, options);
-            console.log("New bookable event created:");
-            console.log({eventId: bookable_event.bookable_event.bookable_event_id});
-
-            return bookable_event.bookable_event.bookable_event_id;
-        }));
-    }
-
-    const tokenOptions = () => {
-        let options = {
-              version: "1",
-              permissions: ["availability"],
-              origin: "http://localhost:8080"
-        }
-
-        if(bookable_event_ids.length > 0){
-            options.bookable_event_ids = bookable_event_ids;
-        }
-
-        return options;
-    };
-
-    const bookableEventsSlotPickerTokenOptions = {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json; charset=utf-8",
-            Authorization: `Bearer ${env.CLIENT_SECRET}`
-        },
-        body: JSON.stringify(tokenOptions()),
-    }
-
-    const slot_picker_token = await getData(baseUrl, slotPickerTokenOptions);
-    const bookable_events_token = await getData(baseUrl, bookableEventsSlotPickerTokenOptions);
-    return res.render("slot-picker", {
-        bookable_event_ids: bookable_event_ids,
-        slot_picker_token: slot_picker_token.element_token.token,
-        bookable_events_token: bookable_events_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/date-time-picker", async (req, res) => {
-    const date_time_picker_token = await getData(baseUrl, dateTimePickerTokenOptions);
-    return res.render("date-time-picker", {
-        date_time_picker_token: date_time_picker_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.get("/calendar-sync", async (req, res) => {
-    const cal_sync_token = await getData(baseUrl, calendarSyncTokenOptions);
-    return res.render("calendar-sync", {
-        cal_sync_token: cal_sync_token.element_token.token,
-        api_domain: rawApiDomain,
-        app_domain: appDomain,
-        sub: env.SUB,
-        locale: req.locale,
-        client_id: env.CLIENT_ID
-    });
-});
-
-app.listen(8080);
-
-console.log(
-    "\x1b[32m\n",
-    "┌─────────────────────────────────────────────────┐\n",
-    "│                                                 │\n",
-    "│  serving on port 8080 - http://localhost:8080/  │\n",
-    "│                                                 │\n",
-    "└─────────────────────────────────────────────────┘\n",
-    "\x1b[0m"
-);

package/demo/slot-picker.ejs

@@ -1,197 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Embedding demo: availability viewer</title>
-    <link href="https://fonts.googleapis.com/css?family=Open+Sans" rel="stylesheet">
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.24.0/moment.js"></script>
-    <link href="/demo/demo-styles.css" rel="stylesheet">
-    <%- include('load-elements.ejs', { mode: 'dev'}) %>
-</head>
-
-<body class="trouble">
-    <% var slug = 'slot-picker'; %>
-    <%- include nav.ejs %>
-
-    <h1>Slot Picker</h1>
-    <div id="cronofy-error-message"></div>
-    <div id="cronofy-slot-picker"></div>
-    <p>Lorem ipsum, dolor sit amet consectetur adipisicing elit. Recusandae, doloribus eaque? Animi, velit culpa nostrum omnis vitae rem placeat ut mollitia autem porro! Qui molestiae porro rerum similique, aliquid deleniti!</p>
-    <div id="cronofy-slot-picker-two"></div>
-    <hr>
-    <h3>Slot Picker: bookable events</h3>
-    <div id="cronofy-slot-picker-bookable-events"></div>
-    <p><a href="http://localhost:8080/slot-picker?locale=en&bookable_events=true">Create some bookable events</a></p>
-    <hr>
-    <div class="wrapper">
-        <div class="column">
-            <h2>Consectetur adipisicing elit</h2>
-            <p>Lorem ipsum dolor sit, amet consectetur adipisicing elit. <a href="/">Voluptate sed ex totam odit</a> quae hic voluptatibus, quisquam dicta animi laborum velit laboriosam, placeat suscipit tenetur voluptates! Illo tempora minus animi.</p>
-            <p>Lorem ipsum, dolor sit amet consectetur adipisicing elit. Quidem consequuntur repudiandae nesciunt, totam dicta earum deleniti magnam eveniet eligendi sunt adipisci veniam esse aliquid aperiam corporis optio fuga tempora sit!</p>
-        </div>
-        <div class="column">
-            <h2>Est deserunt non quis do quis nostrud ad exercitation proident incididunt.</h2>
-            <p>Excepturi dicta neque ut, a expedita quaerat, tempore dolor placeat quibusdam cumque ipsam cum officia voluptate, ea fuga optio necessitatibus inventore tempora?</p>
-            <p>Lorem ipsum dolor sit, amet consectetur adipisicing elit. Natus nisi eveniet voluptas provident esse beatae minus at error dignissimos neque? Temporibus velit numquam aut labore porro neque ipsum, deleniti a?</p>
-            <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Eum sunt eligendi, error quos nulla dolorem alias corrupti iste fugiat deleniti nam unde, porro provident a voluptatem at voluptates, dolores sed!</p>
-        </div>
-    </div>
-    <p>Lorem ipsum dolor sit, amet consectetur adipisicing elit. Natus nisi eveniet voluptas provident esse beatae minus at error dignissimos neque? Temporibus velit numquam aut labore porro neque ipsum, deleniti a?</p>
-    <p>Lorem ipsum dolor sit, amet consectetur adipisicing elit. Debitis saepe maxime corporis nemo hic rerum porro in repudiandae? Libero eligendi impedit reiciendis exercitationem fuga ex eos aliquid itaque facere corrupti.</p>    
-    <hr>
-    <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Eum sunt eligendi, error quos nulla dolorem alias corrupti iste fugiat deleniti nam unde, porro provident a voluptatem at voluptates, dolores sed!</p>
-    <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Voluptatum commodi fuga laboriosam? Quas officiis doloremque iure modi, ipsam dolore ad illum saepe et voluptatum quis tempore ullam dolor, sequi nulla!</p>
-    <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Eum sunt eligendi, error quos nulla dolorem alias corrupti iste fugiat deleniti nam unde, porro provident a voluptatem at voluptates, dolores sed!</p>
-
-    <script>
-        const locale = "<%= locale %>";
-
-        if ("<%= slot_picker_token %>" === "invalid") {
-            const errorMessageWrapper = document.querySelector('#cronofy-error-message');
-            errorMessageWrapper.innerHTML = "<span class='error'>There was a problem generating the element token. Check that your <code>CLIENT_ID</code>, <code>CLIENT_SECRET</code>, and <code>SUB</code> environment variables are correct.</span>"
-        }
-
-        const display = {
-            // 0 = don't show the element
-            // 1 = show the element
-            one: 1,
-            two: 1,
-            three: 1
-        }
-
-        if (display.one) {
-            const slotTimes = function(days, time) {
-                const timeString = `${moment().utc().format("YYYY-MM-DD")}T${time}:00Z`;
-                const output = moment(timeString)
-                    .add(days, "days");
-                return output.utc().format();
-            };
-
-            CronofyElements.SlotPicker({
-                element_token: "<%= slot_picker_token %>",
-                target_id: 'cronofy-slot-picker',
-                api_domain:"<%= api_domain %>",
-                availability_query: {
-                    participants: [
-                        {
-                            required: "all",
-                            members: [
-                                {
-                                    sub: "<%= sub %>",
-                                    // managed_availability: true,
-                                    // availability_rule_ids: ["weekly_work_hours"]
-                                }
-                            ]
-                        }
-                    ],
-                    required_duration: { minutes: 60 },
-                    query_periods: [
-                        { start: slotTimes(1,"07:00"), end: slotTimes(1,"12:00") },
-                        { start: slotTimes(2,"09:00"), end: slotTimes(2,"13:00") },
-                        { start: slotTimes(2,"14:00"), end: slotTimes(2,"17:00") },
-                        { start: slotTimes(3,"09:00"), end: slotTimes(3,"13:00") },
-                        { start: slotTimes(3,"14:00"), end: slotTimes(3,"17:00") },
-                        { start: slotTimes(4,"09:00"), end: slotTimes(5,"17:00") }
-                    ]
-                },
-                // tzid: "America/Mexico_City",
-                // tzid: "Asia/Katmandu",
-                styles: {
-                    prefix: "SP1"
-                },
-                config: {
-                    logs: 'info'
-                },
-                // locale: 'keys',
-                // translations: {
-                //     en: {
-                //         slot_picker: {
-                //             select_day: 'Override select_day'
-                //         }
-                //     }
-                // },
-                callback: slot => console.log('callback',slot),
-                locale: locale
-                // demo: true
-            });
-        }
-        
-        if (display.two) {
-            const slotTimes = function(days, time) {
-                const timeString = `${moment().utc().format("YYYY-MM-DD")}T${time}:00Z`;
-                const output = moment(timeString)
-                    .add(days, "days");
-                return output.utc().format();
-            };
-
-            CronofyElements.SlotPicker({
-                element_token: "<%= slot_picker_token %>",
-                target_id: 'cronofy-slot-picker-two',
-                api_domain:"<%= api_domain %>",
-                availability_query: {
-                    participants: [
-                        {
-                            required: "all",
-                            members: [
-                                { sub: "<%= sub %>" }
-                            ]
-                        }
-                    ],
-                    required_duration: { minutes: 30 },
-                    query_periods: [
-                        { start: slotTimes(1,"23:00"), end: slotTimes(2,"01:00") },
-                        { start: slotTimes(2,"23:00"), end: slotTimes(3,"01:00") }
-                    ]
-                },
-                config: {
-                    mode: 'no_confirm'
-                },
-                styles: {
-                    prefix: "SP2",
-                    padding: "20px"
-                },
-                callback: slot => console.log('callback',slot),
-                locale: locale,
-                locale_modifiers: {
-                  "ja": {"dates": "western"},
-                }
-            });
-        }
-        
-        if (display.three) {
-
-            const events = <%- JSON.stringify(bookable_event_ids) %>.map(event => ({
-                bookable_event_id: event
-            }));
-
-            CronofyElements.SlotPicker({
-                element_token: "<%= bookable_events_token %>",
-                target_id: 'cronofy-slot-picker-bookable-events',
-                api_domain:"<%= api_domain %>",
-                availability_query: {
-                    "bookable_events": events
-                    // "bookable_events": [
-                    //     {
-                    //         "bookable_event_id": "UNKNOWN_ID"
-                    //     }
-                    // ]
-                    // "bookable_events": []
-                },
-                config: {
-                    mode: 'no_confirm'
-                },
-                styles: {
-                    prefix: "SP3",
-                },
-                callback: slot => console.log('callback',slot),
-                locale: locale,
-            });
-        }
-
-        console.log('done.');
-    </script>
-
-</body>
-</html>

package/git.README.md

@@ -1,71 +0,0 @@
-# Cronofy UI Elements
-
-A suite of embeddable components that access the Cronofy API.
-
-Full documentation can be found here: [docs.cronofy.com/developers/ui-elements](https://docs.cronofy.com/developers/ui-elements/)
-
-Information about installing via npm can be found here: [npm.README.md](./npm.README.md)
-
-## Developer documentation
-
-To setup the development environment, run:
-
-    make init
-
-
-You will need to ensure `/src/js/env.js` is updated with your local development settings. See `/src/js/env.example.js` for an example of this.
-
-To start development, run:
-
-    make dev
-
-If using powprox for local API hosting (our default) you can set an environment variable to tell Node about a custom root CA in your `.bash_profile` or equivalent:
-
-    export NODE_EXTRA_CA_CERTS="$HOME/.powprox/ssl/ca/pow-root-ca.crt"
-
-Alternatively, though not recommended, you can disable all TLS verification:
-
-    NODE_TLS_REJECT_UNAUTHORIZED=0 make dev
-
-This will watch the source files and rebuild whenever you save changes. It will also host the demo app (`demo/index.ejs`) on port `8080`
-
-You can make a one-off development build (without watching the files or serving the demo) using:
-
-    make build_dev
-
-You can make a production build with:
-
-    make build
-
-
-To bump a patch version (e.g. from `0.0.1` to `0.0.2`) and make a production build, run:
-
-    bump_patch
-
-To bump a minor version (e.g. from `0.1.0` to `0.2.0`) and make a production build, run:
-
-    bump_minor
-
-To bump a major version (e.g. from `1.0.0` to `2.0.0`) and make a production build, run:
-
-    bump_major
-
-
-### Releasing
-
-> Since moving UI Elements into the monorepo, the npm update flow has been, shall we say, janky. This is because the npm tooling assumes it's always going to be in the root of whatever repo it lives in. These are the new steps needed to account for this jankiness:
-
-You find yourself in the UI Elements root folder (`cronofy/js/elements`) inside the monorepo. You have made changes, and your PR has been approved. You want to cut a new version before releasing changes...
-
-- Run `make bump_patch` (or `bump_minor` or `bump_major` depending on the type of change you've made)
-- That task no longer commits its changes automatically - it will have changed the version number in `package-lock.json` and `package.json` and the changes will be unstaged. Commit these changes ("version bump" or similar is fine for a commit-message).
-- You then need to run `git tag -a vTHE_NEW_VERSION -m "overview of changes"` (so if you've gone from v1.12.0 to v1.12.1, the tag version should look like `tag -a v1.12.1`) *For consistency, run the tag on the branch that contains the changes.*
-- Then `git push` and `git push --tags` (if you haven't pushed the tag, the deployment will fail)
-- Now you can merge your PR and ask someone to deploy the changes for you (make sure you tell them the number of the version you want to be released, e.g. `v1.12.1` - they'll need this to run the deployment). *Note: a UI Elements deployment is not the same thing as a normal app deployment - they are different steps, and need to be initiated independently.*
-
-### Things that need to be published in order to call a UI Element change "done"
-
-- new build file added to S3 bucket (so that it shows up at this URL: `https://elements.cronofy.com/js/CronofyElements.vNEW_VERSION_NUMBER.js`)
-- publish changes to NPM (checkable here: [https://www.npmjs.com/package/cronofy-elements](https://www.npmjs.com/package/cronofy-elements))
-- Add changes to docs if user-facing API has changed
-- Update v# and changelog in the docs (only do this *after* the S3 URL is available)