@mparticle/web-sdk 3.24.0 → 3.25.0

package/src/buttonTracking/buttonTracker.ts

@@ -1,12 +1,20 @@
 import { IMParticleWebSDKInstance } from '../mp-instance';
 import { isFunction } from '../utils';
-import { buildButtonClickEvent } from './buttonClickEvent';
-import { describeButtonClick, IButtonClick } from './buttonDescription';
+import { buildButtonClickEvent, buildLinkClickEvent } from './buttonClickEvent';
+import {
+    describeButtonClick,
+    describePaymentChoice,
+    IButtonClick,
+    IPaymentChoice,
+    isLinkClick,
+    isPicked,
+} from './buttonDescription';
 import {
     CheckoutIntentKind,
     CheckoutIntentSource,
     classifyIntent,
-    classifyIntentFrame,
+    classifyPaymentFrame,
+    PaymentFrameFamily,
 } from './checkoutIntent';
 import { findControl, isExcludedPath } from './controls';
 
@@ -37,6 +45,9 @@ type WindowWithBtn = Window & {
 export interface IButtonTrackerOptions {
     // The Rokt kit signal only runs when this init configures a Rokt kit.
     hasRoktKit: boolean;
+    // Button clicks and clicks on links that leave the page are logged apart.
+    logButtons: boolean;
+    logLinks: boolean;
 }
 
 const btnWindow = (): WindowWithBtn | null =>
@@ -137,12 +148,15 @@ const CAPTURE_PASSIVE: AddEventListenerOptions = {
 };
 const PASSIVE: AddEventListenerOptions = { passive: true };
 
-// Logs every button click as an mParticle event, and hands checkout intent to the
-// Rokt kit as a frozen {kind, t, source, pathname}. Submits and wallet frame focus feed the kit only.
+// Logs button clicks and clicks on links that leave the page as mParticle events, and hands checkout
+// intent to the Rokt kit as a frozen {kind, t, source, pathname}. Submits and wallet frame focus feed the kit only,
+// and so do payment picks: a payment radio's option names, or the payment family of a focused frame.
 export class ButtonTracker {
     private readonly mpInstance: IMParticleWebSDKInstance;
     private active = false;
     private hasRoktKit = false;
+    private logButtons = false;
+    private logLinks = false;
     // Bumped on reset so classification queued before it is dropped.
     private generation = 0;
     private lastCommitClick = -Infinity;
@@ -186,8 +200,13 @@ export class ButtonTracker {
             this.teardown();
         }
         this.hasRoktKit = options.hasRoktKit;
+        this.logButtons = options.logButtons;
+        this.logLinks = options.logLinks;
 
-        if (!this.eventsEnabled() && this.isKitSuppressed()) {
+        if (
+            (!(this.logButtons || this.logLinks) || !this.eventsEnabled()) &&
+            this.isKitSuppressed()
+        ) {
             this.log('opted out, not starting');
             return;
         }
@@ -358,7 +377,11 @@ export class ButtonTracker {
             return;
         }
         const layer = event.type;
-        const logsEvents = layer === 'click' && this.eventsEnabled();
+        const logsEvents =
+            layer === 'click' &&
+            (this.logButtons || this.logLinks) &&
+            this.eventsEnabled() &&
+            !this.hasTargetingOptOut();
         const signalsKit = !this.isKitSuppressed();
         if (!logsEvents && !signalsKit) {
             return;
@@ -372,9 +395,12 @@ export class ButtonTracker {
         // button that disables or relabels itself is seen as it was clicked.
         // Logging and the kit hand-off wait for the next paint.
         let click: IButtonClick | undefined;
+        let asLink = false;
         let box: HTMLInputElement | undefined;
         let kind: CheckoutIntentKind | undefined;
         let source: CheckoutIntentSource | undefined;
+        let choice: IPaymentChoice | undefined;
+        let family: PaymentFrameFamily | undefined;
         let unconfirmedCommit = false;
         if (layer === 'click') {
             // The composed path is only populated during dispatch.
@@ -384,9 +410,28 @@ export class ButtonTracker {
             const excluded = isExcludedPath(path);
             const control = excluded ? undefined : findControl(path, true);
             if (control) {
-                click = logsEvents
-                    ? describeButtonClick(control, path)
-                    : undefined;
+                // With links alone, only an anchor can be logged.
+                click =
+                    logsEvents &&
+                    (this.logButtons || control.matches('a[href]'))
+                        ? describeButtonClick(control, path)
+                        : undefined;
+                if (click) {
+                    asLink = this.logLinks && isLinkClick(click);
+                    // Without link tracking, a link that leaves the page stays a
+                    // button click, except a plain link to another page of the
+                    // site, which button tracking never logged.
+                    const asButton =
+                        this.logButtons &&
+                        !asLink &&
+                        !(
+                            click.linkType === 'internal' &&
+                            control.matches('a[href]:not([role="button"])')
+                        );
+                    if (!asLink && !asButton) {
+                        click = undefined;
+                    }
+                }
                 if (click && click.checked !== undefined) {
                     box = control as HTMLInputElement;
                 }
@@ -396,6 +441,9 @@ export class ButtonTracker {
                     : undefined;
                 kind = intent ? intent.kind : undefined;
                 source = intent ? intent.source : undefined;
+                choice = signalsKit
+                    ? describePaymentChoice(control, path)
+                    : undefined;
             }
             this.lastClick = { t, excluded, kind, source };
         } else if (layer === 'submit') {
@@ -424,7 +472,12 @@ export class ButtonTracker {
                 if (layer === 'blur') {
                     // Read after the blur settles: some browsers have not moved
                     // focus into the frame yet when the window blurs.
-                    kind = classifyIntentFrame(document.activeElement, window);
+                    const frame = classifyPaymentFrame(
+                        document.activeElement,
+                        window
+                    );
+                    kind = frame ? frame.kind : undefined;
+                    family = frame ? frame.family : undefined;
                     source = 'frame';
                 } else if (
                     unconfirmedCommit &&
@@ -444,7 +497,14 @@ export class ButtonTracker {
                                 ? !click.checked
                                 : box.checked;
                     }
-                    this.logClick(click, pathname);
+                    this.logClick(click, pathname, asLink);
+                }
+                // Ahead of the intent, so a pre-selection it fires goes out
+                // with this pick.
+                if (choice && isPicked(choice.radio)) {
+                    this.pickPayment(t, pathname, choice.names);
+                } else if (family) {
+                    this.pickPayment(t, pathname, undefined, family);
                 }
                 if (kind) {
                     this.emit(kind, source, layer, t, pathname);
@@ -456,8 +516,12 @@ export class ButtonTracker {
     }
 
     // Every real click is one event, repeats included, up to a ceiling per page.
-    private logClick(click: IButtonClick, pathname: string): void {
-        if (!this.eventsEnabled()) {
+    private logClick(
+        click: IButtonClick,
+        pathname: string,
+        asLink: boolean
+    ): void {
+        if (!this.eventsEnabled() || this.hasTargetingOptOut()) {
             return;
         }
         if (pathname !== this.pagePath) {
@@ -472,7 +536,9 @@ export class ButtonTracker {
         this.mpInstance._SessionManager.resetSessionTimer();
         const queued = this.queuedForUpload();
         this.mpInstance._Events.logEvent(
-            buildButtonClickEvent(click, pathname)
+            asLink
+                ? buildLinkClickEvent(click, pathname)
+                : buildButtonClickEvent(click, pathname)
         );
         // Only a click waiting for the batch interval is sent early: a held
         // one goes out when released, and with batching off it already has.
@@ -546,12 +612,43 @@ export class ButtonTracker {
         );
     }
 
+    private pickPayment(
+        t: number,
+        pathname: string,
+        names?: string[],
+        family?: PaymentFrameFamily
+    ): void {
+        if (this.isKitSuppressed()) {
+            return;
+        }
+        this.mpInstance._RoktManager.notifyPaymentPick(
+            Object.freeze({
+                t,
+                pathname,
+                names: names ? Object.freeze(names.slice()) : undefined,
+                family,
+            })
+        );
+    }
+
     // Events follow the SDK's opt-out like any other event.
     private eventsEnabled(): boolean {
         const store = this.mpInstance._Store;
         return !!store && store.isEnabled;
     }
 
+    // Read per click, since the launcher options can arrive after the tracker
+    // starts. Only where this init configures a Rokt kit, so Global Privacy
+    // Control alone doesn't stop click logging elsewhere.
+    private hasTargetingOptOut(): boolean {
+        const roktManager = this.mpInstance._RoktManager;
+        return (
+            this.hasRoktKit &&
+            !!roktManager &&
+            roktManager.hasTargetingOptOut()
+        );
+    }
+
     // The Rokt manager owns the kit's privacy gates: flag, opt-out, launcher
     // options and Global Privacy Control.
     private isKitSuppressed(): boolean {

package/src/buttonTracking/checkoutIntent.ts

@@ -82,11 +82,12 @@ const steps = new RegExp(
         ')$'
 );
 const CART_NOUN = '(?:(?:my|your|the) )?(?:shopping )?(?:cart|bag|basket)';
-// "Add to bag", "View cart", "Shopping bag", "Bag", and a count badge such as
-// "1 item in bag", which reads "item in bag" once digits are stripped.
-const cartLabels = new RegExp(
-    '^(?:add(?: [^ ]+){0,5} to ' + CART_NOUN +
-        '|(?:(?:view|open|go to) )?' + CART_NOUN + '(?: items?)?' +
+// "Add to bag" and "Add 2 to cart": a click that puts something in the cart.
+const addToCartLabels = new RegExp('^add(?: [^ ]+){0,5} to ' + CART_NOUN + '$');
+// "View cart", "Shopping bag", "Bag", and a count badge such as "1 item in bag",
+// which reads "item in bag" once digits are stripped: a click that opens the cart.
+const openCartLabels = new RegExp(
+    '^(?:(?:(?:view|open|go to) )?' + CART_NOUN + '(?: items?)?' +
         '|items? in ' + CART_NOUN + ')$'
 );
 const WALLET_NAMES =
@@ -104,20 +105,35 @@ const walletBrands = new RegExp(
     '^(?:' + WALLET_NAMES + ')(?: (?:checkout|check out|express(?: checkout)?|express pay|buy now|pay now|pay|now)' +
         '| (?:logo|icon|mark|button)(?: (?:logo|icon|mark|button))*)?$'
 );
+// The payment method a frame's focus picks, in the Rokt kit's family names.
+export type PaymentFrameFamily =
+    | 'apple_pay'
+    | 'google_pay'
+    | 'amazon_pay'
+    | 'shop_pay'
+    | 'card';
 // Exact HTTPS hosts of hosted wallet button frames.
-const walletFrameHosts = new Set([
-    'pay.google.com',
-    'applepay.cdn-apple.com',
-    'payments.amazon.com',
-    'pay.shopify.com',
-]);
+const walletFrameFamilies: { [host: string]: PaymentFrameFamily } = {
+    'pay.google.com': 'google_pay',
+    'applepay.cdn-apple.com': 'apple_pay',
+    'payments.amazon.com': 'amazon_pay',
+    'pay.shopify.com': 'shop_pay',
+};
 // PayPal serves its buttons and its card fields and pay-later messages from
 // the same hosts; only the button frames are wallet taps.
 const paypalFrameHosts = new Set(['www.paypal.com', 'www.sandbox.paypal.com']);
 const PAYPAL_BUTTON_FRAME = /^\/smart\/(?:buttons|menu)(?:\/|$)/;
+const PAYPAL_CARD_FRAME = /^\/smart\/card-fields?(?:\/|$)/;
+// PayPal's JS SDK, used directly or wrapped by a processor, leaves its frames
+// without a src and names them __zoid__paypal_<component>__ instead.
+const PAYPAL_SDK_FRAME = /^__zoid__paypal_/;
+const PAYPAL_SDK_BUTTON_FRAME = /^__zoid__paypal_(?:buttons|menu)__/;
 // Stripe's quick-pay button frames; its other frames are card and form fields.
 const STRIPE_WALLET_FRAME = /\/elements-inner-(?:payment-request|express-checkout)-/;
+const STRIPE_CARD_FRAME = /\/elements-inner-card\b/;
 // Hosted card-entry and fingerprint frames: focus there is typing card details.
+// Some of these hosts also serve gift card and bank account fields, so none
+// names a family.
 const CARD_FRAME_DOMAINS = [
     'adyen.com',
     'braintreegateway.com',
@@ -211,10 +227,19 @@ function labels(element: Element): string[] {
 }
 
 // A cart button is often a bare icon, so its title names it when nothing else
-// does. Only the cart rule reads the title.
+// does. Only the cart rule reads the title. Opening the cart counts only for a
+// control that opens it on the page, such as a flyout: one that leads to the cart
+// page unloads before a call made on the click can return.
 function isCartControl(control: Element, cores: string[]): boolean {
     const title = cores.length ? undefined : normalize(control.getAttribute('title'));
-    return (title ? [coreLabel(title)] : cores).some(text => cartLabels.test(text));
+    const texts = title ? [coreLabel(title)] : cores;
+    if (texts.some(text => addToCartLabels.test(text))) {
+        return true;
+    }
+    return (
+        (control.hasAttribute('aria-expanded') || control.hasAttribute('aria-haspopup')) &&
+        texts.some(text => openCartLabels.test(text))
+    );
 }
 
 // Which rule recognised the intent: a vendor's own markup, a phrase in the
@@ -252,8 +277,8 @@ function isCommitLabel(text: string, isLink: boolean, pathname: string): boolean
 // pickers, toggles and pay-later messages never count; a vendor's own wallet
 // button counts before any label rule; a confirm label on any source counts
 // before the look-alike exclusions veto; then a wallet-named control, wallet
-// phrases and steps. A cart label, links included, counts only where none of
-// those do.
+// phrases and steps. An add-to-cart label, links included, or a control that
+// opens the cart on the page counts only where none of those do.
 export function classifyIntent(
     control: Element,
     pathname: string
@@ -325,12 +350,20 @@ function isOnDomain(host: string, domain: string): boolean {
     );
 }
 
+export interface IPaymentFrame {
+    kind: 'wallet' | 'frame';
+    family?: PaymentFrameFamily;
+}
+
 // Focus moving into a visible hosted wallet button counts as a wallet click;
-// focus into hosted card fields or messages is only a frame.
-export function classifyIntentFrame(
+// focus into hosted card fields or messages is only a frame. A family comes
+// only from a frame that can draw no other method: PayPal's button frame also
+// draws Pay Later, Venmo and its card form, Stripe's quick-pay frame draws
+// Apple Pay or Google Pay by browser, and its payment form holds several.
+export function classifyPaymentFrame(
     target: EventTarget | null,
     win: Window
-): 'wallet' | 'frame' | undefined {
+): IPaymentFrame | undefined {
     if (
         win.document.visibilityState !== 'visible' ||
         !(target instanceof HTMLIFrameElement)
@@ -343,20 +376,39 @@ export function classifyIntentFrame(
     ) {
         return undefined;
     }
+    // A frame that has its own src is judged by that address, never by its name.
+    if (
+        (!target.src || target.src === 'about:blank') &&
+        PAYPAL_SDK_FRAME.test(target.name)
+    ) {
+        return PAYPAL_SDK_BUTTON_FRAME.test(target.name)
+            ? { kind: 'wallet' }
+            : { kind: 'frame' };
+    }
     try {
         const url = new URL(target.src);
         const host = url.protocol === 'https:' ? url.hostname : '';
         if (paypalFrameHosts.has(host)) {
-            return PAYPAL_BUTTON_FRAME.test(url.pathname) ? 'wallet' : 'frame';
+            if (PAYPAL_BUTTON_FRAME.test(url.pathname)) {
+                return { kind: 'wallet' };
+            }
+            return PAYPAL_CARD_FRAME.test(url.pathname)
+                ? { kind: 'frame', family: 'card' }
+                : { kind: 'frame' };
         }
-        if (walletFrameHosts.has(host)) {
-            return 'wallet';
+        if (Object.prototype.hasOwnProperty.call(walletFrameFamilies, host)) {
+            return { kind: 'wallet', family: walletFrameFamilies[host] };
         }
         if (host === 'js.stripe.com') {
-            return STRIPE_WALLET_FRAME.test(url.pathname) ? 'wallet' : 'frame';
+            if (STRIPE_WALLET_FRAME.test(url.pathname)) {
+                return { kind: 'wallet' };
+            }
+            return STRIPE_CARD_FRAME.test(url.pathname)
+                ? { kind: 'frame', family: 'card' }
+                : { kind: 'frame' };
         }
         if (CARD_FRAME_DOMAINS.some(domain => isOnDomain(host, domain))) {
-            return 'frame';
+            return { kind: 'frame' };
         }
     } catch (e) {
         // An unparseable frame src is not a wallet frame.

package/src/buttonTracking/controls.ts

@@ -139,7 +139,7 @@ const PAYMENT_IN_NAME = /(?:^| )(?:pay|payment|checkout)(?= |$)/;
 const BUTTON_IN_NAME = /(?:^| )(?:btn|button)(?= |$)/;
 const PART_IN_NAME = /(?:^| )(?:logo|icon|image|img|label|text|caption|message|messaging|info|tooltip|help|learn|terms|promo|banner|container|wrapper|wrap|placeholder|form|section|panel|modal|list|group|select|option|tab|toggle|radio|choice|method)(?= |$)/;
 
-function nameWords(value: string | null): string {
+export function nameWords(value: string | null): string {
     return (value || '')
         .slice(0, 64)
         .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
@@ -322,15 +322,19 @@ export function findControl(
 }
 
 // Text that may hold what a shopper typed or what the page opted out: form
-// fields, editable regions, and anything under data-mp-no-track.
-export function isUnsafeTextSource(element: Element): boolean {
+// fields, editable regions, and anything under data-mp-no-track. `own` is a
+// box the element labels, which holds no typing of its own.
+export function isUnsafeTextSource(element: Element, own?: Element): boolean {
+    const inside = 'input, select, textarea, [data-mp-no-track], ' + EDITABLE;
     return (
         element.matches(
             'input, select, textarea, option, optgroup, datalist, ' + EDITABLE
         ) ||
-        !!element.querySelector(
-            'input, select, textarea, [data-mp-no-track], ' + EDITABLE
-        ) ||
+        (own
+            ? Array.from(element.querySelectorAll(inside)).some(
+                  found => found !== own
+              )
+            : !!element.querySelector(inside)) ||
         hasComposedAncestor(
             element,
             'select, datalist, textarea, [data-mp-no-track], ' + EDITABLE

package/src/constants.ts

@@ -191,6 +191,7 @@ const Constants = {
         AstBackgroundEvents: 'astBackgroundEvents',
         AutoLogPageView: 'autoLogPageView',
         AutoButtonTracking: 'autoButtonTracking',
+        AutoLinkTracking: 'autoLinkTracking',
     },
     DefaultInstance: 'default_instance',
     CCPAPurpose: 'data_sale_opt_out',

package/src/cookieConsentManager.ts

@@ -19,6 +19,12 @@ export interface ICookieConsentFlags {
      * Default: false (targeting is allowed)
      */
     noTargeting: boolean;
+
+    /**
+     * When true, indicates the user has opted out of the sale or sharing of their data.
+     * Default: false (sharing is allowed)
+     */
+    doNotShareOrSell?: boolean;
 }
 
 export interface ICookieConsentManager {
@@ -32,6 +38,11 @@ export interface ICookieConsentManager {
      */
     getNoFunctional: () => boolean;
 
+    /**
+     * Sharing is allowed when doNotShareOrSell is false (default)
+     */
+    getDoNotShareOrSell: () => boolean;
+
     /**
      * Syncs the $NoTargeting user attribute based on the current noTargeting flag.
      * Sets the attribute when noTargeting is true, removes it when false.
@@ -40,12 +51,12 @@ export interface ICookieConsentManager {
 }
 
 /**
- * CookieConsentManager handles storage and access of consent flags (noFunctional, noTargeting)
- * that are passed via launcherOptions during SDK initialization.
+ * CookieConsentManager handles storage and access of consent flags (noFunctional, noTargeting,
+ * doNotShareOrSell) that are passed via launcherOptions during SDK initialization.
  *
  * These flags allow Rokt integration to respect user privacy choices.
  *
- * Default behavior: Both flags default to false, meaning all features are allowed
+ * Default behavior: All flags default to false, meaning all features are allowed
  * unless explicitly opted out by the user.
  */
 export default class CookieConsentManager implements ICookieConsentManager {
@@ -53,6 +64,7 @@ export default class CookieConsentManager implements ICookieConsentManager {
         this.flags = {
             noFunctional: flags.noFunctional === true,
             noTargeting: flags.noTargeting === true,
+            doNotShareOrSell: flags.doNotShareOrSell === true,
         };
     }
 
@@ -72,6 +84,14 @@ export default class CookieConsentManager implements ICookieConsentManager {
         return this.flags.noFunctional;
     }
 
+    /**
+     * Returns true if the user has opted out of the sale or sharing of their data.
+     * Sharing is allowed when doNotShareOrSell is false (default).
+     */
+    getDoNotShareOrSell(): boolean {
+        return this.flags.doNotShareOrSell;
+    }
+
     syncNoTargetingAttribute(user: IMParticleUser | null): void {
         if (!user) return;
 

package/src/cookieSyncManager.ts

@@ -118,9 +118,17 @@ export default function CookieSyncManager(
                     return;
                 }
 
-                // For Rokt, block cookie sync when noTargeting privacy flag is true
-                if (moduleId === PARTNER_MODULE_IDS.Rokt && mpInstance._CookieConsentManager.getNoTargeting()) {
-                    return;
+                // For Rokt, block cookie sync under the noTargeting or doNotShareOrSell privacy flag,
+                // or when the browser sends Global Privacy Control
+                if (moduleId === PARTNER_MODULE_IDS.Rokt) {
+                    const nav = typeof navigator === 'undefined' ? undefined : (navigator as Navigator & { globalPrivacyControl?: boolean });
+                    if (
+                        mpInstance._CookieConsentManager.getNoTargeting() ||
+                        mpInstance._CookieConsentManager.getDoNotShareOrSell() ||
+                        (!!nav && nav.globalPrivacyControl === true)
+                    ) {
+                        return;
+                    }
                 }
 
                 const { isEnabledForUserConsent } = mpInstance._Consent;

package/src/mp-instance.ts

@@ -1363,7 +1363,11 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
 function completeSDKInitialization(apiKey, config, mpInstance) {
     const kitBlocker = createKitBlocker(config, mpInstance);
     const { getFeatureFlag } = mpInstance._Helpers;
-    const { AutoLogPageView, AutoButtonTracking } = Constants.FeatureFlags;
+    const {
+        AutoLogPageView,
+        AutoButtonTracking,
+        AutoLinkTracking,
+    } = Constants.FeatureFlags;
 
     // Destroy previous batch uploader to prevent leaked timers and event listeners
     if (mpInstance._APIClient?.uploader) {
@@ -1453,16 +1457,26 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         // Rokt kit only when that kit receives them. Set before
         // processForwarders: the kit can read it during this init, from its own
         // init or from a returning shopper's landing page view.
+        const logButtons = !!getFeatureFlag(AutoButtonTracking);
+        const logLinks = !!getFeatureFlag(AutoLinkTracking);
+        // Links feed intent too, so with link tracking on the kit must also
+        // receive Auto Link Click events.
         const buttonClickBlocker = roktConfig
             ? getButtonClickBlocker(roktConfig, kitBlocker)
             : undefined;
-        if (buttonClickBlocker && getFeatureFlag(AutoButtonTracking)) {
+        const linkClickBlocker =
+            roktConfig && logLinks
+                ? getButtonClickBlocker(roktConfig, kitBlocker, true)
+                : undefined;
+        if (logButtons && (buttonClickBlocker || linkClickBlocker)) {
             mpInstance.Logger.warning(
-                `Checkout intent is off: the ${buttonClickBlocker} keeps some or all Auto Button Click events from the Rokt kit.`
+                buttonClickBlocker
+                    ? `Checkout intent is off: the ${buttonClickBlocker} keeps some or all Auto Button Click events from the Rokt kit.`
+                    : `Checkout intent is off: the ${linkClickBlocker} keeps some or all Auto Link Click events from the Rokt kit.`
             );
         }
         mpInstance._RoktManager.setAutoButtonClicksForwarded(
-            !!roktConfig && !buttonClickBlocker
+            !!roktConfig && !buttonClickBlocker && !linkClickBlocker
         );
 
         mpInstance._Forwarders.processForwarders(
@@ -1509,11 +1523,15 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
             mpInstance._PageViewTracker.teardown();
         }
 
-        if (getFeatureFlag(AutoButtonTracking)) {
+        if (logButtons || logLinks) {
             if (!mpInstance._ButtonTracker) {
                 mpInstance._ButtonTracker = new ButtonTracker(mpInstance);
             }
-            mpInstance._ButtonTracker.init({ hasRoktKit: !!roktConfig });
+            mpInstance._ButtonTracker.init({
+                hasRoktKit: !!roktConfig,
+                logButtons,
+                logLinks,
+            });
         } else {
             // Also retires a tracker left by an earlier bundle load. Like APV,
             // this assumes a single active SDK instance.
@@ -1644,10 +1662,10 @@ function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
     mpInstance.Logger.verbose(StartingInitialization);
 
     // Initialize CookieConsentManager with privacy flags from launcherOptions
-    const { noFunctional, noTargeting } = normalizeRoktLauncherOptions(
+    const { noFunctional, noTargeting, doNotShareOrSell } = normalizeRoktLauncherOptions(
         config?.launcherOptions
     );
-    mpInstance._CookieConsentManager = new CookieConsentManager({ noFunctional, noTargeting });
+    mpInstance._CookieConsentManager = new CookieConsentManager({ noFunctional, noTargeting, doNotShareOrSell });
 
     // Check to see if localStorage is available before main configuration runs
     // since we will need this for the current implementation of user persistence

package/src/roktLauncherOptions.ts

@@ -5,6 +5,7 @@ export interface IRoktLauncherOptions extends Dictionary<any> {
     noDeviceID?: boolean;
     noFunctional?: boolean;
     noTargeting?: boolean;
+    doNotShareOrSell?: boolean;
     sessionId?: string;
     sessionToken?: string;
 }