@zonos/elements 1.5.1 → 1.5.2

package/dist/collection/components/utils/logging/installConstructorCapture.js

@@ -0,0 +1,58 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const constructorNotFound = /^Constructor for .+ was not found/;
+const constructorTag = /^Constructor for "?([^#"]+)#/;
+const recordConstructorFailure = (value) => {
+    var _a;
+    const message = thrownMessage(value, '');
+    if (!message || !constructorNotFound.test(message)) {
+        return;
+    }
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const capture = window.__zonosConstructorCapture;
+    if (!capture) {
+        return;
+    }
+    const tagMatch = constructorTag.exec(message);
+    const tag = (_a = tagMatch === null || tagMatch === void 0 ? void 0 : tagMatch[1]) !== null && _a !== void 0 ? _a : '';
+    if (capture.reported.has(tag)) {
+        return;
+    }
+    capture.reported.add(tag);
+    void sendErrorLog({
+        endpoint: 'stencil://constructor',
+        errors: [message],
+        metadata: {
+            shape: 'constructor-not-found',
+            tag,
+        },
+    });
+};
+/**
+ * Copy a missing-constructor failure onto the existing error log.
+ * Stencil catches `Constructor for "tag#mode" was not found` and passes that
+ * Error to `console.error`. One report is sent per tag, then the original
+ * console.error still runs. This does not request the chunk again.
+ */
+export const installConstructorCapture = () => {
+    if (window.__zonosConstructorCapture) {
+        return;
+    }
+    const listener = (event) => {
+        recordConstructorFailure(event.reason);
+    };
+    window.__zonosConstructorCapture = {
+        listener,
+        reported: new Set(),
+    };
+    window.addEventListener('unhandledrejection', listener);
+    // eslint-disable-next-line no-console -- Stencil reports the missing constructor here
+    const originalError = console.error.bind(console);
+    // eslint-disable-next-line no-console -- record the Stencil diagnostic, then forward it
+    console.error = (...data) => {
+        recordConstructorFailure(data[0]);
+        originalError(...data);
+    };
+};

package/dist/collection/components/utils/logging/reportBlockedStorage.js

@@ -0,0 +1,34 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const reportedIds = () => {
+    if (!window.__zonosReportedBlockedStorage) {
+        window.__zonosReportedBlockedStorage = new Set();
+    }
+    return window.__zonosReportedBlockedStorage;
+};
+/**
+ * Record a blocked storage read or write on the existing error log.
+ * A throw before `window.Zonos` exists is swallowed and does not use up
+ * the per-page dedupe slot, so the later startup read can still report it.
+ */
+export const reportBlockedStorage = (area, operation, key, error) => {
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const dedupeId = `${area}\u0000${operation}\u0000${key}`;
+    const reported = reportedIds();
+    if (reported.has(dedupeId)) {
+        return;
+    }
+    reported.add(dedupeId);
+    void sendErrorLog({
+        endpoint: `storage://${area}/${key}`,
+        errors: [thrownMessage(error, 'SecurityError')],
+        metadata: {
+            area,
+            key,
+            operation,
+            shape: 'blocked-storage',
+        },
+    });
+};

package/dist/collection/components/utils/logging/sendErrorLog.js

@@ -5,6 +5,13 @@ import { log } from "./log";
  * @default 1 hour
  */
 const postReleaseReportingDuration = 1 * 3600 * 1000; // 1 hour
