@chordcommerce/analytics 1.18.3-beta.1 → 1.19.0

package/dist/cjs/client/cdp.d.ts

@@ -1,3 +1,6 @@
-import type { ChordAnalyticsOptions, ChordAnalyticsQueue } from '../types/index.js';
-export declare const addCdpSnippet: (options: ChordAnalyticsOptions) => Promise<void>;
+import type { ChordAnalyticsOptions, ChordAnalyticsQueue, ConsentConfiguration } from '../types/index.js';
+export interface CdpSnippetResult {
+    initialConsent: ConsentConfiguration | null;
+}
+export declare const addCdpSnippet: (options: ChordAnalyticsOptions) => Promise<CdpSnippetResult>;
 export declare const cdpQueue: (namespace: string) => ChordAnalyticsQueue;

package/dist/cjs/client/cdp.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable no-console */
 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) {
@@ -41,14 +42,16 @@ var index_js_1 = require("./consent/index.js");
 var utils_js_1 = require("./utils.js");
 /*
  * Adds the Chord CDP snippet to the page.
+ * Returns initial consent configuration to be tracked after CDP is fully ready.
  */
 var addCdpSnippet = function (options) { return __awaiter(void 0, void 0, void 0, function () {
-    var normalizedCDPDomain, cdpReadyPromise, s;
+    var normalizedCDPDomain, cdpReadyPromise, s, initialConsent;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                if (!document || typeof document.createElement === 'undefined')
-                    return [2 /*return*/];
+                if (!document || typeof document.createElement === 'undefined') {
+                    return [2 /*return*/, { initialConsent: null }];
+                }
                 normalizedCDPDomain = (0, utils_js_1.normalizeCDPDomain)(options.cdpDomain);
                 cdpReadyPromise = new Promise(function (resolve) {
                     var checkCdpReady = function () {
@@ -75,18 +78,23 @@ var addCdpSnippet = function (options) { return __awaiter(void 0, void 0, void 0
             case 1:
                 // Wait for CDP to be ready before setting up consent
                 _a.sent();
+                initialConsent = null;
                 if (!options.consent) return [3 /*break*/, 3];
                 if (options.debug && options.enableLogging) {
-                    console.log('Chord CDP: Setting up consent management');
+                    console.log('[Chord Analytics DEBUG]: Setting up consent management');
                 }
                 return [4 /*yield*/, (0, index_js_1.addCdpConsent)(options).init()];
             case 2:
-                _a.sent();
+                initialConsent = _a.sent();
                 if (options.debug && options.enableLogging) {
-                    console.log('Chord CDP: Consent management setup complete');
+                    console.log('[Chord Analytics DEBUG]: Consent management setup complete');
                 }
                 _a.label = 3;
-            case 3: return [2 /*return*/];
+            case 3:
+                if (options.debug && options.enableLogging) {
+                    console.log('[Chord Analytics DEBUG]: CDP snippet added, initialConsent:', JSON.stringify(initialConsent));
+                }
+                return [2 /*return*/, { initialConsent: initialConsent }];
         }
     });
 }); };

package/dist/cjs/client/consent/index.d.ts

@@ -1,11 +1,9 @@
 import type { ChordAnalyticsOptions, ConsentConfiguration } from '../../types/index.js';
-declare global {
-    interface Window {
-        jitsuConfig: {
-            privacy: ConsentConfiguration;
-        };
-    }
-}
 export declare const addCdpConsent: (options: ChordAnalyticsOptions) => {
-    init: () => Promise<boolean>;
+    init: () => Promise<ConsentConfiguration | null>;
+    getConsentConfig: () => {
+        getCategories: () => Record<string, boolean>;
+        isConsentReady: () => boolean;
+        debug: boolean;
+    };
 };

package/dist/cjs/client/consent/index.js

@@ -42,7 +42,6 @@ var onetrust_js_1 = require("./onetrust.js");
 var shopify_js_1 = require("./shopify.js");
 var segment_js_1 = require("./segment.js");
 var addCdpConsent = function (options) {
-    var adapter = null;
     var lastProcessedConsent = null;
     var POLLING_INTERVAL_MS = 50;
     var TIMEOUT_MS = options.awaitConsentTimeout
@@ -66,6 +65,8 @@ var addCdpConsent = function (options) {
                 return null;
         }
     };
+    // Initialize adapter immediately so getConsentConfig() works
+    var adapter = getAdapter();
     /**
      * Polls if user can be tracked based on consent
      * @returns Promise that resolves to true if condition is met within timeout, false otherwise
@@ -92,57 +93,11 @@ var addCdpConsent = function (options) {
         });
     }); };
     /**
-     * Attempts to configure CDP with retry logic.
+     * Tracks consent preference changes.
+     * Note: Per-event consent stamping is handled in ChordAnalytics via stampConsent().
      */
-    var configureCdpWithRetry = function (updatedConsent, maxRetries, baseDelay) {
-        if (maxRetries === void 0) { maxRetries = 5; }
-        if (baseDelay === void 0) { baseDelay = 100; }
-        return __awaiter(void 0, void 0, void 0, function () {
-            var attempt, tryConfigure;
-            return __generator(this, function (_a) {
-                attempt = 0;
-                tryConfigure = function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var cdp, delay_1;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                cdp = window["_".concat(options.namespace)];
-                                if (cdp && typeof cdp.configure === 'function') {
-                                    try {
-                                        if (Object.keys(updatedConsent).length > 0) {
-                                            cdp.configure({ privacy: updatedConsent });
-                                        }
-                                        return [2 /*return*/, true];
-                                    }
-                                    catch (error) {
-                                        // Continue to retry on error
-                                    }
-                                }
-                                if (!(attempt < maxRetries)) return [3 /*break*/, 2];
-                                delay_1 = baseDelay * Math.pow(2, attempt) // Exponential backoff
-                                ;
-                                return [4 /*yield*/, new Promise(function (resolve) {
-                                        setTimeout(resolve, delay_1);
-                                    })];
-                            case 1:
-                                _a.sent();
-                                attempt++;
-                                return [2 /*return*/, tryConfigure()];
-                            case 2:
-                                console.warn('CDP configuration failed after all retries, falling back to jitsuConfig');
-                                return [2 /*return*/, false];
-                        }
-                    });
-                }); };
-                return [2 /*return*/, tryConfigure()];
-            });
-        });
-    };
-    /**
-     * Updates consent for all future events.
-     */
-    var updateCdpConsent = function (updatedConsent) { return __awaiter(void 0, void 0, void 0, function () {
-        var chordAnalytics, shouldTrackConsentUpdate, cdpConfigured;
+    var trackConsentUpdate = function (updatedConsent) { return __awaiter(void 0, void 0, void 0, function () {
+        var chordAnalytics;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -152,36 +107,23 @@ var addCdpConsent = function (options) {
                     }
                     lastProcessedConsent = updatedConsent;
                     chordAnalytics = window[options.namespace];
-                    shouldTrackConsentUpdate = chordAnalytics &&
+                    if (!(chordAnalytics &&
                         typeof chordAnalytics.track === 'function' &&
-                        updatedConsent.consentCategories !== undefined;
-                    if (!(shouldTrackConsentUpdate &&
-                        // we have to send this BEFORE the CDP is reconfigured or else the track will not be sent, usually in the case of a user opting out
-                        updatedConsent.dontSend === true)) return [3 /*break*/, 2];
+                        updatedConsent.consentCategories !== undefined)) return [3 /*break*/, 2];
                     return [4 /*yield*/, chordAnalytics.track('Consent Preferences Updated', updatedConsent)];
                 case 1:
                     _a.sent();
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, configureCdpWithRetry(updatedConsent)];
-                case 3:
-                    cdpConfigured = _a.sent();
-                    if (!cdpConfigured) {
-                        // CDP has not yet loaded via the snippet or all retries failed.
-                        window.jitsuConfig = { privacy: updatedConsent };
+                    if (options.enableLogging && options.debug) {
+                        console.log('[Chord Analytics DEBUG]: Consent preferences updated, sent tracking event');
                     }
-                    if (!(shouldTrackConsentUpdate &&
-                        // we have to send this AFTER the CDP is reconfigured to ensure the track is sent, usually in the case of a user opting in
-                        updatedConsent.dontSend === false)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, chordAnalytics.track('Consent Preferences Updated', updatedConsent)];
-                case 4:
-                    _a.sent();
-                    _a.label = 5;
-                case 5: return [2 /*return*/];
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
         });
     }); };
     /**
      * Sets up consent management by initializing the adapter and handling consent updates.
+     * Returns the initial consent so it can be tracked after CDP is fully ready (avoiding circular await).
      */
     var setupConsentManagement = function () { return __awaiter(void 0, void 0, void 0, function () {
         var initialConsent;
@@ -189,60 +131,84 @@ var addCdpConsent = function (options) {
             switch (_a.label) {
                 case 0:
                     if (!adapter)
-                        return [2 /*return*/];
+                        return [2 /*return*/, null
+                            // Set up the consent update handler first to catch any immediate updates
+                        ];
                     // Set up the consent update handler first to catch any immediate updates
                     adapter.handleConsentUpdates(function (updatedConsent) {
-                        updateCdpConsent(updatedConsent);
+                        trackConsentUpdate(updatedConsent);
                     });
                     return [4 /*yield*/, adapter.getCurrentConsent()];
                 case 1:
                     initialConsent = _a.sent();
-                    return [4 /*yield*/, updateCdpConsent(initialConsent)];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
+                    lastProcessedConsent = initialConsent;
+                    return [2 /*return*/, initialConsent];
             }
         });
     }); };
     /**
-     * Initializes consent management.
-     * Returns a promise that resolves to true if CDP should be loaded, false otherwise.
+     * Initializes consent management and sets up consent update handlers.
+     * Returns initial consent configuration to be tracked after CDP is fully ready,
+     * or null if consent setup failed or was blocked.
      */
     var init = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var canBeTracked, error_1;
