@chordcommerce/analytics 1.9.0 → 1.10.0

package/dist/client/cdp.d.ts

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

package/dist/client/cdp.js

@@ -1,7 +1,17 @@
+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());
+    });
+};
+import { addCdpConsent } from './consent/index.js';
 /*
  * Adds the Chord CDP snippet to the page.
  */
-export const addCdpSnippet = (options) => {
+export const addCdpSnippet = (options) => __awaiter(void 0, void 0, void 0, function* () {
     if (!document || typeof document.createElement === 'undefined')
         return;
     const s = document.createElement('script');
@@ -11,8 +21,10 @@ export const addCdpSnippet = (options) => {
     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);
-};
+});
 /*
  * Returns the CDP queue to hold events ahead of CDP initialization.
  */

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

@@ -0,0 +1,11 @@
+import type { ChordAnalyticsOptions, ConsentConfiguration } from '../../types/index.js';
+declare global {
+    interface Window {
+        jitsuConfig: {
+            privacy: ConsentConfiguration;
+        };
+    }
+}
+export declare const addCdpConsent: (options: ChordAnalyticsOptions) => {
+    init: () => Promise<boolean>;
+};

package/dist/client/consent/index.js

@@ -0,0 +1,65 @@
+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());
+    });
+};
+import { shopifyConsentAdapter } from './shopify.js';
+export const addCdpConsent = (options) => {
+    let adapter;
+    /**
+     * Returns the adapter for the specified consent management platform.
+     */
+    const getAdapter = () => {
+        var _a;
+        switch ((_a = options.consent) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {
+            case 'shopify':
+                return shopifyConsentAdapter();
+            default:
+                return null;
+        }
+    };
+    /**
+     * Returns whether the CDP should be loaded based on the current consent.
+     */
+    const shouldLoadCdp = () => __awaiter(void 0, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const interval = setInterval(() => {
+                if (adapter === null || adapter === void 0 ? void 0 : adapter.userCanBeTracked()) {
+                    clearInterval(interval);
+                    resolve(true);
+                }
+            }, 500);
+        });
+    });
+    /**
+     * Updates consent for all future events.
+     */
+    const updateCdpConsent = (updatedConsent) => {
+        const cdp = window[`_${options.namespace}`];
+        if (cdp && typeof cdp.configure === 'function') {
+            cdp.configure({ privacy: updatedConsent });
+        }
+        else {
+            // CDP has not yet loaded via the snippet.
+            window.jitsuConfig = { privacy: updatedConsent };
+        }
+    };
+    /**
+     * Adds consent management by setting defaults and handling changes.
+     */
+    const init = () => __awaiter(void 0, void 0, void 0, function* () {
+        adapter = getAdapter();
+        if (adapter === null)
+            return Promise.resolve(false);
+        updateCdpConsent(adapter === null || adapter === void 0 ? void 0 : adapter.getCurrentConsent());
+        adapter === null || adapter === void 0 ? void 0 : adapter.handleConsentUpdates(updateCdpConsent);
+        return shouldLoadCdp();
+    });
+    return {
+        init,
+    };
+};

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

@@ -0,0 +1,21 @@
+import type { ConsentConfiguration } from '../../types/index.js';
+declare global {
+    interface Window {
+        Shopify?: {
+            customerPrivacy?: ShopifyCustomerPrivacyApi;
+        };
+    }
+}
+interface ShopifyCustomerPrivacyApi {
+    getRegion: () => string;
+    analyticsProcessingAllowed: () => boolean;
+    marketingAllowed: () => boolean;
+    preferencesProcessingAllowed: () => boolean;
+    saleOfDataAllowed: () => boolean;
+}
+export declare const shopifyConsentAdapter: () => {
+    getCurrentConsent: () => ConsentConfiguration;
+    handleConsentUpdates: (updateCdpConsent: (consent: ConsentConfiguration) => void) => void;
+    userCanBeTracked: () => boolean;
+};
+export {};

package/dist/client/consent/shopify.js

@@ -0,0 +1,47 @@
+/**
+ * Returns Shopify's Customer Privacy API.
+ */
+const getApi = () => { var _a; return (_a = window.Shopify) === null || _a === void 0 ? void 0 : _a.customerPrivacy; };
+/**
+ * Returns whether the user can currently be tracked.
+ */
+const userCanBeTracked = () => {
+    const api = getApi();
+    if (!api)
+        return false;
+    return !!(api.getRegion() &&
+        api.analyticsProcessingAllowed() &&
+        api.marketingAllowed());
+};
+/**
+ * Returns the user's current consent configuration.
+ */
+const getCurrentConsent = () => {
+    const api = getApi();
+    if (!api)
+        return {};
+    return {
+        consentCategories: {
+            analytics: api.analyticsProcessingAllowed(),
+            marketing: api.marketingAllowed(),
+            preferences: api.preferencesProcessingAllowed(),
+            sale_of_data: api.saleOfDataAllowed(),
+        },
+        dontSend: !userCanBeTracked(),
+    };
+};
+/**
+ * Handles subsequent changes to consent configuration.
+ */
+const handleConsentUpdates = (updateCdpConsent) => {
+    document.addEventListener('visitorConsentCollected', () => {
+        updateCdpConsent(getCurrentConsent());
+    });
+};
+export const shopifyConsentAdapter = () => {
+    return {
+        getCurrentConsent,
+        handleConsentUpdates,
+        userCanBeTracked,
+    };
+};

