@huckleberry-inc/address 4.3.0

package/build/cjs/packages/address/src/graphqlQuery.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const query = `
+query getCountries($locale: SupportedLocale!) {
+  countries(locale: $locale) {
+    name
+    code
+    continent
+    phoneNumberPrefix
+    autocompletionField
+    provinceKey
+    labels {
+      address1
+      address2
+      city
+      company
+      country
+      firstName
+      lastName
+      phone
+      postalCode
+      zone
+    }
+    optionalLabels {
+      address2
+    }
+    formatting {
+      edit
+      show
+    }
+    zones {
+      name
+      code
+    }
+  }
+}
+
+query getCountry($countryCode: SupportedCountry!, $locale: SupportedLocale!) {
+  country(countryCode: $countryCode, locale: $locale) {
+    name
+    code
+    continent
+    phoneNumberPrefix
+    autocompletionField
+    provinceKey
+    labels {
+      address1
+      address2
+      city
+      company
+      country
+      firstName
+      lastName
+      phone
+      postalCode
+      zone
+    }
+    optionalLabels {
+      address2
+    }
+    formatting {
+      edit
+      show
+    }
+    zones {
+      name
+      code
+    }
+  }
+}
+`;
+var query$1 = query;
+
+exports["default"] = query$1;

package/build/cjs/packages/address/src/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var loader = require('./loader.js');
+var format = require('./format.js');
+var AddressFormatter = require('./AddressFormatter.js');
+var index = require('../../../node_modules/@shopify/address-consts/build/esm/index.mjs.js');
+
+
+
+exports.CountryLoaderError = loader.CountryLoaderError;
+exports.loadCountries = loader.loadCountries;
+exports.loadCountry = loader.loadCountry;
+exports.buildOrderedFields = format.buildOrderedFields;
+exports.formatAddress = format.formatAddress;
+exports["default"] = AddressFormatter["default"];
+Object.defineProperty(exports, 'FieldName', {
+	enumerable: true,
+	get: function () { return index.FieldName; }
+});
+exports.GRAPHQL_ENDPOINT = index.GRAPHQL_ENDPOINT;
+Object.defineProperty(exports, 'GraphqlOperationName', {
+	enumerable: true,
+	get: function () { return index.GraphqlOperationName; }
+});
+exports.HEADERS = index.HEADERS;

package/build/cjs/packages/address/src/loader.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var graphqlQuery = require('./graphqlQuery.js');
+var index = require('../../../node_modules/@shopify/address-consts/build/esm/index.mjs.js');
+
+const loadCountries = memoizeAsync(async (locale, {
+  includeHiddenZones = false
+} = {}) => {
+  const response = await fetch(index.GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: index.HEADERS,
+    body: JSON.stringify({
+      query: graphqlQuery["default"],
+      operationName: index.GraphqlOperationName.Countries,
+      variables: {
+        locale: locale.replace(/-/, '_').toUpperCase(),
+        includeHiddenZones
+      }
+    })
+  });
+  const countries = await response.json();
+  if (!('data' in countries) && 'errors' in countries) {
+    throw new CountryLoaderError(countries);
+  }
+  return countries.data.countries;
+});
+const loadCountry = memoizeAsync(async (locale, countryCode, {
+  includeHiddenZones = false
+} = {}) => {
+  const response = await fetch(index.GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: index.HEADERS,
+    body: JSON.stringify({
+      query: graphqlQuery["default"],
+      operationName: index.GraphqlOperationName.Country,
+      variables: {
+        countryCode,
+        locale: locale.replace(/-/, '_').toUpperCase(),
+        includeHiddenZones
+      }
+    })
+  });
+  const country = await response.json();
+  if (!('data' in country) && 'errors' in country) {
+    throw new CountryLoaderError(country);
+  }
+  return country.data.country;
+});
+class CountryLoaderError extends Error {
+  constructor(errors) {
+    const errorMessage = errors.errors.map(error => error.message).join('; ');
+    super(errorMessage);
+  }
+}
+function memoizeAsync(asyncFunction) {
+  const cache = {};
+  return (...args) => {
+    const stringifiedArgs = JSON.stringify(args);
+    if (!cache[stringifiedArgs]) {
+      cache[stringifiedArgs] = asyncFunction.apply(this, args);
+    }
+    return cache[stringifiedArgs];
+  };
+}
+
+exports.CountryLoaderError = CountryLoaderError;
+exports.loadCountries = loadCountries;
+exports.loadCountry = loadCountry;