+const loggedHref = () => {
+    const url = new URL(window.location.href);
+    url.searchParams.delete('payment_intent');
+    url.searchParams.delete('payment_intent_client_secret');
+    url.searchParams.delete('redirect_status');
+    return url.toString();
+};
 export const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostReleaseErrorReporting, }) => {
     log('sendErrorLog', 'warn', endpoint, metadata, errors);
     if (shouldPostReleaseErrorReporting) {
@@ -22,7 +29,7 @@ export const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostRelea
     const errorObject = {
         endpoint,
         errors,
-        href: window.location.href,
+        href: loggedHref(),
         metadata: Object.assign({ appVersion: window.Zonos.version, domain: window.Zonos.domain, publicCredential: window.Zonos.zonosApiKey, userAgent: userAgentData && userAgentData.brands.length > 0
                 ? userAgentData
                 : window.navigator.userAgent }, metadata),

package/dist/collection/components/utils/logging/startZonosInit.js

@@ -0,0 +1,35 @@
+import { sendErrorLog } from "./sendErrorLog";
+import { thrownMessage } from "./thrownMessage";
+const reportInitRejection = (error) => {
+    // sendErrorLog prints only when zonosDebug is on. Keep the failure in the
+    // merchant console without leaving an unhandled rejection.
+    // eslint-disable-next-line no-console -- the page console is the support signal
+    console.error(error);
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    void sendErrorLog({
+        endpoint: 'zonos://init',
+        errors: [thrownMessage(error, 'Unknown init rejection')],
+        metadata: {
+            shape: 'init-rejection',
+        },
+    });
+};
+/**
+ * Run an init that the caller is not waiting on. The rejection is recorded
+ * and not rethrown, so startup does not become an unhandled rejection.
+ */
+export const startZonosInit = (start) => {
+    let pending;
+    try {
+        pending = start();
+    }
+    catch (error) {
+        reportInitRejection(error);
+        return;
+    }
+    void pending.catch((error) => {
+        reportInitRejection(error);
+    });
+};

package/dist/collection/components/utils/logging/thrownMessage.js

@@ -0,0 +1,16 @@
+export const thrownMessage = (error, fallback) => {
+    if (typeof error === 'string' && error) {
+        return error;
+    }
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        error.message) {
+        return error.message;
+    }
+    return fallback;
+};

package/dist/collection/components/utils/safeStorage.js

@@ -0,0 +1,39 @@
+import { reportBlockedStorage, } from "./logging/reportBlockedStorage";
+/**
+ * Touch `window.localStorage` / `window.sessionStorage` inside the try.
+ * Safari throws SecurityError on the getter itself when storage is blocked.
+ * A missing storage object is the same failure: calling `getItem` on it
+ * would report a TypeError instead of blocked storage.
+ */
+const storageFor = (area) => {
+    const storage = area === 'local' ? window.localStorage : window.sessionStorage;
+    if (!storage) {
+        throw new DOMException('', 'SecurityError');
+    }
+    return storage;
+};
+export const safeGetItem = (area, key) => {
+    try {
+        return storageFor(area).getItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'getItem', key, error);
+        return null;
+    }
+};
+export const safeRemoveItem = (area, key) => {
+    try {
+        storageFor(area).removeItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'removeItem', key, error);
+    }
+};
+export const safeSetItem = (area, key, value) => {
+    try {
+        storageFor(area).setItem(key, value);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'setItem', key, error);
+    }
+};

package/dist/collection/scripts/_getZonosQaUrl.js

@@ -1,4 +1,5 @@
 import { log } from "../components/utils/logging/log";
