@salla.sa/applepay 2.14.570 → 2.14.571

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salla.sa/applepay",
-  "version": "2.14.570",
+  "version": "2.14.571",
   "description": "Salla Apple Pay light",
   "main": "dist/app.js",
   "scripts": {
@@ -26,5 +26,5 @@
   "dependencies": {
     "axios": "^1.10.0"
   },
-  "gitHead": "aa8bd72a657c049a4748f38c08555f986ac25a0f"
+  "gitHead": "6ca1f94b0197d7a671c7412e27162e01aa2186b7"
 }

package/src/index.js

@@ -156,6 +156,18 @@ const SallaApplePay = typeof window !== 'undefined' ? {
         // Fresh transaction → clear any cancel flag from a previous attempt.
         SallaApplePay.canceled = false;
 
+        // Analytics latches — one Submitted and one Succeeded per attempt, and
+        // at most one Failed, however many callbacks fire.
+        SallaApplePay._submittedTracked = false;
+        SallaApplePay._failureTracked = false;
+        SallaApplePay._succeededTracked = false;
+
+        // The cart belongs to the attempt, not to the singleton. The mini embed
+        // supplies one up front; on the PDP it stays null until checkout/mini
+        // answers during merchant validation. Without this a second attempt
+        // reports — and submits to — the previous attempt's cart.
+        SallaApplePay.id = SallaApplePay.detail?.cartId || null;
+
         salla.log('🍏 Pay: payments::apple-pay.start-transaction', SallaApplePay.detail);
 
         SallaApplePay.initDefault();
@@ -220,8 +232,17 @@ const SallaApplePay = typeof window !== 'undefined' ? {
             skipBegin = SallaApplePay.detail.onStartedSession(SallaApplePay.session);
         }
         if (!skipBegin) {
-            SallaApplePay.session.begin();
+            try {
+                SallaApplePay.session.begin();
+            } catch (error) {
+                salla.logger.error('🍏 Pay: session.begin() failed', error);
+                SallaApplePay.trackPaymentFailed('client', 'APPLE_PAY_PRESENTATION_FAILED', error?.message || '');
+                SallaApplePay.detail.onError(salla.lang.get('pages.checkout.payment_failed'));
+                Salla.event.createAndDispatch('payments::apple-pay.canceled', {});
+            }
         }
+        // skipBegin path: the caller begins later — onValidateMerchant fires
+        // once the sheet actually opens and emits the (latched) Submitted.
     },
     onPaymentMethodSelected: async (event) => {
         salla.logger.log('🍏 Pay: onPaymentMethodSelected', event);
@@ -306,6 +327,10 @@ const SallaApplePay = typeof window !== 'undefined' ? {
 
     onCancel: (event = {}, message = null) => {
         SallaApplePay.canceled = true;
+        // Sheet opened (Payment Submitted already fired) but the attempt ended
+        // without authorization — dismissal, abort, or validation failure.
+        // Latched: a server rejection tracked earlier absorbs this call.
+        SallaApplePay.trackPaymentFailed('client', 'APPLE_PAY_SESSION_CANCELED', message || '');
         SallaApplePay.detail.onError(message || salla.lang.get('pages.checkout.payment_failed'));
         Salla.event.createAndDispatch('payments::apple-pay.canceled', event);
     },
@@ -367,11 +392,15 @@ const SallaApplePay = typeof window !== 'undefined' ? {
         }
 
         Salla.event.dispatch('payments::apple-pay.authorized.init', event);
+        // The shopper has authorised with Face ID / Touch ID and the token is
+        // about to go to the gateway — this is the submission, not the tap.
+        SallaApplePay.trackPaymentSubmitted();
         http.post(SallaApplePay.detail.authorized.url.replace('{id}', SallaApplePay.id), {
             payment_method: 'apple_pay',
             applepay_token: JSON.stringify(event.payment)
         }, ({ data }) => {
             Salla.event.dispatch('payments::apple-pay.authorized.success', data);
+            SallaApplePay.trackPaymentSucceeded(data);
 
             if (typeof SallaApplePay.detail.authorized.onSuccess === 'function') {
                 SallaApplePay.detail.authorized.onSuccess(data);
@@ -383,6 +412,11 @@ const SallaApplePay = typeof window !== 'undefined' ? {
             let response = error?.response;
 
             Salla.event.dispatch('payments::apple-pay.authorized.failed', response);
+            // Backend rejected the token — latch set so the cancel callback
+            // following the failure UI can't emit a second Failed.
+            SallaApplePay.trackPaymentFailed('server',
+                response?.data?.error?.code || 'APPLE_PAY_FAILED',
+                response?.data?.error?.message || '');
 
             if (typeof SallaApplePay.detail.authorized.onFailed === 'function') {
                 SallaApplePay.detail.authorized.onFailed(response);
@@ -849,6 +883,72 @@ const SallaApplePay = typeof window !== 'undefined' ? {
         };
     },
 
+    track: function (event, extra = {}) {
+        const id = SallaApplePay.id ? String(SallaApplePay.id) : null;
+        try {
+            salla.analytics?.track(event, {
+                payment_method: 'apple_pay',
+                gateway: 'apple_pay',
+                cart_id: id,
+                checkout_id: id,
+                session_id: salla.config?.get?.('jitsu.session_id') || null,
+                ...extra,
+                // The host knows the surface — PDP quick-buy vs the mini-checkout
+                // embed both render salla-quick-buy and share this package.
+                checkout_type: extra.checkout_type
+                    || SallaApplePay.detail?.checkout_type
+                    || 'applepay_checkout',
+            });
+        } catch (error) {
+            salla.logger.error('🍏 Pay: failed to track ' + event, error);
+        }
+    },
+
+    trackPaymentSubmitted: function () {
+        if (SallaApplePay._submittedTracked) {
+            return;
+        }
+        SallaApplePay._submittedTracked = true;
+        // Checkout Started belongs to the host: the mini-checkout embed already
+        // emits its own on open, and on the PDP the cart does not exist until
+        // checkout/mini answers, so salla-quick-buy fires it there with a real id.
+        SallaApplePay.track('Payment Submitted', {});
+    },
+
+    trackPaymentFailed: function (errorType, errorCode, message = '') {
+        // Payment Failed answers a Payment Submitted, and Submitted is emitted at
+        // authorization. Anything that ends the attempt before that — a dismissed
+        // sheet, a refused presentation, merchant validation — is abandonment or a
+        // setup error, not a failed payment, and counting it here would make
+        // Failed exceed Submitted. Those paths still log, still call
+        // detail.onError and still dispatch payments::apple-pay.canceled, so
+        // hosts and error reporting are unaffected; only the funnel is.
+        if (!SallaApplePay._submittedTracked || SallaApplePay._failureTracked) {
+            return;
+        }
+        SallaApplePay._failureTracked = true;
+        SallaApplePay.track('Payment Failed', {
+            error_type: errorType,
+            error_code: errorCode,
+            error_message: message || '',
+        });
+    },
+
+    trackPaymentSucceeded: function (data) {
+        if (SallaApplePay._succeededTracked) {
+            return;
+        }
+        SallaApplePay._succeededTracked = true;
+        const payload = data?.data || data || {};
+        SallaApplePay.track('Payment Succeeded', {
+            order_id: payload.order_id || null,
+            cart_total: payload.total || SallaApplePay.detail?.amount || null,
+            response_status: 'success',
+            has_redirect: false,
+            redirect_url: null,
+        });
+    },
+
     /** Authorize + submit the payment, then close the sheet. */
     prPaymentAuthorized: async function (response) {
         // Guest checkout → persist the payer contact before submitting.
@@ -886,6 +986,8 @@ const SallaApplePay = typeof window !== 'undefined' ? {
         }
 
         Salla.event.dispatch('payments::apple-pay.authorized.init', response);
+        // Authorised on the paired device; the token is about to be submitted.
+        SallaApplePay.trackPaymentSubmitted();
 
         let authorizedData;
         try {
@@ -896,10 +998,16 @@ const SallaApplePay = typeof window !== 'undefined' ? {
 
             authorizedData = data;
             Salla.event.dispatch('payments::apple-pay.authorized.success', data);
+            SallaApplePay.trackPaymentSucceeded(data);
             await response.complete('success');
         } catch (error) {
             const errorResponse = error?.response;
             Salla.event.dispatch('payments::apple-pay.authorized.failed', errorResponse);
+            // Backend rejected the token — latch set so the sheet-close /
+            // cancel that follows can't emit a second Failed.
+            SallaApplePay.trackPaymentFailed('server',
+                errorResponse?.data?.error?.code || 'APPLE_PAY_FAILED',
+                errorResponse?.data?.error?.message || '');
             await response.complete('fail');
             if (typeof SallaApplePay.detail.authorized.onFailed === 'function') {
                 SallaApplePay.detail.authorized.onFailed(errorResponse);