@zonos/elements 1.3.44 → 1.3.46

package/dist/collection/utils/formattedUrl.js

@@ -0,0 +1,80 @@
+// rollup and ts somehow can't compile this with absolute path
+// eslint-disable-next-line no-relative-import-paths/no-relative-import-paths
+import { generateVercelDeployUrl } from "./generateVercelDeployUrl";
+export const formattedUrl = ({ branchName, inCI: _inCI, inVercel: _inVercel, isVercelPreview: _isVercelPreview, packageVersion: _packageVersion, type = 'full', url, }) => {
+    if (!url) {
+        // return origin value so t3 can throw error when it's empty
+        return url;
+    }
+    const trimmedUrl = (_url) => _url === null || _url === void 0 ? void 0 : _url.replace('https://', '');
+    const domainOnlyUrl = trimmedUrl(url);
+    if (!_inCI && !_inVercel) {
+        // local host environment, no need to format url
+        return `https://${domainOnlyUrl}`;
+    }
+    const isProdBranch = branchName && ['main'].includes(branchName);
+    const isServerless = 
+    // url: route.js.zonos.com
+    domainOnlyUrl.includes('route.js') ||
+        // url: zonos-elements-serverless-git-something
+        domainOnlyUrl.includes('serverless-git');
+    const isTest = 
+    // url: test.js.zonos.com
+    domainOnlyUrl.includes('test.') ||
+        // url: zonos-elements-test-git-something
+        domainOnlyUrl.includes('test-git') ||
+        // url: something.preview.js.zonos.com (this is only applicable on preview deployment of `zonos-elements` and `zonos-elements-test`)
+        domainOnlyUrl.includes('preview.js.zonos.com');
+    if (isTest && isProdBranch) {
+        return `https://${domainOnlyUrl}`;
+    }
+    // always use vercel url if in vercel env, non-production branch (not qa or main branch) or the domain using is a test url
+    if ((_isVercelPreview && !isProdBranch) ||
+        isTest ||
+        (_inVercel && type === 'vercel-git')) {
+        // use vercel branch_url instead of the production url
+        if (!branchName) {
+            throw new Error('Fail to get vercel commit ref or branch name');
+        }
+        // get project name based on the `${url}`
+        const isStorybook = 
+        // url: storybook.js.zonos.com
+        domainOnlyUrl.includes('storybook.js') ||
+            // url: zonos-elements-storybook-git-something
+            domainOnlyUrl.includes('storybook-git');
+        const projectName = isStorybook
+            ? 'zonos-elements-storybook'
+            : isServerless
+                ? 'zonos-elements-serverless'
+                : 'zonos-elements';
+        // add -test suffix for test environment
+        const fullProjectName = isTest ? `${projectName}-test` : projectName;
+        // generate generated deploy url based on the branch name
+        const vercelGitBranchSuffix = generateVercelDeployUrl({
+            branchName,
+            projectName: fullProjectName,
+        });
+        return `https://${vercelGitBranchSuffix}`;
+    }
+    // only require package version in production and in CI, so that we still can use dev url (no version prefix).
+    if (!_packageVersion && (isProdBranch || _inCI)) {
+        throw new Error('package version is required');
+    }
+    const version = type === 'major' ? `${_packageVersion === null || _packageVersion === void 0 ? void 0 : _packageVersion.split('.')[0]}` : _packageVersion;
+    const isVersionedUrl = domainOnlyUrl === null || domainOnlyUrl === void 0 ? void 0 : domainOnlyUrl.startsWith('v');
+    const shouldAddVersion = (isProdBranch || _inCI) && !isVersionedUrl;
+    /**
+     * Trimming the `qa` from the domain url only when we add version prefix
+     * @reason We've now introduced alpha versioning for the QA branch deployment.
+     * However, we've generated the domain as `v1.2.4-alpha.1.js.zonos.com`, while the
+     * current CDN URL env uses `qa.js.zonos.com` on qa branch. This discrepancy causes
+     * this function to return an invalid alpha domain (v1.2.4-alpha.1.qa.js.zonos.com).
+     */
+    const trimmedQaUrl = shouldAddVersion
+        ? domainOnlyUrl === null || domainOnlyUrl === void 0 ? void 0 : domainOnlyUrl.replace('qa.js.zonos.com', 'js.zonos.com')
+        : domainOnlyUrl;
+    // only set version for the url once
+    return shouldAddVersion
+        ? `https://v${version}.${trimmedQaUrl}`
+        : `https://${trimmedQaUrl}`;
+};

