@datalyr/web 1.5.0 → 1.6.1

package/dist/datalyr.js

@@ -1,10 +1,10 @@
 /**
- * @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
  */
-var Datalyr = (function () {
+var Datalyr = (function (exports) {
     'use strict';
 
     /******************************************************************************
@@ -1507,10 +1507,13 @@ var Datalyr = (function () {
                 // 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);
@@ -2675,9 +2678,12 @@ var Datalyr = (function () {
                     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) {
@@ -2759,22 +2765,63 @@ var Datalyr = (function () {
         /**
          * 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);
                 }
@@ -2783,7 +2830,7 @@ var Datalyr = (function () {
                 }
             }
             // 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 = {
@@ -3491,6 +3538,15 @@ var Datalyr = (function () {
                                 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();
@@ -3532,13 +3588,19 @@ var Datalyr = (function () {
                 // 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) {
@@ -3929,10 +3991,61 @@ var Datalyr = (function () {
         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);
@@ -3962,7 +4075,9 @@ var Datalyr = (function () {
             });
             // 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;
@@ -3986,8 +4101,8 @@ var Datalyr = (function () {
                 // 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;
@@ -4207,7 +4322,12 @@ var Datalyr = (function () {
         window.datalyr = datalyr;
     }
 
-    return datalyr;
+    exports.datalyr = datalyr;
+    exports.default = datalyr;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
 
-})();
+})({});
 //# sourceMappingURL=datalyr.js.map