swell-js 3.21.9 → 3.22.1

package/dist/api-35708af6.js

@@ -0,0 +1,207 @@
+import { c as cardApi } from './card-4257bc68.js';
+import { g as getCookie, s as setCookie } from './cookie-4cde18fb.js';
+import { c as cacheApi } from './cache-b92f4460.js';
+import { m as methods$1 } from './cart-35e7bdb4.js';
+import { m as methods$2 } from './account-328cc590.js';
+import { m as methods$3 } from './products-d194c3c6.js';
+import { m as methods$4 } from './categories-b1d04223.js';
+import { m as methods$5 } from './attributes-bfef7db7.js';
+import { m as methods$6 } from './subscriptions-f077cac6.js';
+import { d as defaultMethods, n as trimEnd, K as utils, l as trimStart, k as trimBoth, j as toSnake, o as stringifyQuery, E as base64Encode, t as toCamel, e as setOptions } from './index-ca9cb73c.js';
+import { m as methods$7 } from './content-c366a9f8.js';
+import { m as methods$8 } from './settings-34395c72.js';
+import { P as PaymentController } from './index-ae8e1259.js';
+import { m as methods$9 } from './locale-62622809.js';
+import { m as methods$a } from './currency-004374be.js';
+
+function methods(request) {
+  const { get, list } = defaultMethods(request, '/invoices', ['list', 'get']);
+  return {
+    get: (id, ...args) => {
+      return cacheApi.getFetch('invoices', id, () => get(id, ...args));
+    },
+
+    list,
+  };
+}
+
+const options = {
+  store: null,
+  key: null,
+  url: null,
+  useCamelCase: null,
+  previewContent: null,
+};
+
+const api = {
+  version: '3.22.0',
+  options,
+  request,
+
+  init(store, key, opt = {}) {
+    options.key = key;
+    options.store = store;
+    options.url = opt.url
+      ? trimEnd(opt.url)
+      : `https://${store}.swell.store`;
+    options.vaultUrl = opt.vaultUrl
+      ? trimEnd(opt.vaultUrl)
+      : `https://vault.schema.io`;
+    options.timeout = (opt.timeout && parseInt(opt.timeout, 10)) || 20000;
+    options.useCamelCase = opt.useCamelCase || false;
+    options.previewContent = opt.previewContent || false;
+    options.session = opt.session;
+    options.locale = opt.locale;
+    options.currency = opt.currency;
+    options.api = api;
+    options.getCart = opt.getCart;
+    options.updateCart = opt.updateCart;
+    setOptions(options);
+  },
+
+  // Backward compatibility
+  auth(...args) {
+    return this.init(...args);
+  },
+
+  get(url, query) {
+    return request('get', url, query);
+  },
+
+  put(url, data) {
+    return request('put', url, data);
+  },
+
+  post(url, data) {
+    return request('post', url, data);
+  },
+
+  delete(url, data) {
+    return request('delete', url, data);
+  },
+
+  cache: cacheApi,
+
+  card: cardApi,
+
+  cart: methods$1(request, options),
+
+  account: methods$2(request),
+
+  products: methods$3(request, options),
+
+  categories: methods$4(request),
+
+  attributes: methods$5(request),
+
+  subscriptions: methods$6(request),
+
+  invoices: methods(request),
+
+  content: methods$7(request, options),
+
+  settings: methods$8(request, options),
+
+  payment: new PaymentController(request, options),
+
+  locale: methods$9(request, options),
+
+  currency: methods$a(request, options),
+
+  utils,
+};
+
+async function request(
+  method,
+  url,
+  id = undefined,
+  data = undefined,
+  opt = undefined,
+) {
+  const allOptions = {
+    ...options,
+    ...opt,
+  };
+
+  const session = allOptions.session || getCookie('swell-session');
+  const locale = allOptions.locale || getCookie('swell-locale');
+  const currency = allOptions.currency || getCookie('swell-currency');
+
+  const baseUrl = `${allOptions.url}${allOptions.base || ''}/api`;
+  const reqMethod = String(method).toLowerCase();
+
+  let reqUrl = url;
+  let reqData = id;
+
+  if (data !== undefined || typeof id === 'string') {
+    reqUrl = [trimEnd(url), trimStart(id)].join('/');
+    reqData = data;
+  }
+
+  reqUrl = allOptions.fullUrl || `${baseUrl}/${trimBoth(reqUrl)}`;
+  reqData = allOptions.useCamelCase ? toSnake(reqData) : reqData;
+
+  let reqBody;
+  if (reqMethod === 'get') {
+    let exQuery;
+    [reqUrl, exQuery] = reqUrl.split('?');
+    const fullQuery = [exQuery, stringifyQuery(reqData)]
+      .join('&')
+      .replace(/^&/, '');
+    reqUrl = `${reqUrl}${fullQuery ? `?${fullQuery}` : ''}`;
+  } else {
+    reqBody = JSON.stringify(reqData);
+  }
+
+  const reqHeaders = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+    Authorization: `Basic ${base64Encode(String(allOptions.key))}`,
+  };
+
+  if (session) {
+    reqHeaders['X-Session'] = session;
+  }
+
+  if (locale) {
+    reqHeaders['X-Locale'] = locale;
+  }
+
+  if (currency) {
+    reqHeaders['X-Currency'] = currency;
+  }
+
+  const response = await fetch(reqUrl, {
+    method: reqMethod,
+    headers: reqHeaders,
+    body: reqBody,
+    credentials: 'include',
+    mode: 'cors',
+  });
+
+  const responseSession = response.headers.get('X-Session');
+
+  if (typeof responseSession === 'string' && session !== responseSession) {
+    setCookie('swell-session', responseSession);
+  }
+
+  const result = await response.json();
+
+  if (result && result.error) {
+    const err = new Error(result.error.message);
+    err.status = response.status;
+    err.code = result.error.code;
+    err.param = result.error.param;
+    throw err;
+  } else if (!response.ok) {
+    const err = new Error(
+      'A connection error occurred while making the request',
+    );
+    err.code = 'connection_error';
+    throw err;
+  }
+
+  return options.useCamelCase ? toCamel(result) : result;
+}
+
+export { api as a };