package/dist/client/index.d.ts

@@ -23,6 +23,7 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
     options: ChordAnalyticsOptions<T>;
     constructor(options: ChordAnalyticsOptions<T>);
     cdp: () => AnyAnalytics;
+    ccdp: () => AnyAnalytics;
     logger: (message?: any, ...optionalParams: any[]) => void;
     /**
      * Validate the body of a `track` event against the Chord tracking plan.

package/dist/client/index.js

@@ -22,15 +22,24 @@ export class ChordAnalytics {
          */
         this.invoked = true;
         /*
-         * Return the CDP instance or the queue.
+         * Return the CDP instance provided in `options.cdp`.
          */
         this.cdp = () => {
-            const { cdp, namespace } = this.options;
-            const a = cdp || (window === null || window === void 0 ? void 0 : window[`_${namespace}`]) || cdpQueue(namespace);
+            var _a;
+            const a = (_a = this.options) === null || _a === void 0 ? void 0 : _a.cdp;
             if (typeof a === 'function')
                 return a();
             return a;
         };
+        /*
+         * Return the Chord CDP instance or queue.
+         */
+        this.ccdp = () => {
+            const { cdpDomain, cdpWriteKey, namespace } = this.options;
+            if (!cdpDomain || !cdpWriteKey)
+                return null;
+            return (window === null || window === void 0 ? void 0 : window[`_${namespace}`]) || cdpQueue(namespace);
+        };
         /*
          * Log a message to the console if `options.enableLogging` is true.
          */
@@ -90,6 +99,10 @@ export class ChordAnalytics {
                     if (a && typeof a.track === 'function') {
                         a.track(event, finalEventProps, options, () => resolve());
                     }
+                    const b = this.ccdp();
+                    if (b && typeof b.track === 'function') {
+                        b.track(event, finalEventProps, options, () => resolve());
+                    }
                 }
                 catch (error) {
                     this.logger(error);
@@ -105,6 +118,10 @@ export class ChordAnalytics {
                 if (a && typeof a.identify === 'function') {
                     a.identify(...props);
                 }
+                const b = this.ccdp();
+                if (b && typeof b.identify === 'function') {
+                    b.identify(...props);
+                }
             }
             catch (error) {
                 this.logger(error);
@@ -119,6 +136,10 @@ export class ChordAnalytics {
                 if (a && typeof a.page === 'function') {
                     a.page({ meta: this.meta() });
                 }
+                const b = this.ccdp();
+                if (b && typeof b.page === 'function') {
+                    b.page({ meta: this.meta() });
+                }
             }
             catch (error) {
                 this.logger(error);
@@ -130,6 +151,10 @@ export class ChordAnalytics {
                 if (a && typeof a.reset === 'function') {
                     a.reset();
                 }
+                const b = this.ccdp();
+                if (b && typeof b.reset === 'function') {
+                    b.reset();
+                }
             }
             catch (error) {
                 this.logger(error);

package/dist/types/client.d.ts

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

package/dist/types/consent.d.ts

@@ -0,0 +1,11 @@
+export interface ConsentAdapter {
+    getCurrentConsent: () => ConsentConfiguration;
+    handleConsentUpdates: (fn: (ConsentConfiguration: any) => void) => void;
+    userCanBeTracked: () => boolean;
+}
+export interface ConsentConfiguration {
+    consentCategories?: {
+        [key: string]: boolean;
+    };
+    dontSend?: boolean;
+}

package/dist/types/consent.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -2,5 +2,6 @@ export type { AnalyticsSnippet, Analytics, AnalyticsBrowser, EventProperties, Op
 export * from './objects.js';
 export * from './typewriter.js';
 export * from './client.js';
+export * from './consent.js';
 export * from './input.js';
 export * from './formatters.js';

package/dist/types/index.js

@@ -1,5 +1,6 @@
 export * from './objects.js';
 export * from './typewriter.js';
 export * from './client.js';
+export * from './consent.js';
 export * from './input.js';
 export * from './formatters.js';

package/package.json

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