package/build/cjs/packages/address/src/utilities.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../node_modules/@shopify/address-consts/build/esm/index.mjs.js');
+
+const FIELD_REGEXP = /({\w+})/g;
+/* eslint-disable @typescript-eslint/naming-convention */
+const FIELDS_MAPPING = {
+  '{firstName}': index.FieldName.FirstName,
+  '{lastName}': index.FieldName.LastName,
+  '{country}': index.FieldName.Country,
+  '{city}': index.FieldName.City,
+  '{zip}': index.FieldName.PostalCode,
+  '{province}': index.FieldName.Zone,
+  '{address1}': index.FieldName.Address1,
+  '{address2}': index.FieldName.Address2,
+  '{phone}': index.FieldName.Phone,
+  '{company}': index.FieldName.Company
+};
+/* eslint-enable @typescript-eslint/naming-convention */
+
+/*
+ * Returns empty string if all replacement fields are empty.
+ */
+function renderLineTemplate(country, template, address) {
+  const result = template.match(FIELD_REGEXP);
+  let line = template;
+  if (!result) {
+    return '';
+  }
+  let lineIsEmpty = true;
+  result.forEach(key => {
+    const addressKey = key.replace('{', '').replace('}', '');
+    if (address[addressKey]) {
+      lineIsEmpty = false;
+    }
+    switch (addressKey) {
+      case index.FieldName.Country:
+        line = line.replace(`{${index.FieldName.Country}}`, country.name);
+        break;
+      case index.FieldName.Zone:
+        line = line.replace(`{${index.FieldName.Zone}}`, address.province ? getZone(country.zones, address.province).name : '');
+        break;
+      default:
+        line = line.replace(key, address[addressKey] || '');
+        break;
+    }
+  });
+  if (lineIsEmpty) {
+    return '';
+  } else {
+    return line.trim().replace('  ', ' ');
+  }
+}
+function getZone(zones, zoneCode) {
+  return zones.find(zone => zone.code === zoneCode) || {
+    name: '',
+    code: ''
+  };
+}
+
+exports.FIELDS_MAPPING = FIELDS_MAPPING;
+exports.FIELD_REGEXP = FIELD_REGEXP;
+exports.renderLineTemplate = renderLineTemplate;