package/dist/api.js

@@ -1,19 +1,19 @@
-export { a as default } from './api-6ad3ed1e.js';
-import './card-91071403.js';
-import './index-512fc30d.js';
+export { a as default } from './api-35708af6.js';
+import './card-4257bc68.js';
+import './index-ca9cb73c.js';
 import 'qs';
 import 'deepmerge';
 import 'fast-case';
-import './cookie-b78058af.js';
-import './cache-751d89b1.js';
-import './cart-ff3e3ef6.js';
-import './products-7f2fbc3e.js';
-import './attributes-7a214d6b.js';
+import './cookie-4cde18fb.js';
+import './cache-b92f4460.js';
+import './cart-35e7bdb4.js';
+import './products-d194c3c6.js';
+import './attributes-bfef7db7.js';
 import './account-328cc590.js';
-import './categories-8f6a4584.js';
-import './subscriptions-8044a530.js';
-import './content-0afdcb05.js';
-import './settings-c5569614.js';
-import './index-abe4ebcd.js';
-import './locale-4391bcf3.js';
-import './currency-42145ec0.js';
+import './categories-b1d04223.js';
+import './subscriptions-f077cac6.js';
+import './content-c366a9f8.js';
+import './settings-34395c72.js';
+import './index-ae8e1259.js';
+import './locale-62622809.js';
+import './currency-004374be.js';

package/dist/attributes-bfef7db7.js

@@ -0,0 +1,16 @@
+import { d as defaultMethods } from './index-ca9cb73c.js';
+import { c as cacheApi } from './cache-b92f4460.js';
+
+function methods(request) {
+  const { get, list } = defaultMethods(request, '/attributes', ['list', 'get']);
+
+  return {
+    get: (id, ...args) => {
+      return cacheApi.getFetch('attributes', id, () => get(id, ...args));
+    },
+
+    list,
+  };
+}
+
+export { methods as m };

package/dist/attributes.js

@@ -1,6 +1,6 @@
-export { m as default } from './attributes-7a214d6b.js';
-import './index-512fc30d.js';
+export { m as default } from './attributes-bfef7db7.js';
+import './index-ca9cb73c.js';
 import 'qs';
 import 'deepmerge';
 import 'fast-case';
-import './cache-751d89b1.js';
+import './cache-b92f4460.js';

package/dist/cache-b92f4460.js

