ctct-helpers 0.0.1-security → 1.23.75

package/dist/ctct-helpers.js

@@ -0,0 +1,933 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("ctct-helpers", [], factory);
+	else if(typeof exports === 'object')
+		exports["ctct-helpers"] = factory();
+	else
+		root["CtctHelpers"] = factory();
+})(window, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "https://static.ctctcdn.com/h/ctct-helpers/1.1.11/";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 2);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+module.exports = require("jquery");
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+
+module.exports = require("deepmerge");
+
+/***/ }),
+/* 2 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./src/js/env.js
+/**
+ * @module ctct-helpers/env
+ */
+var getHostName = function getHostName() {
+  return window.location.hostname;
+};
+/**
+ * Get the current CTCT environment by parsing a URL
+ * @param {String} [hostname] An optional hostname to parse
+ * @returns Current env (e.g. ".l1"), "." for prod, "local" for localhost
+ *
+ * @example
+ * const env = getEnv();
+ * if (env === 'local') {
+ *   return 'https://localhost:9000/mock/contacts/lists';
+ * }
+ * return `https://app${env}constantcontact.com/v1/contacts/lists`;
+ */
+
+
+var getEnv = function getEnv() {
+  var hostname = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getHostName();
+  return hostname.includes('constantcontact') ? (hostname.match(/\.[dls]1\./) || '.')[0] : 'local';
+};
+
+
+// CONCATENATED MODULE: ./src/js/csrf-token.js
+/**
+ * @module ctct-helpers/csrf-token
+ */
+
+/**
+ * Get the crsfToken from the page
+ * @returns {String} The users' csrfToken, or 'local' if not found
+ *
+ * @example
+ * const options = { headers: {} };
+ * const token = getCsrfToken();
+ * if (env !== 'local') {
+ *   options.headers['X-CSRF-Token'] = token;
+ * }
+ * const restHandler = new RestHandler('https://example.com', options);
+ */
+var getCsrfToken = function getCsrfToken() {
+  var tokenEl = document.querySelector('meta[name="csrf-token"]');
+
+  if (tokenEl) {
+    return tokenEl.content;
+  }
+
+  return 'local';
+};
+
+
+// EXTERNAL MODULE: external "deepmerge"
+var external_deepmerge_ = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./src/js/rest-handler.js
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+/**
+ * @module ctct-helpers/rest-handler
+ */
+
+
+var rest_handler_merge = function merge() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return external_deepmerge_["all"](args);
+};
+
+var PARSERS = {
+  json: function () {
+    var _json = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee(response) {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", response.json());
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function json(_x) {
+      return _json.apply(this, arguments);
+    }
+
+    return json;
+  }(),
+  string: function () {
+    var _string = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee2(response) {
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", response.text());
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    function string(_x2) {
+      return _string.apply(this, arguments);
+    }
+
+    return string;
+  }(),
+  arrayBuffer: function () {
+    var _arrayBuffer = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee3(response) {
+      return regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", response.arrayBuffer());
+
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    function arrayBuffer(_x3) {
+      return _arrayBuffer.apply(this, arguments);
+    }
+
+    return arrayBuffer;
+  }(),
+  form: function () {
+    var _form = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee4(response) {
+      return regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", response.formData());
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    function form(_x4) {
+      return _form.apply(this, arguments);
+    }
+
+    return form;
+  }(),
+  blob: function () {
+    var _blob = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee5(response) {
+      return regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return", response.blob());
+
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
+
+    function blob(_x5) {
+      return _blob.apply(this, arguments);
+    }
+
+    return blob;
+  }()
+};
+
+var parsePayload = function parsePayload(payload) {
+  switch (_typeof(payload)) {
+    case 'string':
+      return payload;
+
+    case 'object':
+      return JSON.stringify(payload);
+
+    default:
+      throw new Error('Request body must be either a String or an Object');
+  }
+};
+
+var parseResponse =
+/*#__PURE__*/
+function () {
+  var _ref = _asyncToGenerator(
+  /*#__PURE__*/
+  regeneratorRuntime.mark(function _callee6(response, parser) {
+    var body;
+    return regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return parser(response);
+
+          case 2:
+            body = _context6.sent;
+
+            if (!response.ok) {
+              _context6.next = 5;
+              break;
+            }
+
+            return _context6.abrupt("return", body);
+
+          case 5:
+            return _context6.abrupt("return", Promise.reject({
+              status: response.status,
+              statusText: response.statusText,
+              body: body
+            }));
+
+          case 6:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+
+  return function parseResponse(_x6, _x7) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var DEFAULTS = {
+  // Custom options
+  timeout: 60 * 1000 * 2,
+  // 2 minutes
+  includeResponseHeaders: false,
+  // Fetch options
+  // https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters
+  mode: 'cors',
+  credentials: 'same-origin',
+  cache: 'no-store',
+  redirect: 'follow',
+  headers: {
+    'X-Requested-With': 'XMLHttpRequest'
+  }
+};
+/**
+ * A simple REST handler for making AJAX requests to a single back-end service with CORS enabled.
+ * Built around Fetch and Promises. {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API}
+ *
+ * By default, it is assumed that data is sent and received as JSON.
+ * Unlike straight fetch(), each method will reject if the status is not 200-299 ("ok").
+ *
+ * @example
+ * // with Promises
+ * const restHandler = new RestHandler('example.com/api');
+ * restHandler.get('/some/endpoint')
+ *   .then((body) => {
+ *     console.log(body); // => { ... }
+ *   }).catch((error) => {
+ *     console.log(error); // => { status: 404, statusText: "", body: {...} }
+ *   });
+ *
+ * @example
+ * // with async/await
+ * const restHandler = new RestHandler('example.com/api');
+ * const example = async () => {
+ *   try {
+ *    const body = await restHandler.get('/some/endpoint');
+ *    console.log(body); // => { ... }
+ *   } catch (error) {
+ *    console.log(error); // => { status: 404, statusText: "", body: {...} }
+ *   }
+ * };
+ *
+ * @example
+ * // with non-JSON parser
+ * const restHandler = new RestHandler('example.com/api');
+ * restHandler.get('/some/endpoint', { parser: RestHandler.PARSERS.string })
+ *   .then((body) => console.log(typeof body)); // => "string"
+ *
+ * @example
+ * // get response body and headers
+ * const restHandler = new RestHandler('example.com/api');
+ * // To get headers, see https://developer.mozilla.org/en-US/docs/Web/API/Headers
+ * restHandler.get('/some/endpoint', { includeResponseHeaders: true })
+ *   .then(({body, headers}) => console.log(body, headers));
+ */
+
+var RestHandler =
+/*#__PURE__*/
+function () {
+  /**
+   * Constructor
+   * @param {String} baseUrl - the base URL of the service without 'https://' (e.g. 'example.com/api')
+   * @param opts
+   */
+  function RestHandler(baseUrl) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    _classCallCheck(this, RestHandler);
+
+    this.baseUrl = baseUrl.indexOf('https://') > -1 ? baseUrl : "https://".concat(baseUrl);
+    this.defaults = rest_handler_merge({}, DEFAULTS, opts);
+  } // Because Jasmine is dumb and you can't directly mock out window.fetch
+
+
+  _createClass(RestHandler, [{
+    key: "_fetch",
+    value: function () {
+      var _fetch2 = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee7(url, options) {
+        var timeout;
+        return regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                timeout = options.timeout; // https://gist.github.com/davej/728b20518632d97eef1e5a13bf0d05c7
+
+                return _context7.abrupt("return", Promise.race([window.fetch(url, options), new Promise(function (resolve, reject) {
+                  return setTimeout(function () {
+                    return reject(new Error("Request timeout after ".concat(timeout, "ms")));
+                  }, timeout);
+                }) // eslint-disable-line no-unused-vars
+                ]));
+
+              case 2:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7);
+      }));
+
+      function _fetch(_x8, _x9) {
+        return _fetch2.apply(this, arguments);
+      }
+
+      return _fetch;
+    }()
+    /**
+     * Make an AJAX request. User must specify the method type in the options.
+     * Not intended to be called directly - use one of the REST methods (i.e. .get(), .post()).
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults ('method' is required)
+     * @throws {Error} if the response has an unsupported content-type header
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "send",
+    value: function () {
+      var _send = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee8(url) {
+        var opts,
+            result,
+            options,
+            response,
+            contentType,
+            _args8 = arguments;
+        return regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                opts = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {};
+                options = rest_handler_merge({}, this.defaults, opts);
+                _context8.next = 4;
+                return this._fetch("".concat(this.baseUrl).concat(url), options);
+
+              case 4:
+                response = _context8.sent;
+                // Make smart inferences: https://css-tricks.com/using-fetch/
+                contentType = response.headers.get('content-type');
+
+                if (contentType) {
+                  _context8.next = 10;
+                  break;
+                }
+
+                // Some responses (e.g. PUT) might not return content at all!
+                result = true;
+                _context8.next = 29;
+                break;
+
+              case 10:
+                if (!options.parser) {
+                  _context8.next = 16;
+                  break;
+                }
+
+                _context8.next = 13;
+                return parseResponse(response, options.parser);
+
+              case 13:
+                result = _context8.sent;
+                _context8.next = 29;
+                break;
+
+              case 16:
+                if (!contentType.includes('application/json')) {
+                  _context8.next = 22;
+                  break;
+                }
+
+                _context8.next = 19;
+                return parseResponse(response, PARSERS.json);
+
+              case 19:
+                result = _context8.sent;
+                _context8.next = 29;
+                break;
+
+              case 22:
+                if (!contentType.includes('text/html')) {
+                  _context8.next = 28;
+                  break;
+                }
+
+                _context8.next = 25;
+                return parseResponse(response, PARSERS.string);
+
+              case 25:
+                result = _context8.sent;
+                _context8.next = 29;
+                break;
+
+              case 28:
+                throw new Error("content-type ".concat(contentType, " is not supported. Try providing a custom options.parser!"));
+
+              case 29:
+                // Optionally include response headers
+                if (options.includeResponseHeaders) {
+                  result = {
+                    body: result,
+                    headers: response.headers
+                  };
+                }
+
+                return _context8.abrupt("return", result);
+
+              case 31:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function send(_x10) {
+        return _send.apply(this, arguments);
+      }
+
+      return send;
+    }()
+    /**
+     * Perform a GET request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "get",
+    value: function get(url) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = rest_handler_merge({}, {
+        method: 'GET'
+      }, opts);
+      return this.send(url, options);
+    }
+    /**
+     * Perform a POST request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object|String} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @throws {Error} if data is not a string or an object
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "post",
+    value: function post(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = parsePayload(data);
+      var options = rest_handler_merge({}, {
+        method: 'POST',
+        body: payload
+      }, opts);
+      return this.send(url, options);
+    }
+    /**
+     * Perform a PATCH request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object|String} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @throws {Error} if data is not a string or an object
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "patch",
+    value: function patch(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = parsePayload(data);
+      var options = rest_handler_merge({}, {
+        method: 'PATCH',
+        body: payload
+      }, opts);
+      return this.send(url, options);
+    }
+    /**
+     * Perform a PUT request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object|String} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @throws {Error} if data is not a string or an object
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "put",
+    value: function put(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = parsePayload(data);
+      var options = rest_handler_merge({}, {
+        method: 'PUT',
+        body: payload
+      }, opts);
+      return this.send(url, options);
+    }
+    /**
+     * Perform a DELETE request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} resolves to the parsed response body, rejects if not "ok"
+     */
+
+  }, {
+    key: "delete",
+    value: function _delete(url) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var options = rest_handler_merge({}, {
+        method: 'DELETE'
+      }, opts);
+      return this.send(url, options);
+    }
+  }]);
+
+  return RestHandler;
+}();
+/**
+ * Convenience methods for parsing the response of a fetch() call.
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Body#Methods}
+ * @static
+ */
+
+
+RestHandler.PARSERS = PARSERS; // Export the class below instead of same line as class declaration.
+
+/* harmony default export */ var rest_handler = (RestHandler);
+// EXTERNAL MODULE: external "jquery"
+var external_jquery_ = __webpack_require__(0);
+var external_jquery_default = /*#__PURE__*/__webpack_require__.n(external_jquery_);
+
+// CONCATENATED MODULE: ./src/js/rest-handler-legacy.js
+function rest_handler_legacy_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function rest_handler_legacy_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function rest_handler_legacy_createClass(Constructor, protoProps, staticProps) { if (protoProps) rest_handler_legacy_defineProperties(Constructor.prototype, protoProps); if (staticProps) rest_handler_legacy_defineProperties(Constructor, staticProps); return Constructor; }
+
+/**
+ * @module ctct-helpers/rest-handler-legacy
+ */
+
+/**
+ * DO NOT USE THIS MODULE unless you absolutely need to use $.ajax() over fetch()!
+ * A simple REST handler for making AJAX requests to a single back-end service
+ * with CORS enabled. It is assumed that data is sent and received as JSON.
+ * Built around jQuery.ajax(), promisified for compatibility
+ *
+ * @example
+ * const restHandler = new RestHandler('https://example.com/api');
+ * restHandler.get('/some/endpoint').then((data) => {
+ *   console.log(data);
+ * }).catch((error) => {
+ *   console.error(error);
+ * });
+ */
+
+var rest_handler_legacy_RestHandlerLegacy =
+/*#__PURE__*/
+function () {
+  /**
+   * Constructor
+   * @param {String} baseUrl - the base URL of the service (e.g. 'https://example.com/api')
+   * @param opts
+   */
+  function RestHandlerLegacy(baseUrl) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    rest_handler_legacy_classCallCheck(this, RestHandlerLegacy);
+
+    this.baseUrl = "https://".concat(baseUrl); // http://api.jquery.com/jquery.ajax/#jQuery-ajax-settings
+
+    this.defaults = {
+      timeout: 60 * 1000 * 2,
+      // 2 minutes
+      contentType: 'application/json',
+      dataType: 'json',
+      global: true,
+      // Set to false to avoid bubbling errors
+      crossDomain: true,
+      headers: {
+        'X-Requested-With': 'XMLHttpRequest'
+      },
+      xhrFields: {
+        withCredentials: true
+      }
+    };
+    this.defaults = this._extend({}, this.defaults, opts);
+  }
+  /**
+   * Extend (NOT deep copy) multiple objects
+   * @param {...*} args objects to extend
+   * @return {Object} the new object
+   */
+
+
+  rest_handler_legacy_createClass(RestHandlerLegacy, [{
+    key: "_extend",
+    value: function _extend() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return external_jquery_default.a.extend.apply(null, args);
+    }
+    /**
+     * Make an AJAX request. User must specify the method type in the options.
+     * Not intended to be called directly - use one of the REST methods below.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults ('method' is required)
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "send",
+    value: function send(url) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var options = this._extend({}, this.defaults, opts);
+
+      var jqXHR = external_jquery_default.a.ajax("".concat(this.baseUrl).concat(url), options);
+      return Promise.resolve(jqXHR);
+    }
+    /**
+     * Perform a GET request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "get",
+    value: function get(url) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var options = this._extend({}, {
+        method: 'GET'
+      }, opts);
+
+      return this.send(url, options);
+    }
+    /**
+     * Perform a POST request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "post",
+    value: function post(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = JSON.stringify(data);
+
+      var options = this._extend({}, {
+        method: 'POST',
+        data: payload
+      }, opts);
+
+      return this.send(url, options);
+    }
+    /**
+     * Perform a PATCH request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "patch",
+    value: function patch(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = JSON.stringify(data);
+
+      var options = this._extend({}, {
+        method: 'PATCH',
+        data: payload
+      }, opts);
+
+      return this.send(url, options);
+    }
+    /**
+     * Perform a PUT request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} data - the request body as a JS object
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "put",
+    value: function put(url, data) {
+      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var payload = JSON.stringify(data);
+
+      var options = this._extend({}, {
+        method: 'PUT',
+        data: payload
+      }, opts);
+
+      return this.send(url, options);
+    }
+    /**
+     * Perform a DELETE request on the requested resource.
+     * @param {String} url - the URL to the resource (e.g. '/some/endpoint')
+     * @param {Object} opts - options to override the defaults
+     * @return {Promise} a promisified jqXHR object
+     */
+
+  }, {
+    key: "delete",
+    value: function _delete(url) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var options = this._extend({}, {
+        method: 'DELETE'
+      }, opts);
+
+      return this.send(url, options);
+    }
+  }]);
+
+  return RestHandlerLegacy;
+}(); // Export the class below instead of same line as class declaration.
+
+
+/* harmony default export */ var rest_handler_legacy = (rest_handler_legacy_RestHandlerLegacy);
+// CONCATENATED MODULE: ./src/js/index.js
+/* concated harmony reexport getEnv */__webpack_require__.d(__webpack_exports__, "getEnv", function() { return getEnv; });
+/* concated harmony reexport getCsrfToken */__webpack_require__.d(__webpack_exports__, "getCsrfToken", function() { return getCsrfToken; });
+/* concated harmony reexport RestHandler */__webpack_require__.d(__webpack_exports__, "RestHandler", function() { return rest_handler; });
+/* concated harmony reexport RestHandlerLegacy */__webpack_require__.d(__webpack_exports__, "RestHandlerLegacy", function() { return rest_handler_legacy; });
+
+
+
+
+/* harmony default export */ var js = __webpack_exports__["default"] = ({
+  getEnv: getEnv,
+  getCsrfToken: getCsrfToken,
+  RestHandler: rest_handler,
+  RestHandlerLegacy: rest_handler_legacy
+});
+
+
+/***/ })
+/******/ ]);
+});
+//# sourceMappingURL=ctct-helpers.js.map