+        var canBeTracked, result, error_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    adapter = getAdapter();
+                    if (options.debug && options.enableLogging) {
+                        console.log('[Chord Analytics DEBUG]: consent init() called, adapter:', adapter ? options.consent : 'null');
+                    }
                     if (adapter === null) {
                         console.error("Consent management adapter \"".concat(options.consent, "\" is not supported."));
-                        return [2 /*return*/, false];
+                        return [2 /*return*/, null];
                     }
                     if (!options.awaitConsent) return [3 /*break*/, 2];
+                    if (options.debug && options.enableLogging) {
+                        console.log('[Chord Analytics DEBUG]: awaitConsent is true, checking if user can be tracked');
+                    }
                     return [4 /*yield*/, checkUserCanBeTracked()];
                 case 1:
                     canBeTracked = _a.sent();
-                    if (!canBeTracked)
-                        return [2 /*return*/, false];
+                    if (!canBeTracked) {
+                        if (options.debug && options.enableLogging) {
+                            console.log('[Chord Analytics DEBUG]: User cannot be tracked, returning null');
+                        }
+                        return [2 /*return*/, null];
+                    }
                     _a.label = 2;
                 case 2:
                     _a.trys.push([2, 4, , 5]);
                     return [4 /*yield*/, setupConsentManagement()];
                 case 3:
