@funnelfox/billing 0.7.1 → 0.8.0-add-release-docs.8

package/dist/chunk-index.es.js

@@ -368,6 +368,9 @@ function generateUUID() {
         return v.toString(16);
     });
 }
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -486,7 +489,7 @@ var PaymentMethod;
 /**
  * @fileoverview Constants for Funnefox SDK
  */
-const SDK_VERSION = '0.7.1';
+const SDK_VERSION = '0.8.0-add-release-docs.8';
 const DEFAULTS = {
     BASE_URL: 'https://billing.funnelfox.com',
     REGION: 'default',
@@ -720,7 +723,7 @@ class PrimerWrapper {
         }
         catch (error) {
             onMethodRenderError(allowedPaymentMethod);
-            throw new PrimerError('Failed to initialize Primer checkout', error);
+            throw new PrimerError(`Failed to initialize Primer checkout method ${allowedPaymentMethod}`, error);
         }
     }
     async initMethod(method, htmlNode, options) {
@@ -754,7 +757,7 @@ class PrimerWrapper {
             }
         }
         catch (error) {
-            throw new PrimerError('Failed to initialize Primer checkout', error);
+            throw new PrimerError(`Failed to initialize Primer checkout method ${method}`, error);
         }
     }
     async renderCardCheckoutWithElements(elements, { onSubmit, onInputChange, onCardInputValueChange, isCardholderNameRequired, isPostalCodeRequired, onMethodRenderError, onMethodRender, }) {
@@ -914,7 +917,7 @@ class PrimerWrapper {
         }
         catch (error) {
             onMethodRenderError(PaymentMethod.PAYMENT_CARD);
-            throw new PrimerError('Failed to initialize Primer checkout', error);
+            throw new PrimerError('Failed to initialize Primer checkout method PAYMENT_CARD', error);
         }
     }
     async initializeHeadlessCheckout(clientToken, primerOptions, method) {
@@ -1054,6 +1057,9 @@ class PrimerWrapper {
         }
         return element;
     }
+    refreshClientSession() {
+        return this.currentHeadless?.then(headless => headless.refreshClientSession());
+    }
 }
 PrimerWrapper.headlessManager = new HeadlessManager();
 
@@ -1493,6 +1499,216 @@ async function loadAirwallexDeviceFingerprint(sessionId, isLivemode = true) {
     });
 }
 
