@chordcommerce/analytics 1.9.1 → 1.11.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,69 @@
+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 { ketchConsentAdapter } from './ketch.js';
+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 'ketch':
+                return ketchConsentAdapter();
+            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);
+        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);
+    });
+    return {
+        init,
+    };
+};

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

@@ -0,0 +1,16 @@
+import type { ConsentConfiguration } from '../../types/index.js';
+declare global {
+    interface Window {
+        ketch?: (action: string, eventName: string, handler: () => void) => undefined;
+        ketchConsent?: KetchConsentCategories;
+    }
+}
+interface KetchConsentCategories {
+    [key: string]: boolean;
+}
+export declare const ketchConsentAdapter: () => {
+    getCurrentConsent: () => ConsentConfiguration;
+    handleConsentUpdates: (updateCdpConsent: (consent: ConsentConfiguration) => void) => void;
+    userCanBeTracked: () => boolean;
+};
+export {};

package/dist/client/consent/ketch.js

@@ -0,0 +1,38 @@
+/**
+ * Returns Ketch's consent categories.
+ */
+const getApi = () => window.ketch && window.ketchConsent;
+/**
+ * Returns whether the user can currently be tracked.
+ */
+const userCanBeTracked = () => {
+    const api = getApi();
+    return api && !!Object.keys(api).length;
+};
+/**
+ * Returns the user's current consent configuration.
+ */
+const getCurrentConsent = () => {
+    const api = getApi();
+    if (!api)
+        return {};
+    return {
+        consentCategories: Object.assign({}, api),
+        dontSend: !userCanBeTracked(),
+    };
+};
+/**
+ * Handles subsequent changes to consent configuration.
+ */
+const handleConsentUpdates = (updateCdpConsent) => {
+    window.ketch('addListener', 'consent', () => {
+        updateCdpConsent(getCurrentConsent());
+    });
+};
+export const ketchConsentAdapter = () => {
+    return {
+        getCurrentConsent,
+        handleConsentUpdates,
+        userCanBeTracked,
+    };
+};

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/types/client.d.ts

@@ -30,6 +30,7 @@ export interface ChordAnalyticsOptions<T extends ObjectTypes = ObjectTypes> {
     cdp?: AnyAnalytics | (() => AnyAnalytics);
     cdpDomain?: string;
     cdpWriteKey?: string;
+    consent?: 'ketch' | '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.1",
+  "version": "1.11.0",
   "author": "Chord Commerce <help@chord.co> (https://www.chord.co)",
   "type": "module",
   "main": "dist/index.js",