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

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

@@ -1,85 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onetrustConsentAdapter = void 0;
-/**
- * Returns OneTrust's API.
- */
-var getApi = function () {
-    var oneTrust = window.OneTrust;
-    if (oneTrust &&
-        typeof oneTrust === 'object' &&
-        'OnConsentChanged' in oneTrust &&
-        'GetDomainData' in oneTrust) {
-        return oneTrust;
-    }
-    return undefined;
-};
+var onetrust_api_js_1 = require("./onetrust-api.js");
 /**
  * Returns whether the user can currently be tracked.
+ * Uses duck typing to check if OneTrust is fully loaded.
  */
 var userCanBeTracked = function () {
-    // Always loads, a la `consentModel: 'opt-out'` in the Segment wrapper.
-    var api = getApi();
-    return !!api;
+    // Always loads when OneTrust is ready, a la `consentModel: 'opt-out'`
+    return !!(0, onetrust_api_js_1.getOneTrustGlobal)();
 };
 /**
  * Returns the user's current consent configuration.
+ * Reads FRESH from OneTrust - no caching!
  */
 var getCurrentConsent = function () {
-    var api = getApi();
-    var activeGroups = window.OnetrustActiveGroups;
-    if (!api || !activeGroups || typeof activeGroups !== 'string')
+    var api = (0, onetrust_api_js_1.getOneTrustGlobal)();
+    if (!api)
         return {};
-    var activeGroupIds = new Set(activeGroups.trim().split(',').filter(Boolean));
     return {
-        consentCategories: api
-            .GetDomainData()
-            .Groups.reduce(function (acc, _a) {
-            var CustomGroupId = _a.CustomGroupId;
-            var groupId = CustomGroupId.trim();
-            acc[groupId] = activeGroupIds.has(groupId);
-            return acc;
-        }, {}),
-        dontSend: !userCanBeTracked(),
+        consentCategories: (0, onetrust_api_js_1.getNormalizedCategories)(),
     };
 };
 /**
  * Handles subsequent changes to consent configuration.
+ * Sets up OnConsentChanged listener with retry logic.
  */
 var handleConsentUpdates = function (updateCdpConsent, options) {
     var maxRetries = 100;
     var retryInterval = 50;
     var attempts = 0;
     var setupHandler = function () {
-        var api = getApi();
+        var api = (0, onetrust_api_js_1.getOneTrustGlobal)();
         if (!api) {
             attempts++;
             if (attempts < maxRetries) {
                 if (options.debug && options.enableLogging) {
-                    // eslint-disable-next-line no-console
-                    console.log('OneTrust API not found, retrying...');
+                    console.log('[Chord Analytics DEBUG]: OneTrust API not found, retrying...');
                 }
                 setTimeout(setupHandler, retryInterval);
             }
             return;
         }
         if (options.debug && options.enableLogging) {
-            // eslint-disable-next-line no-console
-            console.log('OneTrust API found, setting up consent changed handler');
+            console.log('[Chord Analytics DEBUG]: OneTrust API found, setting up consent changed handler');
         }
         api.OnConsentChanged(function () {
             updateCdpConsent(getCurrentConsent());
+            if (options.debug && options.enableLogging) {
+                console.log('[Chord Analytics DEBUG]: OneTrust consent changed, sending Consent Preferences Updated track event');
+            }
         });
     };
     setupHandler();
 };
 var onetrustConsentAdapter = function (options) {
     return {
+        // Existing methods for backwards compatibility
         getCurrentConsent: getCurrentConsent,
         handleConsentUpdates: function (updateCdpConsent) {
             handleConsentUpdates(updateCdpConsent, options);
         },
         userCanBeTracked: userCanBeTracked,
+        getCategories: function () { return (0, onetrust_api_js_1.getNormalizedCategories)(); },
+        isConsentReady: function () { return !!(0, onetrust_api_js_1.getOneTrustGlobal)(); },
+        getConsentModel: function () {
+            var api = (0, onetrust_api_js_1.getOneTrustGlobal)();
+            if (!api)
+                return 'opt-out';
+            return (0, onetrust_api_js_1.coerceConsentModel)(api.GetDomainData().ConsentModel.Name);
+        },
+        getApi: onetrust_api_js_1.getOneTrustGlobal,
     };
 };
 exports.onetrustConsentAdapter = onetrustConsentAdapter;

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

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

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

@@ -110,20 +110,16 @@ var userCanBeTracked = function () { return __awaiter(void 0, void 0, void 0, fu
  */
 var getCurrentConsent = function () { return __awaiter(void 0, void 0, void 0, function () {
     var api;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
             case 0: return [4 /*yield*/, waitForApi()];
             case 1:
-                api = _b.sent();
+                api = _a.sent();
                 if (!api)
                     return [2 /*return*/, {}];
-                _a = {
-                    consentCategories: __assign(__assign({}, api.customPreferences), api.destinationPreferences)
-                };
-                return [4 /*yield*/, userCanBeTracked()];
-            case 2: return [2 /*return*/, (_a.dontSend = !(_b.sent()),
-                    _a)];
+                return [2 /*return*/, {
+                        consentCategories: __assign(__assign({}, api.customPreferences), api.destinationPreferences),
+                    }];
         }
     });
 }); };