package/build/cjs/utilities.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var addressConsts = require('@huckleberry-inc/address-consts');
+
+const FIELD_REGEXP = /({\w+})/g;
+/* eslint-disable @typescript-eslint/naming-convention */
+const FIELDS_MAPPING = {
+  '{firstName}': addressConsts.FieldName.FirstName,
+  '{lastName}': addressConsts.FieldName.LastName,
+  '{country}': addressConsts.FieldName.Country,
+  '{city}': addressConsts.FieldName.City,
+  '{zip}': addressConsts.FieldName.PostalCode,
+  '{province}': addressConsts.FieldName.Zone,
+  '{address1}': addressConsts.FieldName.Address1,
+  '{address2}': addressConsts.FieldName.Address2,
+  '{phone}': addressConsts.FieldName.Phone,
+  '{company}': addressConsts.FieldName.Company
+};
+/* eslint-enable @typescript-eslint/naming-convention */
+
+/*
+ * Returns empty string if all replacement fields are empty.
+ */
+function renderLineTemplate(country, template, address) {
+  const result = template.match(FIELD_REGEXP);
+  let line = template;
+  if (!result) {
+    return '';
+  }
+  let lineIsEmpty = true;
+  result.forEach(key => {
+    const addressKey = key.replace('{', '').replace('}', '');
+    if (address[addressKey]) {
+      lineIsEmpty = false;
+    }
+    switch (addressKey) {
+      case addressConsts.FieldName.Country:
+        line = line.replace(`{${addressConsts.FieldName.Country}}`, country.name);
+        break;
+      case addressConsts.FieldName.Zone:
+        line = line.replace(`{${addressConsts.FieldName.Zone}}`, address.province ? getZone(country.zones, address.province).name : '');
+        break;
+      default:
+        line = line.replace(key, address[addressKey] || '');
+        break;
+    }
+  });
+  if (lineIsEmpty) {
+    return '';
+  } else {
+    return line.trim().replace('  ', ' ');
+  }
+}
+function getZone(zones, zoneCode) {
+  return zones.find(zone => zone.code === zoneCode) || {
+    name: '',
+    code: ''
+  };
+}
+
+exports.FIELDS_MAPPING = FIELDS_MAPPING;
+exports.FIELD_REGEXP = FIELD_REGEXP;
+exports.renderLineTemplate = renderLineTemplate;

package/build/esm/AddressFormatter.mjs

@@ -0,0 +1,94 @@
+import { formatAddress, buildOrderedFields } from './format.mjs';
+import { loadCountry, loadCountries } from './loader.mjs';
+
+const ORDERED_COUNTRIES_CACHE = new Map();
+class AddressFormatter {
+  /**
+   * Useful in tests or any situation where the cache has undesirable
+   * side-effects.
+   */
+  static resetCache() {
+    ORDERED_COUNTRIES_CACHE.clear();
+  }
+  constructor(locale) {
+    this.locale = locale;
+    this.locale = locale;
+  }
+  updateLocale(locale) {
+    this.locale = locale;
+  }
+  async getCountry(countryCode, {
+    includeHiddenZones = false
+  } = {}) {
+    const country = this.loadCountryFromCache(countryCode, includeHiddenZones);
+    if (country) return country;
+    return loadCountry(this.locale, countryCode, {
+      includeHiddenZones
+    });
+  }
+  async getCountries({
+    includeHiddenZones = false
+  } = {}) {
+    const cacheKey = this.cacheKey(this.locale, includeHiddenZones);
+    const cachedCountries = ORDERED_COUNTRIES_CACHE.get(cacheKey);
+    if (cachedCountries) return cachedCountries;
+    const countries = await loadCountries(this.locale, {
+      includeHiddenZones
+    });
+    ORDERED_COUNTRIES_CACHE.set(cacheKey, countries);
+    return countries;
+  }
+  async getZoneName(countryCode, zoneCode) {
+    const country = await this.getCountry(countryCode);
+    const countryZone = country.zones.find(item => item.code === zoneCode);
+    if (!(countryZone !== null && countryZone !== void 0 && countryZone.name)) return undefined;
+    return countryZone.name;
+  }
+
+  /* Returns the address ordered in an array based based on the country code
+   * Eg.:
+   *   [
+   *     'Shopify',
+   *     'First Name Last Name',
+   *     'Address 1',
+   *     'address2',
+   *     'Montréal',
+   *     'Canada Quebec H2J 4B7',
+   *     '514 444 3333'
+   *   ]
+   */
+  async format(address) {
+    const country = await this.getCountry(address.country);
+    return formatAddress(address, country);
+  }
+
+  /* Returns an array that shows how to order fields based on the country code
+   * Eg.:
+   *   [
+   *     ['company'],
+   *     ['firstName', 'lastName'],
+   *     ['address1'],
+   *     ['address2'],
+   *     ['city'],
+   *     ['country', 'province', 'zip'],
+   *     ['phone']
+   *   ]
+   */
+  async getOrderedFields(countryCode) {
+    const country = await this.getCountry(countryCode);
+    return buildOrderedFields(country);
+  }
+  cacheKey(locale, includeHiddenZones) {
+    /* Cache list of countries per locale, both with and without hidden zones included */
+    return `${locale}-${includeHiddenZones}`;
+  }
+  loadCountryFromCache(countryCode, includeHiddenZones) {
+    const cachedCountries = ORDERED_COUNTRIES_CACHE.get(this.cacheKey(this.locale, includeHiddenZones));
+    if (!cachedCountries) return null;
+    return cachedCountries.find(({
+      code
+    }) => code === countryCode);
+  }
+}
+
+export { AddressFormatter as default };