-                    _a.sent();
-                    return [3 /*break*/, 5];
+                    result = _a.sent();
+                    if (options.debug && options.enableLogging) {
+                        console.log('[Chord Analytics DEBUG]: setupConsentManagement() returned:', JSON.stringify(result));
+                    }
+                    return [2 /*return*/, result];
                 case 4:
                     error_1 = _a.sent();
                     if (options.debug && options.enableLogging) {
-                        console.error('Error setting up consent management:', error_1);
+                        console.error('[Chord Analytics DEBUG]: Error setting up consent management:', error_1);
                     }
-                    return [3 /*break*/, 5];
-                case 5: return [2 /*return*/, true];
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
             }
         });
     }); };
+    var getConsentConfig = function () {
+        if (!(adapter === null || adapter === void 0 ? void 0 : adapter.getCategories) || !(adapter === null || adapter === void 0 ? void 0 : adapter.isConsentReady)) {
+            return undefined;
+        }
+        return {
+            getCategories: function () { return adapter.getCategories(); },
+            isConsentReady: function () { return adapter.isConsentReady(); },
+            debug: options.debug && options.enableLogging,
+        };
+    };
     return {
         init: init,
+        getConsentConfig: getConsentConfig,
     };
 };
 exports.addCdpConsent = addCdpConsent;

