@datalyr/web 1.5.0 → 1.6.1

package/dist/datalyr.esm.js

@@ -1,5 +1,5 @@
 /**
- * @datalyr/web v1.5.0
+ * @datalyr/web v1.6.1
  * Datalyr Web SDK - Modern attribution tracking for web applications
  * (c) 2026 Datalyr Inc.
  * Released under the MIT License
@@ -1504,10 +1504,13 @@ class AttributionManager {
             // Optionally set the cookie for future use
             cookies.set('_fbp', adCookies._fbp, 90);
         }
-        // Generate _fbc if we have fbclid but no _fbc
+        // Generate _fbc if we have fbclid but no _fbc.
+        // Meta's fbc format is `fb.{subdomainIndex}.{creationTime}.{fbclid}` where
+        // creationTime is UNIX time in MILLISECONDS (matches the _fbp generation above
+        // and the real _fbc cookie the Meta Pixel writes). Do NOT use seconds here.
         const fbclid = this.getCurrentFbclid();
         if (fbclid && !adCookies._fbc) {
-            const timestamp = Math.floor(Date.now() / 1000);
+            const timestamp = Date.now();
             adCookies._fbc = `fb.1.${timestamp}.${fbclid}`;
             // Optionally set the cookie for future use
             cookies.set('_fbc', adCookies._fbc, 90);
@@ -2672,9 +2675,12 @@ class ContainerManager {
                 s = b.getElementsByTagName(e)[0];
                 s.parentNode.insertBefore(t, s);
             })(window, document, 'script', 'https://connect.facebook.net/en_US/fbevents.js');
-            // Initialize pixel
+            // Initialize pixel only — do NOT fire PageView here. The SDK's own pageview
+            // tracking (track('pageview')) routes through trackToPixels and fires a single
+            // mapped PageView with a shared eventID. Firing it again here produced TWO
+            // PageViews per load (one un-deduped). Note: if the host app disables pageview
+            // tracking entirely, no PageView is sent — which is the correct outcome.
             window.fbq('init', config.pixel_id);
-            window.fbq('track', 'PageView');
             this.log('Meta Pixel initialized:', config.pixel_id);
         }
         catch (error) {
@@ -2756,22 +2762,63 @@ class ContainerManager {
     /**
      * Track event to all initialized pixels
      */