package/build/esm/format.mjs

@@ -0,0 +1,48 @@
+import { renderLineTemplate, FIELD_REGEXP, FIELDS_MAPPING } from './utilities.mjs';
+
+const LINE_DELIMITER = '_';
+const DEFAULT_FORM_LAYOUT = '{firstName}{lastName}_{company}_{address1}_{address2}_{city}_{country}{province}{zip}_{phone}';
+const DEFAULT_SHOW_LAYOUT = '{lastName} {firstName}_{company}_{address1} {address2}_{city} {province} {zip}_{country}_{phone}';
+
+/**
+ * When it's time to render any address, use this function so that it's properly
+ * formatted for the country's locale.
+ *
+ * ```typescript
+ * ['Shopify', 'Lindenstraße 9-14', '10969 Berlin', 'Germany'];
+ * ```
+ * @returns all lines of a formatted address as an array of strings.
+ */
+function formatAddress(address, country) {
+  const layout = country.formatting.show || DEFAULT_SHOW_LAYOUT;
+  return layout.split(LINE_DELIMITER).map(lineTemplate => renderLineTemplate(country, lineTemplate, address).trim());
+}
+
+/**
+ * In an edit form, this function can be used to properly order all the input
+ * fields.
+ *
+ * ```typescript
+ * [
+ *   ['firstName', 'lastName'],
+ *   ['company'],
+ *   ['address1'],
+ *   ['address2'],
+ *   ['city'],
+ *   ['country', 'province', 'zip'],
+ *   ['phone'],
+ * ];
+ * ```
+ */
+function buildOrderedFields(country) {
+  const format = country ? country.formatting.edit : DEFAULT_FORM_LAYOUT;
+  return format.split(LINE_DELIMITER).map(lineTemplate => {
+    const result = lineTemplate.match(FIELD_REGEXP);
+    if (!result) {
+      return [];
+    }
+    return result.map(field => FIELDS_MAPPING[field]);
+  });
+}
+
+export { buildOrderedFields, formatAddress };

package/build/esm/graphqlQuery.mjs

@@ -0,0 +1,72 @@
+const query = `
+query countries($locale: SupportedLocale!) {
+  getCountries(locale: $locale) {
+    name
+    code
+    continent
+    phoneNumberPrefix
+    autocompletionField
+    provinceKey
+    labels {
+      address1
+      address2
+      city
+      company
+      country
+      firstName
+      lastName
+      phone
+      postalCode
+      zone
+    }
+    optionalLabels {
+      address2
+    }
+    formatting {
+      edit
+      show
+    }
+    zones {
+      name
+      code
+    }
+  }
+}
+
+query country($countryCode: SupportedCountry!, $locale: SupportedLocale!) {
+  getCountry(countryCode: $countryCode, locale: $locale) {
+    name
+    code
+    continent
+    phoneNumberPrefix
+    autocompletionField
+    provinceKey
+    labels {
+      address1
+      address2
+      city
+      company
+      country
+      firstName
+      lastName
+      phone
+      postalCode
+      zone
+    }
+    optionalLabels {
+      address2
+    }
+    formatting {
+      edit
+      show
+    }
+    zones {
+      name
+      code
+    }
+  }
+}
+`;
+var query$1 = query;
+
+export { query$1 as default };