package/dist/cjs/client/consent/ketch.d.ts

@@ -12,5 +12,7 @@ export declare const ketchConsentAdapter: () => {
     getCurrentConsent: () => ConsentConfiguration;
     handleConsentUpdates: (updateCdpConsent: (consent: ConsentConfiguration) => void) => void;
     userCanBeTracked: () => boolean;
+    getCategories: () => Record<string, boolean>;
+    isConsentReady: () => boolean;
 };
 export {};

package/dist/cjs/client/consent/ketch.js

@@ -32,7 +32,6 @@ var getCurrentConsent = function () {
         return {};
     return {
         consentCategories: __assign({}, api),
-        dontSend: !userCanBeTracked(),
     };
 };
 /**
@@ -48,6 +47,11 @@ var ketchConsentAdapter = function () {
         getCurrentConsent: getCurrentConsent,
         handleConsentUpdates: handleConsentUpdates,
         userCanBeTracked: userCanBeTracked,
+        getCategories: function () {
+            var api = getApi();
+            return api ? __assign({}, api) : {};
+        },
+        isConsentReady: function () { return !!getApi(); },
     };
 };
 exports.ketchConsentAdapter = ketchConsentAdapter;

package/dist/cjs/client/consent/onetrust-api.d.ts

@@ -0,0 +1,103 @@
+/**
+ * OneTrust API Utilities
+ *
+ * Provides type-safe access to OneTrust's global API with proper duck typing
+ * to ensure the API is fully loaded before use.
+ *
+ * Modeled after analytics-next's onetrust-api.ts
+ */
+/**
+ * OneTrust consent model types
+ */
+export declare enum OtConsentModel {
+    optIn = "opt-in",
+    optOut = "opt-out",
+    implied = "implied consent"
+}
+/**
+ * OneTrust domain data structure
+ */
+export interface OneTrustDomainData {
+    ShowAlertNotice: boolean;
+    Groups: OneTrustGroup[];
+    ConsentModel: {
+        Name: OtConsentModel | string;
+    };
+}
+export interface OneTrustGroup {
+    CustomGroupId: string;
+}
+/**
+ * OneTrust consent changed event
+ */
+type OtConsentChangedEvent = CustomEvent<string[]>;
+/**
+ * OneTrust global API interface
+ */
+export interface OneTrustGlobal {
+    GetDomainData: () => OneTrustDomainData;
+    OnConsentChanged: (cb: (event: OtConsentChangedEvent) => void) => void;
+    IsAlertBoxClosed: () => boolean;
+}
+declare global {
+    interface Window {
+        OneTrust?: OneTrustGlobal | Record<string, unknown>;
+        OnetrustActiveGroups?: string;
+    }
+}
+/**
+ * Get the OneTrust global API if it's ready.
+ *
+ * Uses duck typing to check if OneTrust is fully loaded.
+ * window.OneTrust may exist but not be ready (e.g., just has geolocationResponse).
+ *
+ * @returns OneTrustGlobal if ready, undefined otherwise
+ */
+export declare const getOneTrustGlobal: () => OneTrustGlobal | undefined;
+/**
+ * Get the raw OnetrustActiveGroups string.
+ *
+ * @returns Comma-separated string of active group IDs, or undefined
+ */
+export declare const getOneTrustActiveGroups: () => string | undefined;
+/**
+ * Get normalized active group IDs as an array.
+ * Reads FRESH from window.OnetrustActiveGroups each time - no caching!
+ *
+ * @returns Array of active group IDs
+ *
+ * @example
+ * // window.OnetrustActiveGroups = ",C0001,C0003,"
+ * getNormalizedActiveGroupIds() // ["C0001", "C0003"]
+ */
+export declare const getNormalizedActiveGroupIds: () => string[];
+/**
+ * Get all configured consent groups from OneTrust.
+ *
+ * @returns Array of group info objects
+ */
+export declare const getAllGroups: () => {
+    groupId: string;
+}[];
+/**
+ * Get normalized consent categories.
+ * Reads FRESH from OneTrust globals each time - NO CACHING!
+ *
+ * This ensures if a user changes consent between two track() calls,
+ * each event reflects the consent state AT THAT MOMENT.
+ *
+ * @returns Record of category ID to consent boolean
+ *
+ * @example
+ * getNormalizedCategories()
+ * // { "C0001": true, "C0002": false, "C0003": true }
+ */
+export declare const getNormalizedCategories: () => Record<string, boolean>;
+/**
+ * Coerce OneTrust consent model name to our simplified model.
+ *
+ * @param model - OneTrust consent model name
+ * @returns 'opt-in' or 'opt-out'
+ */
+export declare const coerceConsentModel: (model: OtConsentModel | string) => 'opt-in' | 'opt-out';
+export {};