package/dist/collection/utils/generateCloudflareDeployUrl.js

@@ -0,0 +1,21 @@
+/**
+ * Generate a Cloudflare deploy URL based on the branch name and project name
+ * @note not including https://
+ * @return {url} string
+ * @urlExample build-cloudflare-2.zonos-elements.page.dev
+ */
+export const generateCloudflareDeployUrl = ({ branchName, projectName, }) => {
+    const normalizedProjectName = projectName.toLowerCase().replace(/\s+/g, '-');
+    // remove dots and replace non-alphanumeric characters with dashes
+    const normalizedBranchName = branchName
+        .toLowerCase()
+        .replace(/\./g, '-') // Replace periods with hyphens
+        .replace(/\//g, '-') // Replace slashes with hyphens
+        .replace(/[^a-z0-9-_]/g, '') // Remove any characters that aren't alphanumeric, hyphens, or underscores
+        .replace(/-+/g, '-') // Collapse multiple hyphens into a single hyphen
+        .replace(/^-+|-+$/g, ''); // Trim hyphens from start and end
+    if (!normalizedProjectName || !normalizedBranchName) {
+        return null;
+    }
+    return `${normalizedBranchName}.${normalizedProjectName}.pages.dev`;
+};

package/dist/collection/utils/getGraphQlShortId.js

@@ -0,0 +1 @@
+export const getGraphQlShortId = (id) => { var _a; return ((_a = id === null || id === void 0 ? void 0 : id.match(/_(.*?)-/)) === null || _a === void 0 ? void 0 : _a[1]) || null; };

package/dist/esm/{cart-9f40efd7.js → cart-2198741e.js}

@@ -1,5 +1,5 @@
 import { c as createStore, z as zonosStore } from './zonosStore-8fc9ceb2.js';
-import { a as logError, l as log } from './logError-c456c092.js';
+import { l as log, a as logError } from './logError-c456c092.js';
 import { i as isDarkColor } from './isDarkColor-3119e351.js';
 import { g as getBorderRadius } from './getBorderRadius-3ba98361.js';
 
@@ -7171,6 +7171,57 @@ const translate = (...[key, replacement]) => {
     return ((_b = translationStore.translatedChunks[key]) === null || _b === void 0 ? void 0 : _b.value) || key;
 };
 
+const fallbackApiType = ['vercel', 'cloudflare'];
+const MAIN_BASE_API_TYPE = fallbackApiType[0];
+const fallbackApiList = {
+    cloudflare: "https://route.elements.zonos.com",
+    vercel: "https://v1.route.js.zonos.com",
+};
+const MAIN_BASE_API = fallbackApiList[MAIN_BASE_API_TYPE];
+/**
+ * Next available fallback api type
+ */
+const getNextFallbackApiType = (currentApiType = MAIN_BASE_API_TYPE) => {
+    const currentIndex = fallbackApiType.indexOf(currentApiType);
+    const nextFallbackApiType = fallbackApiType[currentIndex + 1];
+    if (!nextFallbackApiType) {
+        return null;
+    }
+    return nextFallbackApiType;
+};
+
+const sendErrorLog = async ({ endpoint, errors, metadata }) => {
+    const userAgentData = 'userAgentData' in window.navigator
+        ? // userAgentData is not yet supported in all browsers
+            window.navigator.userAgentData
+        : null;
+    const errorObject = {
+        endpoint,
+        errors,
+        metadata: Object.assign({ href: window.location.href, userAgent: userAgentData && userAgentData.brands.length > 0
+                ? userAgentData
+                : window.navigator.userAgent }, metadata),
+    };
+    try {
+        // use native fetch because in handleFetch also calls sendErrorLog and it will possibly cause circular dependencies issue
+        void fetch(`${MAIN_BASE_API}/api/zonos-elements/log-error`, {
+            body: JSON.stringify(errorObject),
+            method: 'POST',
+        });
+    }
+    catch (_err) {
+        const nextFallbackApi = getNextFallbackApiType();
+        if (!nextFallbackApi) {
+            return;
+        }
+        // request to the fallback API if the first one fails
+        void fetch(`${fallbackApiList[nextFallbackApi]}/api/zonos-elements/log-error`, {
+            body: JSON.stringify(errorObject),
+            method: 'POST',
+        });
+    }
+};
+
 var __rest = (undefined && undefined.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -7198,14 +7249,36 @@ const getResponseBody = async ({ response, shouldLog = true, shouldThrow = false
         return null;
     }
 };
-const handleRequest = async (url, options) => {
+const encodeString = (text) => {
+    try {
+        // encode the string, remove the "=" at the end of the encoded string
+        const encodedString = btoa(text).replace(/=/g, '');
+        return encodedString;
+    }
+    catch (error) {
+        // return the reverse string if the encoding failed
+        return text
+            .replace(/[^A-Za-z0-9]/g, '')
+            .split('')
+            .reverse()
+            .join('');
+    }
+};
+const handleRequest = async ({ basePathType, options, path, }) => {
     let response;
+    // fallback to the main base API if the passed in base path is not available
+    const baseUrl = fallbackApiList[basePathType] || MAIN_BASE_API_TYPE;
+    const url = baseUrl + path;
+    // adding random encoded token to the url so that the request will be cached differently for each store
+    const modifiedUrl = new URL(url);
+    modifiedUrl.searchParams.set('zToken', encodeString(window.location.hostname));
     try {
-        response = await fetch(url, options);
+        response = await fetch(modifiedUrl.toString(), options);
     }
     catch (e) {
         if (e instanceof Error) {
             return {
+                baseUrl,
                 errors: [{ message: e.message, type: 'unknown' }],
                 json: null,
                 response: null,
@@ -7214,6 +7287,7 @@ const handleRequest = async (url, options) => {
         }
         const message = 'Fail to fetch';
         return {
+            baseUrl,
             errors: [{ message, type: 'unknown' }],
             json: null,
             response: null,
@@ -7229,6 +7303,7 @@ const handleRequest = async (url, options) => {
     if (response.ok) {
         const data = await getResponseBody({ response });
         return {
+            baseUrl,
             errors: [],
             json: data,
             response,
@@ -7243,6 +7318,7 @@ const handleRequest = async (url, options) => {
         });
         const message = JSON.stringify(data);
         return {
+            baseUrl,
             errors: [{ message, type: status }],
             json: null,
             response,
@@ -7252,6 +7328,7 @@ const handleRequest = async (url, options) => {
     catch (e) {
         const message = 'Unknown error';
         return {
+            baseUrl,
             errors: [{ message: `${status}: ${message}`, type: status }],
             json: null,
             response: null,
@@ -7259,38 +7336,63 @@ const handleRequest = async (url, options) => {
         };
     }
 };
-function encodeString(text) {
-    try {
-        // encode the string, remove the "=" at the end of the encoded string
-        const encodedString = btoa(text).replace(/=/g, '');
-        return encodedString;
-    }
-    catch (error) {
-        // return the reverse string if the encoding failed
-        return text
-            .replace(/[^A-Za-z0-9]/g, '')
-            .split('')
-            .reverse()
-            .join('');
+const handleRequestWithFallback = async ({ basePathType, options, path, }) => {
+    const _a = await handleRequest({
+        basePathType,
+        options,
+        path,
+    }), { errors, response } = _a, rest = __rest(_a, ["errors", "response"]);
+    const nextFallbackApiType = getNextFallbackApiType(basePathType);
+    const unknownError = errors.find(({ type }) => type === 'unknown');
+    const shouldCallFallback = 
+    // If next fallback is available, and the error is unknown (fail to fetch) or 404
+    nextFallbackApiType && (!!unknownError || (response === null || response === void 0 ? void 0 : response.status) === 404);
+    if (shouldCallFallback) {
+        void sendErrorLog({
+            endpoint: fallbackApiList[basePathType] + path,
+            errors: errors.map(({ message }) => message),
+            metadata: {
+                currentBasePath: basePathType,
+                nextFallbackApiType,
+                status: response === null || response === void 0 ? void 0 : response.status,
+                statusText: response === null || response === void 0 ? void 0 : response.statusText,
+            },
+        });
+        log(`=== "${path}" failed to fetch, trying next fallback ${nextFallbackApiType}`);
+        return handleRequestWithFallback({
+            basePathType: nextFallbackApiType,
+            options,
+            path,
+        });
     }
-}
-const handleFetch = async (url, _opts) => {
+    // No more fallbacks, just return the result
+    return Object.assign({ errors, response }, rest);
+};
+/**
+ * Fetch request and will request to fallback API when the first one fails
+ * @param path Path name of the request (e.g. /api/something/com).
+ * @param _opts fetch options
+ */
+const handleFetch = async (path, _opts) => {
     const opts = __rest(_opts || {}, []);
     const body = opts.body ? JSON.stringify(opts.body) : undefined;
     const method = opts.method || 'GET';
-    // adding random encoded token to the url so that the request will be cached differently for each store
-    const modifiedUrl = new URL(url);
-    modifiedUrl.searchParams.set('zToken', encodeString(window.location.hostname));
     // headers content type
     const headers = Object.assign({ 'Content-Type': 'application/json', 'Zonos-Is-BigCommerce': window.Zonos.isBigCommerce.toString(), 'Zonos-Referer': window.location.hostname, 'Zonos-Version': window.Zonos.version, credentialtoken: window.Zonos.zonosApiKey || 'Empty credential token from zonos-elements' }, opts.headers);
     const options = Object.assign(Object.assign({}, opts), { body: method === 'GET' ? undefined : body, headers,
         method });
-    return handleRequest(modifiedUrl.toString(), options);
+    // This is for testing fallback API, set fallback API type to start with
+    const useFallbackApi = new URLSearchParams(window.location.search).get('useFallbackApi');
+    return handleRequestWithFallback({
+        basePathType: useFallbackApi || MAIN_BASE_API_TYPE,
+        options,
+        path,
+    });
 };
 
 const getCountries = async () => {
     try {
-        const { errors, json } = await handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/get-countries`, {
+        const { errors, json } = await handleFetch('/api/zonos-elements/get-countries', {
             method: 'GET',
         });
         if (errors.length || !json) {
@@ -7308,7 +7410,7 @@ const getCountryLandedCost = async (countryCode) => {
     if (!countryCode) {
         return null;
     }
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/country-landed-cost/${countryCode}`;
+    const url = `/api/zonos-elements/country-landed-cost/${countryCode}`;
     const { errors, json } = await handleFetch(url);
     if (errors.length || !json) {
         logError(`Error fetching country landed cost: ${(_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message}`);
@@ -7337,8 +7439,12 @@ const getExchangeRate = async ({ country, isGuaranteed, sourceCurrency, targetCu
     if (sourceCurrency === targetCurrency && !isGuaranteed) {
         return defaultUsExchangeRate;
     }
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/exchange-rates?sourceCurrency=${sourceCurrency}&targetCurrency=${targetCurrency}&isGuaranteed=${isGuaranteed}&country=${country}`;
-    const { errors, json } = await handleFetch(url);
+    const searchParams = new URLSearchParams();
+    searchParams.set('sourceCurrency', sourceCurrency);
+    searchParams.set('targetCurrency', targetCurrency);
+    searchParams.set('isGuaranteed', String(isGuaranteed));
+    searchParams.set('country', country || '');
+    const { errors, json } = await handleFetch(`/api/zonos-elements/exchange-rates?${searchParams.toString()}`);
     if (errors.length || !json) {
         logError(`Error fetching country landed cost: ${(_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message}`);
         return defaultUsExchangeRate;
@@ -7358,8 +7464,7 @@ const getInclusivePricing = async (countryCode) => {
     if (!countryCode) {
         return null;
     }
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/inclusive-prices/${countryCode}`;
-    const { errors, json } = await handleFetch(url);
+    const { errors, json } = await handleFetch(`/api/zonos-elements/inclusive-prices/${countryCode}`);
     if (errors.length || !json) {
         logError(`Error fetching country inclusive price setting: ${(_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message}`);
         return null;
@@ -7369,8 +7474,13 @@ const getInclusivePricing = async (countryCode) => {
 
 const getLocaleMessages = async ({ countryCode, localeTo, storeId, }) => {
     var _a;
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/locale-messages?countryCode=${countryCode}&storeId=${storeId}&localeTo=${localeTo}`;
-    const { errors, json } = await handleFetch(url);
+    const searchParams = new URLSearchParams();
+    searchParams.set('countryCode', countryCode);
+    searchParams.set('storeId', storeId.toString());
+    if (localeTo) {
+        searchParams.set('localeTo', localeTo);
+    }
+    const { errors, json } = await handleFetch(`/api/zonos-elements/locale-messages?${searchParams.toString()}`);
     if (errors.length || !json) {
         logError('Error fetching exchange rate', (_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message);
         return [];
@@ -7390,14 +7500,11 @@ const getLocalization = async () => {
         // load and use country from session storage when zCountry query param is not present
         const countryLoadedSession = window.sessionStorage.getItem('zonos--country');
         const zCountry = getZCountryUrlParam(currentUrl.searchParams) || countryLoadedSession;
-        const localizationUrl = new URL(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/localization`);
+        const searchParams = new URLSearchParams();
         if (zCountry) {
-            localizationUrl.searchParams.set('zCountry', zCountry);
+            searchParams.set('zCountry', zCountry);
         }
-        const fetchUrl = localizationUrl.href;
-        const { errors, json } = await handleFetch(fetchUrl, {
-            method: 'GET',
-        });
+        const { errors, json } = await handleFetch(`/api/zonos-elements/localization?${searchParams.toString()}`);
         if (errors.length || !json) {
             return { country: null, locale: null };
         }
@@ -7413,8 +7520,7 @@ const getLocalization = async () => {
 
 const getShippingZones = async () => {
     var _a, _b;
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/shipping-zones`;
-    const { errors, json } = await handleFetch(url);
+    const { errors, json } = await handleFetch('/api/zonos-elements/shipping-zones');
     if (errors.length || !json) {
         logError(`Error fetching shipping zones: ${(_a = errors.find(Boolean)) === null || _a === void 0 ? void 0 : _a.message}`);
         return null;
@@ -7821,7 +7927,7 @@ const updateCheckoutSessionLanguage = async () => {
     if (!cartStore.checkoutSessionId) {
         return null;
     }
-    const { errors, json } = await handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/update-checkout-session-metadata`, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/update-checkout-session-metadata', {
         body: {
             id: cartStore.checkoutSessionId,
             metadata: [
@@ -7933,13 +8039,13 @@ const triggerBuildLandedCost = async (buildLandedCost) => {
         checkoutSessionId: data.checkoutSessionId,
         contact: data.contact,
         shippingAddress: data.shippingAddress,
-        zonosApiRoute: "https://v1.route.js.zonos.com",
+        zonosApiRoute: MAIN_BASE_API,
     });
     if (!landedCost || ((_a = landedCost.errors) === null || _a === void 0 ? void 0 : _a.length)) {
         throw new Error(`Failed to build landed cost: ${((_c = (_b = landedCost === null || landedCost === void 0 ? void 0 : landedCost.errors) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) || 'Unknown error'}`);
     }
     // Validate the landed cost object to make sure the returned value from buildLandedCost has a valid schema
-    const { errors, json } = await handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/validate-landed-cost`, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/validate-landed-cost', {
         body: landedCost,
         headers: {
             'Content-Type': 'application/json',
@@ -7961,8 +8067,7 @@ const calculateLandedCost = async (abortController) => {
         return json;
     }
     // request to get landed cost info
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/calculate-landed-cost`;
-    const { errors, json } = await handleFetch(url, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/calculate-landed-cost', {
         body: prepCalculateLandedCost(),
         method: 'POST',
         signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal,
@@ -8493,13 +8598,11 @@ const stripeStoreInitCheckoutSession = async () => {
         return false;
     }
     stripeStore.isFetchingSession = true;
-    const { errors, json } = await handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/create-checkout-session`, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/create-checkout-session', {
         body: {
             currency: ((_a = cartStore.items.find(Boolean)) === null || _a === void 0 ? void 0 : _a.currencyCode) || '',
             itemsAmount: total,
-            metadata: [
-                { key: 'language', value: localizationStore.selectedLocale },
-            ],
+            metadata: [{ key: 'language', value: localizationStore.selectedLocale }],
             presentmentCountryCode: localizationStore.selectedCountryCode || null,
         },
         method: 'POST',
@@ -8524,7 +8627,7 @@ const stripeStoreInitCheckoutSession = async () => {
 const stripeStoreUpdateCheckoutSession = async ({ currency, id, itemsAmount, landedCostId, presentmentCountryCode, }) => {
     // No need to set loading state here because this function will be called under the hood to update
     // landed cost id for the section.
-    const { errors, json } = await handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/update-checkout-session`, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/update-checkout-session', {
         body: {
             currency,
             id,
@@ -8623,8 +8726,7 @@ const stripeStoreTranslateAddressToLatin = async ({ addressInvalidCharactersList
     if (!isAddressOutdated) {
         return;
     }
-    const routeUrl = "https://v1.route.js.zonos.com";
-    const { errors, json } = await handleFetch(`${routeUrl}/api/zonos-elements/validate-address`, {
+    const { errors, json } = await handleFetch('/api/zonos-elements/validate-address', {
         body: requestBody,
         method: 'POST',
     });
@@ -8982,4 +9084,4 @@ const cartStoreResetTabItems = () => {
     cartStoreResetSelectedShippingOption();
 };
 
-export { getZCountryUrlParam as A, setZCountryUrlParam as B, currencyDisplay as C, currencyConvertAndFormat as D, currencyConvert as E, currencyFormat as F, cartStoreHasOneEligibleItem as G, stripeStoreRetrievePayment as H, stripeStoreMessageBasedOnStatus as I, stripeStoreTranslateAddressToLatin as J, cartStoreUpdateSelectedShippingOption as K, cartStoreGetShippingTransitInfo as L, localizationStoreUpdateSelectedLocale as M, localizationStoreUpdateSelectedCountryCode as a, stripeStoreCleanupDomesticShippingSession as b, stripeStoreSaveDomesticShippingSession as c, cartStore as d, cartStoreUpdateItems as e, cartStoreReset as f, cartStoreResetTabItems as g, cartStoreClearCheckoutInterval as h, initStripeElements as i, stripeStore as j, stripeStoreInitCheckoutSession as k, localizationStore as l, cartStoreStartCheckoutInterval as m, cartStoreUpdateToErrorState as n, stripeStorePrefetchLandedCost as o, cartStoreNextStep as p, stripeStoreHandleInventoryCheck as q, stripeStoreConfirmPayment as r, stripeStoreGetDomesticShippingSession as s, translate as t, stripeStoreReset as u, localizationStoreOnUpdate as v, handleFetch as w, jsonParse as x, isValidSelector as y, initLocalizationStore as z };
+export { initLocalizationStore as A, getZCountryUrlParam as B, setZCountryUrlParam as C, currencyDisplay as D, currencyConvertAndFormat as E, currencyConvert as F, currencyFormat as G, cartStoreHasOneEligibleItem as H, stripeStoreRetrievePayment as I, stripeStoreMessageBasedOnStatus as J, stripeStoreTranslateAddressToLatin as K, cartStoreUpdateSelectedShippingOption as L, cartStoreGetShippingTransitInfo as M, localizationStoreUpdateSelectedLocale as N, localizationStoreUpdateSelectedCountryCode as a, stripeStoreCleanupDomesticShippingSession as b, sendErrorLog as c, stripeStoreSaveDomesticShippingSession as d, cartStore as e, cartStoreUpdateItems as f, cartStoreReset as g, cartStoreResetTabItems as h, initStripeElements as i, cartStoreClearCheckoutInterval as j, stripeStore as k, localizationStore as l, stripeStoreInitCheckoutSession as m, cartStoreStartCheckoutInterval as n, cartStoreUpdateToErrorState as o, stripeStorePrefetchLandedCost as p, cartStoreNextStep as q, stripeStoreHandleInventoryCheck as r, stripeStoreGetDomesticShippingSession as s, translate as t, stripeStoreConfirmPayment as u, stripeStoreReset as v, localizationStoreOnUpdate as w, handleFetch as x, jsonParse as y, isValidSelector as z };

package/dist/esm/{sendErrorLog-aea606c0.js → createCustomEvent-451d7879.js}

@@ -1,4 +1,4 @@
-import { w as handleFetch, d as cartStore, l as localizationStore } from './cart-9f40efd7.js';
+import { x as handleFetch, e as cartStore, l as localizationStore } from './cart-2198741e.js';
 import { z as zonosStore } from './zonosStore-8fc9ceb2.js';
 
 const trackConversionEvent = async (eventName, metadata) => {
@@ -13,7 +13,6 @@ const trackConversionEvent = async (eventName, metadata) => {
         !window.Zonos.zonosConversionTest) {
         return;
     }
-    const url = `${"https://v1.route.js.zonos.com"}/api/zonos-elements/track-conversion-event`;
     const countryCode = localizationStore.selectedCountryCode;
     const organizationId = zonosStore.organizationId;
     const checkoutSessionId = cartStore.checkoutSessionId;
@@ -28,7 +27,7 @@ const trackConversionEvent = async (eventName, metadata) => {
         metadata,
         organizationId,
     };
-    await handleFetch(url, {
+    await handleFetch('/api/zonos-elements/track-conversion-event', {
         body,
         method: 'POST',
     });
@@ -46,22 +45,4 @@ const createCustomEvent = (eventName, detail) => {
     });
 };
 
-const sendErrorLog = async ({ endpoint, errors, metadata }) => {
-    const userAgentData = 'userAgentData' in window.navigator
-        ? // userAgentData is not yet supported in all browsers
-            window.navigator.userAgentData
-        : null;
-    const errorObject = {
-        endpoint,
-        errors,
-        metadata: Object.assign({ href: window.location.href, userAgent: userAgentData && userAgentData.brands.length > 0
-                ? userAgentData
-                : window.navigator.userAgent }, metadata),
-    };
-    void handleFetch(`${"https://v1.route.js.zonos.com"}/api/zonos-elements/log-error`, {
-        body: errorObject,
-        method: 'POST',
-    });
-};
-
-export { createCustomEvent as c, getIsTestMode as g, sendErrorLog as s, trackConversionEvent as t };
+export { createCustomEvent as c, getIsTestMode as g, trackConversionEvent as t };

package/dist/esm/index.js

@@ -90,13 +90,17 @@ const getZonosQaUrl = () => {
         return null;
     }
     const qaUrl = extractZonosQaUrl(window.location.href);
-    const cdnUrl = "https://v1.3.44.js.zonos.com";
+    const cdnUrl = "https://v1.3.46.js.zonos.com";
     // when the qaUrl is not set and the built URL is from the test domain, use the test domain for testing
-    if (!qaUrl && cdnUrl.includes('test.')) {
+    if (!qaUrl &&
+        (cdnUrl.includes('test.') ||
+            // Vercel git domain
+            cdnUrl.includes('test-'))) {
         return cdnUrl;
     }
     // when local demo app is running, it needs to use the local dev script unless the qaUrl is set
-    if (!qaUrl && window.location.hostname === 'dev.demo.elements.zonos.com') {
+    if (!qaUrl &&
+        ['dev.demo.elements.zonos.com'].includes(window.location.hostname)) {
         return 'https://dev.elements.zonos.com';
     }
     if (!qaUrl) {
@@ -260,10 +264,10 @@ const zonosLoadUrl = (() => {
     }
     return null;
 })();
-const ZONOS_URL = "https://v1.3.44.js.zonos.com";
-const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.44";
-const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.44";
-const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.44";
+const ZONOS_URL = "https://v1.3.46.js.zonos.com";
+const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.46";
+const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.46";
+const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.46";
 const MAIN_LOAD_CDN_TYPE = 'jsdelivr';
 const INTER_FONT_URL = 'https://rsms.me';
 const GOOGLE_FONT_URL = 'https://fonts.googleapis.com';
@@ -284,7 +288,7 @@ Zonos.isBigCommerce = false;
  */
 Zonos.isNpm = true;
 Zonos.zonosQaUrl = null;
-Zonos.version = `v${"1.3.44"}`;
+Zonos.version = `v${"1.3.46"}`;
 Zonos.modeAlerted = false;
 Zonos.tempCartData = null;
 Zonos.paypal = null;