package/build/esm/index.mjs

@@ -0,0 +1,4 @@
+export * from '@huckleberry-inc/address-consts';
+export { CountryLoaderError, loadCountries, loadCountry } from './loader.mjs';
+export { buildOrderedFields, formatAddress } from './format.mjs';
+export { default } from './AddressFormatter.mjs';

package/build/esm/loader.mjs

@@ -0,0 +1,64 @@
+import { GRAPHQL_ENDPOINT, HEADERS, GraphqlOperationName } from '@huckleberry-inc/address-consts';
+import query from './graphqlQuery.mjs';
+
+const loadCountries = memoizeAsync(async (locale, {
+  includeHiddenZones = false
+} = {}) => {
+  const response = await fetch(GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: HEADERS,
+    body: JSON.stringify({
+      query,
+      operationName: GraphqlOperationName.Countries,
+      variables: {
+        locale: locale.replace(/-/, '_').toUpperCase(),
+        includeHiddenZones
+      }
+    })
+  });
+  const countries = await response.json();
+  if (!('data' in countries) && 'errors' in countries) {
+    throw new CountryLoaderError(countries);
+  }
+  return countries.data.countries;
+});
+const loadCountry = memoizeAsync(async (locale, countryCode, {
+  includeHiddenZones = false
+} = {}) => {
+  const response = await fetch(GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: HEADERS,
+    body: JSON.stringify({
+      query,
+      operationName: GraphqlOperationName.Country,
+      variables: {
+        countryCode,
+        locale: locale.replace(/-/, '_').toUpperCase(),
+        includeHiddenZones
+      }
+    })
+  });
+  const country = await response.json();
+  if (!('data' in country) && 'errors' in country) {
+    throw new CountryLoaderError(country);
+  }
+  return country.data.country;
+});
+class CountryLoaderError extends Error {
+  constructor(errors) {
+    const errorMessage = errors.errors.map(error => error.message).join('; ');
+    super(errorMessage);
+  }
+}
+function memoizeAsync(asyncFunction) {
+  const cache = {};
+  return (...args) => {
+    const stringifiedArgs = JSON.stringify(args);
+    if (!cache[stringifiedArgs]) {
+      cache[stringifiedArgs] = asyncFunction.apply(this, args);
+    }
+    return cache[stringifiedArgs];
+  };
+}
+
+export { CountryLoaderError, loadCountries, loadCountry };

package/build/esm/node_modules/@shopify/address-consts/build/esm/index.mjs.mjs

@@ -0,0 +1,27 @@
+let FieldName;
+(function (FieldName) {
+  FieldName["FirstName"] = "firstName";
+  FieldName["LastName"] = "lastName";
+  FieldName["Country"] = "country";
+  FieldName["City"] = "city";
+  FieldName["PostalCode"] = "zip";
+  FieldName["Zone"] = "province";
+  FieldName["Address1"] = "address1";
+  FieldName["Address2"] = "address2";
+  FieldName["Phone"] = "phone";
+  FieldName["Company"] = "company";
+})(FieldName || (FieldName = {}));
+const GRAPHQL_ENDPOINT = 'https://atlas.shopifysvc.com/graphql';
+let GraphqlOperationName;
+
+/* eslint-disable @typescript-eslint/naming-convention */
+(function (GraphqlOperationName) {
+  GraphqlOperationName["Countries"] = "countries";
+  GraphqlOperationName["Country"] = "country";
+})(GraphqlOperationName || (GraphqlOperationName = {}));
+const HEADERS = {
+  'Content-Type': 'application/json',
+  'Access-Control-Allow-Origin': '*'
+};
+
+export { FieldName, GRAPHQL_ENDPOINT, GraphqlOperationName, HEADERS };