@final-commerce/common 2.5.1-online.1 → 2.5.1-online.2

package/dist/index.js

@@ -30,6 +30,7 @@ __export(index_exports, {
   BookingResourceStatus: () => BookingResourceStatus,
   BookingRulesError: () => BookingRulesError,
   BookingType: () => BookingType,
+  CANADA_PROVINCES: () => CANADA_PROVINCES,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
   COUNTRY_CURRENCIES: () => COUNTRY_CURRENCIES,
   CURRENCY_CONFIG: () => CURRENCY_CONFIG,
@@ -46,6 +47,7 @@ __export(index_exports, {
   DualWriteStrategy: () => DualWriteStrategy,
   EUFixedRates: () => EUFixedRates,
   EUROPE: () => EUROPE,
+  EVERYWHERE_KEY: () => EVERYWHERE_KEY,
   ExtensionCategory: () => ExtensionCategory,
   FINANCIAL_INVARIANTS: () => FINANCIAL_INVARIANTS,
   FULFILLMENT_STATES: () => FULFILLMENT_STATES,
@@ -96,6 +98,12 @@ __export(index_exports, {
   SYSTEM_FAMILY_IDS: () => SYSTEM_FAMILY_IDS,
   SYSTEM_UNITS: () => SYSTEM_UNITS,
   SYSTEM_UNIT_IDS: () => SYSTEM_UNIT_IDS,
+  ShippingChannel: () => ShippingChannel,
+  ShippingNoOptionReason: () => ShippingNoOptionReason,
+  ShippingOptionType: () => ShippingOptionType,
+  ShippingRateType: () => ShippingRateType,
+  ShippingZoneError: () => ShippingZoneError,
+  ShippingZoneKind: () => ShippingZoneKind,
   StationStatus: () => StationStatus,
   StripeCurrencyCode: () => StripeCurrencyCode,
   StripeStatus: () => StripeStatus,
@@ -103,6 +111,7 @@ __export(index_exports, {
   TopMetericsSort: () => TopMetericsSort,
   UserTypes: () => UserTypes,
   addAmounts: () => addAmounts,
+  addressPlaceKeys: () => addressPlaceKeys,
   amountToString: () => amountToString,
   assertUnitSane: () => assertUnitSane,
   availableIn: () => availableIn,
@@ -163,19 +172,31 @@ __export(index_exports, {
   isSystemFamilyCode: () => isSystemFamilyCode,
   isValidQuantity: () => isValidQuantity,
   isWhole: () => isWhole,
+  listCountries: () => listCountries,
+  listProvinces: () => listProvinces,
   mapToLegacyStatus: () => mapToLegacyStatus,
   maxPrecisionFor: () => maxPrecisionFor,
   mergeFragment: () => mergeFragment,
   multiplyAmount: () => multiplyAmount,
+  normalizeAddress: () => normalizeAddress,
+  normalizeCityKey: () => normalizeCityKey,
+  normalizeCountry: () => normalizeCountry,
   normalizeMongoIdString: () => normalizeMongoIdString,
+  normalizePostCode: () => normalizePostCode,
+  normalizeProvince: () => normalizeProvince,
   occupancyIn: () => occupancyIn,
   parseAmountToMinorUnits: () => parseAmountToMinorUnits,
   parseCurrencyCode: () => parseCurrencyCode,
   parseStripeCurrencyCode: () => parseStripeCurrencyCode,
+  placeKey: () => placeKey,
   planWindow: () => planWindow,
+  postCodeMatchesProvince: () => postCodeMatchesProvince,
   presentAt: () => presentAt,
+  priceForTotal: () => priceForTotal,
+  provincesForPostCode: () => provincesForPostCode,
   removeFragment: () => removeFragment,
   resolveFamily: () => resolveFamily,
+  resolveShipping: () => resolveShipping,
   resolveTemplate: () => resolveTemplate,
   resolveUnit: () => resolveUnit,
   roundToPrecision: () => roundToPrecision,
@@ -191,6 +212,7 @@ __export(index_exports, {
   toMinorUnits: () => toMinorUnits,
   validateConfig: () => validateConfig,
   validateFragmentCompatibility: () => validateFragmentCompatibility,
+  validateShippingZone: () => validateShippingZone,
   violatesFinancialInvariant: () => violatesFinancialInvariant,
   windowEndsAt: () => windowEndsAt,
   withinPresence: () => withinPresence
@@ -685,6 +707,50 @@ var ResourceAvailabilityState = /* @__PURE__ */ ((ResourceAvailabilityState2) =>
   return ResourceAvailabilityState2;
 })(ResourceAvailabilityState || {});
 
+// enums/shipping.enum.ts
+var ShippingZoneKind = /* @__PURE__ */ ((ShippingZoneKind2) => {
+  ShippingZoneKind2["COUNTRY"] = "country";
+  ShippingZoneKind2["PROVINCE"] = "province";
+  ShippingZoneKind2["CITY"] = "city";
+  ShippingZoneKind2["EVERYWHERE"] = "everywhere";
+  return ShippingZoneKind2;
+})(ShippingZoneKind || {});
+var ShippingOptionType = /* @__PURE__ */ ((ShippingOptionType2) => {
+  ShippingOptionType2["SHIP"] = "ship";
+  ShippingOptionType2["PICKUP"] = "pickup";
+  return ShippingOptionType2;
+})(ShippingOptionType || {});
+var ShippingRateType = /* @__PURE__ */ ((ShippingRateType2) => {
+  ShippingRateType2["FLAT"] = "flat";
+  return ShippingRateType2;
+})(ShippingRateType || {});
+var ShippingChannel = /* @__PURE__ */ ((ShippingChannel2) => {
+  ShippingChannel2["WEB"] = "web";
+  ShippingChannel2["POS"] = "pos";
+  return ShippingChannel2;
+})(ShippingChannel || {});
+var ShippingNoOptionReason = /* @__PURE__ */ ((ShippingNoOptionReason2) => {
+  ShippingNoOptionReason2["INCOMPLETE"] = "INCOMPLETE";
+  ShippingNoOptionReason2["ADDRESS_MISMATCH"] = "ADDRESS_MISMATCH";
+  ShippingNoOptionReason2["NO_COVERAGE"] = "NO_COVERAGE";
+  ShippingNoOptionReason2["BLOCKED"] = "BLOCKED";
+  ShippingNoOptionReason2["NO_OPTION"] = "NO_OPTION";
+  return ShippingNoOptionReason2;
+})(ShippingNoOptionReason || {});
+var ShippingZoneError = /* @__PURE__ */ ((ShippingZoneError2) => {
+  ShippingZoneError2["NO_PLACES"] = "NO_PLACES";
+  ShippingZoneError2["INVALID_PLACE"] = "INVALID_PLACE";
+  ShippingZoneError2["DUPLICATE_PLACE"] = "DUPLICATE_PLACE";
+  ShippingZoneError2["NO_WEBSITE_OPTION"] = "NO_WEBSITE_OPTION";
+  ShippingZoneError2["INVALID_PRICE"] = "INVALID_PRICE";
+  ShippingZoneError2["INVALID_DAYS"] = "INVALID_DAYS";
+  ShippingZoneError2["INVALID_TIERS"] = "INVALID_TIERS";
+  ShippingZoneError2["NO_CHANNEL"] = "NO_CHANNEL";
+  ShippingZoneError2["PICKUP_WITHOUT_STORE"] = "PICKUP_WITHOUT_STORE";
+  ShippingZoneError2["MISSING_NAME"] = "MISSING_NAME";
+  return ShippingZoneError2;
+})(ShippingZoneError || {});
+
 // utils/currency.util.ts
 var CURRENCY_CONFIG = {
   // Major currencies with 2 decimal places
@@ -3404,6 +3470,318 @@ function planWindow({ rule, timeZone, presence, startAt, endAt, now, busy = [] }
 }
 var holdExpiresAt = (rule, now) => new Date(now.getTime() + (rule.window.holdMinutes ?? DEFAULT_HOLD_MINUTES) * 6e4);
 
+// shipping/fold-text.ts
+function foldText(value) {
+  return value.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, " ").trim();
+}
+
+// shipping/countries.ts
+var NOT_COUNTRIES = /* @__PURE__ */ new Set(["AC", "CP", "CQ", "DG", "EA", "EU", "EZ", "IC", "QO", "TA", "UN", "XA", "XB", "ZZ"]);
+var ALIASES = {
+  usa: "US",
+  "united states of america": "US",
+  uk: "GB",
+  "great britain": "GB",
+  england: "GB",
+  uae: "AE",
+  can: "CA",
+  mex: "MX",
+  aus: "AU",
+  gbr: "GB"
+};
+var NAME_LOCALES = ["en", "fr"];
+function regionNames(locale) {
+  try {
+    return new Intl.DisplayNames([locale], { type: "region", fallback: "none" });
+  } catch {
+    return null;
+  }
+}
+function canonicalCode(code) {
+  try {
+    return new Intl.Locale(`und-${code}`).maximize().region ?? code;
+  } catch {
+    return code;
+  }
+}
+function allCodes() {
+  const names = regionNames("en");
+  if (!names) return [];
+  const codes2 = [];
+  for (let a = 65; a <= 90; a++) {
+    for (let b = 65; b <= 90; b++) {
+      const code = String.fromCharCode(a, b);
+      if (!NOT_COUNTRIES.has(code) && names.of(code) && canonicalCode(code) === code) codes2.push(code);
+    }
+  }
+  return codes2;
+}
+var lookup = null;
+var codes = null;
+function countryCodes() {
+  codes ??= allCodes();
+  return codes;
+}
+function countryLookup() {
+  if (lookup) return lookup;
+  lookup = new Map(Object.entries(ALIASES));
+  for (const locale of NAME_LOCALES) {
+    const names = regionNames(locale);
+    if (!names) continue;
+    for (const code of countryCodes()) {
+      const name = names.of(code);
+      if (name) lookup.set(foldText(name), code);
+    }
+  }
+  return lookup;
+}
+function normalizeCountry(value) {
+  const text = (value ?? "").trim();
+  if (!text) return void 0;
+  const upper = text.toUpperCase();
+  if (upper.length === 2) {
+    if (NOT_COUNTRIES.has(upper)) return void 0;
+    const code = canonicalCode(upper);
+    if (countryCodes().includes(code)) return code;
+  }
+  return countryLookup().get(foldText(text));
+}
+function listCountries(locale = "en") {
+  const names = regionNames(locale) ?? regionNames("en");
+  return countryCodes().map((code) => ({ code, name: names?.of(code) ?? code })).sort((a, b) => a.name.localeCompare(b.name, locale));
+}
+
+// shipping/provinces.ts
+var CANADA_PROVINCES = [
+  { code: "AB", name: "Alberta", nameFr: "Alberta", postalLetters: ["T"] },
+  { code: "BC", name: "British Columbia", nameFr: "Colombie-Britannique", postalLetters: ["V"] },
+  { code: "MB", name: "Manitoba", nameFr: "Manitoba", postalLetters: ["R"] },
+  { code: "NB", name: "New Brunswick", nameFr: "Nouveau-Brunswick", postalLetters: ["E"] },
+  {
+    code: "NL",
+    name: "Newfoundland and Labrador",
+    nameFr: "Terre-Neuve-et-Labrador",
+    postalLetters: ["A"],
+    aliases: ["NF", "LB", "Newfoundland", "Labrador"]
+  },
+  { code: "NS", name: "Nova Scotia", nameFr: "Nouvelle-\xC9cosse", postalLetters: ["B"] },
+  { code: "NT", name: "Northwest Territories", nameFr: "Territoires du Nord-Ouest", postalLetters: ["X"] },
+  { code: "NU", name: "Nunavut", nameFr: "Nunavut", postalLetters: ["X"] },
+  { code: "ON", name: "Ontario", nameFr: "Ontario", postalLetters: ["K", "L", "M", "N", "P"] },
+  {
+    code: "PE",
+    name: "Prince Edward Island",
+    nameFr: "\xCEle-du-Prince-\xC9douard",
+    postalLetters: ["C"],
+    aliases: ["PEI"]
+  },
+  { code: "QC", name: "Quebec", nameFr: "Qu\xE9bec", postalLetters: ["G", "H", "J"], aliases: ["PQ"] },
+  { code: "SK", name: "Saskatchewan", nameFr: "Saskatchewan", postalLetters: ["S"] },
+  { code: "YT", name: "Yukon", nameFr: "Yukon", postalLetters: ["Y"], aliases: ["YK"] }
+];
+var PROVINCES_BY_COUNTRY = { CA: CANADA_PROVINCES };
+var lookups = /* @__PURE__ */ new Map();
+function provinceLookup(country) {
+  const provinces = PROVINCES_BY_COUNTRY[country];
+  if (!provinces) return void 0;
+  let lookup2 = lookups.get(country);
+  if (!lookup2) {
+    lookup2 = /* @__PURE__ */ new Map();
+    for (const p of provinces) {
+      for (const label of [p.code, p.name, p.nameFr, ...p.aliases ?? []]) lookup2.set(foldText(label), p.code);
+    }
+    lookups.set(country, lookup2);
+  }
+  return lookup2;
+}
+function normalizeProvince(country, value) {
+  if (!country || !value?.trim()) return void 0;
+  return provinceLookup(country)?.get(foldText(value));
+}
+function listProvinces(country) {
+  return PROVINCES_BY_COUNTRY[country] ?? [];
+}
+function provincesForPostCode(country, postCode) {
+  const letter = postCode?.charAt(0);
+  if (!country || !letter) return [];
+  return listProvinces(country).filter((p) => p.postalLetters.includes(letter)).map((p) => p.code);
+}
+
+// shipping/normalize.ts
+var EVERYWHERE_KEY = "*";
+function normalizeCityKey(value) {
+  const words = foldText(value ?? "").split(" ").filter(Boolean).map((word) => word === "saint" ? "st" : word === "sainte" ? "ste" : word);
+  return words.length ? words.join("") : void 0;
+}
+function normalizePostCode(value) {
+  const compact = (value ?? "").replace(/[^0-9a-z]/gi, "").toUpperCase();
+  return compact || void 0;
+}
+function normalizeAddress(address) {
+  if (!address) return {};
+  const country = normalizeCountry(address.country);
+  const postCode = normalizePostCode(address.postCode ?? address.postalCode ?? address.zip);
+  const fromPostCode = provincesForPostCode(country, postCode);
+  const province = normalizeProvince(country, address.state ?? address.province) ?? (fromPostCode.length === 1 ? fromPostCode[0] : void 0);
+  return { country, province, cityKey: normalizeCityKey(address.city), postCode };
+}
+function postCodeMatchesProvince(address) {
+  const candidates = provincesForPostCode(address.country, address.postCode);
+  if (!address.province || candidates.length === 0) return true;
+  return candidates.includes(address.province);
+}
+function placeKey(place) {
+  const country = normalizeCountry(place.country);
+  if (!country) return void 0;
+  if (!place.province) return country;
+  const province = normalizeProvince(country, place.province);
+  if (!province) return void 0;
+  if (!place.city) return `${country}-${province}`;
+  const city = normalizeCityKey(place.city);
+  return city ? `${country}-${province}/${city}` : void 0;
+}
+function addressPlaceKeys(address) {
+  const keys = [];
+  if (address.country && address.province && address.cityKey) {
+    keys.push(`${address.country}-${address.province}/${address.cityKey}`);
+  }
+  if (address.country && address.province) keys.push(`${address.country}-${address.province}`);
+  if (address.country) keys.push(address.country);
+  keys.push(EVERYWHERE_KEY);
+  return keys;
+}
+
+// shipping/resolve.ts
+function resolveShipping({ zones, address, itemsTotal, channel }) {
+  const shipsToCountries = countriesShippedTo(zones);
+  const none = (reason, zone2) => ({
+    zoneId: zone2?.id ?? null,
+    options: [],
+    reason,
+    message: zone2?.message?.trim() || null,
+    shipsToCountries
+  });
+  const normalized = normalizeAddress(address);
+  if (!normalized.country) return none("INCOMPLETE" /* INCOMPLETE */);
+  if (!postCodeMatchesProvince(normalized)) return none("ADDRESS_MISMATCH" /* ADDRESS_MISMATCH */);
+  const zone = findZone(zones, addressPlaceKeys(normalized));
+  if (!zone) return none("NO_COVERAGE" /* NO_COVERAGE */);
+  const offered = zone.options.filter((option) => isOffered(option, zone, channel));
+  if (offered.length === 0) {
+    return none(zone.ships ? "NO_OPTION" /* NO_OPTION */ : "BLOCKED" /* BLOCKED */, zone);
+  }
+  const quotes = offered.map((option) => quote(option, zone.id, itemsTotal));
+  const ship = quotes.filter((q) => q.type === "ship" /* SHIP */).sort((a, b) => a.amount - b.amount);
+  const pickup = quotes.filter((q) => q.type === "pickup" /* PICKUP */).sort((a, b) => a.amount - b.amount);
+  return {
+    zoneId: zone.id,
+    options: [...ship, ...pickup],
+    reason: null,
+    message: zone.ships ? null : zone.message?.trim() || null,
+    shipsToCountries
+  };
+}
+function findZone(zones, keys) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const zone of zones) {
+    for (const key of zoneKeys(zone)) if (!byKey.has(key)) byKey.set(key, zone);
+  }
+  for (const key of keys) {
+    const zone = byKey.get(key);
+    if (zone) return zone;
+  }
+  return void 0;
+}
+function zoneKeys(zone) {
+  if (zone.kind === "everywhere" /* EVERYWHERE */) return [EVERYWHERE_KEY];
+  return zone.places.map(placeKey).filter((key) => Boolean(key));
+}
+function isOffered(option, zone, channel) {
+  if (!option.channels.some((c) => c === channel)) return false;
+  if (option.type === "pickup" /* PICKUP */) return channel !== "pos" /* POS */;
+  return zone.ships;
+}
+function priceForTotal(option, itemsTotal) {
+  const tiers = [...option.priceByTotal ?? []].sort((a, b) => a.from - b.from);
+  let price = option.price;
+  for (const tier of tiers) if (itemsTotal >= tier.from) price = tier.price;
+  if (option.freeOver != null && itemsTotal >= option.freeOver) return 0;
+  return price;
+}
+function quote(option, zoneId, itemsTotal) {
+  const amount = priceForTotal(option, itemsTotal);
+  const freeOver = option.freeOver ?? null;
+  return {
+    optionId: option.id,
+    zoneId,
+    type: option.type,
+    name: option.name?.trim() || null,
+    amount,
+    amountToFree: freeOver != null && amount > 0 ? freeOver - itemsTotal : null,
+    minDays: option.minDays ?? null,
+    maxDays: option.maxDays ?? null,
+    outletId: option.outletId ?? null
+  };
+}
+function countriesShippedTo(zones) {
+  const countries = /* @__PURE__ */ new Set();
+  for (const zone of zones) {
+    if (!zone.ships) continue;
+    for (const key of zoneKeys(zone)) if (key !== EVERYWHERE_KEY) countries.add(key.slice(0, 2));
+  }
+  return [...countries].sort();
+}
+
+// shipping/validate.ts
+function validateShippingZone(zone) {
+  const problems = [...placeProblems(zone)];
+  for (const option of zone.options) problems.push(...optionProblems(option));
+  const reachesWebsite = zone.options.some((option) => option.channels.includes("web" /* WEB */));
+  if (zone.ships && !reachesWebsite) problems.push({ code: "NO_WEBSITE_OPTION" /* NO_WEBSITE_OPTION */ });
+  return problems;
+}
+function placeProblems(zone) {
+  if (zone.kind === "everywhere" /* EVERYWHERE */) {
+    return zone.places.length ? [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }] : [];
+  }
+  if (zone.places.length === 0) return [{ code: "NO_PLACES" /* NO_PLACES */ }];
+  if (!zone.places.every((place) => fitsKind(place, zone.kind))) return [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }];
+  const keys = zone.places.map(placeKey);
+  if (keys.some((key) => !key)) return [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }];
+  if (new Set(keys).size !== keys.length) return [{ code: "DUPLICATE_PLACE" /* DUPLICATE_PLACE */ }];
+  return [];
+}
+function fitsKind(place, kind) {
+  const hasProvince = Boolean(place.province?.trim());
+  const hasCity = Boolean(place.city?.trim());
+  if (kind === "country" /* COUNTRY */) return !hasProvince && !hasCity;
+  if (kind === "province" /* PROVINCE */) return hasProvince && !hasCity;
+  if (kind === "city" /* CITY */) return hasProvince && hasCity;
+  return false;
+}
+var isAmount = (value) => Number.isInteger(value) && value >= 0;
+var isDays = (value) => value == null || isAmount(value);
+function optionProblems(option) {
+  const problems = [];
+  const isPickup = option.type === "pickup" /* PICKUP */;
+  if (!isAmount(option.price) || option.freeOver != null && !isAmount(option.freeOver)) {
+    problems.push("INVALID_PRICE" /* INVALID_PRICE */);
+  }
+  if (!isPickup && !option.name?.trim()) problems.push("MISSING_NAME" /* MISSING_NAME */);
+  if (!isDays(option.minDays) || !isDays(option.maxDays) || (option.minDays ?? 0) > (option.maxDays ?? Infinity)) {
+    problems.push("INVALID_DAYS" /* INVALID_DAYS */);
+  }
+  if (!tiersAreValid(option)) problems.push("INVALID_TIERS" /* INVALID_TIERS */);
+  if (option.channels.length === 0) problems.push("NO_CHANNEL" /* NO_CHANNEL */);
+  if (isPickup && !option.outletId) problems.push("PICKUP_WITHOUT_STORE" /* PICKUP_WITHOUT_STORE */);
+  return problems.map((code) => ({ code, optionId: option.id }));
+}
+function tiersAreValid(option) {
+  const tiers = option.priceByTotal ?? [];
+  const froms = tiers.map((tier) => tier.from);
+  return tiers.every((tier) => Number.isInteger(tier.from) && tier.from > 0 && isAmount(tier.price)) && new Set(froms).size === froms.length;
+}
+
 // constants/adyen.constants.ts
 var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
 function isAdyenRolloutCountry(alpha2) {
@@ -3462,6 +3840,7 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   BookingResourceStatus,
   BookingRulesError,
   BookingType,
+  CANADA_PROVINCES,
   CONDITION_OPERATORS,
   COUNTRY_CURRENCIES,
   CURRENCY_CONFIG,
@@ -3478,6 +3857,7 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   DualWriteStrategy,
   EUFixedRates,
   EUROPE,
+  EVERYWHERE_KEY,
   ExtensionCategory,
   FINANCIAL_INVARIANTS,
   FULFILLMENT_STATES,
@@ -3528,6 +3908,12 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   SYSTEM_FAMILY_IDS,
   SYSTEM_UNITS,
   SYSTEM_UNIT_IDS,
+  ShippingChannel,
+  ShippingNoOptionReason,
+  ShippingOptionType,
+  ShippingRateType,
+  ShippingZoneError,
+  ShippingZoneKind,
   StationStatus,
   StripeCurrencyCode,
   StripeStatus,
@@ -3535,6 +3921,7 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   TopMetericsSort,
   UserTypes,
   addAmounts,
+  addressPlaceKeys,
   amountToString,
   assertUnitSane,
   availableIn,
@@ -3595,19 +3982,31 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   isSystemFamilyCode,
   isValidQuantity,
   isWhole,
+  listCountries,
+  listProvinces,
   mapToLegacyStatus,
   maxPrecisionFor,
   mergeFragment,
   multiplyAmount,
+  normalizeAddress,
+  normalizeCityKey,
+  normalizeCountry,
   normalizeMongoIdString,
+  normalizePostCode,
+  normalizeProvince,
   occupancyIn,
   parseAmountToMinorUnits,
   parseCurrencyCode,
   parseStripeCurrencyCode,
+  placeKey,
   planWindow,
+  postCodeMatchesProvince,
   presentAt,
+  priceForTotal,
+  provincesForPostCode,
   removeFragment,
   resolveFamily,
+  resolveShipping,
   resolveTemplate,
   resolveUnit,
   roundToPrecision,
@@ -3623,6 +4022,7 @@ var PAYMENT_CHANNELS = ["inPerson", "online"];
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
+  validateShippingZone,
   violatesFinancialInvariant,
   windowEndsAt,
   withinPresence