+const MAX_QUERY_LENGTH = 1800;
+function getErrorImage(orgId, options) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const params = new URLSearchParams({
+        message: truncate(options.message, 500),
+        code: options.code || 'SDK_ERROR',
+        timestamp: Date.now().toString(),
+        sdk_version: SDK_VERSION,
+    });
+    if (options.req_id) {
+        appendIfFits(params, 'req_id', options.req_id, MAX_QUERY_LENGTH);
+    }
+    if (options.context) {
+        Object.entries(options.context).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                appendIfFits(params, key, truncate(String(value), 1000), MAX_QUERY_LENGTH);
+            }
+        });
+    }
+    const origin = (options.baseUrl || DEFAULTS.BASE_URL).replace(/\/$/, '');
+    const url = `${origin}/sdk_report/${encodeURIComponent(orgId)}/crash?${params.toString()}`;
+    const img = new Image();
+    img.src = url;
+    img.style.display = 'none';
+    img.onload = () => {
+        img.remove();
+    };
+    img.onerror = () => {
+        img.remove();
+    };
+    (document.body || document.documentElement)?.appendChild(img);
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+function appendIfFits(params, key, value, maxLength) {
+    const nextParams = new URLSearchParams(params);
+    nextParams.append(key, value);
+    if (nextParams.toString().length > maxLength) {
+        return false;
+    }
+    params.append(key, value);
+    return true;
+}
+
+let activeScope = null;
+const recentSignatures = new Map();
+const DEDUPE_WINDOW_MS = 3000;
+let isListening = false;
+function startUnhandledErrorTelemetry(scope) {
+    if (!scope.enabled || !isBrowser()) {
+        return () => { };
+    }
+    activeScope = scope;
+    attachListeners();
+    return () => {
+        stopUnhandledErrorTelemetry(scope.id);
+    };
+}
+function stopUnhandledErrorTelemetry(scopeId) {
+    if (activeScope?.id === scopeId) {
+        activeScope = null;
+        recentSignatures.clear();
+        detachListeners();
+    }
+}
+function attachListeners() {
+    if (isListening || typeof window === 'undefined') {
+        return;
+    }
+    window.addEventListener('error', handleWindowError);
+    window.addEventListener('unhandledrejection', handleUnhandledRejection);
+    isListening = true;
+}
+function detachListeners() {
+    if (!isListening || typeof window === 'undefined') {
+        return;
+    }
+    window.removeEventListener('error', handleWindowError);
+    window.removeEventListener('unhandledrejection', handleUnhandledRejection);
+    isListening = false;
+}
+function handleWindowError(event) {
+    const normalized = normalizeError(event.error || event.message || 'Unhandled browser error', 'UNHANDLED_ERROR');
+    reportToActiveScopes(normalized, {
+        event_type: 'error',
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+    });
+}
+function handleUnhandledRejection(event) {
+    const normalized = normalizeError(event.reason || 'Unhandled promise rejection', 'UNHANDLED_REJECTION');
+    reportToActiveScopes(normalized, {
+        event_type: 'unhandledrejection',
+    });
+}
+function reportToActiveScopes(error, eventContext) {
+    if (!activeScope) {
+        return;
+    }
+    if (!canReport(error, eventContext.event_type)) {
+        return;
+    }
+    try {
+        const context = activeScope.getContext();
+        getErrorImage(activeScope.orgId, {
+            baseUrl: activeScope.baseUrl,
+            message: `${error.name}: ${error.message}`,
+            code: error.code,
+            context: {
+                ...eventContext,
+                order_id: context.orderId,
+                price_id: context.priceId,
+                page_url: getPageUrl(),
+            },
+        });
+    }
+    catch {
+        // Telemetry must never affect checkout behavior.
+    }
+}
+function canReport(error, eventType) {
+    const now = Date.now();
+    pruneExpiredSignatures(now);
+    const signature = buildSignature(error, eventType);
+    const previousReportTime = recentSignatures.get(signature);
+    if (typeof previousReportTime === 'number' &&
+        now - previousReportTime < DEDUPE_WINDOW_MS) {
+        return false;
+    }
+    recentSignatures.set(signature, now);
+    return true;
+}
+function pruneExpiredSignatures(now) {
+    recentSignatures.forEach((timestamp, signature) => {
+        if (now - timestamp >= DEDUPE_WINDOW_MS) {
+            recentSignatures.delete(signature);
+        }
+    });
+}
+function buildSignature(error, eventType) {
+    const firstStackLine = error.stack?.split('\n')[0] || '';
+    return [
+        eventType || '',
+        error.code || '',
+        error.message || '',
+        firstStackLine,
+    ].join('|');
+}
+function normalizeError(reason, fallbackCode) {
+    if (reason instanceof Error) {
+        return {
+            name: reason.name || 'Error',
+            message: reason.message || 'Unknown error',
+            code: getErrorCode(reason, fallbackCode),
+            stack: reason.stack,
+        };
+    }
+    if (typeof reason === 'object' && reason !== null) {
+        const record = reason;
+        return {
+            name: toSafeString(record.name) || 'Error',
+            message: toSafeString(record.message) || safeStringify(reason),
+            code: toSafeString(record.code) || fallbackCode,
+            stack: toSafeString(record.stack),
+        };
+    }
+    return {
+        name: 'Error',
+        message: toSafeString(reason) || 'Unknown error',
+        code: fallbackCode,
+    };
+}
+function getErrorCode(error, fallbackCode) {
+    const record = error;
+    return typeof record.code === 'string' && record.code
+        ? record.code
+        : fallbackCode;
+}
+function toSafeString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return '';
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'Unserializable error';
+    }
+}
+function getPageUrl() {
+    if (typeof window === 'undefined' || !window.location) {
+        return '';
+    }
+    const location = window.location;
+    if (location.origin && location.pathname) {
+        return `${location.origin}${location.pathname}`;
+    }
+    return (location.href || '').split(/[?#]/)[0];
+}
+
 /**
  * @fileoverview Checkout instance manager for Funnefox SDK
  */
@@ -1502,6 +1718,8 @@ class CheckoutInstance extends EventEmitter {
         this.counter = 0;
         this.cachedSessionResponse = null;
         this.cardSessionFieldConfig = {};
+        this.isTelemetryEnabled = false;
+        this.telemetryCleanup = null;
         this.handleInputChange = (inputName, error) => {
             this.emit(EVENTS.INPUT_ERROR, { name: inputName, error });
         };
@@ -1664,6 +1882,7 @@ class CheckoutInstance extends EventEmitter {
             await this.createSession();
             await this._initializePrimerCheckout();
             this._setState('ready');
+            this.startUnhandledTelemetry();
             this.checkoutConfig?.onInitialized?.();
             return this;
         }
@@ -1738,6 +1957,7 @@ class CheckoutInstance extends EventEmitter {
             sessionResponse = await sessionRequest;
         }
         this.cachedSessionResponse = sessionResponse;
+        this.isTelemetryEnabled = !!sessionResponse.data?.sdk_telemetry_enabled;
         this.isCollectingApplePayEmail =
             !!sessionResponse.data?.collect_apple_pay_email;
         this.applySessionCardFieldConfig(sessionResponse);
@@ -1991,6 +2211,7 @@ class CheckoutInstance extends EventEmitter {
             throw new CheckoutError('Cannot update price while payment is processing');
         }
         try {
+            this.onLoaderChangeWithRace(true);
             this._setState('updating');
             // Invalidate session cache
             CheckoutInstance.sessionCache.clear();
@@ -2001,9 +2222,12 @@ class CheckoutInstance extends EventEmitter {
                 clientMetadata,
             });
             this.checkoutConfig.priceId = newPriceId;
+            await this.primerWrapper.refreshClientSession();
+            this.onLoaderChangeWithRace(false);
             this._setState('ready');
         }
         catch (error) {
+            this.onLoaderChangeWithRace(false);
             this._setState('error');
             this.emit(EVENTS.ERROR, error);
             throw error;
@@ -2022,6 +2246,7 @@ class CheckoutInstance extends EventEmitter {
         if (this.isDestroyed)
             return;
         try {
+            this.stopUnhandledTelemetry();
             CheckoutInstance.sessionCache.clear();
             await this.primerWrapper.destroy();
             this._setState('destroyed');
@@ -2196,6 +2421,7 @@ class CheckoutInstance extends EventEmitter {
         }
         await this.primerWrapper.initializeHeadlessCheckout(this.clientToken, checkoutOptions, method);
         const methodInterface = await this.primerWrapper.initMethod(method, element, methodOptions);
+        this.startUnhandledTelemetry(method);
         return {
             ...methodInterface,
             destroy: async () => {
@@ -2204,25 +2430,35 @@ class CheckoutInstance extends EventEmitter {
             },
         };
     }
-}
-CheckoutInstance.sessionCache = new Map();
-
-function getErrorImage(orgId, options) {
-    const params = new URLSearchParams({
-        message: options.message,
-        code: options.code,
-        timestamp: Date.now().toString(),
-        sdk_version: SDK_VERSION,
-    });
-    if (options.req_id) {
-        params.append('req_id', options.req_id);
+    startUnhandledTelemetry(paymentMethod) {
+        if (paymentMethod) {
+            this.telemetryPaymentMethod = paymentMethod;
+        }
+        if (!this.isTelemetryEnabled || this.telemetryCleanup) {
+            return;
+        }
+        this.telemetryCleanup = startUnhandledErrorTelemetry({
+            id: this.id,
+            orgId: this.orgId,
+            baseUrl: this.baseUrl,
+            enabled: this.isTelemetryEnabled,
+            getContext: () => ({
+                checkoutId: this.id,
+                orderId: this.orderId,
+                priceId: this.checkoutConfig.priceId,
+                state: this.state,
+                paymentMethod: this.telemetryPaymentMethod,
+                reqId: this.cachedSessionResponse?.req_id,
+            }),
+        });
+    }
+    stopUnhandledTelemetry() {
+        this.telemetryCleanup?.();
+        this.telemetryCleanup = null;
+        this.telemetryPaymentMethod = undefined;
     }
-    const url = `https://billing.funnelfox.com/sdk_report/${encodeURIComponent(orgId)}/crash?${params.toString()}`;
-    const img = new Image();
-    img.src = url;
-    img.style.display = 'none';
-    document.body.appendChild(img);
 }
+CheckoutInstance.sessionCache = new Map();
 
 /**
  * @fileoverview Public API with configuration and orchestration logic
@@ -2263,6 +2499,7 @@ async function createCheckout(options) {
     }
     catch (error) {
         getErrorImage(options.orgId, {
+            baseUrl: options.apiConfig?.baseUrl,
             message: error.message,
             code: error.code,
             req_id: error?.response?.req_id,
@@ -2314,6 +2551,7 @@ async function silentPurchase(options) {
     }
     catch (error) {
         getErrorImage(orgId, {
+            baseUrl,
             message: error.message,
             code: error.code,
             req_id: error?.response?.req_id,
@@ -2364,6 +2602,7 @@ async function initMethod(method, element, options) {
     }
     catch (error) {
         getErrorImage(options.orgId, {
+            baseUrl: options.baseUrl,
             message: error.message,
             code: error.code,
             req_id: error?.response?.req_id,
@@ -2402,6 +2641,7 @@ async function getAvailablePaymentMethods(params) {
     }
     catch (error) {
         getErrorImage(params.orgId, {
+            baseUrl: params.baseUrl,
             message: error.message,
             code: error.code,
             req_id: error?.response?.req_id,
@@ -2424,5 +2664,6 @@ const Billing = {
 if (typeof window !== 'undefined') {
     window.Billing = Billing;
 }
+console.debug('Billing SDK inited');
 
 export { APIError as A, Billing as B, CheckoutError as C, DEFAULT_BUTTONS_OPTIONS as D, EVENTS as E, FunnefoxSDKError as F, NetworkError as N, PaymentMethod as P, SDK_VERSION as S, ValidationError as V, PrimerError as a, ConfigurationError as b, DEFAULTS as c, CHECKOUT_STATES as d, ERROR_CODES as e, configure as f, createCheckout as g, createClientSession as h, getAvailablePaymentMethods as i };