@funnelfox/billing 0.7.1 → 0.8.0-beta.1

package/dist/funnelfox-billing.js

@@ -374,6 +374,9 @@
             return v.toString(16);
         });
     }
+    function isBrowser() {
+        return typeof window !== 'undefined' && typeof document !== 'undefined';
+    }
     function sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
@@ -492,7 +495,7 @@
     /**
      * @fileoverview Constants for Funnefox SDK
      */
-    const SDK_VERSION = '0.7.1';
+    const SDK_VERSION = '0.8.0-beta.1';
     const DEFAULTS = {
         BASE_URL: 'https://billing.funnelfox.com',
         REGION: 'default',
@@ -1499,6 +1502,219 @@
         });
     }
 
+    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 url = `https://billing.funnelfox.com/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, {
+                message: `${error.name}: ${error.message}`,
+                code: error.code,
+                req_id: context.reqId,
+                context: {
+                    ...eventContext,
+                    checkout_id: context.checkoutId,
+                    order_id: context.orderId,
+                    price_id: context.priceId,
+                    checkout_state: context.state,
+                    payment_method: context.paymentMethod,
+                    stack: error.stack,
+                    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
      */
@@ -1508,6 +1724,8 @@
             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 });
             };
@@ -1670,6 +1888,7 @@
                 await this.createSession();
                 await this._initializePrimerCheckout();
                 this._setState('ready');
+                this.startUnhandledTelemetry();
                 this.checkoutConfig?.onInitialized?.();
                 return this;
             }
@@ -1744,6 +1963,8 @@
                 sessionResponse = await sessionRequest;
             }
             this.cachedSessionResponse = sessionResponse;
+            this.isTelemetryEnabled =
+                !!sessionResponse.data?.sdk_telemetry_enabled || true;
             this.isCollectingApplePayEmail =
                 !!sessionResponse.data?.collect_apple_pay_email;
             this.applySessionCardFieldConfig(sessionResponse);
@@ -2028,6 +2249,7 @@
             if (this.isDestroyed)
                 return;
             try {
+                this.stopUnhandledTelemetry();
                 CheckoutInstance.sessionCache.clear();
                 await this.primerWrapper.destroy();
                 this._setState('destroyed');
@@ -2202,6 +2424,7 @@
             }
             await this.primerWrapper.initializeHeadlessCheckout(this.clientToken, checkoutOptions, method);
             const methodInterface = await this.primerWrapper.initMethod(method, element, methodOptions);
+            this.startUnhandledTelemetry(method);
             return {
                 ...methodInterface,
                 destroy: async () => {
@@ -2210,25 +2433,34 @@
                 },
             };
         }
-    }
-    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,
+                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