merchi_cart 0.0.0

package/lib/MerchiSDK/merchi.js

@@ -0,0 +1,332 @@
+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 _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 _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(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);
+    this.id = generateUUID();
+    this.sessionToken = void 0;
+    this.invoiceToken = void 0;
+    this.clientToken = void 0;
+    this.cartToken = void 0;
+    this.AutomaticPaymentRelationship = void 0;
+    this.Notification = void 0;
+    this.EnrolledDomain = void 0;
+    this.Backup = void 0;
+    this.SystemRole = void 0;
+    this.UserCompany = void 0;
+    this.Variation = void 0;
+    this.CountryTax = void 0;
+    this.MenuItem = void 0;
+    this.VariationField = void 0;
+    this.Assignment = void 0;
+    this.InternalTag = void 0;
+    this.Inventory = void 0;
+    this.JobComment = void 0;
+    this.VariationOption = void 0;
+    this.SupplyDomain = void 0;
+    this.ProductionComment = void 0;
+    this.DraftComment = void 0;
+    this.Shipment = void 0;
+    this.ShipmentItem = void 0;
+    this.ShipmentItemFulfillment = void 0;
+    this.ShipmentMethod = void 0;
+    this.ShipmentMethodVariation = void 0;
+    this.Draft = void 0;
+    this.DraftTemplate = void 0;
+    this.VariationFieldsOption = void 0;
+    this.Category = void 0;
+    this.MerchiFile = void 0;
+    this.Invoice = void 0;
+    this.CompanyInvitation = void 0;
+    this.Bank = void 0;
+    this.Job = void 0;
+    this.DomainInvitation = void 0;
+    this.Product = void 0;
+    this.DomainTag = void 0;
+    this.EmailAddress = void 0;
+    this.PhoneNumber = void 0;
+    this.Company = void 0;
+    this.Address = void 0;
+    this.ComponentTag = void 0;
+    this.Discount = void 0;
+    this.DiscountGroup = void 0;
+    this.User = void 0;
+    this.Session = void 0;
+    this.Theme = void 0;
+    this.ThemeCssSetting = void 0;
+    this.Item = void 0;
+    this.EmailCounter = void 0;
+    this.SeoDomainPage = void 0;
+    this.Domain = void 0;
+    this.ExchangeRate = void 0;
+    this.Payment = void 0;
+    this.PaymentDevice = void 0;
+    this.Page = void 0;
+    this.ShortUrl = void 0;
+    this.CartItem = void 0;
+    this.InventoryUnitVariation = void 0;
+    this.VariationsGroup = void 0;
+    this.Menu = void 0;
+    this.Cart = void 0;
+    this.CartShipmentGroup = void 0;
+    this.CartShipmentQuote = void 0;
+    this.Quote = void 0;
+    this.Component = void 0;
+    this.ComponentVersion = void 0;
+    this.QuoteItem = void 0;
+    this.MatchingInventory = void 0;
+    this.SubscriptionPlan = void 0;
+    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 */
+    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);
+    };
+    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;
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["AutomaticPaymentRelationship","Session","JobComment","Domain","ExchangeRate","Job","Menu","Backup","VariationField","VariationOption","ProductionComment","Product","InternalTag","Inventory","QuoteItem","Category","Invoice","UserCompany","InventoryUnitVariation","VariationFieldsOption","Bank","Shipment","ShipmentItem","ShipmentItemFulfillment","ShipmentMethod","ShipmentMethodVariation","DomainInvitation","EmailCounter","MenuItem","SupplyDomain","Cart","CartShipmentGroup","CartShipmentQuote","Theme","ThemeCssSetting","Component","ComponentVersion","MerchiFile","EmailAddress","SeoDomainPage","ShortUrl","VariationsGroup","Quote","Draft","DraftTemplate","Discount","DiscountGroup","User","Company","ComponentTag","EnrolledDomain","CountryTax","Item","DomainTag","DraftComment","Notification","Payment","Page","CompanyInvitation","SystemRole","PaymentDevice","PhoneNumber","Variation","CartItem","Address","Assignment","MatchingInventory","SubscriptionPlan","generateUUID","apiFetch","apiFetchWithProgress","getCookie","cloneClass","original","arg","copy","bind","Object","assign","Merchi","sessionToken","clientToken","invoiceToken","cartToken","_this","_classCallCheck","id","authenticatedFetch","resource","options","expectEmptyResponse","query","push","authenticatedFetchWithProgress","progressCallback","getCurrentUser","_ref","_ref$embed","embed","defaultEmbed","user","enrolledDomains","domain","Promise","resolve","get","_objectSpread","then","session","setupClass","_createClass","key","value","cls","result","merchi"],"sources":["../../src/MerchiSDK/merchi.ts"],"sourcesContent":["import {\n  Entity,\n  // eslint-disable-next-line no-unused-vars\n  EmbedDescriptor,\n} from './entity';\nimport { AutomaticPaymentRelationship } from './entities/automatic_payment_relationship';\nimport { Session } from './entities/session';\nimport { JobComment } from './entities/job_comment';\nimport { Domain } from './entities/domain';\nimport { ExchangeRate } from './entities/exchange_rate';\nimport { Job } from './entities/job';\nimport { Menu } from './entities/menu';\nimport { Backup } from './entities/backup';\nimport { VariationField } from './entities/variation_field';\nimport { VariationOption } from './entities/variation_option';\nimport { ProductionComment } from './entities/production_comment';\nimport { Product } from './entities/product';\nimport { InternalTag } from './entities/internal_tag';\nimport { Inventory } from './entities/inventory';\nimport { QuoteItem } from './entities/quote_item';\nimport { Category } from './entities/category';\nimport { Invoice } from './entities/invoice';\nimport { UserCompany } from './entities/user_company';\nimport { InventoryUnitVariation } from './entities/inventory_unit_variation';\nimport { VariationFieldsOption } from './entities/variation_fields_option';\nimport { Bank } from './entities/bank';\nimport { Shipment } from './entities/shipment';\nimport { ShipmentItem } from './entities/shipment_item';\nimport { ShipmentItemFulfillment } from './entities/shipment_item_fulfillment';\nimport { ShipmentMethod } from './entities/shipment_method';\nimport { ShipmentMethodVariation } from './entities/shipment_method_variation';\nimport { DomainInvitation } from './entities/domain_invitation';\nimport { EmailCounter } from './entities/email_counter';\nimport { MenuItem } from './entities/menu_item';\nimport { SupplyDomain } from './entities/supply_domain';\nimport { Cart } from './entities/cart';\nimport { CartShipmentGroup } from './entities/cart_shipment_group';\nimport { CartShipmentQuote } from './entities/cart_shipment_quote';\nimport { Theme } from './entities/theme';\nimport { ThemeCssSetting } from './entities/theme_css_setting';\nimport { Component } from './entities/component';\nimport { ComponentVersion } from './entities/component_version';\nimport { MerchiFile } from './entities/file';\nimport { EmailAddress } from './entities/email_address';\nimport { SeoDomainPage } from './entities/seo_domain_page';\nimport { ShortUrl } from './entities/short_url';\nimport { VariationsGroup } from './entities/variations_group';\nimport { Quote } from './entities/quote';\nimport { Draft } from './entities/draft';\nimport { DraftTemplate } from './entities/draft_template';\nimport { Discount } from './entities/discount';\nimport { DiscountGroup } from './entities/discount_group';\nimport { User } from './entities/user';\nimport { Company } from './entities/company';\nimport { ComponentTag } from './entities/component_tag';\nimport { EnrolledDomain } from './entities/enrolled_domain';\nimport { CountryTax } from './entities/country_tax';\nimport { Item } from './entities/item';\nimport { DomainTag } from './entities/domain_tag';\nimport { DraftComment } from './entities/draft_comment';\nimport { Notification } from './entities/notification';\nimport { Payment } from './entities/payment';\nimport { Page } from './entities/page';\nimport { CompanyInvitation } from './entities/company_invitation';\nimport { SystemRole } from './entities/system_role';\nimport { PaymentDevice } from './entities/payment_device';\nimport { PhoneNumber } from './entities/phone_number';\nimport { Variation } from './entities/variation';\nimport { CartItem } from './entities/cart_item';\nimport { Address } from './entities/address';\nimport { Assignment } from './entities/assignment';\nimport { MatchingInventory } from './entities/matching_inventory';\nimport { SubscriptionPlan } from './entities/subscription_plan';\nimport { generateUUID } from './uuid';\n// eslint-disable-next-line no-unused-vars\nimport { RequestOptions, apiFetch, apiFetchWithProgress } from './request';\nimport { getCookie } from './cookie';\n\n// the type of classes\nexport interface Type<T, A extends any[]> extends Function {\n  new (...args: A): T;\n}\n\nfunction cloneClass<T, A extends []>(\n  original: Type<T, A>,\n  arg: any\n): Type<T, A> {\n  // copy the constructor, but use the empty object as `this`\n  const copy = original.bind({}, arg);\n  // pick up any static members (this is shallow, the members are not copied)\n  Object.assign(copy, original);\n  return copy;\n}\n\ninterface UserRequestOptions {\n  embed?: EmbedDescriptor;\n}\n\nexport class Merchi {\n  public id: string = generateUUID();\n\n  public sessionToken?: string;\n  public invoiceToken?: string;\n  public clientToken?: string;\n  public cartToken?: string;\n\n  public AutomaticPaymentRelationship: typeof AutomaticPaymentRelationship;\n  public Notification: typeof Notification;\n  public EnrolledDomain: typeof EnrolledDomain;\n  public Backup: typeof Backup;\n  public SystemRole: typeof SystemRole;\n  public UserCompany: typeof UserCompany;\n  public Variation: typeof Variation;\n  public CountryTax: typeof CountryTax;\n  public MenuItem: typeof MenuItem;\n  public VariationField: typeof VariationField;\n  public Assignment: typeof Assignment;\n  public InternalTag: typeof InternalTag;\n  public Inventory: typeof Inventory;\n  public JobComment: typeof JobComment;\n  public VariationOption: typeof VariationOption;\n  public SupplyDomain: typeof SupplyDomain;\n  public ProductionComment: typeof ProductionComment;\n  public DraftComment: typeof DraftComment;\n  public Shipment: typeof Shipment;\n  public ShipmentItem: typeof ShipmentItem;\n  public ShipmentItemFulfillment: typeof ShipmentItemFulfillment;\n  public ShipmentMethod: typeof ShipmentMethod;\n  public ShipmentMethodVariation: typeof ShipmentMethodVariation;\n  public Draft: typeof Draft;\n  public DraftTemplate: typeof DraftTemplate;\n  public VariationFieldsOption: typeof VariationFieldsOption;\n  public Category: typeof Category;\n  public MerchiFile: typeof MerchiFile;\n  public Invoice: typeof Invoice;\n  public CompanyInvitation: typeof CompanyInvitation;\n  public Bank: typeof Bank;\n  public Job: typeof Job;\n  public DomainInvitation: typeof DomainInvitation;\n  public Product: typeof Product;\n  public DomainTag: typeof DomainTag;\n  public EmailAddress: typeof EmailAddress;\n  public PhoneNumber: typeof PhoneNumber;\n  public Company: typeof Company;\n  public Address: typeof Address;\n  public ComponentTag: typeof ComponentTag;\n  public Discount: typeof Discount;\n  public DiscountGroup: typeof DiscountGroup;\n  public User: typeof User;\n  public Session: typeof Session;\n  public Theme: typeof Theme;\n  public ThemeCssSetting: typeof ThemeCssSetting;\n  public Item: typeof Item;\n  public EmailCounter: typeof EmailCounter;\n  public SeoDomainPage: typeof SeoDomainPage;\n  public Domain: typeof Domain;\n  public ExchangeRate: typeof ExchangeRate;\n  public Payment: typeof Payment;\n  public PaymentDevice: typeof PaymentDevice;\n  public Page: typeof Page;\n  public ShortUrl: typeof ShortUrl;\n  public CartItem: typeof CartItem;\n  public InventoryUnitVariation: typeof InventoryUnitVariation;\n  public VariationsGroup: typeof VariationsGroup;\n  public Menu: typeof Menu;\n  public Cart: typeof Cart;\n  public CartShipmentGroup: typeof CartShipmentGroup;\n  public CartShipmentQuote: typeof CartShipmentQuote;\n  public Quote: typeof Quote;\n  public Component: typeof Component;\n  public ComponentVersion : typeof ComponentVersion;\n  public QuoteItem: typeof QuoteItem;\n  public MatchingInventory: typeof MatchingInventory;\n  public SubscriptionPlan: typeof SubscriptionPlan;\n\n  public setupClass(cls: typeof Entity) {\n    const result = cloneClass(cls, this) as typeof Entity;\n    result.merchi = this;\n    return result;\n  }\n\n  public constructor(\n    sessionToken?: string,\n    clientToken?: string,\n    invoiceToken?: string,\n    cartToken?: string\n  ) {\n    if (sessionToken) {\n      this.sessionToken = sessionToken;\n    } else {\n      this.sessionToken = getCookie('session_token');\n    }\n\n    if (clientToken) {\n      this.clientToken = clientToken;\n    } else {\n      this.clientToken = getCookie('client_token');\n    }\n\n    if (invoiceToken) {\n      this.invoiceToken = invoiceToken;\n    } else {\n      this.invoiceToken = getCookie('invoice_token');\n    }\n\n    if (cartToken) {\n      this.cartToken = cartToken;\n    } else {\n      this.cartToken = getCookie('cart_token');\n    }\n\n    // re-export configured versions of all classes\n    this.AutomaticPaymentRelationship = this.setupClass(\n      AutomaticPaymentRelationship\n    ) as typeof AutomaticPaymentRelationship;\n    this.Variation = this.setupClass(Variation) as typeof Variation;\n    this.DraftComment = this.setupClass(DraftComment) as typeof DraftComment;\n    this.Component = this.setupClass(Component) as typeof Component;\n    this.ComponentVersion = this.setupClass(ComponentVersion) as typeof ComponentVersion;\n    this.Theme = this.setupClass(Theme) as typeof Theme;\n    this.ThemeCssSetting = this.setupClass(ThemeCssSetting) as typeof ThemeCssSetting;\n    this.Company = this.setupClass(Company) as typeof Company;\n    this.MenuItem = this.setupClass(MenuItem) as typeof MenuItem;\n    this.InternalTag = this.setupClass(InternalTag) as typeof InternalTag;\n    this.Inventory = this.setupClass(Inventory) as typeof Inventory;\n    this.Notification = this.setupClass(Notification) as typeof Notification;\n    this.Shipment = this.setupClass(Shipment) as typeof Shipment;\n    this.ShipmentItem = this.setupClass(ShipmentItem) as typeof ShipmentItem;\n    this.ShipmentItemFulfillment = this.setupClass(\n      ShipmentItemFulfillment\n    ) as typeof ShipmentItemFulfillment;\n    this.ShipmentMethod = this.setupClass(\n      ShipmentMethod\n    ) as typeof ShipmentMethod;\n    this.ShipmentMethodVariation = this.setupClass(\n      ShipmentMethodVariation\n    ) as typeof ShipmentMethodVariation;\n    this.Domain = this.setupClass(Domain) as typeof Domain;\n    this.ExchangeRate = this.setupClass(ExchangeRate) as typeof ExchangeRate;\n    this.Invoice = this.setupClass(Invoice) as typeof Invoice;\n    this.Job = this.setupClass(Job) as typeof Job;\n    this.ComponentTag = this.setupClass(ComponentTag) as typeof ComponentTag;\n    this.Category = this.setupClass(Category) as typeof Category;\n    this.VariationField = this.setupClass(\n      VariationField\n    ) as typeof VariationField;\n    this.InventoryUnitVariation = this.setupClass(\n      InventoryUnitVariation\n    ) as typeof InventoryUnitVariation;\n    this.PhoneNumber = this.setupClass(PhoneNumber) as typeof PhoneNumber;\n    this.QuoteItem = this.setupClass(QuoteItem) as typeof QuoteItem;\n    this.Menu = this.setupClass(Menu) as typeof Menu;\n    this.Assignment = this.setupClass(Assignment) as typeof Assignment;\n    this.Draft = this.setupClass(Draft) as typeof Draft;\n    this.DraftTemplate = this.setupClass(DraftTemplate) as typeof DraftTemplate;\n    this.VariationsGroup = this.setupClass(\n      VariationsGroup\n    ) as typeof VariationsGroup;\n    this.EnrolledDomain = this.setupClass(\n      EnrolledDomain\n    ) as typeof EnrolledDomain;\n    this.CompanyInvitation = this.setupClass(\n      CompanyInvitation\n    ) as typeof CompanyInvitation;\n    this.Quote = this.setupClass(Quote) as typeof Quote;\n    this.EmailAddress = this.setupClass(EmailAddress) as typeof EmailAddress;\n    this.SeoDomainPage = this.setupClass(SeoDomainPage) as typeof SeoDomainPage;\n    this.ProductionComment = this.setupClass(\n      ProductionComment\n    ) as typeof ProductionComment;\n    this.Backup = this.setupClass(Backup) as typeof Backup;\n    this.CountryTax = this.setupClass(CountryTax) as typeof CountryTax;\n    this.ShortUrl = this.setupClass(ShortUrl) as typeof ShortUrl;\n    this.Product = this.setupClass(Product) as typeof Product;\n    this.SystemRole = this.setupClass(SystemRole) as typeof SystemRole;\n    this.CartItem = this.setupClass(CartItem) as typeof CartItem;\n    this.UserCompany = this.setupClass(UserCompany) as typeof UserCompany;\n    this.DomainTag = this.setupClass(DomainTag) as typeof DomainTag;\n    this.VariationFieldsOption = this.setupClass(\n      VariationFieldsOption\n    ) as typeof VariationFieldsOption;\n    this.Address = this.setupClass(Address) as typeof Address;\n    this.Item = this.setupClass(Item) as typeof Item;\n    this.SupplyDomain = this.setupClass(SupplyDomain) as typeof SupplyDomain;\n    this.DomainInvitation = this.setupClass(\n      DomainInvitation\n    ) as typeof DomainInvitation;\n    this.EmailCounter = this.setupClass(EmailCounter) as typeof EmailCounter;\n    this.Session = this.setupClass(Session) as typeof Session;\n    this.Bank = this.setupClass(Bank) as typeof Bank;\n    this.Discount = this.setupClass(Discount) as typeof Discount;\n    this.DiscountGroup = this.setupClass(DiscountGroup) as typeof DiscountGroup;\n    this.Payment = this.setupClass(Payment) as typeof Payment;\n    this.PaymentDevice = this.setupClass(PaymentDevice) as typeof PaymentDevice;\n    this.Page = this.setupClass(Page) as typeof Page;\n    this.Cart = this.setupClass(Cart) as typeof Cart;\n    this.CartShipmentGroup = this.setupClass(\n      CartShipmentGroup\n    ) as typeof CartShipmentGroup;\n    this.CartShipmentQuote = this.setupClass(\n      CartShipmentQuote\n    ) as typeof CartShipmentQuote;\n    this.MerchiFile = this.setupClass(MerchiFile) as typeof MerchiFile;\n    this.User = this.setupClass(User) as typeof User;\n    this.JobComment = this.setupClass(JobComment) as typeof JobComment;\n    this.VariationOption = this.setupClass(\n      VariationOption\n    ) as typeof VariationOption;\n    this.MatchingInventory = this.setupClass(\n      MatchingInventory\n    ) as typeof MatchingInventory;\n    this.SubscriptionPlan = this.setupClass(\n      SubscriptionPlan\n    ) as typeof SubscriptionPlan;\n  }\n\n  public authenticatedFetch = (\n    resource: string,\n    options: RequestOptions,\n    expectEmptyResponse?: boolean\n  ) => {\n    if (!options.query) {\n      /* istanbul ignore next */\n      options.query = [];\n    }\n    if (this.sessionToken) {\n      /* istanbul ignore next */\n      options.query.push(['session_token', this.sessionToken]);\n    }\n    if (this.clientToken) {\n      /* istanbul ignore next */\n      options.query.push(['client_token', this.clientToken]);\n    }\n    if (this.invoiceToken) {\n      /* istanbul ignore next */\n      options.query.push(['invoice_token', this.invoiceToken]);\n    }\n    if (this.cartToken) {\n      /* istanbul ignore next */\n      options.query.push(['cart_token', this.cartToken]);\n    }\n    return apiFetch(resource, options, expectEmptyResponse);\n  };\n\n  /* istanbul ignore next */\n  public authenticatedFetchWithProgress = (\n    resource: string,\n    options: RequestOptions,\n    progressCallback?: (progress: number) => void\n  ) => {\n    if (!options.query) {\n      options.query = [];\n    }\n    if (this.sessionToken) {\n      options.query.push(['session_token', this.sessionToken]);\n    }\n    if (this.clientToken) {\n      options.query.push(['client_token', this.clientToken]);\n    }\n    if (this.invoiceToken) {\n      options.query.push(['invoice_token', this.invoiceToken]);\n    }\n    if (this.cartToken) {\n      options.query.push(['cart_token', this.cartToken]);\n    }\n    return apiFetchWithProgress(resource, options, progressCallback);\n  };\n\n  public getCurrentUser = (options?: UserRequestOptions) => {\n    const { embed = {} } = options || {};\n    const defaultEmbed = { user: { enrolledDomains: { domain: {} } } };\n    if (!this.sessionToken) {\n      return Promise.resolve(null);\n    }\n    return this.Session.get(this.sessionToken, {\n      embed: { ...defaultEmbed, ...embed },\n    }).then((session: any) => session.user);\n  };\n}\n"],"mappings":"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"}