@@ -0,0 +1,165 @@
+import { s as set, g as get, m as merge, t as toCamel, i as toCamelPath, h as getOptions } from './index-ca9cb73c.js';
+
+const RECORD_TIMEOUT = 5000;
+
+let VALUES = {
+  /*
+  [model]: {
+    [id]: {
+      data,
+      record,
+      recordTimer,
+      presets,
+    }
+  }
+*/
+};
+
+const cacheApi = {
+  options: {
+    enabled: true,
+    debug: false,
+  },
+
+  debug(...args) {
+    if (this.options.debug) {
+      console.log(...args);
+    }
+  },
+
+  values({ model, id }, setValues = undefined) {
+    this.debug('cache.values', ...arguments);
+    if (setValues !== undefined) {
+      for (let key in setValues) {
+        set(VALUES, `${model}.${id}.${key}`, setValues[key]);
+      }
+      return;
+    }
+    return get(VALUES, `${model}.${id}`, {});
+  },
+
+  preset(details) {
+    this.debug('cache.preset', ...arguments);
+    const { presets = [] } = this.values(details);
+    presets.push(details);
+    this.values(details, { presets });
+  },
+
+  set(details) {
+    this.debug('cache.set', ...arguments);
+    let { model, id, path, value } = details;
+    let { data = {}, record, presets } = this.values(details);
+
+    if (id === null) {
+      return;
+    }
+
+    if (record === undefined) {
+      return this.preset(details);
+    }
+
+    data = merge(record || {}, data);
+
+    const { useCamelCase } = getOptions();
+    if (useCamelCase && value && typeof value === 'object') {
+      value = toCamel(value);
+    }
+
+    if (path || value instanceof Array) {
+      let upData = { ...(data || {}) };
+      let upPath = useCamelCase ? toCamelPath(path) : path;
+      set(upData, upPath || '', value);
+      data = upData;
+    } else if (value && typeof value === 'object') {
+      data = data || {};
+      data = merge(data, value);
+    } else {
+      data = value;
+    }
+
+    this.values(details, { data });
+
+    try {
+      // Make sure values have clean refs
+      const cache = VALUES[model][id];
+      if (cache !== undefined) {
+        if (cache.data !== undefined) {
+          cache.data = JSON.parse(JSON.stringify(cache.data));
+        }
+        if (cache.record !== undefined) {
+          cache.record = JSON.parse(JSON.stringify(cache.record));
+        }
+      }
+    } catch (err) {
+      // noop
+    }
+  },
+
+  get(model, id) {
+    this.debug('cache.get', ...arguments);
+    const { data, recordTimer } = this.values({ model, id });
+    this.debug('cache.get:data+recordTimer', ...arguments);
+    if (recordTimer) {
+      return data;
+    }
+  },
+
+  setRecord(record, details) {
+    this.debug('cache.setRecord', ...arguments);
+    let { recordTimer, presets } = this.values(details);
+
+    if (recordTimer) {
+      clearTimeout(recordTimer);
+    }
+
+    recordTimer = setTimeout(() => {
+      this.values(details, { record: undefined, recordTimer: undefined });
+    }, RECORD_TIMEOUT);
+
+    // Record has to be null at minimum, not undefined
+    this.values(details, {
+      record: record !== undefined ? record : null,
+      recordTimer,
+    });
+
+    if (presets) {
+      for (let preset of presets) {
+        this.set(preset);
+      }
+      this.values(details, { presets: undefined });
+    }
+
+    const result = this.get(details.model, details.id);
+
+    return result !== undefined ? result : record;
+  },
+
+  async getFetch(model, id, fetch) {
+    if (this.options.enabled) {
+      this.debug('cache.getFetch', ...arguments);
+      const value = this.get(model, id);
+
+      if (value !== undefined) {
+        return value;
+      }
+    }
+
+    const record = await fetch();
+    return this.setRecord(record, { model, id });
+  },
+
+  clear(model = undefined, id = undefined) {
+    this.debug('cache.clear', ...arguments);
+    if (model) {
+      if (id) {
+        set(VALUES, `${model}.${id}`, undefined);
+      } else {
+        set(VALUES, model, undefined);
+      }
+    } else {
+      VALUES = {};
+    }
+  },
+};
+
+export { cacheApi as c };

package/dist/cache.js

@@ -1,5 +1,5 @@
-export { c as default } from './cache-751d89b1.js';
-import './index-512fc30d.js';
+export { c as default } from './cache-b92f4460.js';
+import './index-ca9cb73c.js';
 import 'qs';
 import 'deepmerge';
 import 'fast-case';

package/dist/card-4257bc68.js