package/dist/cjs/client/consent/onetrust-api.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * OneTrust API Utilities
+ *
+ * Provides type-safe access to OneTrust's global API with proper duck typing
+ * to ensure the API is fully loaded before use.
+ *
+ * Modeled after analytics-next's onetrust-api.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceConsentModel = exports.getNormalizedCategories = exports.getAllGroups = exports.getNormalizedActiveGroupIds = exports.getOneTrustActiveGroups = exports.getOneTrustGlobal = exports.OtConsentModel = void 0;
+/**
+ * OneTrust consent model types
+ */
+// eslint-disable-next-line no-shadow
+var OtConsentModel;
+(function (OtConsentModel) {
+    OtConsentModel["optIn"] = "opt-in";
+    OtConsentModel["optOut"] = "opt-out";
+    OtConsentModel["implied"] = "implied consent";
+})(OtConsentModel || (exports.OtConsentModel = OtConsentModel = {}));
+/**
+ * Get the OneTrust global API if it's ready.
+ *
+ * Uses duck typing to check if OneTrust is fully loaded.
+ * window.OneTrust may exist but not be ready (e.g., just has geolocationResponse).
+ *
+ * @returns OneTrustGlobal if ready, undefined otherwise
+ */
+var getOneTrustGlobal = function () {
+    var oneTrust = window.OneTrust;
+    if (!oneTrust)
+        return undefined;
+    // Duck typing - check for required methods to ensure OneTrust is fully loaded
+    if (typeof oneTrust === 'object' &&
+        'OnConsentChanged' in oneTrust &&
+        'IsAlertBoxClosed' in oneTrust &&
+        'GetDomainData' in oneTrust) {
+        return oneTrust;
+    }
+    return undefined;
+};
+exports.getOneTrustGlobal = getOneTrustGlobal;
+/**
+ * Get the raw OnetrustActiveGroups string.
+ *
+ * @returns Comma-separated string of active group IDs, or undefined
+ */
+var getOneTrustActiveGroups = function () {
+    var groups = window.OnetrustActiveGroups;
+    if (!groups || typeof groups !== 'string')
+        return undefined;
+    return groups;
+};
+exports.getOneTrustActiveGroups = getOneTrustActiveGroups;
+/**
+ * Get normalized active group IDs as an array.
+ * Reads FRESH from window.OnetrustActiveGroups each time - no caching!
+ *
+ * @returns Array of active group IDs
+ *
+ * @example
+ * // window.OnetrustActiveGroups = ",C0001,C0003,"
+ * getNormalizedActiveGroupIds() // ["C0001", "C0003"]
+ */
+var getNormalizedActiveGroupIds = function () {
+    var groups = (0, exports.getOneTrustActiveGroups)();
+    if (!groups)
+        return [];
+    return groups.trim().split(',').filter(Boolean);
+};
+exports.getNormalizedActiveGroupIds = getNormalizedActiveGroupIds;
+/**
+ * Get all configured consent groups from OneTrust.
+ *
+ * @returns Array of group info objects
+ */
+var getAllGroups = function () {
+    var oneTrust = (0, exports.getOneTrustGlobal)();
+    if (!oneTrust)
+        return [];
+    return oneTrust.GetDomainData().Groups.map(function (group) { return ({
+        groupId: group.CustomGroupId.trim(),
+    }); });
+};
+exports.getAllGroups = getAllGroups;
+/**
+ * Get normalized consent categories.
+ * Reads FRESH from OneTrust globals each time - NO CACHING!
+ *
+ * This ensures if a user changes consent between two track() calls,
+ * each event reflects the consent state AT THAT MOMENT.
+ *
+ * @returns Record of category ID to consent boolean
+ *
+ * @example
+ * getNormalizedCategories()
+ * // { "C0001": true, "C0002": false, "C0003": true }
+ */
+var getNormalizedCategories = function () {
+    var activeGroupIds = (0, exports.getNormalizedActiveGroupIds)();
+    return (0, exports.getAllGroups)().reduce(function (acc, group) {
+        acc[group.groupId] = activeGroupIds.includes(group.groupId);
+        return acc;
+    }, {});
+};
+exports.getNormalizedCategories = getNormalizedCategories;
+/**
+ * Coerce OneTrust consent model name to our simplified model.
+ *
+ * @param model - OneTrust consent model name
+ * @returns 'opt-in' or 'opt-out'
+ */
+var coerceConsentModel = function (model) {
+    switch (model) {
+        case OtConsentModel.optIn:
+        case OtConsentModel.implied:
+        case 'opt-in':
+        case 'implied consent':
+            return 'opt-in';
+        case OtConsentModel.optOut:
+        case 'opt-out':
+        default:
+            // Default to opt-out for unknown models (e.g., 'custom', 'notice')
+            return 'opt-out';
+    }
+};
+exports.coerceConsentModel = coerceConsentModel;

package/dist/cjs/client/consent/onetrust.d.ts

@@ -1,22 +1,10 @@
 import type { ChordAnalyticsOptions, ConsentConfiguration } from '../../types/index.js';
-declare global {
-    interface Window {
-        OneTrust?: OneTrustApi;
-        OnetrustActiveGroups?: string;
-    }
-}
-interface OneTrustApi {
-    OnConsentChanged: (callback: () => void) => void;
-    GetDomainData: () => {
-        Groups: OneTrustGroup[];
-    };
-}
-interface OneTrustGroup {
-    CustomGroupId: string;
-}
 export declare const onetrustConsentAdapter: (options: ChordAnalyticsOptions) => {
     getCurrentConsent: () => ConsentConfiguration;
     handleConsentUpdates: (updateCdpConsent: (consent: ConsentConfiguration) => void) => void;
     userCanBeTracked: () => boolean;
+    getCategories: () => Record<string, boolean>;
+    isConsentReady: () => boolean;
+    getConsentModel: () => 'opt-in' | 'opt-out';
+    getApi: () => import("./onetrust-api.js").OneTrustGlobal;
 };
-export {};