@chordcommerce/analytics 1.12.1 → 1.13.0

package/dist/client/cdp.js

@@ -21,9 +21,21 @@ export const addCdpSnippet = (options) => __awaiter(void 0, void 0, void 0, func
     s.setAttribute('data-init-only', 'true');
     s.setAttribute('data-namespace', `_${options.namespace}`);
     s.setAttribute('data-write-key', options.cdpWriteKey);
-    if (options.consent)
-        yield addCdpConsent(options).init();
-    document.head.appendChild(s);
+    if (options.consent) {
+        // If awaitConsent is true, wait for consent before loading CDP
+        if (options.awaitConsent) {
+            yield addCdpConsent(options).init();
+            document.head.appendChild(s);
+        }
+        else {
+            document.head.appendChild(s);
+            // If not awaiting consent, initialize in the background
+            addCdpConsent(options).init().catch(console.error);
+        }
+    }
+    else {
+        document.head.appendChild(s);
+    }
 });
 /*
  * Returns the CDP queue to hold events ahead of CDP initialization.

package/dist/client/consent/index.js

@@ -11,7 +11,9 @@ import { ketchConsentAdapter } from './ketch.js';
 import { onetrustConsentAdapter } from './onetrust.js';
 import { shopifyConsentAdapter } from './shopify.js';
 export const addCdpConsent = (options) => {
-    let adapter;
+    let adapter = null;
+    const POLLING_INTERVAL_MS = 50;
+    const TIMEOUT_MS = 60000;
     /**
      * Returns the adapter for the specified consent management platform.
      */
@@ -29,10 +31,10 @@ export const addCdpConsent = (options) => {
         }
     };
     /**
-     * Returns whether the CDP should be loaded based on the current consent.
-     * Resolves to true when consent is granted, or false after a 10-second timeout.
+     * Polls if user can be tracked based on consent
+     * @returns Promise that resolves to true if condition is met within timeout, false otherwise
      */
-    const shouldLoadCdp = () => __awaiter(void 0, void 0, void 0, function* () {
+    const checkUserCanBeTracked = () => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
             // Checking immediately first
             if (adapter === null || adapter === void 0 ? void 0 : adapter.userCanBeTracked()) {
@@ -44,11 +46,11 @@ export const addCdpConsent = (options) => {
                     clearInterval(interval);
                     resolve(true);
                 }
-            }, 50);
+            }, POLLING_INTERVAL_MS);
             setTimeout(() => {
                 clearInterval(interval);
                 resolve(false);
-            }, 10000);
+            }, TIMEOUT_MS);
         });
     });
     /**
@@ -65,16 +67,40 @@ export const addCdpConsent = (options) => {
         }
     };
     /**
-     * Adds consent management by setting defaults and handling changes.
+     * Sets up consent management by initializing the adapter and handling consent updates.
+     */
+    const setupConsentManagement = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!adapter)
+            return;
+        const isReady = yield checkUserCanBeTracked();
+        if (!isReady)
+            return;
+        const initialConsent = adapter.getCurrentConsent();
+        updateCdpConsent(initialConsent);
+        adapter.handleConsentUpdates((updatedConsent) => {
+            updateCdpConsent(updatedConsent);
+        });
+    });
+    /**
+     * Initializes consent management.
+     * Returns a promise that resolves to true if CDP should be loaded, false otherwise.
      */
     const init = () => __awaiter(void 0, void 0, void 0, function* () {
         adapter = getAdapter();
-        if (adapter === null)
-            return Promise.resolve(false);
-        yield shouldLoadCdp();
-        updateCdpConsent(adapter === null || adapter === void 0 ? void 0 : adapter.getCurrentConsent());
-        adapter === null || adapter === void 0 ? void 0 : adapter.handleConsentUpdates(updateCdpConsent);
-        return Promise.resolve(true);
+        if (adapter === null) {
+            console.error(`Consent management adapter "${options.consent}" is not supported.`);
+            return false;
+        }
+        if (options.awaitConsent) {
+            const canBeTracked = yield checkUserCanBeTracked();
+            if (!canBeTracked)
+                return false;
+        }
+        // Set up consent management in the background
+        setupConsentManagement().catch((error) => {
+            console.error('Error setting up consent management:', error);
+        });
+        return true;
     });
     return {
         init,

package/dist/client/index.d.ts

@@ -67,7 +67,7 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
      * Send a `page` event to the CDP.
      */
     page: {
-        (): void;
+        (props?: Record<string, any>): void;
     };
     reset: () => void;
     trackCartViewed: (props: CartViewedInput<T>, options?: AnyOptions) => Promise<void>;

package/dist/client/index.js

@@ -167,19 +167,19 @@ export class ChordAnalytics {
         /**
          * Send a `page` event to the CDP.
          */
-        this.page = () => {
+        this.page = (props = {}) => {
             try {
                 const pagePromises = [];
                 const a = this.ccdp();
                 if (a && typeof a.page === 'function') {
                     pagePromises.push(new Promise((resolve) => {
-                        a.page({ meta: this.meta() }, () => resolve());
+                        a.page(Object.assign(Object.assign({}, props), { meta: this.meta() }), () => resolve());
                     }));
                 }
                 const b = this.cdp();
                 if (b && typeof b.page === 'function') {
                     pagePromises.push(new Promise((resolve) => {
-                        b.page({ meta: this.meta() }, () => resolve());
+                        b.page(Object.assign(Object.assign({}, props), { meta: this.meta() }), () => resolve());
                     }));
                 }
                 // We don't return the promise to maintain the void return type
@@ -609,6 +609,7 @@ export class ChordAnalytics {
             enableLogging: debug,
             namespace: 'chord',
             stripNull: true,
+            awaitConsent: true,
         };
         this.options = Object.assign(Object.assign({}, defaults), options);
         if (((_b = this.options) === null || _b === void 0 ? void 0 : _b.cdpDomain) && ((_c = this.options) === null || _c === void 0 ? void 0 : _c.cdpWriteKey) && window) {

package/dist/types/client.d.ts

@@ -31,6 +31,7 @@ export interface ChordAnalyticsOptions<T extends ObjectTypes = ObjectTypes> {
     cdpDomain?: string;
     cdpWriteKey?: string;
     consent?: 'ketch' | 'onetrust' | 'shopify';
+    awaitConsent?: boolean;
     debug?: boolean;
     enableLogging?: boolean;
     formatters: ChordAnalyticsFormatters<T>;

package/package.json

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