@duckduckgo/autoconsent 5.3.0 → 6.0.0

package/lib/cmps/airbnb.ts

@@ -4,9 +4,7 @@ import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class Airbnb extends AutoConsentCMPBase {
-  constructor() {
-    super("airbnb");
-  }
+  name: "airbnb";
 
   runContext: RunContext = {
     urlPattern: '^https://(www\\.)?airbnb\\.[^/]+/'

package/lib/cmps/all.ts

@@ -1,13 +1,10 @@
-import { AutoConsentCMP } from './base';
 import TrustArcTop from './trustarc-top';
 import TrustArcFrame from './trustarc-frame';
 import CookieBot from './cookiebot';
 import SourcePointFrame from './sourcepoint-frame';
 import ConsentManager from './consentmanager';
 import Evidon from './evidon';
-import { AutoConsentCMPRule } from '../rules';
 import Onetrust from './onetrust';
-import { AutoCMP } from '../types';
 import Klaro from './klaro';
 import Uniconsent from './uniconsent';
 import Conversant from './conversant';
@@ -15,23 +12,17 @@ import Tiktok from './tiktok';
 import Airbnb from './airbnb';
 
 
-const rules: AutoCMP[] = [
-  new TrustArcTop(),
-  new TrustArcFrame(),
-  new CookieBot(),
-  new SourcePointFrame(),
-  new ConsentManager(),
-  new Evidon(),
-  new Onetrust(),
-  new Klaro(),
-  new Uniconsent(),
-  new Conversant(),
-  new Tiktok(),
-  new Airbnb(),
+export const dynamicCMPs = [
+  TrustArcTop,
+  TrustArcFrame,
+  CookieBot,
+  SourcePointFrame,
+  ConsentManager,
+  Evidon,
+  Onetrust,
+  Klaro,
+  Uniconsent,
+  Conversant,
+  Tiktok,
+  Airbnb,
 ];
-
-export function createAutoCMP(config: AutoConsentCMPRule): AutoConsentCMP {
-  return new AutoConsentCMP(config);
-}
-
-export default rules;

package/lib/cmps/base.ts

@@ -3,7 +3,10 @@
 import { AutoCMP } from "../types";
 import { AutoConsentCMPRule, AutoConsentRuleStep, RunContext } from "../rules";
 import { enableLogs } from "../config";
-import { click, doEval, elementExists, elementVisible, hide, wait, waitForElement, waitForThenClick, waitForVisible } from "../rule-executors";
+import { click, elementExists, elementVisible, hide, wait, waitForElement, waitForThenClick, waitForVisible } from "../rule-executors";
+import { requestEval } from "../eval-handler";
+import AutoConsent from "../web";
+import { getFunctionBody, snippets } from "../eval-snippets";
 
 export async function success(action: Promise<boolean>): Promise<boolean> {
   const result = await action;
@@ -20,12 +23,12 @@ export const defaultRunContext: RunContext = {
 }
 
 export default class AutoConsentCMPBase implements AutoCMP {
-
   name: string
   runContext: RunContext = defaultRunContext;
+  autoconsent: AutoConsent;
 
-  constructor(name: string) {
-    this.name = name;
+  constructor(autoconsentInstance: AutoConsent) {
+    this.autoconsent = autoconsentInstance;
   }
 
   get hasSelfTest(): boolean {
@@ -40,6 +43,33 @@ export default class AutoConsentCMPBase implements AutoCMP {
     throw new Error('Not Implemented');
   }
 
+  mainWorldEval(snippetId: keyof typeof snippets): Promise<boolean> {
+    const snippet = snippets[snippetId];
+    if (!snippet) {
+      console.warn('Snippet not found', snippetId);
+      return Promise.resolve(false);
+    }
+
+    if (this.autoconsent.config.isMainWorld) {
+      enableLogs && console.log('inline eval:', snippetId, snippet);
+      let result = false;
+      try {
+        result = !!snippet.call(globalThis);
+      } catch (e) {
+        // ignore exceptions
+        enableLogs && console.error('error evaluating rule', snippetId, e);
+      }
+      return Promise.resolve(result);
+    }
+
+    const snippetSrc = getFunctionBody(snippet);
+    enableLogs && console.log('async eval:', snippetId, snippetSrc);
+    return requestEval(snippetSrc).catch((e) => {
+      enableLogs && console.error('error evaluating rule', snippetId, e);
+      return false;
+    });
+  }
+
   checkRunContext(): boolean {
     const runCtx: RunContext = {
       ...defaultRunContext,
@@ -88,90 +118,11 @@ export default class AutoConsentCMPBase implements AutoCMP {
   }
 }
 
-async function evaluateRuleStep(rule: AutoConsentRuleStep) {
-  const results = [];
-  if (rule.exists) {
-    results.push(elementExists(rule.exists));
-  }
-  if (rule.visible) {
-    results.push(elementVisible(rule.visible, rule.check));
-  }
-  if (rule.eval) {
-    const res = doEval(rule.eval)
-    results.push(res);
-  }
-  if (rule.waitFor) {
-    results.push(waitForElement(rule.waitFor, rule.timeout));
-  }
-  if (rule.waitForVisible) {
-    results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
-  }
-  if (rule.click) {
-    results.push(click(rule.click, rule.all));
-  }
-  if (rule.waitForThenClick) {
-    results.push(waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
-  }
-  if (rule.wait) {
-    results.push(wait(rule.wait));
-  }
-  if (rule.hide) {
-    results.push(hide(rule.hide, rule.method));
-  }
-  if (rule.if) {
-    if (!rule.if.exists && !rule.if.visible) {
-      console.error('invalid conditional rule', rule.if);
-      return false;
-    }
-    const condition = await evaluateRuleStep(rule.if);
-    enableLogs && console.log('Condition is', condition);
-    if (condition) {
-      results.push(_runRulesSequentially(rule.then));
-    } else if (rule.else) {
-      results.push(_runRulesSequentially(rule.else));
-    }
-  }
-  if (rule.any) {
-    for (const step of rule.any) {
-      if (await evaluateRuleStep(step)) {
-        return true
-      }
-    }
-    return false
-  }
-
-  if (results.length === 0) {
-    enableLogs && console.warn('Unrecognized rule', rule);
-    return false;
-  }
-
-  // boolean and of results
-  const all = await Promise.all(results);
-  return all.reduce((a, b) => a && b, true);
-}
-
-async function _runRulesParallel(rules: AutoConsentRuleStep[]): Promise<boolean> {
-  const results = rules.map(rule => evaluateRuleStep(rule));
-  const detections = await Promise.all(results);
-  return detections.every(r => !!r);
-}
-
-async function _runRulesSequentially(rules: AutoConsentRuleStep[]): Promise<boolean> {
-  for (const rule of rules) {
-    enableLogs && console.log('Running rule...', rule);
-    const result = await evaluateRuleStep(rule);
-    enableLogs && console.log('...rule result', result);
-    if (!result && !rule.optional) {
-      return false;
-    }
-  }
-  return true;
-}
-
 export class AutoConsentCMP extends AutoConsentCMPBase {
 
-  constructor(public config: AutoConsentCMPRule) {
-    super(config.name);
+  constructor(public config: AutoConsentCMPRule, autoconsentInstance: AutoConsent) {
+    super(autoconsentInstance);
+    this.name = config.name;
     this.runContext = config.runContext || defaultRunContext;
   }
 
@@ -193,14 +144,14 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
 
   async detectCmp() {
     if (this.config.detectCmp) {
-      return _runRulesParallel(this.config.detectCmp);
+      return this._runRulesParallel(this.config.detectCmp);
     }
     return false;
   }
 
   async detectPopup() {
     if (this.config.detectPopup) {
-      return _runRulesSequentially(this.config.detectPopup);
+      return this._runRulesSequentially(this.config.detectPopup);
     }
     return false;
   }
@@ -208,7 +159,7 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
   async optOut() {
     if (this.config.optOut) {
       enableLogs && console.log('Initiated optOut()', this.config.optOut);
-      return _runRulesSequentially(this.config.optOut);
+      return this._runRulesSequentially(this.config.optOut);
     }
     return false;
   }
@@ -216,22 +167,102 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
   async optIn() {
     if (this.config.optIn) {
       enableLogs && console.log('Initiated optIn()', this.config.optIn);
-      return _runRulesSequentially(this.config.optIn);
+      return this._runRulesSequentially(this.config.optIn);
     }
     return false;
   }
 
   async openCmp() {
     if (this.config.openCmp) {
-      return _runRulesSequentially(this.config.openCmp);
+      return this._runRulesSequentially(this.config.openCmp);
     }
     return false;
   }
 
   async test() {
     if (this.hasSelfTest) {
-      return _runRulesSequentially(this.config.test);
+      return this._runRulesSequentially(this.config.test);
     }
     return super.test();
   }
+
+  async evaluateRuleStep(rule: AutoConsentRuleStep) {
+    const results = [];
+    if (rule.exists) {
+      results.push(elementExists(rule.exists));
+    }
+    if (rule.visible) {
+      results.push(elementVisible(rule.visible, rule.check));
+    }
+    if (rule.eval) {
+      const res = this.mainWorldEval(rule.eval)
+      results.push(res);
+    }
+    if (rule.waitFor) {
+      results.push(waitForElement(rule.waitFor, rule.timeout));
+    }
+    if (rule.waitForVisible) {
+      results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
+    }
+    if (rule.click) {
+      results.push(click(rule.click, rule.all));
+    }
+    if (rule.waitForThenClick) {
+      results.push(waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
+    }
+    if (rule.wait) {
+      results.push(wait(rule.wait));
+    }
+    if (rule.hide) {
+      results.push(hide(rule.hide, rule.method));
+    }
+    if (rule.if) {
+      if (!rule.if.exists && !rule.if.visible) {
+        console.error('invalid conditional rule', rule.if);
+        return false;
+      }
+      const condition = await this.evaluateRuleStep(rule.if);
+      enableLogs && console.log('Condition is', condition);
+      if (condition) {
+        results.push(this._runRulesSequentially(rule.then));
+      } else if (rule.else) {
+        results.push(this._runRulesSequentially(rule.else));
+      }
+    }
+    if (rule.any) {
+      for (const step of rule.any) {
+        if (await this.evaluateRuleStep(step)) {
+          return true
+        }
+      }
+      return false
+    }
+  
+    if (results.length === 0) {
+      enableLogs && console.warn('Unrecognized rule', rule);
+      return false;
+    }
+  
+    // boolean and of results
+    const all = await Promise.all(results);
+    return all.reduce((a, b) => a && b, true);
+  }
+
+  async _runRulesParallel(rules: AutoConsentRuleStep[]): Promise<boolean> {
+    const results = rules.map(rule => this.evaluateRuleStep(rule));
+    const detections = await Promise.all(results);
+    return detections.every(r => !!r);
+  }
+  
+  async _runRulesSequentially(rules: AutoConsentRuleStep[]): Promise<boolean> {
+    for (const rule of rules) {
+      enableLogs && console.log('Running rule...', rule);
+      const result = await this.evaluateRuleStep(rule);
+      enableLogs && console.log('...rule result', result);
+      if (!result && !rule.optional) {
+        return false;
+      }
+    }
+    return true;
+  }
 }

package/lib/cmps/consentmanager.ts

@@ -1,9 +1,10 @@
-import { click, doEval, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
+import { click, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
 import AutoConsentCMPBase from "./base";
 
 // Note: JS API is also available:
 // https://help.consentmanager.net/books/cmp/page/javascript-api
 export default class ConsentManager extends AutoConsentCMPBase {
+  name = "consentmanager.net";
 
   prehideSelectors = ["#cmpbox,#cmpbox2"];
   apiAvailable = false;
@@ -20,12 +21,8 @@ export default class ConsentManager extends AutoConsentCMPBase {
     return false;
   }
 
-  constructor() {
-    super("consentmanager.net");
-  }
-
   async detectCmp() {
-    this.apiAvailable = await doEval('window.__cmp && typeof __cmp("getCMPData") === "object"');
+    this.apiAvailable = await this.mainWorldEval('EVAL_CONSENTMANAGER_1');
     if (!this.apiAvailable) {
       return elementExists("#cmpbox");
     } else {
@@ -38,7 +35,7 @@ export default class ConsentManager extends AutoConsentCMPBase {
       // wait before making this check because early in the page lifecycle this may incorrectly return
       // true, causing an opt-out when it is not needed.
       await wait(500);
-      return await doEval("!__cmp('consentStatus').userChoiceExists");
+      return await this.mainWorldEval('EVAL_CONSENTMANAGER_2');
     }
     return elementVisible("#cmpbox .cmpmore", 'any');
   }
@@ -46,7 +43,7 @@ export default class ConsentManager extends AutoConsentCMPBase {
   async optOut() {
     await wait(500);
     if (this.apiAvailable) {
-      return await doEval("__cmp('setConsent', 0)");
+      return await this.mainWorldEval('EVAL_CONSENTMANAGER_3');
     }
 
     if (click(".cmpboxbtnno")) {
@@ -68,14 +65,14 @@ export default class ConsentManager extends AutoConsentCMPBase {
 
   async optIn() {
     if (this.apiAvailable) {
-      return await doEval("__cmp('setConsent', 1)");
+      return await this.mainWorldEval('EVAL_CONSENTMANAGER_4');
     }
     return click(".cmpboxbtnyes");
   }
 
   async test() {
     if (this.apiAvailable) {
-      return await doEval("__cmp('consentStatus').userChoiceExists");
+      return await this.mainWorldEval('EVAL_CONSENTMANAGER_5');
     }
   }
 }

package/lib/cmps/conversant.ts

@@ -5,10 +5,7 @@ import AutoConsentCMPBase from "./base";
 export default class Conversant extends AutoConsentCMPBase {
 
   prehideSelectors = [".cmp-root"]
-
-  constructor() {
-    super("Conversant");
-  }
+  name = "Conversant";
 
   get hasSelfTest(): boolean {
     return true;

package/lib/cmps/cookiebot.ts

@@ -1,14 +1,10 @@
-import { click, doEval, elementExists, wait, waitForElement } from '../rule-executors';
+import { click, elementExists, wait, waitForElement } from '../rule-executors';
 import AutoConsentCMPBase from './base';
 
 export default class Cookiebot extends AutoConsentCMPBase {
-
+  name = 'Cybotcookiebot';
   prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner,#cb-cookieoverlay"]
 
-  constructor() {
-    super('Cybotcookiebot');
-  }
-
   get hasSelfTest(): boolean {
     return true;
   }
@@ -64,14 +60,14 @@ export default class Cookiebot extends AutoConsentCMPBase {
     }
 
     // some sites have custom submit buttons with no obvious selectors. In this case we just call the submitConsent API.
-    if (await doEval('window.CookieConsent.hasResponse !== true')) {
-      await doEval('window.Cookiebot.dialog.submitConsent()');
+    if (await this.mainWorldEval('EVAL_COOKIEBOT_1')) {
+      await this.mainWorldEval('EVAL_COOKIEBOT_2');
       await wait(500);
     }
 
     // site with 3rd confirm settings modal
     if (elementExists('#cb-confirmedSettings')) {
-      await doEval('endCookieProcess()');
+      await this.mainWorldEval('EVAL_COOKIEBOT_3');
     }
 
     return true;
@@ -89,6 +85,6 @@ export default class Cookiebot extends AutoConsentCMPBase {
   }
 
   async test() {
-    return doEval('window.CookieConsent.declined === true');
+    return this.mainWorldEval('EVAL_COOKIEBOT_4');
   }
 }

package/lib/cmps/evidon.ts

@@ -3,9 +3,7 @@ import { getStyleElement, hideElements } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class Evidon extends AutoConsentCMPBase {
-  constructor() {
-    super("Evidon");
-  }
+  name = "Evidon";
 
   get hasSelfTest(): boolean {
     return false;

package/lib/cmps/klaro.ts

@@ -1,15 +1,11 @@
-import { click, doEval, elementExists, elementVisible, waitForElement } from "../rule-executors";
+import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
 import AutoConsentCMPBase from "./base";
 
 export default class Klaro extends AutoConsentCMPBase {
-
+  name = "Klaro";
   prehideSelectors = [".klaro"]
   settingsOpen = false;
 
-  constructor() {
-    super("Klaro");
-  }
-
   get hasSelfTest(): boolean {
     return true;
   }
@@ -65,6 +61,6 @@ export default class Klaro extends AutoConsentCMPBase {
   }
 
   async test() {
-    return await doEval('klaro.getManager().config.services.every(c => c.required || !klaro.getManager().consents[c.name])');
+    return await this.mainWorldEval('EVAL_KLARO_1');
   }
 }

package/lib/cmps/onetrust.ts

@@ -1,16 +1,12 @@
-import { click, doEval, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
+import { click, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
 import { RunContext } from "../rules";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class Onetrust extends AutoConsentCMPBase {
-
+  name = "Onetrust";
   prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.onetrust-pc-dark-filter,.js-consent-banner"]
 
-  constructor() {
-    super("Onetrust");
-  }
-
   runContext: RunContext = {
     urlPattern: '^(?!.*https://www\\.nba\\.com/)'
   }
@@ -64,6 +60,6 @@ export default class Onetrust extends AutoConsentCMPBase {
   }
 
   async test() {
-    return await doEval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
+    return await this.mainWorldEval('EVAL_ONETRUST_1');
   }
 }

package/lib/cmps/sourcepoint-frame.ts

@@ -5,6 +5,7 @@ import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class SourcePoint extends AutoConsentCMPBase {
+  name = "Sourcepoint-frame";
   prehideSelectors = ["div[id^='sp_message_container_'],.message-overlay",'#sp_privacy_manager_container']
 
   ccpaNotice = false;
@@ -15,10 +16,6 @@ export default class SourcePoint extends AutoConsentCMPBase {
     frame: true,
   }
 
-  constructor() {
-    super("Sourcepoint-frame");
-  }
-
   get hasSelfTest(): boolean {
     return false; // self-test is done by parent frame
   }

package/lib/cmps/tiktok.ts

@@ -5,9 +5,7 @@ import { isElementVisible } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class Tiktok extends AutoConsentCMPBase {
-  constructor() {
-    super("tiktok.com");
-  }
+  name = "tiktok.com";
 
   runContext: RunContext = {
     urlPattern: 'tiktok'

package/lib/cmps/trustarc-frame.ts

@@ -4,9 +4,7 @@ import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
 
 export default class TrustArcFrame extends AutoConsentCMPBase {
-  constructor() {
-    super("TrustArc-frame");
-  }
+  name = "TrustArc-frame";
 
   runContext: RunContext = {
     main: false,

package/lib/cmps/trustarc-top.ts

@@ -1,6 +1,7 @@
-import { click, doEval, elementExists, elementVisible } from "../rule-executors";
+import { click, elementExists, elementVisible } from "../rule-executors";
 import { RunContext } from "../rules";
 import { getStyleElement, hideElements } from "../utils";
+import AutoConsent from "../web";
 import AutoConsentCMPBase from "./base";
 
 const cookieSettingsButton = "#truste-show-consent";
@@ -11,7 +12,7 @@ const bannerOverlay = '#trustarc-banner-overlay';
 const bannerContainer = '#truste-consent-track';
 
 export default class TrustArcTop extends AutoConsentCMPBase {
-
+  name = "TrustArc-top";
   prehideSelectors = [
     ".trustarc-banner-container",
     `.truste_popframe,.truste_overlay,.truste_box_overlay,${bannerContainer}`,
@@ -24,8 +25,8 @@ export default class TrustArcTop extends AutoConsentCMPBase {
   _shortcutButton: HTMLElement;
   _optInDone: boolean;
 
-  constructor() {
-    super("TrustArc-top");
+  constructor(autoconsentInstance: AutoConsent) {
+    super(autoconsentInstance);
     this._shortcutButton = null; // indicates if the "reject all" button is detected
     this._optInDone = false;
   }
@@ -97,6 +98,6 @@ export default class TrustArcTop extends AutoConsentCMPBase {
   async test() {
     //Test JS variable to check the user's preference
     //PrefCookie = undefined means no consent is set, PrefCookie = '0' means consent is set to required only 
-    return await doEval("window && window.truste && window.truste.eu.bindMap.prefCookie === '0'");
+    return await this.mainWorldEval('EVAL_TRUSTARC_TOP');
   }
 }

package/lib/cmps/uniconsent.ts

@@ -2,9 +2,7 @@ import { elementExists, elementVisible, wait, waitForElement, waitForThenClick }
 import AutoConsentCMPBase from "./base";
 
 export default class Uniconsent extends AutoConsentCMPBase {
-  constructor() {
-    super("Uniconsent");
-  }
+  name = "Uniconsent";
 
   get prehideSelectors(): string[] {
     return ['.unic', '.modal:has(.unic)'];