@chordcommerce/analytics 1.14.0 → 1.15.0

package/dist/client/cdp.js

@@ -8,15 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { addCdpConsent } from './consent/index.js';
+import { normalizeCDPDomain } from './utils.js';
 /*
  * Adds the Chord CDP snippet to the page.
  */
 export const addCdpSnippet = (options) => __awaiter(void 0, void 0, void 0, function* () {
     if (!document || typeof document.createElement === 'undefined')
         return;
+    const normalizedCDPDomain = normalizeCDPDomain(options.cdpDomain);
     const s = document.createElement('script');
     s.async = true;
-    s.src = `${options.cdpDomain}/p.js`;
+    s.src = `${normalizedCDPDomain}/p.js`;
     s.setAttribute('data-debug', `${!!options.debug}`);
     s.setAttribute('data-init-only', 'true');
     s.setAttribute('data-namespace', `_${options.namespace}`);

package/dist/client/consent/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ketchConsentAdapter } from './ketch.js';
 import { onetrustConsentAdapter } from './onetrust.js';
 import { shopifyConsentAdapter } from './shopify.js';
+import { segmentConsentAdapter } from './segment.js';
 export const addCdpConsent = (options) => {
     let adapter = null;
     let lastProcessedConsent = null;
@@ -27,6 +28,8 @@ export const addCdpConsent = (options) => {
                 return onetrustConsentAdapter();
             case 'shopify':
                 return shopifyConsentAdapter();
+            case 'segment':
+                return segmentConsentAdapter();
             default:
                 return null;
         }
@@ -54,6 +57,35 @@ export const addCdpConsent = (options) => {
             }, TIMEOUT_MS);
         });
     });
+    /**
+     * Attempts to configure CDP with retry logic.
+     */
+    const configureCdpWithRetry = (updatedConsent, maxRetries = 5, baseDelay = 100) => __awaiter(void 0, void 0, void 0, function* () {
+        let attempt = 0;
+        const tryConfigure = () => __awaiter(void 0, void 0, void 0, function* () {
+            const cdp = window[`_${options.namespace}`];
+            if (cdp && typeof cdp.configure === 'function') {
+                try {
+                    cdp.configure({ privacy: updatedConsent });
+                    return true;
+                }
+                catch (error) {
+                    // Continue to retry on error
+                }
+            }
+            if (attempt < maxRetries) {
+                const delay = baseDelay * Math.pow(2, attempt); // Exponential backoff
+                yield new Promise((resolve) => {
+                    setTimeout(resolve, delay);
+                });
+                attempt++;
+                return tryConfigure();
+            }
+            console.warn('CDP configuration failed after all retries, falling back to jitsuConfig');
+            return false;
+        });
+        return tryConfigure();
+    });
     /**
      * Updates consent for all future events.
      */
@@ -64,7 +96,6 @@ export const addCdpConsent = (options) => {
         }
         lastProcessedConsent = updatedConsent;
         const chordAnalytics = window[options.namespace];
-        const cdp = window[`_${options.namespace}`];
         const shouldTrackConsentUpdate = chordAnalytics &&
             typeof chordAnalytics.track === 'function' &&
             updatedConsent.consentCategories !== undefined;
@@ -73,11 +104,9 @@ export const addCdpConsent = (options) => {
             updatedConsent.dontSend === true) {
             yield chordAnalytics.track('Consent Preferences Updated', updatedConsent);
         }
