@hellotext/hellotext 1.4.1 → 1.5.1

package/docs/tracking.md

@@ -0,0 +1,155 @@
+## Tracking Events
+
+Track subscriber events as they happen on your website and let Hellotext report them back to your business.
+
+Tracking events is straightforward and perhaps the simplest example is tracking a page view:
+
+```javascript
+Hellotext.track('page.viewed')
+```
+
+In the example above only the name of the action is required.
+
+### Handling Responses
+
+The `track` method returns a Promise that can be `await`ed using the async/await syntax. Or using `.then` on the returned Promise.
+
+```javascript
+const response = await Hellotext.track('page.viewed')
+```
+
+The return of the `Hellotext.track` method is an instance of a `Response` object that ships with the package. You can check the status of the response via methods, like:
+
+```javascript
+if (response.failed) {
+  console.log('failed because', response.data)
+}
+
+if (response.succeeded) {
+  console.log('success')
+  console.log(response.data) // { status: "received" }
+}
+```
+
+### Parameters
+
+The parameters passed to the action must be a valid set of parameters as described in
+[Tracking Actions](https://www.hellotext.com/api#tracking).
+
+#### URL Parameter
+
+The library takes care of handling the `url` parameter with the current URL automatically and is not required to specify it explicitly.
+If you want to provide another url, you can pass a `url` key in the params object when tracking an event.
+
+```javascript
+Hellotext.track('page.viewed', {
+  url: 'www.example.org',
+})
+```
+
+### Errors
+
+Failing to provide valid set of parameters will result in an error object being returned, describing the parameters that did not satisfy the rules.
+
+```javascript
+const response = await Hellotext.track('app.installed', { app_parameters: { name: 'My App' } })
+
+console.log(response.data)
+```
+
+yields
+
+```javascript
+{
+  errors: [
+    {
+      type: 'parameter_not_unique',
+      parameter: 'name',
+      description:
+        'The value must be unique and it is already present in another object of the same type.',
+    },
+  ]
+}
+```
+
+For a complete list of errors types. See [Error Types](https://www.hellotext.com/api#errors)
+
+### Associated objects
+
+Generally, most actions also require an associated object. These can be of type [`app`](https://www.hellotext.com/api#apps), [`coupon`](https://www.hellotext.com/api#coupons), [`form`](https://www.hellotext.com/api#forms), [`order`](https://www.hellotext.com/api#orders), [`product`](https://www.hellotext.com/api#products) and [`refund`](https://www.hellotext.com/api#refunds).
+Aside from [Custom Actions](https://www.hellotext.com/api#create_an_action), which don't require the trackable to be present.
+
+You can create the associated object directly by defining its parameters in a hash:
+
+```javascript
+Hellotext.track('order.placed', {
+  amount: 395.0,
+  currency: 'USD',
+  order_parameters: {
+    amount: '395.00',
+    reference: '654321',
+  },
+})
+```
+
+If you want to reuse existing objects, you must pass the identifier of an existing associated object. For example, to track a product purchase the identifier of a previously created product object as the `product`.
+For more information about identifiers, view the [Tracking API](https://www.hellotext.com/api#tracking)
+
+```javascript
+Hellotext.track('product.purchased', {
+  amount: 395.0,
+  currency: 'USD',
+  product: 'erA2RAXE',
+})
+```
+
+## List of actions
+
+The following is a complete list of built-in actions and their required associated objects.
+
+| Action                | Description                                              | Required Parameter                                                        |
+| --------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------- |
+| **app.installed**     | An app was installed.                                    | `app` or [app_parameters](https://www.hellotext.com/api#app)              |
+| **app.removed**       | An app was removed.                                      | `app` or [app_parameters](https://www.hellotext.com/api#app)              |
+| **app.spent**         | A customer spent on an app.                              | `app` or [app_parameters](https://www.hellotext.com/api#app)              |
+| **cart.abandoned**    | A cart was abandoned.                                    | `product` or [product_parameters](https://www.hellotext.com/api#products) |
+| **cart.added**        | Added an item to the cart.                               | `product` or [product_parameters](https://www.hellotext.com/api#products) |
+| **cart.removed**      | Removed an item from the cart.                           | `product` or [product_parameters](https://www.hellotext.com/api#products) |
+| **coupon.redeemed**   | A coupon was redeem by a customer.                       | `coupon` or [coupon_parameters](https://www.hellotext.com/api#coupons)    |
+| **form.completed**    | A form was completed by the customer.                    | `form` or [form_parameters](https://www.hellotext.com/api#forms)          |
+| **order.placed**      | Order has been placed.                                   | `order` or [order_parameters](https://www.hellotext.com/api#orders)       |
+| **order.confirmed**   | Order has been confirmed by you.                         | `order` or [order_parameters](https://www.hellotext.com/api#orders)       |
+| **order.cancelled**   | Order has been cancelled either by you or your customer. | `order` or [order_parameters](https://www.hellotext.com/api#orders)       |
+| **order.shipped**     | Order has been shipped to your customer.                 | `order` or [order_parameters](https://www.hellotext.com/api#orders)       |
+| **order.delivered**   | Order has been delivered to your customer.               | `order` or [order_parameters](https://www.hellotext.com/api#orders)       |
+| **page.viewed**       | A page was viewed by a customer.                         | `url`                                                                     |
+| **product.purchased** | A product has been purchased.                            | `product` or [product_parameters](https://www.hellotext.com/api#products) |
+| **product.viewed**    | A product page has been viewed.                          | `product` or [product_parameters](https://www.hellotext.com/api#products) |
+| **refund.requested**  | A customer requested a refund.                           | `refund` or [refund_parameters](https://www.hellotext.com/api#refunds)    |
+| **refund.received**   | A refund was issued by you to your customer.             | `refund` or [refund_parameters](https://www.hellotext.com/api#refunds)    |
+
+You can also create your **[own defined actions](https://www.hellotext.com/api#actions)**.
+
+## Additional Properties
+
+You can include additional attributes to the tracked event, additional properties must be included inside the `metadata` object:
+
+```javascript
+Hellotext.track('product.purchased', {
+  amount: 0.2,
+  currency: 'USD',
+  metadata: {
+    myProperty: 'custom',
+  },
+  tracked_at: 1665684173,
+})
+```
+
+### List of additional attributes
+
+| Property       | Description                                                                                                                                                                           | Type     | Default |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------- |
+| **amount**     | Monetary amount that represents the revenue associated to this tracked event.                                                                                                         | float    | `0`     |
+| **currency**   | Currency for the `amount` given in ISO 4217 format.                                                                                                                                   | currency | `USD`   |
+| **metadata**   | Set of key-value pairs that you can attach to an event. This can be useful for storing additional information about the object in a structured format.                                | hash     | `{}`    |
+| **tracked_at** | Original date when the event happened. This is useful if you want to record an event that happened in the past. If no value is provided its value will be the same from `created_at`. | epoch    | `null`  |

package/lib/api/businesses.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("../core");
+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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var _default = /*#__PURE__*/function () {
+  function _default() {
+    _classCallCheck(this, _default);
+  }
+  _createClass(_default, null, [{
+    key: "endpoint",
+    get: function get() {
+      return _core.Configuration.endpoint('public/businesses');
+    }
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator(function* (id) {
+        return fetch("".concat(this.endpoint, "/").concat(id), {
+          method: 'GET',
+          headers: {
+            Authorization: "Bearer ".concat(id),
+            Accept: 'application.json',
+            'Content-Type': 'application/json'
+          }
+        });
+      });
+      function get(_x) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+  }]);
+  return _default;
+}();
+exports.default = _default;

package/lib/api/events.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("../core");
+var _models = require("../models");
+var _response = require("./response");
+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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var EventsAPI = /*#__PURE__*/function () {
+  function EventsAPI() {
+    _classCallCheck(this, EventsAPI);
+  }
+  _createClass(EventsAPI, null, [{
+    key: "endpoint",
+    get: function get() {
+      return _core.Configuration.endpoint('track/events');
+    }
+  }, {
+    key: "create",
+    value: function () {
+      var _create = _asyncToGenerator(function* (_ref) {
+        var {
+          headers,
+          body
+        } = _ref;
+        if (_models.Query.inPreviewMode) {
+          return new _response.Response(true, {
+            received: true
+          });
+        }
+        var response = yield fetch(this.endpoint, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(body)
+        });
+        return new _response.Response(response.status === 200, yield response.json());
+      });
+      function create(_x) {
+        return _create.apply(this, arguments);
+      }
+      return create;
+    }()
+  }]);
+  return EventsAPI;
+}();
+exports.default = EventsAPI;

package/lib/api/forms.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _hellotext = _interopRequireDefault(require("../hellotext"));
+var _core = require("../core");
+var _response = require("./response");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return 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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var FormsAPI = /*#__PURE__*/function () {
+  function FormsAPI() {
+    _classCallCheck(this, FormsAPI);
+  }
+  _createClass(FormsAPI, null, [{
+    key: "endpoint",
+    get: function get() {
+      return _core.Configuration.endpoint('public/forms');
+    }
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator(function* (id) {
+        return fetch("".concat(this.endpoint, "/").concat(id), {
+          method: 'GET',
+          headers: _hellotext.default.headers
+        });
+      });
+      function get(_x) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+  }, {
+    key: "submit",
+    value: function () {
+      var _submit = _asyncToGenerator(function* (id, data) {
+        var response = yield fetch("".concat(this.endpoint, "/").concat(id, "/submissions"), {
+          method: 'POST',
+          headers: _hellotext.default.headers,
+          body: JSON.stringify(_objectSpread({
+            session: _hellotext.default.session
+          }, data))
+        });
+        return new _response.Response(response.ok, response);
+      });
+      function submit(_x2, _x3) {
+        return _submit.apply(this, arguments);
+      }
+      return submit;
+    }()
+  }]);
+  return FormsAPI;
+}();
+exports.default = FormsAPI;

package/lib/api/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Response", {
+  enumerable: true,
+  get: function get() {
+    return _response.Response;
+  }
+});
+exports.default = void 0;
+var _sessions = _interopRequireDefault(require("./sessions"));
+var _businesses = _interopRequireDefault(require("./businesses"));
+var _events = _interopRequireDefault(require("./events"));
+var _forms = _interopRequireDefault(require("./forms"));
+var _response = require("./response");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var API = /*#__PURE__*/function () {
+  function API() {
+    _classCallCheck(this, API);
+  }
+  _createClass(API, null, [{
+    key: "sessions",
+    value: function sessions(businessId) {
+      return new _sessions.default(businessId);
+    }
+  }, {
+    key: "businesses",
+    get: function get() {
+      return _businesses.default;
+    }
+  }, {
+    key: "events",
+    get: function get() {
+      return _events.default;
+    }
+  }, {
+    key: "forms",
+    get: function get() {
+      return _forms.default;
+    }
+  }]);
+  return API;
+}();
+exports.default = API;

package/lib/api/response.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Response = void 0;
+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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
+var id = 0;
+function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
+var _success = /*#__PURE__*/_classPrivateFieldLooseKey("success");
+var Response = /*#__PURE__*/function () {
+  function Response(success, response) {
+    _classCallCheck(this, Response);
+    Object.defineProperty(this, _success, {
+      writable: true,
+      value: void 0
+    });
+    this.response = response;
+    _classPrivateFieldLooseBase(this, _success)[_success] = success;
+  }
+  _createClass(Response, [{
+    key: "data",
+    get: function get() {
+      return this.response;
+    }
+  }, {
+    key: "json",
+    value: function () {
+      var _json = _asyncToGenerator(function* () {
+        return yield this.response.json();
+      });
+      function json() {
+        return _json.apply(this, arguments);
+      }
+      return json;
+    }()
+  }, {
+    key: "failed",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _success)[_success] === false;
+    }
+  }, {
+    key: "succeeded",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _success)[_success] === true;
+    }
+  }]);
+  return Response;
+}();
+exports.Response = Response;

package/lib/api/sessions.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("../core");
+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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var SessionsAPI = /*#__PURE__*/function () {
+  function SessionsAPI(businessId) {
+    _classCallCheck(this, SessionsAPI);
+    this.businessId = businessId;
+  }
+  _createClass(SessionsAPI, [{
+    key: "create",
+    value: function () {
+      var _create = _asyncToGenerator(function* () {
+        var response = yield fetch(SessionsAPI.endpoint, {
+          method: 'POST',
+          headers: {
+            Authorization: "Bearer ".concat(this.businessId),
+            Accept: 'application/json'
+          }
+        });
+        return response.json();
+      });
+      function create() {
+        return _create.apply(this, arguments);
+      }
+      return create;
+    }()
+  }], [{
+    key: "endpoint",
+    get: function get() {
+      return _core.Configuration.endpoint('track/sessions');
+    }
+  }]);
+  return SessionsAPI;
+}();
+exports.default = SessionsAPI;

package/lib/api/submissions.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _hellotext = _interopRequireDefault(require("../hellotext"));
+var _core = require("../core");
+var _response = require("./response");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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); }); }; }
+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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var SubmissionsAPI = /*#__PURE__*/function () {
+  function SubmissionsAPI() {
+    _classCallCheck(this, SubmissionsAPI);
+  }
+  _createClass(SubmissionsAPI, null, [{
+    key: "endpoint",
+    get: function get() {
+      return _core.Configuration.endpoint('public/submissions');
+    }
+  }, {
+    key: "resendOTP",
+    value: function () {
+      var _resendOTP = _asyncToGenerator(function* (id) {
+        var response = yield fetch("".concat(this.endpoint, "/").concat(id, "/otps"), {
+          method: 'POST',
+          headers: _hellotext.default.headers
+        });
+        return new _response.Response(response.ok, response);
+      });
+      function resendOTP(_x) {
+        return _resendOTP.apply(this, arguments);
+      }
+      return resendOTP;
+    }()
+  }, {
+    key: "verifyOTP",
+    value: function () {
+      var _verifyOTP = _asyncToGenerator(function* (id, otp) {
+        var response = yield fetch("".concat(this.endpoint, "/").concat(id, "/otps/").concat(otp, "/verify"), {
+          method: 'POST',
+          headers: _hellotext.default.headers
+        });
+        return new _response.Response(response.ok, response);
+      });
+      function verifyOTP(_x2, _x3) {
+        return _verifyOTP.apply(this, arguments);
+      }
+      return verifyOTP;
+    }()
+  }]);
+  return SubmissionsAPI;
+}();
+var _default = SubmissionsAPI;
+exports.default = _default;

package/lib/api.js

@@ -0,0 +1,73 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.default = void 0
+var _sessions = _interopRequireDefault(require('./api/sessions'))
+var _businesses = _interopRequireDefault(require('./api/businesses'))
+var _events = _interopRequireDefault(require('./api/events'))
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj }
+}
+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, _toPropertyKey(descriptor.key), descriptor)
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps)
+  if (staticProps) _defineProperties(Constructor, staticProps)
+  Object.defineProperty(Constructor, 'prototype', { writable: false })
+  return Constructor
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, 'string')
+  return typeof key === 'symbol' ? key : String(key)
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== 'object' || input === null) return input
+  var prim = input[Symbol.toPrimitive]
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || 'default')
+    if (typeof res !== 'object') return res
+    throw new TypeError('@@toPrimitive must return a primitive value.')
+  }
+  return (hint === 'string' ? String : Number)(input)
+}
+var API = /*#__PURE__*/ (function () {
+  function API() {
+    _classCallCheck(this, API)
+  }
+  _createClass(API, null, [
+    {
+      key: 'sessions',
+      value: function sessions(businessId) {
+        return new _sessions.default(businessId)
+      },
+    },
+    {
+      key: 'businesses',
+      get: function get() {
+        return _businesses.default
+      },
+    },
+    {
+      key: 'events',
+      get: function get() {
+        return _events.default
+      },
+    },
+  ])
+  return API
+})()
+exports.default = API