merchi_sdk_ts 0.0.1-a

package/dist/merchi.js

@@ -0,0 +1,259 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 _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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { AutomaticPaymentRelationship } from './entities/automatic_payment_relationship';
+import { Session } from './entities/session';
+import { JobComment } from './entities/job_comment';
+import { Domain } from './entities/domain';
+import { ExchangeRate } from './entities/exchange_rate';
+import { Job } from './entities/job';
+import { Menu } from './entities/menu';
+import { Backup } from './entities/backup';
+import { VariationField } from './entities/variation_field';
+import { VariationOption } from './entities/variation_option';
+import { ProductionComment } from './entities/production_comment';
+import { Product } from './entities/product';
+import { InternalTag } from './entities/internal_tag';
+import { Inventory } from './entities/inventory';
+import { QuoteItem } from './entities/quote_item';
+import { Category } from './entities/category';
+import { Invoice } from './entities/invoice';
+import { UserCompany } from './entities/user_company';
+import { InventoryUnitVariation } from './entities/inventory_unit_variation';
+import { VariationFieldsOption } from './entities/variation_fields_option';
+import { Bank } from './entities/bank';
+import { Shipment } from './entities/shipment';
+import { ShipmentItem } from './entities/shipment_item';
+import { ShipmentItemFulfillment } from './entities/shipment_item_fulfillment';
+import { ShipmentMethod } from './entities/shipment_method';
+import { ShipmentMethodVariation } from './entities/shipment_method_variation';
+import { DomainInvitation } from './entities/domain_invitation';
+import { EmailCounter } from './entities/email_counter';
+import { MenuItem } from './entities/menu_item';
+import { SupplyDomain } from './entities/supply_domain';
+import { Cart } from './entities/cart';
+import { CartShipmentGroup } from './entities/cart_shipment_group';
+import { CartShipmentQuote } from './entities/cart_shipment_quote';
+import { Theme } from './entities/theme';
+import { ThemeCssSetting } from './entities/theme_css_setting';
+import { Component } from './entities/component';
+import { ComponentVersion } from './entities/component_version';
+import { MerchiFile } from './entities/file';
+import { EmailAddress } from './entities/email_address';
+import { SeoDomainPage } from './entities/seo_domain_page';
+import { ShortUrl } from './entities/short_url';
+import { VariationsGroup } from './entities/variations_group';
+import { Quote } from './entities/quote';
+import { Draft } from './entities/draft';
+import { DraftTemplate } from './entities/draft_template';
+import { Discount } from './entities/discount';
+import { DiscountGroup } from './entities/discount_group';
+import { User } from './entities/user';
+import { Company } from './entities/company';
+import { ComponentTag } from './entities/component_tag';
+import { EnrolledDomain } from './entities/enrolled_domain';
+import { CountryTax } from './entities/country_tax';
+import { Item } from './entities/item';
+import { DomainTag } from './entities/domain_tag';
+import { DraftComment } from './entities/draft_comment';
+import { Notification } from './entities/notification';
+import { Payment } from './entities/payment';
+import { Page } from './entities/page';
+import { CompanyInvitation } from './entities/company_invitation';
+import { SystemRole } from './entities/system_role';
+import { PaymentDevice } from './entities/payment_device';
+import { PhoneNumber } from './entities/phone_number';
+import { Variation } from './entities/variation';
+import { CartItem } from './entities/cart_item';
+import { Address } from './entities/address';
+import { Assignment } from './entities/assignment';
+import { MatchingInventory } from './entities/matching_inventory';
+import { SubscriptionPlan } from './entities/subscription_plan';
+import { generateUUID } from './uuid';
+// eslint-disable-next-line no-unused-vars
+import { apiFetch, apiFetchWithProgress } from './request';
+import { getCookie } from './cookie';
+
+// the type of classes
+
+function cloneClass(original, arg) {
+  // copy the constructor, but use the empty object as `this`
+  var copy = original.bind({}, arg);
+  // pick up any static members (this is shallow, the members are not copied)
+  Object.assign(copy, original);
+  return copy;
+}
+export var Merchi = /*#__PURE__*/function () {
+  function Merchi(sessionToken, clientToken, invoiceToken, cartToken) {
+    var _this = this;
+    _classCallCheck(this, Merchi);
+    _defineProperty(this, "id", generateUUID());
+    _defineProperty(this, "authenticatedFetch", function (resource, options, expectEmptyResponse) {
+      if (!options.query) {
+        /* istanbul ignore next */
+        options.query = [];
+      }
+      if (_this.sessionToken) {
+        /* istanbul ignore next */
+        options.query.push(['session_token', _this.sessionToken]);
+      }
+      if (_this.clientToken) {
+        /* istanbul ignore next */
+        options.query.push(['client_token', _this.clientToken]);
+      }
+      if (_this.invoiceToken) {
+        /* istanbul ignore next */
+        options.query.push(['invoice_token', _this.invoiceToken]);
+      }
+      if (_this.cartToken) {
+        /* istanbul ignore next */
+        options.query.push(['cart_token', _this.cartToken]);
+      }
+      return apiFetch(resource, options, expectEmptyResponse);
+    });
+    /* istanbul ignore next */
+    _defineProperty(this, "authenticatedFetchWithProgress", function (resource, options, progressCallback) {
+      if (!options.query) {
+        options.query = [];
+      }
+      if (_this.sessionToken) {
+        options.query.push(['session_token', _this.sessionToken]);
+      }
+      if (_this.clientToken) {
+        options.query.push(['client_token', _this.clientToken]);
+      }
+      if (_this.invoiceToken) {
+        options.query.push(['invoice_token', _this.invoiceToken]);
+      }
+      if (_this.cartToken) {
+        options.query.push(['cart_token', _this.cartToken]);
+      }
+      return apiFetchWithProgress(resource, options, progressCallback);
+    });
+    _defineProperty(this, "getCurrentUser", function (options) {
+      var _ref = options || {},
+        _ref$embed = _ref.embed,
+        embed = _ref$embed === void 0 ? {} : _ref$embed;
+      var defaultEmbed = {
+        user: {
+          enrolledDomains: {
+            domain: {}
+          }
+        }
+      };
+      if (!_this.sessionToken) {
+        return Promise.resolve(null);
+      }
+      return _this.Session.get(_this.sessionToken, {
+        embed: _objectSpread(_objectSpread({}, defaultEmbed), embed)
+      }).then(function (session) {
+        return session.user;
+      });
+    });
+    if (sessionToken) {
+      this.sessionToken = sessionToken;
+    } else {
+      this.sessionToken = getCookie('session_token');
+    }
+    if (clientToken) {
+      this.clientToken = clientToken;
+    } else {
+      this.clientToken = getCookie('client_token');
+    }
+    if (invoiceToken) {
+      this.invoiceToken = invoiceToken;
+    } else {
+      this.invoiceToken = getCookie('invoice_token');
+    }
+    if (cartToken) {
+      this.cartToken = cartToken;
+    } else {
+      this.cartToken = getCookie('cart_token');
+    }
+
+    // re-export configured versions of all classes
+    this.AutomaticPaymentRelationship = this.setupClass(AutomaticPaymentRelationship);
+    this.Variation = this.setupClass(Variation);
+    this.DraftComment = this.setupClass(DraftComment);
+    this.Component = this.setupClass(Component);
+    this.ComponentVersion = this.setupClass(ComponentVersion);
+    this.Theme = this.setupClass(Theme);
+    this.ThemeCssSetting = this.setupClass(ThemeCssSetting);
+    this.Company = this.setupClass(Company);
+    this.MenuItem = this.setupClass(MenuItem);
+    this.InternalTag = this.setupClass(InternalTag);
+    this.Inventory = this.setupClass(Inventory);
+    this.Notification = this.setupClass(Notification);
+    this.Shipment = this.setupClass(Shipment);
+    this.ShipmentItem = this.setupClass(ShipmentItem);
+    this.ShipmentItemFulfillment = this.setupClass(ShipmentItemFulfillment);
+    this.ShipmentMethod = this.setupClass(ShipmentMethod);
+    this.ShipmentMethodVariation = this.setupClass(ShipmentMethodVariation);
+    this.Domain = this.setupClass(Domain);
+    this.ExchangeRate = this.setupClass(ExchangeRate);
+    this.Invoice = this.setupClass(Invoice);
+    this.Job = this.setupClass(Job);
+    this.ComponentTag = this.setupClass(ComponentTag);
+    this.Category = this.setupClass(Category);
+    this.VariationField = this.setupClass(VariationField);
+    this.InventoryUnitVariation = this.setupClass(InventoryUnitVariation);
+    this.PhoneNumber = this.setupClass(PhoneNumber);
+    this.QuoteItem = this.setupClass(QuoteItem);
+    this.Menu = this.setupClass(Menu);
+    this.Assignment = this.setupClass(Assignment);
+    this.Draft = this.setupClass(Draft);
+    this.DraftTemplate = this.setupClass(DraftTemplate);
+    this.VariationsGroup = this.setupClass(VariationsGroup);
+    this.EnrolledDomain = this.setupClass(EnrolledDomain);
+    this.CompanyInvitation = this.setupClass(CompanyInvitation);
+    this.Quote = this.setupClass(Quote);
+    this.EmailAddress = this.setupClass(EmailAddress);
+    this.SeoDomainPage = this.setupClass(SeoDomainPage);
+    this.ProductionComment = this.setupClass(ProductionComment);
+    this.Backup = this.setupClass(Backup);
+    this.CountryTax = this.setupClass(CountryTax);
+    this.ShortUrl = this.setupClass(ShortUrl);
+    this.Product = this.setupClass(Product);
+    this.SystemRole = this.setupClass(SystemRole);
+    this.CartItem = this.setupClass(CartItem);
+    this.UserCompany = this.setupClass(UserCompany);
+    this.DomainTag = this.setupClass(DomainTag);
+    this.VariationFieldsOption = this.setupClass(VariationFieldsOption);
+    this.Address = this.setupClass(Address);
+    this.Item = this.setupClass(Item);
+    this.SupplyDomain = this.setupClass(SupplyDomain);
+    this.DomainInvitation = this.setupClass(DomainInvitation);
+    this.EmailCounter = this.setupClass(EmailCounter);
+    this.Session = this.setupClass(Session);
+    this.Bank = this.setupClass(Bank);
+    this.Discount = this.setupClass(Discount);
+    this.DiscountGroup = this.setupClass(DiscountGroup);
+    this.Payment = this.setupClass(Payment);
+    this.PaymentDevice = this.setupClass(PaymentDevice);
+    this.Page = this.setupClass(Page);
+    this.Cart = this.setupClass(Cart);
+    this.CartShipmentGroup = this.setupClass(CartShipmentGroup);
+    this.CartShipmentQuote = this.setupClass(CartShipmentQuote);
+    this.MerchiFile = this.setupClass(MerchiFile);
+    this.User = this.setupClass(User);
+    this.JobComment = this.setupClass(JobComment);
+    this.VariationOption = this.setupClass(VariationOption);
+    this.MatchingInventory = this.setupClass(MatchingInventory);
+    this.SubscriptionPlan = this.setupClass(SubscriptionPlan);
+  }
+  _createClass(Merchi, [{
+    key: "setupClass",
+    value: function setupClass(cls) {
+      var result = cloneClass(cls, this);
+      result.merchi = this;
+      return result;
+    }
+  }]);
+  return Merchi;
+}();