+import { safeRemoveItem } from "../components/utils/safeStorage";
 import { extractZonosQaUrl, extractZonosQaUrlApi, } from "./_extractZonosQaUrl";
 /**
  * Get the Zonos QA URL and return it. Will remove `zonosQaUrl` from the url query if it doesn't exists.
@@ -49,8 +50,8 @@ export const getZonosQaUrl = () => {
     void fetch(fullUrl)
         .then(() => {
         // cleanup checkout session to avoid using the prod session in preview domain
-        window.sessionStorage.removeItem('zonos--checkout-session-id');
-        window.sessionStorage.removeItem('zonos--client-secret');
+        safeRemoveItem('session', 'zonos--checkout-session-id');
+        safeRemoveItem('session', 'zonos--client-secret');
     })
         .catch(() => {
         alert(`[ZONOS-WARNING] '${fullUrl}' IS NO LONGER AVAILABLE. REMOVING zonosQaUrl PARAM AND RELOADING THE PAGE`);

package/dist/collection/scripts/_zonosBase.js

@@ -1,8 +1,11 @@
 var _a;
 import { createCustomEvent } from "../components/utils/createCustomEvent";
 import { IframeService } from "../components/utils/iframe/IframeHelpers";
+import { installConstructorCapture } from "../components/utils/logging/installConstructorCapture";
 import { log } from "../components/utils/logging/log";
 import { logError } from "../components/utils/logging/logError";
+import { startZonosInit } from "../components/utils/logging/startZonosInit";
+import { safeGetItem } from "../components/utils/safeStorage";
 import { checkIfLoadVersionDomain } from "./_checkIfLoadVersionDomain";
 import { getNextFallbackUrl, MAIN_LOAD_CDN_TYPE, } from "./_getNextFallbackUrl";
 import { getWithTestPublicCredential } from "./_getWithTestPublicCredential";
@@ -85,6 +88,7 @@ Zonos.zonosController = null;
 Zonos.loadTimeApiInfoList = [];
 Zonos.logIntervalId = null;
 Zonos.init = async (params) => {
+    installConstructorCapture();
     const { appearance, checkoutSettings, currencyConverter, helloSettings, onCountryChange, overrideCurrencyFormat, storeId, zonosApiKey, } = params;
     _a.cartId = getCartIdFromQueryParam();
     // Expose the checkout cart callbacks on the global so Stripe loading can be
@@ -120,7 +124,7 @@ Zonos.init = async (params) => {
                 window.Zonos.isLegacyCheckout = _a.isLegacyCheckout;
                 window.Zonos.zonosMode = _a.zonosMode;
                 // call init again after the script is loaded
-                void window.Zonos.init(params);
+                startZonosInit(() => window.Zonos.init(params));
             });
             script.addEventListener('error', () => {
                 alert(`[ZONOS - loadZonos] Failed to load "loadZonos.js" from zonosQaUrl: ${zonosQaUrl}`);
@@ -156,7 +160,7 @@ Zonos.init = async (params) => {
         }
     }
     // Check if the stripe client secret is available in the url or session storage, inject hidden button to trigger checkout right away to check status of client secret
-    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || sessionStorage.getItem('zonos--client-secret');
+    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || safeGetItem('session', 'zonos--client-secret');
     const shouldAttemptImmediatelyOpenCheckout = (_a.cartId && _a.cartData) || !!clientSecretUrlParam;
     // inject hidden button to body to trigger checkout right away if we have cartData or stripe client secret
     if (shouldAttemptImmediatelyOpenCheckout) {

package/dist/collection/types/generated/graphql.frontend.types.js

@@ -665,14 +665,6 @@ export function getSdk(client, withWrapper = defaultWrapper) {
                 variables,
             }), 'insertOrderImportLock', 'mutation', variables);
         },
-        insertReserveOrder(variables, requestHeaders, signal) {
-            return withWrapper(wrappedRequestHeaders => client.request({
-                document: '',
-                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
-                signal,
-                variables,
-            }), 'insertReserveOrder', 'mutation', variables);
-        },
         insertReserveOrderEvent(variables, requestHeaders, signal) {
             return withWrapper(wrappedRequestHeaders => client.request({
                 document: '',
@@ -713,14 +705,6 @@ export function getSdk(client, withWrapper = defaultWrapper) {
                 variables,
             }), 'storeVersionSetting', 'query', variables);
         },
-        updateReserveOrder(variables, requestHeaders, signal) {
-            return withWrapper(wrappedRequestHeaders => client.request({
-                document: '',
-                requestHeaders: Object.assign(Object.assign({}, requestHeaders), wrappedRequestHeaders),
-                signal,
-                variables,
-            }), 'updateReserveOrder', 'mutation', variables);
-        },
         upsertBigCommerceSettings(variables, requestHeaders, signal) {
             return withWrapper(wrappedRequestHeaders => client.request({
                 document: '',