-        if (cdp && typeof cdp.configure === 'function') {
-            cdp.configure({ privacy: updatedConsent });
-        }
-        else {
-            // CDP has not yet loaded via the snippet.
+        const cdpConfigured = yield configureCdpWithRetry(updatedConsent);
+        if (!cdpConfigured) {
+            // CDP has not yet loaded via the snippet or all retries failed.
             window.jitsuConfig = { privacy: updatedConsent };
         }
         if (shouldTrackConsentUpdate &&
@@ -97,8 +126,8 @@ export const addCdpConsent = (options) => {
             updateCdpConsent(updatedConsent);
         });
         // Process initial consent - this will be skipped if the adapter already triggered an update
-        const initialConsent = adapter.getCurrentConsent();
-        updateCdpConsent(initialConsent);
+        const initialConsent = yield adapter.getCurrentConsent();
+        yield updateCdpConsent(initialConsent);
     });
     /**
      * Initializes consent management.

package/dist/client/consent/segment.d.ts

@@ -0,0 +1,17 @@
+import type { ConsentConfiguration } from '../../types/index.js';
+declare global {
+    interface Window {
+        segmentConsent?: SegmentConsentCategories;
+    }
+}
+interface SegmentConsentCategories {
+    [key: string]: {
+        [key: string]: boolean;
+    };
+}
+export declare const segmentConsentAdapter: () => {
+    getCurrentConsent: () => Promise<ConsentConfiguration>;
+    handleConsentUpdates: (updateCdpConsent: (consent: ConsentConfiguration) => void) => void;
+    userCanBeTracked: () => Promise<boolean>;
+};
+export {};

package/dist/client/consent/segment.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const getApi = () => window.segmentConsent;
+/**
+ * Waits for the Segment consent API to be populated with retry logic.
+ */
+const waitForApi = (maxRetries = 10, baseDelay = 100) => __awaiter(void 0, void 0, void 0, function* () {
+    let attempt = 0;
+    const checkAndWait = () => __awaiter(void 0, void 0, void 0, function* () {
+        const api = getApi();
+        if (api &&
+            typeof api === 'object' &&
+            api.customPreferences &&
+            typeof api.customPreferences === 'object' &&
+            Object.keys(api.customPreferences).length > 0) {
+            return api;
+        }
+        if (attempt < maxRetries) {
+            const delay = baseDelay * Math.pow(2, attempt);
+            yield new Promise((resolve) => {
+                setTimeout(resolve, delay);
+            });
+            attempt++;
+            return checkAndWait();
+        }
+        return null;
+    });
+    return checkAndWait();
+    console.warn('Segment API failed to load after all retries');
+    return null;
+});
+/**
+ * Returns whether the user can currently be tracked.
+ */
+const userCanBeTracked = () => __awaiter(void 0, void 0, void 0, function* () {
+    const api = yield waitForApi();
+    return (!!api &&
+        !!(api.customPreferences.functional &&
+            api.customPreferences.marketingAndAnalytics));
+});
+/**
+ * Returns the user's current consent configuration.
+ */
+const getCurrentConsent = () => __awaiter(void 0, void 0, void 0, function* () {
+    const api = yield waitForApi();
+    if (!api)
+        return {};
+    return {
+        consentCategories: Object.assign(Object.assign({}, api.customPreferences), api.destinationPreferences),
+        dontSend: !(yield userCanBeTracked()),
+    };
+});
+/**
+ * Handles subsequent changes to consent configuration.
+ */
+const handleConsentUpdates = (updateCdpConsent) => {
+    document.addEventListener('chord-cdp:consent-updated', () => __awaiter(void 0, void 0, void 0, function* () {
+        updateCdpConsent(yield getCurrentConsent());
+    }));
+};
+export const segmentConsentAdapter = () => {
+    return {
+        getCurrentConsent,
+        handleConsentUpdates,
+        userCanBeTracked,
+    };
+};

package/dist/client/utils.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCDPDomain(cdpDomain: string): string;

package/dist/client/utils.js

@@ -0,0 +1,8 @@
+export function normalizeCDPDomain(cdpDomain) {
+    let domain = cdpDomain.replace(/\/+$/, '');
+    if (domain.endsWith('/p.js')) {
+        domain = domain.slice(0, -'/p.js'.length);
+        domain = domain.replace(/\/+$/, '');
+    }
+    return domain;
+}

package/dist/types/client.d.ts

@@ -30,7 +30,7 @@ export interface ChordAnalyticsOptions<T extends ObjectTypes = ObjectTypes> {
     cdp?: AnyAnalytics | (() => AnyAnalytics);
     cdpDomain?: string;
     cdpWriteKey?: string;
-    consent?: 'ketch' | 'onetrust' | 'shopify';
+    consent?: 'ketch' | 'onetrust' | 'shopify' | 'segment';
     awaitConsent?: boolean;
     debug?: boolean;
     enableLogging?: boolean;

package/dist/types/consent.d.ts

@@ -1,7 +1,7 @@
 export interface ConsentAdapter {
-    getCurrentConsent: () => ConsentConfiguration;
+    getCurrentConsent: () => ConsentConfiguration | Promise<ConsentConfiguration>;
     handleConsentUpdates: (fn: (ConsentConfiguration: any) => void) => void;
-    userCanBeTracked: () => boolean;
+    userCanBeTracked: () => boolean | Promise<boolean>;
 }
 export interface ConsentConfiguration {
     consentCategories?: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chordcommerce/analytics",
   "description": "Chord Commerce event tracking",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "author": "Chord Commerce <help@chord.co> (https://www.chord.co)",
   "type": "module",
   "main": "dist/index.js",