package/lib/MerchiSDK/merchi.test.js

@@ -0,0 +1,36 @@
+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);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/MerchiSDK/request.js

@@ -0,0 +1,137 @@
+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 = void 0;
+    _this.errorCode = void 0;
+    _this.errorMessage = void 0;
+    _this.original = void 0;
+    _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();
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getErrorFromCode","ApiError","_Error","_inherits","err","_this","_classCallCheck","message","JSON","stringify","_callSuper","statusCode","errorCode","errorMessage","original","name","_createClass","_wrapNativeSuper","Error","version","backendFetch","resource","options","server","window","merchiBackendUri","BACKEND_URI","url","URL","query","_iterator","_createForOfIteratorHelper","_step","s","n","done","entry","value","searchParams","append","e","f","fetch","toString","apiFetch","expectEmptyResponse","then","response","status","json","Promise","reject","apiFetchWithProgress","progressCallback","body","reader","getReader","bodyText","errorText","haveError","expected","repeat","readChunk","read","_ref","jsonText","parse","chunk","TextDecoder","decode","i","length","char","expectedChar","progress","Math","min","max"],"sources":["../../src/MerchiSDK/request.ts"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport { ErrorType, getErrorFromCode } from './constants/errors';\n\n/* this constant are expected to be defined in webpack (or provided as\n   globals by some other means. */\ndeclare const BACKEND_URI: string;\n\nexport interface RequestOptions extends RequestInit {\n  query?: string[][];\n}\n\nexport class ApiError extends Error {\n  public statusCode?: number;\n  public errorCode?: ErrorType;\n  public errorMessage: string;\n  public original: any;\n  public constructor(err: any) {\n    const message = JSON.stringify(err);\n    /* istanbul ignore next */\n    super(message);\n    this.statusCode = err.statusCode;\n    this.errorCode = getErrorFromCode(err.errorCode);\n    this.errorMessage = err.message ?\n      err.message : 'No error message';\n    this.name = 'ApiError';\n    this.original = err;\n  }\n}\n\nexport const version = 'v6';\n\nexport function backendFetch(resource: string, options?: RequestOptions) {\n  const server = (window as any).merchiBackendUri\n    ? (window as any).merchiBackendUri\n    : BACKEND_URI;\n  const url = new URL(server + version + resource);\n  if (options && options.query) {\n    for (const entry of options.query) {\n      url.searchParams.append(entry[0], entry[1]);\n    }\n  }\n  return fetch(url.toString(), options);\n}\n\nexport function apiFetch(\n  resource: string,\n  options?: RequestOptions,\n  expectEmptyResponse?: boolean\n) {\n  return backendFetch(resource, options as RequestInit | undefined).then(\n    function (response) {\n      if (response.status < 200 || response.status > 299) {\n        return response.json().then(function (json) {\n          const err = new ApiError(json);\n          return Promise.reject(err);\n        });\n      } else {\n        return expectEmptyResponse ? '' : response.json();\n      }\n    }\n  );\n}\n\n/* istanbul ignore next */\nexport function apiFetchWithProgress(\n  resource: string,\n  options?: RequestOptions,\n  progressCallback?: (progress: number) => void\n) {\n  return backendFetch(resource, options as RequestInit | undefined).then(\n    function (response) {\n      if (!response.body) {\n        const err = new ApiError('empty response');\n        return Promise.reject(err);\n      }\n      const reader = response.body.getReader();\n      let bodyText = '';\n      let errorText = '';\n      let haveError = false;\n      const expected = '{\"loadingBar\": \"' + '.'.repeat(100) + '\"}';\n      function readChunk(): any {\n        return reader.read().then(({done, value}) => {\n          if (done) {\n            if (response.status < 200 || response.status > 299) {\n              const err = new ApiError('Unknown error');\n              return Promise.reject(err);\n            } else if(haveError) {\n              try {\n                const jsonText = JSON.parse(errorText);\n                return Promise.reject(new ApiError(jsonText));\n              } catch (e) {\n                return Promise.reject(new ApiError(errorText));\n              }\n            } else {\n              return bodyText;\n            }\n          } else {\n            const chunk = new TextDecoder().decode(value);\n            if (haveError) {\n              errorText += chunk;\n            } else {\n              for (let i = 0; i < chunk.length; ++i) {\n                const char = chunk[i];\n                const expectedChar = expected[bodyText.length];\n                if (expectedChar == char && !haveError) {\n                  bodyText += char;\n                } else {\n                  haveError = true;\n                  errorText += char;\n                }\n              }\n            }\n            if (!haveError && progressCallback) {\n              const progress = Math.min(Math.max(0, bodyText.length - 16), 100);\n              progressCallback(progress);\n            }\n            return readChunk();\n          }\n        });\n      }\n      return readChunk();\n    }\n  );\n}\n"],"mappings":"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"}