@@ -0,0 +1,141 @@
+import { j as toSnake, F as vaultRequest } from './index-ca9cb73c.js';
+
+const cardApi = {
+  async createToken(data) {
+    let error = null;
+    let code = null;
+    let param = null;
+    if (!data) {
+      error = 'Card details are missing in `swell.card.createToken(card)`';
+      param = '';
+    }
+    const card = toSnake(data);
+    if (!card.nonce) {
+      if (!this.validateNumber(card.number)) {
+        error = 'Card number appears to be invalid';
+        code = 'invalid_card_number';
+        param = 'number';
+      }
+      if (card.exp) {
+        const exp = this.expiry(card.exp);
+        card.exp_month = exp.month;
+        card.exp_year = exp.year;
+      }
+      if (!this.validateExpiry(card.exp_month, card.exp_year)) {
+        error = 'Card expiry appears to be invalid';
+        code = 'invalid_card_expiry';
+        param = 'exp_month';
+      }
+      if (!this.validateCVC(card.cvc)) {
+        error = 'Card CVC code appears to be invalid';
+        code = 'invalid_card_cvc';
+        param = 'exp_cvc';
+      }
+    }
+
+    if (error) {
+      const err = new Error(error);
+      err.code = code || 'invalid_card';
+      err.status = 402;
+      err.param = param;
+      throw err;
+    }
+
+    // Get a token from the vault
+    const result = await vaultRequest('post', '/tokens', card);
+    if (result.errors) {
+      const param = Object.keys(result.errors)[0];
+      const err = new Error(result.errors[param].message || 'Unknown error');
+      err.code = 'vault_error';
+      err.status = 402;
+      err.param = param;
+      throw err;
+    }
+    return result;
+  },
+
+  expiry(value) {
+    if (value && value.month && value.year) {
+      return value;
+    }
+
+    const parts = new String(value).split(/[\s\/\-]+/, 2);
+    const month = parts[0];
+    let year = parts[1];
+
+    // Convert 2 digit year
+    if (year && year.length === 2 && /^\d+$/.test(year)) {
+      const prefix = new Date().getFullYear().toString().substring(0, 2);
+      year = prefix + year;
+    }
+
+    return {
+      month: ~~month,
+      year: ~~year,
+    };
+  },
+
+  types() {
+    let e, t, n, r;
+    t = {};
+    for (e = n = 40; n <= 49; e = ++n) t[e] = 'Visa';
+    for (e = r = 50; r <= 59; e = ++r) t[e] = 'MasterCard';
+    return (
+      (t[34] = t[37] = 'American Express'),
+      (t[60] = t[62] = t[64] = t[65] = 'Discover'),
+      (t[35] = 'JCB'),
+      (t[30] = t[36] = t[38] = t[39] = 'Diners Club'),
+      t
+    );
+  },
+
+  type(num) {
+    return this.types()[num.slice(0, 2)] || 'Unknown';
+  },
+
+  luhnCheck(num) {
+    let t, n, r, i, s, o;
+    (r = !0), (i = 0), (n = (num + '').split('').reverse());
+    for (s = 0, o = n.length; s < o; s++) {
+      (t = n[s]), (t = parseInt(t, 10));
+      if ((r = !r)) t *= 2;
+      t > 9 && (t -= 9), (i += t);
+    }
+    return i % 10 === 0;
+  },
+
+  validateNumber(num) {
+    return (
+      (num = (num + '').replace(/\s+|-/g, '')),
+      num.length >= 10 && num.length <= 16 && this.luhnCheck(num)
+    );
+  },
+
+  validateExpiry(month, year) {
+    let r, i;
+    return (
+      (month = String(month).trim()),
+      (year = String(year).trim()),
+      /^\d+$/.test(month)
+        ? /^\d+$/.test(year)
+          ? parseInt(month, 10) <= 12
+            ? ((i = new Date(year, month)),
+              (r = new Date()),
+              i.setMonth(i.getMonth() - 1),
+              i.setMonth(i.getMonth() + 1, 1),
+              i > r)
+            : !1
+          : !1
+        : !1
+    );
+  },
+
+  validateCVC(val) {
+    return (
+      (val = String(val).trim()),
+      /^\d+$/.test(val) && val.length >= 3 && val.length <= 4
+    );
+  },
+};
+
+export { cardApi as c };

package/dist/card.js

@@ -1,5 +1,5 @@
-export { c as default } from './card-91071403.js';
-import './index-512fc30d.js';
+export { c as default } from './card-4257bc68.js';
+import './index-ca9cb73c.js';
 import 'qs';
 import 'deepmerge';
 import 'fast-case';