@chordcommerce/analytics 1.18.3-beta.1 → 1.19.0-beta.1

package/dist/cjs/client/index.js

@@ -58,7 +58,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChordAnalytics = void 0;
 var cdp_js_1 = require("./cdp.js");
-var index_js_1 = require("../validators/index.js");
+var index_js_1 = require("./consent/index.js");
+var index_js_2 = require("../validators/index.js");
 var utils_js_1 = require("../utils.js");
 var DEBUG_MODE_STORAGE_KEY = 'chordcommerce/analytics/debug';
 var ChordAnalytics = /** @class */ (function () {
@@ -81,7 +82,20 @@ var ChordAnalytics = /** @class */ (function () {
          * Promise that resolves when CDP is ready
          */
         this.cdpReadyPromise = null;
+        this.consentConfig = null;
         this.resetInProgress = false;
+        /**
+         * Queue for events waiting for consent to be ready
+         */
+        this.consentEventQueue = [];
+        /**
+         * Whether we're currently waiting for consent and watching for it
+         */
+        this.consentWatcherActive = false;
+        /**
+         * Promise that resolves when consent is ready (shared across all queued events)
+         */
+        this.consentReadyPromise = null;
         /**
          * Set debug mode for Chord Analytics
          * @param enabled - Whether debug mode should be enabled
@@ -127,12 +141,153 @@ var ChordAnalytics = /** @class */ (function () {
         this.isResetting = function () {
             return _this.resetInProgress;
         };
+        /**
+         * Wait for consent manager to be ready (no timeout - queues indefinitely).
+         * Uses a shared promise so multiple events share the same watcher.
+         */
+        this.waitForConsent = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.consentConfig)
+                            return [2 /*return*/];
+                        if (this.consentConfig.isConsentReady())
+                            return [2 /*return*/];
+                        if (!this.consentReadyPromise) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.consentReadyPromise];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        // Start a new consent watcher - polls until consent is ready
+                        this.consentReadyPromise = new Promise(function (resolve) {
+                            var interval = setInterval(function () {
+                                var _a;
+                                if ((_a = _this.consentConfig) === null || _a === void 0 ? void 0 : _a.isConsentReady()) {
+                                    clearInterval(interval);
+                                    _this.consentReadyPromise = null;
+                                    resolve(true);
+                                }
+                            }, 100);
+                        });
+                        return [4 /*yield*/, this.consentReadyPromise];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * Queue an event to be sent when consent is ready.
+         * Starts a consent watcher if not already active.
+         */
+        this.queueEventForConsent = function (type, args) {
+            return new Promise(function (resolve) {
+                _this.consentEventQueue.push({ type: type, args: args, resolve: resolve });
+                // Start watching for consent if not already
+                if (!_this.consentWatcherActive) {
+                    _this.consentWatcherActive = true;
+                    _this.watchForConsentAndFlush();
+                }
+            });
+        };
+        /**
+         * Watch for consent to become ready, then flush the queue.
+         */
+        this.watchForConsentAndFlush = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.waitForConsent()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.flushConsentQueue()];
+                    case 2:
+                        _a.sent();
+                        this.consentWatcherActive = false;
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * Flush all queued events now that consent is ready.
+         */
+        this.flushConsentQueue = function () { return __awaiter(_this, void 0, void 0, function () {
+            var queue, sendPromises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queue = __spreadArray([], this.consentEventQueue, true);
+                        this.consentEventQueue = [];
+                        sendPromises = queue.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, error_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 9, , 10]);
+                                        _a = item.type;
+                                        switch (_a) {
+                                            case 'track': return [3 /*break*/, 1];
+                                            case 'page': return [3 /*break*/, 3];
+                                            case 'identify': return [3 /*break*/, 5];
+                                        }
+                                        return [3 /*break*/, 7];
+                                    case 1: return [4 /*yield*/, this.sendTrackEvent(item.args[0], item.args[1], item.args[2])];
+                                    case 2:
+                                        _b.sent();
+                                        return [3 /*break*/, 8];
+                                    case 3: return [4 /*yield*/, this.sendPageEvent(item.args[0], item.args[1])];
+                                    case 4:
+                                        _b.sent();
+                                        return [3 /*break*/, 8];
+                                    case 5: return [4 /*yield*/, this.sendIdentifyEvent(item.args[0], item.args[1], item.args[2])];
+                                    case 6:
+                                        _b.sent();
+                                        return [3 /*break*/, 8];
+                                    case 7: return [3 /*break*/, 8];
+                                    case 8: return [3 /*break*/, 10];
+                                    case 9:
+                                        error_1 = _b.sent();
+                                        this.logger('[Chord Analytics]: Error sending queued event:', error_1);
+                                        return [3 /*break*/, 10];
+                                    case 10:
+                                        item.resolve();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(sendPromises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * Configure CDP with fresh consent categories before each event.
+         * Uses Jitsu's configure() to update privacy.consentCategories.
+         */
+        this.configureConsentOnCdp = function () {
+            if (!_this.consentConfig)
+                return;
+            var categories = _this.consentConfig.getCategories();
+            var privacyConfig = { privacy: { consentCategories: categories } };
+            var a = _this.ccdp();
+            if (a && typeof a.configure === 'function') {
+                a.configure(privacyConfig);
+            }
+            var b = _this.cdp();
+            if (b && typeof b.configure === 'function') {
+                b.configure(privacyConfig);
+            }
+        };
         this.validate = function (event, props) {
             if (!event) {
                 _this.logger('No event name provided');
                 return [{ success: false }];
             }
-            var schema = event && index_js_1.eventSchemas[event];
+            var schema = event && index_js_2.eventSchemas[event];
             if (!schema)
                 return [{ success: true, data: props }];
             return schema.map(function (s) { return s.safeParse(props); });
@@ -159,21 +314,58 @@ var ChordAnalytics = /** @class */ (function () {
         };
         /**
          * Send a `track` event to the CDP with any event name and properties.
+         * If consent is not ready, the event is queued until consent is available.
          */
         this.track = function (event, props, options) { return __awaiter(_this, void 0, void 0, function () {
-            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, finalEventProps;
-            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log("[Chord Analytics DEBUG]: track() called with event: \"".concat(event, "\""));
+                        }
                         if (!event)
                             this.logger('No event name provided');
                         if (!this.cdpReadyPromise) return [3 /*break*/, 2];
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") waiting for cdpReadyPromise"));
+                        }
                         return [4 /*yield*/, this.cdpReadyPromise];
                     case 1:
                         _a.sent();
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") cdpReadyPromise resolved"));
+                        }
                         _a.label = 2;
                     case 2:
+                        // If consent is configured but not ready, queue the event
+                        if (this.consentConfig && !this.consentConfig.isConsentReady()) {
+                            if (this.options.enableLogging && this.options.debug) {
+                                // eslint-disable-next-line no-console
+                                console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") consent not ready, queuing event"));
+                            }
+                            return [2 /*return*/, this.queueEventForConsent('track', [event, props, options])];
+                        }
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") sending event now"));
+                        }
+                        // Consent ready (or not configured) - send immediately
+                        return [2 /*return*/, this.sendTrackEvent(event, props, options)];
+                }
+            });
+        }); };
+        /**
+         * Internal method to actually send a track event to CDP.
+         */
+        this.sendTrackEvent = function (event, props, options) { return __awaiter(_this, void 0, void 0, function () {
+            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, finalEventProps;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
                         formattedProps = this.options.stripNull && props ? (0, utils_js_1.pruneNullValues)(props) : props;
                         middlewareProps = {};
                         if (this.middleware.length > 0) {
@@ -215,7 +407,9 @@ var ChordAnalytics = /** @class */ (function () {
                                 }
                             });
                         }
-                        return [2 /*return*/, new Promise(function (resolve) {
+                        // Configure CDP with fresh consent before sending
+                        this.configureConsentOnCdp();
+                        return [4 /*yield*/, new Promise(function (resolve) {
                                 var cdpPromises = [];
                                 try {
                                     var a_1 = _this.ccdp();
@@ -247,19 +441,104 @@ var ChordAnalytics = /** @class */ (function () {
                                     resolve();
                                 }
                             })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         }); };
         /**
          * Send an `identify` event to the CDP with user id and traits.
+         * If consent is not ready, the event is queued until consent is available.
          */
-        this.identify = function () {
-            var props = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                props[_i] = arguments[_i];
-            }
+        this.identify = function (userIdOrTraits, traitsOrOptions, options) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.cdpReadyPromise) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cdpReadyPromise];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // If consent is configured but not ready, queue the event
+                        if (this.consentConfig && !this.consentConfig.isConsentReady()) {
+                            return [2 /*return*/, this.queueEventForConsent('identify', [
+                                    userIdOrTraits,
+                                    traitsOrOptions,
+                                    options,
+                                ])];
+                        }
+                        // Consent ready (or not configured) - send immediately
+                        return [2 /*return*/, this.sendIdentifyEvent(userIdOrTraits, traitsOrOptions, options)];
+                }
+            });
+        }); };
+        /**
+         * Internal method to actually send an identify event to CDP.
+         */
+        this.sendIdentifyEvent = function (userIdOrTraits, traitsOrOptions, options) { return __awaiter(_this, void 0, void 0, function () {
+            var userId, traits, opts, identifyPromises, a_2, b_2, results, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof userIdOrTraits === 'string') {
+                            userId = userIdOrTraits;
+                            traits = traitsOrOptions;
+                            opts = options;
+                        }
+                        else {
+                            traits = userIdOrTraits;
+                            opts = traitsOrOptions;
+                        }
+                        // Configure CDP with fresh consent before sending
+                        this.configureConsentOnCdp();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        identifyPromises = [];
+                        a_2 = this.ccdp();
+                        if (a_2 && typeof a_2.identify === 'function') {
+                            identifyPromises.push(new Promise(function (resolve) {
+                                if (userId) {
+                                    a_2.identify(userId, traits, opts, function () { return resolve(); });
+                                }
+                                else {
+                                    a_2.identify(traits, opts, function () { return resolve(); });
+                                }
+                            }));
+                        }
+                        b_2 = this.cdp();
+                        if (b_2 && typeof b_2.identify === 'function') {
+                            identifyPromises.push(new Promise(function (resolve) {
+                                if (userId) {
+                                    b_2.identify(userId, traits, opts, function () { return resolve(); });
+                                }
+                                else {
+                                    b_2.identify(traits, opts, function () { return resolve(); });
+                                }
+                            }));
+                        }
+                        return [4 /*yield*/, Promise.allSettled(identifyPromises)];
+                    case 2:
+                        results = _a.sent();
+                        this.logger('identify event sent', results);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        this.logger(error_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * Send a `page` event to the CDP.
+         * If consent is not ready, the event is queued until consent is available.
+         */
+        this.page = function (options, props) {
+            if (props === void 0) { props = {}; }
             return __awaiter(_this, void 0, void 0, function () {
-                var identifyPromises, a_2, b_2, results, error_1;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
@@ -269,80 +548,55 @@ var ChordAnalytics = /** @class */ (function () {
                             _a.sent();
                             _a.label = 2;
                         case 2:
-                            _a.trys.push([2, 4, , 5]);
-                            identifyPromises = [];
-                            a_2 = this.ccdp();
-                            if (a_2 && typeof a_2.identify === 'function') {
-                                identifyPromises.push(new Promise(function (resolve) {
-                                    a_2.identify.apply(a_2, __spreadArray(__spreadArray([], props, false), [function () { return resolve(); }], false));
-                                }));
-                            }
-                            b_2 = this.cdp();
-                            if (b_2 && typeof b_2.identify === 'function') {
-                                identifyPromises.push(new Promise(function (resolve) {
-                                    b_2.identify.apply(b_2, __spreadArray(__spreadArray([], props, false), [function () { return resolve(); }], false));
-                                }));
+                            // If consent is configured but not ready, queue the event
+                            if (this.consentConfig && !this.consentConfig.isConsentReady()) {
+                                return [2 /*return*/, this.queueEventForConsent('page', [options, props])];
                             }
-                            return [4 /*yield*/, Promise.allSettled(identifyPromises)];
-                        case 3:
-                            results = _a.sent();
-                            this.logger('identify event sent', results);
-                            return [3 /*break*/, 5];
-                        case 4:
-                            error_1 = _a.sent();
-                            this.logger(error_1);
-                            return [3 /*break*/, 5];
-                        case 5: return [2 /*return*/];
+                            // Consent ready (or not configured) - send immediately
+                            return [2 /*return*/, this.sendPageEvent(options, props)];
                     }
                 });
             });
         };
         /**
-         * Send a `page` event to the CDP.
+         * Internal method to actually send a page event to CDP.
          */
-        this.page = function (props) {
+        this.sendPageEvent = function (options, props) {
             if (props === void 0) { props = {}; }
             return __awaiter(_this, void 0, void 0, function () {
                 var pagePromises, a_3, b_3;
                 var _this = this;
                 return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!this.cdpReadyPromise) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this.cdpReadyPromise];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            try {
-                                pagePromises = [];
-                                a_3 = this.ccdp();
-                                if (a_3 && typeof a_3.page === 'function') {
-                                    pagePromises.push(new Promise(function (resolve) {
-                                        a_3.page(__assign(__assign({}, props), { meta: _this.meta() }), function () { return resolve(); });
-                                    }));
-                                }
-                                b_3 = this.cdp();
-                                if (b_3 && typeof b_3.page === 'function') {
-                                    pagePromises.push(new Promise(function (resolve) {
-                                        b_3.page(__assign(__assign({}, props), { meta: _this.meta() }), function () { return resolve(); });
-                                    }));
-                                }
-                                // We don't return the promise to maintain the void return type
-                                Promise.allSettled(pagePromises).then(function (results) {
-                                    _this.logger('page event sent', results);
-                                });
-                            }
-                            catch (error) {
-                                this.logger(error);
-                            }
-                            return [2 /*return*/];
+                    // Configure CDP with fresh consent before sending
+                    this.configureConsentOnCdp();
+                    try {
+                        pagePromises = [];
+                        a_3 = this.ccdp();
+                        if (a_3 && typeof a_3.page === 'function') {
+                            pagePromises.push(new Promise(function (resolve) {
+                                a_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () { return resolve(); });
+                            }));
+                        }
+                        b_3 = this.cdp();
+                        if (b_3 && typeof b_3.page === 'function') {
+                            pagePromises.push(new Promise(function (resolve) {
+                                b_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () { return resolve(); });
+                            }));
+                        }
+                        // We don't return the promise to maintain the void return type
+                        Promise.allSettled(pagePromises).then(function (results) {
+                            _this.logger('page event sent', results);
+                        });
                     }
+                    catch (error) {
+                        this.logger(error);
+                    }
+                    return [2 /*return*/];
                 });
             });
         };
         this.reset = function () { return __awaiter(_this, void 0, void 0, function () {
-            var a, b, maxAttempts, attempts, userState, error_2;
+            var a, b, maxAttempts, attempts, userState, error_3;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -380,8 +634,8 @@ var ChordAnalytics = /** @class */ (function () {
                         return [3 /*break*/, 1];
                     case 3: return [3 /*break*/, 6];
                     case 4:
-                        error_2 = _b.sent();
-                        this.logger(error_2);
+                        error_3 = _b.sent();
+                        this.logger(error_3);
                         return [3 /*break*/, 6];
                     case 5:
                         this.resetInProgress = false;
@@ -855,31 +1109,71 @@ var ChordAnalytics = /** @class */ (function () {
             stripNull: true,
         };
         this.options = __assign(__assign({}, defaults), options);
+        if (this.options.consent) {
+            var consentManager = (0, index_js_1.addCdpConsent)(this.options);
+            this.consentConfig = consentManager.getConsentConfig() || null;
+        }
         if (((_b = this.options) === null || _b === void 0 ? void 0 : _b.cdpDomain) && ((_c = this.options) === null || _c === void 0 ? void 0 : _c.cdpWriteKey) && window) {
             window[this.options.namespace] = (window === null || window === void 0 ? void 0 : window[this.options.namespace]) || this;
             this.initializeCdp();
         }
     }
     /**
-     * Initialize CDP snippet and wait for it to be ready
+     * Initialize CDP snippet and wait for it to be ready.
+     * Fires initial consent track event after CDP is fully initialized to avoid circular await.
      */
     ChordAnalytics.prototype.initializeCdp = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var error_3;
+            var snippetPromise, initialConsent, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        this.cdpReadyPromise = (0, cdp_js_1.addCdpSnippet)(this.options);
-                        return [4 /*yield*/, this.cdpReadyPromise];
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: initializeCdp() started');
+                        }
+                        _a.label = 1;
                     case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
+                        _a.trys.push([1, 6, , 7]);
+                        snippetPromise = (0, cdp_js_1.addCdpSnippet)(this.options);
+                        // Create a void promise for cdpReadyPromise that resolves when snippet is done
+                        // eslint-disable-next-line @typescript-eslint/no-empty-function
+                        this.cdpReadyPromise = snippetPromise.then(function () { });
+                        return [4 /*yield*/, snippetPromise];
                     case 2:
-                        error_3 = _a.sent();
-                        console.error('CDP initialization failed:', error_3);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                        initialConsent = (_a.sent()).initialConsent;
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: snippetPromise resolved, initialConsent:', JSON.stringify(initialConsent));
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: consentCategories defined?', (initialConsent === null || initialConsent === void 0 ? void 0 : initialConsent.consentCategories) !== undefined);
+                        }
+                        if (!(initialConsent && initialConsent.consentCategories !== undefined)) return [3 /*break*/, 4];
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: About to call this.track() for Consent Preferences Updated');
+                        }
+                        return [4 /*yield*/, this.track('Consent Preferences Updated', initialConsent)];
+                    case 3:
+                        _a.sent();
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: Initial consent preferences tracked');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        if (this.options.enableLogging && this.options.debug) {
+                            // eslint-disable-next-line no-console
+                            console.log('[Chord Analytics DEBUG]: Skipping initial consent track - no consent or no consentCategories');
+                        }
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_4 = _a.sent();
+                        // eslint-disable-next-line no-console
+                        console.error('CDP initialization failed:', error_4);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
                 }
             });
         });