@@ -150,6 +146,16 @@ var segmentConsentAdapter = function () {
         getCurrentConsent: getCurrentConsent,
         handleConsentUpdates: handleConsentUpdates,
         userCanBeTracked: userCanBeTracked,
+        getCategories: function () {
+            var api = getApi();
+            if (!(api === null || api === void 0 ? void 0 : api.customPreferences))
+                return {};
+            return __assign(__assign({}, api.customPreferences), api.destinationPreferences);
+        },
+        isConsentReady: function () {
+            var api = getApi();
+            return !!((api === null || api === void 0 ? void 0 : api.customPreferences) && Object.keys(api.customPreferences).length > 0);
+        },
     };
 };
 exports.segmentConsentAdapter = segmentConsentAdapter;

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

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

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

@@ -30,7 +30,6 @@ var getCurrentConsent = function () {
             preferences: api.preferencesProcessingAllowed(),
             sale_of_data: api.saleOfDataAllowed(),
         },
-        dontSend: !userCanBeTracked(),
     };
 };
 /**
@@ -46,6 +45,18 @@ var shopifyConsentAdapter = function () {
         getCurrentConsent: getCurrentConsent,
         handleConsentUpdates: handleConsentUpdates,
         userCanBeTracked: userCanBeTracked,
+        getCategories: function () {
+            var api = getApi();
+            if (!api)
+                return {};
+            return {
+                analytics: api.analyticsProcessingAllowed(),
+                marketing: api.marketingAllowed(),
+                preferences: api.preferencesProcessingAllowed(),
+                sale_of_data: api.saleOfDataAllowed(),
+            };
+        },
+        isConsentReady: function () { return !!getApi(); },
     };
 };
 exports.shopifyConsentAdapter = shopifyConsentAdapter;

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

@@ -30,10 +30,24 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
      * Promise that resolves when CDP is ready
      */
     private cdpReadyPromise;
+    private consentConfig;
     private resetInProgress;
+    /**
+     * Queue for events waiting for consent to be ready
+     */
+    private consentEventQueue;
+    /**
+     * Whether we're currently waiting for consent and watching for it
+     */
+    private consentWatcherActive;
+    /**
+     * Promise that resolves when consent is ready (shared across all queued events)
+     */
+    private consentReadyPromise;
     constructor(options: ChordAnalyticsOptions<T>);
     /**
-     * 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.
      */
     private initializeCdp;
     /**
@@ -45,6 +59,29 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
     ccdp: () => AnyAnalytics;
     logger: (message?: any, ...optionalParams: any[]) => void;
     isResetting: () => boolean;
+    /**
+     * Wait for consent manager to be ready (no timeout - queues indefinitely).
+     * Uses a shared promise so multiple events share the same watcher.
+     */
+    private waitForConsent;
+    /**
+     * Queue an event to be sent when consent is ready.
+     * Starts a consent watcher if not already active.
+     */
+    private queueEventForConsent;
+    /**
+     * Watch for consent to become ready, then flush the queue.
+     */
+    private watchForConsentAndFlush;
+    /**
+     * Flush all queued events now that consent is ready.
+     */
+    private flushConsentQueue;
+    /**
+     * Configure CDP with fresh consent categories before each event.
+     * Uses Jitsu's configure() to update privacy.consentCategories.
+     */
+    private configureConsentOnCdp;
     validate: (event: string, props: EventProperties) => ValidateResult[];
     /**
      * Generate the event `meta` property.
@@ -67,21 +104,36 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
     addSourceMiddleware: (func: AnalyticsMiddleware) => void;
     /**
      * 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.
      */
     track: (event: string, props?: EventProperties, options?: Options) => Promise<void>;
+    /**
+     * Internal method to actually send a track event to CDP.
+     */
+    private sendTrackEvent;
     /**
      * 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.
      */
     identify: {
         (userId?: string, traits?: IdentifyTraits, options?: AnyOptions): Promise<void>;
         (traits?: IdentifyTraits, options?: AnyOptions): Promise<void>;
     };
+    /**
+     * Internal method to actually send an identify event to CDP.
+     */
+    private sendIdentifyEvent;
     /**
      * Send a `page` event to the CDP.
+     * If consent is not ready, the event is queued until consent is available.
      */
     page: {
-        (props?: Record<string, any>): void;
+        (props?: Record<string, any>, options?: Options): void;
     };
+    /**
+     * Internal method to actually send a page event to CDP.
+     */
+    private sendPageEvent;
     reset: () => Promise<void>;
     trackCartViewed: (props: CartViewedInput<T>, options?: AnyOptions) => Promise<void>;
     trackCheckoutStarted: (props: CheckoutStartedInput<T>, options?: AnyOptions) => Promise<void>;