package/dist/merchi.test.js

@@ -0,0 +1,35 @@
+import { setup, mockFetch } from './test_util';
+import { Merchi } from './merchi';
+setup();
+test('can get current user merchi has session token', function () {
+  var testToken = 'YrDwzmh8&QGtAfg9quh(4QfSlE^RPXWl';
+  var merchi = new Merchi(testToken);
+  mockFetch(true, {
+    session: {
+      user: {
+        name: 'currentUser'
+      }
+    }
+  }, 200);
+  return merchi.getCurrentUser().then(function (user) {
+    return expect(user.name).toBe('currentUser');
+  });
+});
+test('get current user return empty if there is no cookie', function () {
+  Object.defineProperty(document, 'cookie', {
+    get: jest.fn().mockImplementation(function () {
+      return '';
+    })
+  });
+  var merchi = new Merchi();
+  mockFetch(true, {
+    user: {
+      name: 'currentUser'
+    }
+  }, 200);
+  return merchi.getCurrentUser({
+    embed: {}
+  }).then(function (user) {
+    return expect(user).toBe(null);
+  });
+});

package/dist/request.js

@@ -0,0 +1,132 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+// eslint-disable-next-line no-unused-vars
+import { getErrorFromCode } from './constants/errors';
+
+/* this constant are expected to be defined in webpack (or provided as
+   globals by some other means. */
+
+export var ApiError = /*#__PURE__*/function (_Error) {
+  _inherits(ApiError, _Error);
+  function ApiError(err) {
+    var _this;
+    _classCallCheck(this, ApiError);
+    var message = JSON.stringify(err);
+    /* istanbul ignore next */
+    _this = _callSuper(this, ApiError, [message]);
+    _this.statusCode = err.statusCode;
+    _this.errorCode = getErrorFromCode(err.errorCode);
+    _this.errorMessage = err.message ? err.message : 'No error message';
+    _this.name = 'ApiError';
+    _this.original = err;
+    return _this;
+  }
+  return _createClass(ApiError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var version = 'v6';
+export function backendFetch(resource, options) {
+  var server = window.merchiBackendUri ? window.merchiBackendUri : BACKEND_URI;
+  var url = new URL(server + version + resource);
+  if (options && options.query) {
+    var _iterator = _createForOfIteratorHelper(options.query),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        url.searchParams.append(entry[0], entry[1]);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return fetch(url.toString(), options);
+}
+export function apiFetch(resource, options, expectEmptyResponse) {
+  return backendFetch(resource, options).then(function (response) {
+    if (response.status < 200 || response.status > 299) {
+      return response.json().then(function (json) {
+        var err = new ApiError(json);
+        return Promise.reject(err);
+      });
+    } else {
+      return expectEmptyResponse ? '' : response.json();
+    }
+  });
+}
+
+/* istanbul ignore next */
+export function apiFetchWithProgress(resource, options, progressCallback) {
+  return backendFetch(resource, options).then(function (response) {
+    if (!response.body) {
+      var err = new ApiError('empty response');
+      return Promise.reject(err);
+    }
+    var reader = response.body.getReader();
+    var bodyText = '';
+    var errorText = '';
+    var haveError = false;
+    var expected = '{"loadingBar": "' + '.'.repeat(100) + '"}';
+    function readChunk() {
+      return reader.read().then(function (_ref) {
+        var done = _ref.done,
+          value = _ref.value;
+        if (done) {
+          if (response.status < 200 || response.status > 299) {
+            var _err = new ApiError('Unknown error');
+            return Promise.reject(_err);
+          } else if (haveError) {
+            try {
+              var jsonText = JSON.parse(errorText);
+              return Promise.reject(new ApiError(jsonText));
+            } catch (e) {
+              return Promise.reject(new ApiError(errorText));
+            }
+          } else {
+            return bodyText;
+          }
+        } else {
+          var chunk = new TextDecoder().decode(value);
+          if (haveError) {
+            errorText += chunk;
+          } else {
+            for (var i = 0; i < chunk.length; ++i) {
+              var _char = chunk[i];
+              var expectedChar = expected[bodyText.length];
+              if (expectedChar == _char && !haveError) {
+                bodyText += _char;
+              } else {
+                haveError = true;
+                errorText += _char;
+              }
+            }
+          }
+          if (!haveError && progressCallback) {
+            var _progress = Math.min(Math.max(0, bodyText.length - 16), 100);
+            progressCallback(_progress);
+          }
+          return readChunk();
+        }
+      });
+    }
+    return readChunk();
+  });
+}

package/dist/request.test.js

@@ -0,0 +1,46 @@
+import { apiFetch } from './request';
+import { ErrorType } from './constants/errors';
+import { setup, mockFetch } from './test_util';
+setup();
+test('can pass through data from server', function () {
+  mockFetch(true, {
+    'animal': 'turtle'
+  }, 200);
+  return apiFetch('/test').then(function (data) {
+    expect(data.animal).toBe('turtle');
+  });
+});
+test('can pass through data from server with override url', function () {
+  window.merchiBackendUri = 'http://override.example.com/';
+  mockFetch(true, {
+    'animal': 'turtle'
+  }, 200);
+  return apiFetch('/test').then(function (data) {
+    expect(data.animal).toBe('turtle');
+  });
+});
+test('404 creates ApiError', function () {
+  mockFetch(false, {
+    'statusCode': 404,
+    'errorCode': ErrorType.RESOURCE_NOT_FOUND
+  }, 404);
+  apiFetch('/test')["catch"](function (e) {
+    expect(e.statusCode).toBe(404);
+    expect(e.name).toBe('ApiError');
+    expect(e.errorCode).toBe(ErrorType.RESOURCE_NOT_FOUND);
+    expect(e.errorMessage).toBe('No error message');
+  });
+});
+test('will get default errorCode', function () {
+  mockFetch(false, {
+    'statusCode': 404,
+    'errorCode': -1,
+    'message': 'just a test'
+  }, 404);
+  apiFetch('/test')["catch"](function (e) {
+    expect(e.statusCode).toBe(404);
+    expect(e.name).toBe('ApiError');
+    expect(e.errorCode).toBe(ErrorType.UNKNOWN_ERROR);
+    expect(e.errorMessage).toBe('just a test');
+  });
+});

package/dist/test_util.js

@@ -0,0 +1,19 @@
+export function setup() {
+  beforeAll(function () {
+    global.BACKEND_URI = 'http://example.com/';
+  });
+}
+export function mockFetch(ok, data, status) {
+  var mock = jest.fn();
+  mock.mockImplementation(function () {
+    return Promise.resolve({
+      status: status,
+      ok: ok,
+      json: function json() {
+        return Promise.resolve(data);
+      }
+    });
+  });
+  global.fetch = mock;
+  return mock;
+}

package/dist/toasts.js

@@ -0,0 +1,27 @@
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+export var toastNotifications = function toastNotifications(merchi, options) {
+  var resource = '/notifications-check-update/';
+  var data = new FormData();
+  var entities = options.entities,
+    sections = options.sections,
+    notificationTypes = options.notificationTypes;
+  data.set('entities', JSON.stringify(entities));
+  data.set('sections', JSON.stringify(sections));
+  data.set('notificationTypes', JSON.stringify(notificationTypes));
+  var fetchOptions = {
+    method: 'POST',
+    body: data
+  };
+  return merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+    return data.notifications.map(function (n) {
+      return new merchi.Notification().fromJson(n);
+    });
+  });
+};

package/dist/toasts.test.js

@@ -0,0 +1,46 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { setup, mockFetch } from './test_util';
+import { toastNotifications } from './toasts';
+import { Merchi } from './merchi';
+import { NotificationSection } from './constants/notification_sections';
+import { NotificationType } from './constants/notification_types';
+setup();
+test('fetch toast of jobs', function () {
+  var merchi = new Merchi();
+  var fetch = mockFetch(true, {
+    'notifications': [{
+      id: 1,
+      message: 'test'
+    }]
+  }, 200);
+  var entities = [{
+    id: 1,
+    type: 'job'
+  }];
+  var sections = [NotificationSection.JOB_NOTIFICATIONS];
+  var notificationTypes = _defineProperty({}, NotificationType.JOB_PAID, true);
+  var options = {
+    entities: entities,
+    sections: sections,
+    notificationTypes: notificationTypes
+  };
+  var invocation = toastNotifications(merchi, options);
+  var expectUrl = "".concat(global.BACKEND_URI, "v6/notifications-check-update/");
+  expect(fetch.mock.calls[0][0]).toEqual(expectUrl);
+  expect(fetch.mock.calls[0][1].method).toEqual('POST');
+  expect(JSON.parse(fetch.mock.calls[0][1].body.get('entities'))).toEqual([{
+    id: 1,
+    type: 'job'
+  }]);
+  expect(fetch.mock.calls[0][1].body.get('sections')).toEqual("[".concat(NotificationSection.JOB_NOTIFICATIONS, "]"));
+  expect(JSON.parse(fetch.mock.calls[0][1].body.get('notificationTypes'))).toEqual(_defineProperty({}, NotificationType.JOB_PAID, true));
+  invocation.then(function (notifications) {
+    expect(notifications.length).toBe(1);
+    expect(notifications[0].id).toBe(1);
+    expect(notifications[0].message).toBe('test');
+  });
+  return invocation;
+});

package/dist/util/float.js

@@ -0,0 +1,24 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+export function kahanSum(values) {
+  /* Return the kahan summation of the input number array */
+  var accumulator = 0;
+  var compensation = 0;
+  var _iterator = _createForOfIteratorHelper(values),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var value = _step.value;
+      var y = value - compensation;
+      var t = accumulator + y;
+      compensation = t - accumulator - y;
+      accumulator = t;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return accumulator;
+}

package/dist/util/query_string.js

@@ -0,0 +1,11 @@
+export function getQueryStringValue(name) {
+  var query = window.location.search.substring(1);
+  var vars = query.split('&');
+  for (var i = 0; i < vars.length; i++) {
+    var pair = vars[i].split('=');
+    if (pair[0] === name) {
+      return decodeURIComponent(pair[1]);
+    }
+  }
+  return undefined;
+}

package/dist/util/query_string.test.js

@@ -0,0 +1,6 @@
+import { getQueryStringValue } from './query_string';
+test('lol', function () {
+  expect(getQueryStringValue('a')).toBe(undefined);
+  history.replaceState({}, 'Test', '/test?a=3');
+  expect(getQueryStringValue('a')).toBe('3');
+});

package/dist/util/validation.js

@@ -0,0 +1,3 @@
+export var isUndefinedOrNull = function isUndefinedOrNull(value) {
+  return value === undefined || value === null;
+};

package/dist/util/validation.test.js

@@ -0,0 +1,12 @@
+import { isUndefinedOrNull } from './validation';
+test('return true if value is null', function () {
+  expect(isUndefinedOrNull(null)).toBe(true);
+});
+test('return true if value is undefined', function () {
+  expect(isUndefinedOrNull(undefined)).toBe(true);
+});
+test('return false if value other than undefined or null', function () {
+  expect(isUndefinedOrNull(false)).toBe(false);
+  expect(isUndefinedOrNull('')).toBe(false);
+  expect(isUndefinedOrNull(0)).toBe(false);
+});

package/dist/uuid.js

@@ -0,0 +1,8 @@
+export function generateUUID() {
+  var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  uuid = uuid.replace(/[xy]/g, function (c) {
+    var r = Math.random() * 16 % 16 | 0;
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return uuid;
+}