package/dist/cjs/types/consent.d.ts

@@ -1,11 +1,22 @@
 export interface ConsentAdapter {
     getCurrentConsent: () => ConsentConfiguration | Promise<ConsentConfiguration>;
-    handleConsentUpdates: (fn: (ConsentConfiguration: any) => void) => void;
+    handleConsentUpdates: (fn: (consent: ConsentConfiguration) => void) => void;
     userCanBeTracked: () => boolean | Promise<boolean>;
+    /**
+     * Get current consent categories - called FRESH on every event, no caching!
+     */
+    getCategories?: () => Record<string, boolean>;
+    /**
+     * Check if consent manager is ready (duck typing check)
+     */
+    isConsentReady?: () => boolean;
+    /**
+     * Get the consent model ('opt-in' or 'opt-out')
+     */
+    getConsentModel?: () => 'opt-in' | 'opt-out';
 }
 export interface ConsentConfiguration {
     consentCategories?: {
         [key: string]: boolean;
     };
-    dontSend?: boolean;
 }

package/dist/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/client/cdp.js

@@ -1,3 +1,4 @@
+/* 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) {
@@ -11,10 +12,12 @@ import { addCdpConsent } from './consent/index.js';
 import { normalizeCDPDomain } from './utils.js';
 /*
  * Adds the Chord CDP snippet to the page.
+ * Returns initial consent configuration to be tracked after CDP is fully ready.
  */
 export const addCdpSnippet = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!document || typeof document.createElement === 'undefined')