-    trackToPixels(eventName, properties = {}) {
-        var _a, _b, _c, _e, _f, _g;
+    trackToPixels(eventName, properties = {}, eventId) {
+        var _a, _b, _c, _e, _f, _g, _h, _j;
+        // Datalyr-internal events ($identify, $group, $alias, $auto_identify,
+        // $app_download_click, …) are not conversions — never forward them to ad
+        // pixels. (Previously they fired as noise custom events with the $ stripped.)
+        if (eventName.startsWith('$'))
+            return;
         // Sanitize inputs to prevent XSS
         const sanitizedEventName = this.sanitizeEventName(eventName);
         const sanitizedProperties = this.sanitizeProperties(properties);
         // Track to Meta Pixel
         if (((_b = (_a = this.pixels) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.enabled) && window.fbq) {
             try {
-                window.fbq('track', sanitizedEventName, sanitizedProperties);
+                // Map our event name to Meta's standard event vocabulary so the browser
+                // Pixel fires e.g. "Purchase", not "purchase". This MUST match the
+                // platform_standard_event the postback worker sends server-side, or Meta
+                // won't dedupe (dedup = event_name + event_id). These defaults mirror the
+                // server-side auto-detect map; custom rule choices may not line up.
+                const metaEventMap = {
+                    page_view: 'PageView', pageview: 'PageView',
+                    view_content: 'ViewContent', product_viewed: 'ViewContent', view_item: 'ViewContent',
+                    add_to_cart: 'AddToCart', product_added: 'AddToCart',
+                    add_to_wishlist: 'AddToWishlist',
+                    initiate_checkout: 'InitiateCheckout', begin_checkout: 'InitiateCheckout', checkout_started: 'InitiateCheckout',
+                    add_payment_info: 'AddPaymentInfo',
+                    purchase: 'Purchase', order_completed: 'Purchase', order_paid: 'Purchase',
+                    lead: 'Lead',
+                    complete_registration: 'CompleteRegistration', sign_up: 'CompleteRegistration', signup: 'CompleteRegistration',
+                    search: 'Search',
+                    subscribe: 'Subscribe', subscription_created: 'Subscribe',
+                    start_trial: 'StartTrial', trial_started: 'StartTrial',
+                    contact: 'Contact',
+                    schedule: 'Schedule',
+                };
+                // Source of truth: the workspace's Meta conversion-rule map (from
+                // /container-scripts, keyed by the exact trigger event name) — this is what
+                // the server-side CAPI sends, so it guarantees event_name dedup alignment.
+                // Fall back to the static default map, then the sanitized raw name.
+                const ruleEventMap = (_e = (_c = this.pixels) === null || _c === void 0 ? void 0 : _c.meta) === null || _e === void 0 ? void 0 : _e.event_mappings;
+                const metaEvent = (ruleEventMap === null || ruleEventMap === void 0 ? void 0 : ruleEventMap[eventName])
+                    || metaEventMap[String(eventName).toLowerCase()]
+                    || sanitizedEventName;
+                // Pass the shared eventID so this Pixel event dedupes against the
+                // server-side CAPI event carrying the same event_id.
+                if (eventId) {
+                    window.fbq('track', metaEvent, sanitizedProperties, { eventID: eventId });
+                }
+                else {
+                    window.fbq('track', metaEvent, sanitizedProperties);
+                }
             }
             catch (error) {
                 this.log('Error tracking Meta Pixel event:', error);
             }
         }
         // Track to Google Tag
-        if (((_e = (_c = this.pixels) === null || _c === void 0 ? void 0 : _c.google) === null || _e === void 0 ? void 0 : _e.enabled) && window.gtag) {
+        if (((_g = (_f = this.pixels) === null || _f === void 0 ? void 0 : _f.google) === null || _g === void 0 ? void 0 : _g.enabled) && window.gtag) {
             try {
                 window.gtag('event', sanitizedEventName, sanitizedProperties);
             }
@@ -2780,7 +2827,7 @@ class ContainerManager {
             }
         }
         // Track to TikTok Pixel
-        if (((_g = (_f = this.pixels) === null || _f === void 0 ? void 0 : _f.tiktok) === null || _g === void 0 ? void 0 : _g.enabled) && window.ttq) {
+        if (((_j = (_h = this.pixels) === null || _h === void 0 ? void 0 : _h.tiktok) === null || _j === void 0 ? void 0 : _j.enabled) && window.ttq) {
             try {
                 // Map common events to TikTok names
                 const tiktokEventMap = {
@@ -3488,6 +3535,15 @@ class Datalyr {
                             this.identify(email, { email });
                         });
                     }
+                    // Stamp attribution signals into the Shopify cart (OPT-IN, default off).
+                    // Lets server-side order webhooks recover the browser visitor + Meta click
+                    // signals (the postback webhook reads these as note_attributes). Inert unless
+                    // enabled; best-effort and never blocks init.
+                    if (this.config.shopifyCartAttributes === true) {
+                        this.syncShopifyCartAttributes().catch((error) => {
+                            this.log('Shopify cart attribute sync failed:', error);
+                        });
+                    }
                     // Track initial page view if enabled (AFTER encryption ready)
                     if (this.config.trackPageViews) {
                         this.page();
@@ -3529,13 +3585,19 @@ class Datalyr {
             // PRIVACY: Heavy fingerprinting removed - using minimal fingerprinting only
             // Update session activity
             this.session.updateActivity(eventName);
+            // Generate the event_id ONCE here so the same value is used for both the
+            // ingested event (→ CAPI dedup key in the postback worker) and the browser
+            // Meta Pixel co-fire below. Sharing it is what lets Meta dedupe the Pixel
+            // event against the server-side CAPI event (dedup = event_id + event_name).
+            const eventId = generateUUID();
             // Create event payload
-            const payload = this.createEventPayload(eventName, properties);
+            const payload = this.createEventPayload(eventName, properties, eventId);
             // Queue event
             this.queue.enqueue(payload);
-            // Track to third-party pixels if container is initialized
+            // Track to third-party pixels if container is initialized.
+            // Pass the shared eventId so the Meta Pixel fires with the same { eventID }.
             if (this.container) {
-                this.container.trackToPixels(eventName, properties);
+                this.container.trackToPixels(eventName, properties, eventId);
             }
             // Call plugin handlers
             if (this.config.plugins) {
@@ -3926,10 +3988,61 @@ class Datalyr {
     getSuperProperties() {
         return Object.assign({}, this.superProperties);
     }
+    /**
+     * Stamp Datalyr attribution signals into the Shopify cart as cart attributes.
+     * Cart attributes become `order.note_attributes` with the same names, which the
+     * server-side order webhook reads to recover the browser visitor_id + Meta click
+     * signals (_fbc/_fbp/fbclid) — enabling accurate Meta CAPI attribution for orders.
+     *
+     * Opt-in (config.shopifyCartAttributes), best-effort, runs once during init.
+     * Merges via Shopify's /cart/update.js (does not clobber other cart attributes).
+     */
+    syncShopifyCartAttributes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof window === "undefined" || typeof document === "undefined")
+                return;
+            const isShopify = !!(window.Shopify ||
+                document.querySelector('meta[name="shopify-checkout-api-token"]') ||
+                window.location.hostname.includes(".myshopify.com"));
+            if (!isShopify)
+                return;
+            const attribution = this.attribution.getAttributionData();
+            const fbclid = attribution.clickIdType === "fbclid" ? attribution.clickId : null;
+            // Cookies are freshest (the real Meta Pixel may have just written them);
+            // fall back to whatever the SDK captured in attribution.
+            const attributes = {};
+            const visitorId = this.identity.getAnonymousId();
+            const fbc = this.cookies.get("_fbc") || attribution._fbc;
+            const fbp = this.cookies.get("_fbp") || attribution._fbp;
+            if (visitorId)
+                attributes._datalyr_visitor_id = visitorId;
+            if (fbc)
+                attributes._datalyr_fbc = String(fbc);
+            if (fbp)
+                attributes._datalyr_fbp = String(fbp);
+            if (fbclid)
+                attributes._datalyr_fbclid = String(fbclid);
+            if (Object.keys(attributes).length === 0)
+                return;
+            try {
+                yield fetch("/cart/update.js", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    credentials: "same-origin",
+                    body: JSON.stringify({ attributes }),
+                });
+                this.log("Shopify cart attributes stamped:", Object.keys(attributes));
+            }
+            catch (error) {
+                // Never let cart sync affect tracking — swallow (e.g. no cart yet / CSP).
+                this.log("Shopify /cart/update.js failed:", error);
+            }
+        });
+    }
     /**
      * Create event payload
      */
-    createEventPayload(eventName, properties) {
+    createEventPayload(eventName, properties, eventIdArg) {
         // Sanitize and merge properties
         const sanitizedProperties = sanitizeEventData(properties);
         const eventData = deepMerge({}, this.superProperties, sanitizedProperties);
@@ -3959,7 +4072,9 @@ class Datalyr {
         });
         // Create payload using snake_case only (matches backend API and production script)
         const identityFields = this.identity.getIdentityFields();
-        const eventId = generateUUID();
+        // Use the caller-provided event_id (shared with the Meta Pixel co-fire for
+        // dedup); fall back to a fresh UUID for any direct caller that omits it.
+        const eventId = eventIdArg !== null && eventIdArg !== void 0 ? eventIdArg : generateUUID();
         // Ensure we have all required identity fields
         const distinctId = identityFields.distinct_id;
         const anonymousId = identityFields.anonymous_id;
@@ -3983,8 +4098,8 @@ class Datalyr {
             // Resolution metadata
             resolution_method: 'browser_sdk',
             resolution_confidence: 1.0,
-            // SDK metadata
-            sdk_version: '1.4.1',
+            // SDK metadata (keep in sync with package.json version)
+            sdk_version: '1.6.0',
             sdk_name: 'datalyr-web-sdk'
         };
         return payload;
@@ -4204,5 +4319,5 @@ if (typeof window !== 'undefined') {
     window.datalyr = datalyr;
 }
 
-export { datalyr as default };
+export { datalyr, datalyr as default };
 //# sourceMappingURL=datalyr.esm.js.map