-        return;
+    if (!document || typeof document.createElement === 'undefined') {
+        return { initialConsent: null };
+    }
     const normalizedCDPDomain = normalizeCDPDomain(options.cdpDomain);
     // Create a promise that resolves when CDP is ready
     const cdpReadyPromise = new Promise((resolve) => {
@@ -39,15 +42,20 @@ export const addCdpSnippet = (options) => __awaiter(void 0, void 0, void 0, func
     document.head.appendChild(s);
     // Wait for CDP to be ready before setting up consent
     yield cdpReadyPromise;
+    let initialConsent = null;
     if (options.consent) {
         if (options.debug && options.enableLogging) {
-            console.log('Chord CDP: Setting up consent management');
+            console.log('[Chord Analytics DEBUG]: Setting up consent management');
         }
-        yield addCdpConsent(options).init();
+        initialConsent = yield addCdpConsent(options).init();
         if (options.debug && options.enableLogging) {
-            console.log('Chord CDP: Consent management setup complete');
+            console.log('[Chord Analytics DEBUG]: Consent management setup complete');
         }
     }
+    if (options.debug && options.enableLogging) {
+        console.log('[Chord Analytics DEBUG]: CDP snippet added, initialConsent:', JSON.stringify(initialConsent));
+    }
+    return { initialConsent };
 });
 /*
  * Returns the CDP queue to hold events ahead of CDP initialization.