@duckduckgo/autoconsent 2.1.2 → 2.2.1

package/lib/cmps/consentmanager.ts

@@ -1,14 +1,15 @@
-import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
+import { click, doEval, 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 {
 
-  prehideSelectors = ["#cmpbox,#cmpbox2"]
+  prehideSelectors = ["#cmpbox,#cmpbox2"];
+  apiAvailable = false;
 
   get hasSelfTest(): boolean {
-    return false;
+    return this.apiAvailable;
   }
 
   get isIntermediate(): boolean {
@@ -20,14 +21,27 @@ export default class ConsentManager extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists("#cmpbox");
+    this.apiAvailable = await doEval('window.__cmp && typeof __cmp("getCMPData") === "object"');
+    if (!this.apiAvailable) {
+      return elementExists("#cmpbox");
+    } else {
+      return true;
+    }
   }
 
   async detectPopup() {
+    if (this.apiAvailable) {
+      return await doEval("!__cmp('consentStatus').userChoiceExists");
+    }
     return elementVisible("#cmpbox .cmpmore", 'any');
   }
 
   async optOut() {
+    await wait(500);
+    if (this.apiAvailable) {
+      return await doEval("__cmp('setConsent', 0)");
+    }
+
     if (click(".cmpboxbtnno")) {
       return true;
     }
@@ -46,6 +60,15 @@ export default class ConsentManager extends AutoConsentCMPBase {
   }
 
   async optIn() {
+    if (this.apiAvailable) {
+      return await doEval("__cmp('setConsent', 1)");
+    }
     return click(".cmpboxbtnyes");
   }
+
+  async test() {
+    if (this.apiAvailable) {
+      return await doEval("__cmp('consentStatus').userChoiceExists");
+    }
+  }
 }

package/lib/cmps/conversant.ts

@@ -0,0 +1,60 @@
+import { click, elementExists, elementVisible, waitForElement, waitForThenClick } from "../rule-executors";
+import { waitFor } from "../utils";
+import AutoConsentCMPBase from "./base";
+
+export default class Conversant extends AutoConsentCMPBase {
+
+  prehideSelectors = [".cmp-root"]
+
+  constructor() {
+    super("Conversant");
+  }
+
+  get hasSelfTest(): boolean {
+    return true;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
+  async detectCmp() {
+    return elementExists(".cmp-root .cmp-receptacle");
+  }
+
+  async detectPopup() {
+    return elementVisible(".cmp-root .cmp-receptacle", 'any');
+  }
+
+  async optOut() {
+    if (!(await waitForThenClick(".cmp-main-button:not(.cmp-main-button--primary)"))) {
+      return false;
+    }
+
+    if (!(await waitForElement(".cmp-view-tab-tabs"))) {
+      return false;
+    }
+
+    await waitForThenClick(".cmp-view-tab-tabs > :first-child");
+    await waitForThenClick(".cmp-view-tab-tabs > .cmp-view-tab--active:first-child");
+
+    for (const item of Array.from(document.querySelectorAll('.cmp-accordion-item'))) {
+      (<HTMLElement>item.querySelector('.cmp-accordion-item-title')).click();
+      await waitFor(() => !!item.querySelector('.cmp-accordion-item-content.cmp-active'), 10, 50);
+      const content = item.querySelector('.cmp-accordion-item-content.cmp-active');
+      content.querySelectorAll('.cmp-toggle-actions .cmp-toggle-deny:not(.cmp-toggle-deny--active)').forEach((e: HTMLElement) => e.click());
+      content.querySelectorAll('.cmp-toggle-actions .cmp-toggle-checkbox:not(.cmp-toggle-checkbox--active)').forEach((e: HTMLElement) => e.click());
+      // await waitFor(() => !item.querySelector('.cmp-toggle-deny--active,.cmp-toggle-checkbox--active'), 5, 50); // this may take a long time
+    }
+    await click(".cmp-main-button:not(.cmp-main-button--primary)");
+    return true;
+  }
+
+  async optIn() {
+    return waitForThenClick(".cmp-main-button.cmp-main-button--primary");
+  }
+
+  async test() {
+    return document.cookie.includes('cmp-data=0');
+  }
+}

package/lib/cmps/klaro.ts

@@ -0,0 +1,66 @@
+import { click, doEval, elementExists, elementVisible, waitForElement } from "../rule-executors";
+import AutoConsentCMPBase from "./base";
+
+export default class Klaro extends AutoConsentCMPBase {
+
+  prehideSelectors = [".klaro"]
+  settingsOpen = false;
+
+  constructor() {
+    super("Klaro");
+  }
+
+  get hasSelfTest(): boolean {
+    return true;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
+  async detectCmp() {
+    if (elementExists('.klaro > .cookie-modal')) {
+      this.settingsOpen = true;
+      return true;
+    }
+    return elementExists(".klaro > .cookie-notice");
+  }
+
+  async detectPopup() {
+    return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", 'any');
+  }
+
+  async optOut() {
+    if (click('.klaro .cn-decline')) {
+      return true;
+    }
+
+    if (!this.settingsOpen) {
+      click('.klaro .cn-learn-more');
+      await waitForElement('.klaro > .cookie-modal', 2000);
+      this.settingsOpen = true;
+    }
+
+    if (click('.klaro .cn-decline')) {
+      return true;
+    }
+
+    click('.cm-purpose:not(.cm-toggle-all) > input:not(.half-checked)', true);
+    return click('.cm-btn-accept');
+  }
+
+  async optIn() {
+    if (click('.klaro .cm-btn-accept-all')) {
+      return true;
+    }
+    if (this.settingsOpen) {
+      click('.cm-purpose:not(.cm-toggle-all) > input.half-checked', true);
+      return click('.cm-btn-accept');
+    }
+    return click('.klaro .cookie-notice .cm-btn-success');
+  }
+
+  async test() {
+    return await doEval('klaro.getManager().config.services.every(c => c.required || !klaro.getManager().consents[c.name])');
+  }
+}

package/lib/cmps/onetrust.ts

@@ -4,7 +4,7 @@ import AutoConsentCMPBase from "./base";
 
 export default class Onetrust extends AutoConsentCMPBase {
 
-  prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.optanon-alert-box-wrapper,.onetrust-pc-dark-filter,.js-consent-banner"]
+  prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.onetrust-pc-dark-filter,.js-consent-banner"]
 
   constructor() {
     super("Onetrust");
@@ -19,11 +19,11 @@ export default class Onetrust extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+    return elementExists("#onetrust-banner-sdk");
   }
 
   async detectPopup() {
-    return elementVisible("#onetrust-banner-sdk,.optanon-alert-box-wrapper", 'all');
+    return elementVisible("#onetrust-banner-sdk", 'all');
   }
 
   async optOut() {

package/lib/cmps/sourcepoint-frame.ts

@@ -32,7 +32,7 @@ export default class SourcePoint extends AutoConsentCMPBase {
       return true;
     }
     return (url.pathname === '/index.html' || url.pathname === '/privacy-manager/index.html')
-        && url.searchParams.has('message_id') && url.searchParams.has('requestUUID');
+        && (url.searchParams.has('message_id') || url.searchParams.has('requestUUID') || url.searchParams.has('consentUUID'));
   }
 
   async detectPopup() {
@@ -57,16 +57,17 @@ export default class SourcePoint extends AutoConsentCMPBase {
 
   async optOut() {
     if (!this.isManagerOpen()) {
-      const actionable = await waitForElement('button.sp_choice_type_12,button.sp_choice_type_13');
+      const actionable = await waitForElement('.sp_choice_type_12,.sp_choice_type_13');
       if (!actionable) {
         return false;
       }
-      if (!elementExists("button.sp_choice_type_12")) {
+      if (!elementExists(".sp_choice_type_12")) {
         // do not sell button
-        return click("button.sp_choice_type_13");
+        return click(".sp_choice_type_13");
       }
 
-      click("button.sp_choice_type_12");
+      click(".sp_choice_type_12");
+      // the page may navigate at this point but that's okay
       await waitFor(
         () => location.pathname === "/privacy-manager/index.html",
         200,
@@ -88,9 +89,8 @@ export default class SourcePoint extends AutoConsentCMPBase {
         await wait(1000);
         return click(rejectSelector1);
       } else if (path === 1) {
-        return click(rejectSelector2);
+        click(rejectSelector2);
       } else if (path === 2) {
-        // TODO: check if this is still working
         await waitForElement('.pm-features', 10000);
         click('.checked > span', true);
 
@@ -99,6 +99,7 @@ export default class SourcePoint extends AutoConsentCMPBase {
     } catch (e) {
       enableLogs && console.warn(e);
     }
-    return click('.sp_choice_type_SAVE_AND_EXIT');
+    click('.sp_choice_type_SAVE_AND_EXIT');
+    return true;
   }
 }

package/lib/cmps/sourcepoint-top.ts

@@ -35,6 +35,11 @@ export default class SourcePoint extends AutoConsentCMPBase {
   }
 
   async optOut() {
+    // unblock scrolling
+    const container = document.querySelector('.sp-message-open');
+    if (container) {
+      container.classList.remove('sp-message-open');
+    }
     return true;
   }
 

package/lib/cmps/trustarc-frame.ts

@@ -100,6 +100,9 @@ export default class TrustArcFrame extends AutoConsentCMPBase {
   }
 
   async optIn() {
+    if (click('.call')) {
+      return true;
+    }
     await this.navigateToSettings();
     click(".switch span:nth-child(2)", true);
 

package/lib/cmps/uniconsent.ts

@@ -0,0 +1,71 @@
+import { elementExists, elementVisible, wait, waitForElement, waitForThenClick } from "../rule-executors";
+import AutoConsentCMPBase from "./base";
+
+export default class Uniconsent extends AutoConsentCMPBase {
+  constructor() {
+    super("Uniconsent");
+  }
+
+  get prehideSelectors(): string[] {
+    return ['.unic', '.modal:has(.unic)'];
+  }
+
+  get hasSelfTest(): boolean {
+    return true;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
+  async detectCmp() {
+    return elementExists(".unic .unic-box,.unic .unic-bar");
+  }
+
+  async detectPopup() {
+    return elementVisible(".unic .unic-box,.unic .unic-bar", 'any');
+  }
+
+  async optOut() {
+    await waitForElement(".unic button", 1000);
+    document.querySelectorAll(".unic button").forEach((button: HTMLButtonElement) => {
+      const text = button.textContent;
+      if (text.includes('Manage Options') || text.includes('Optionen verwalten')) {
+        button.click();
+      }
+    });
+
+    if (await waitForElement('.unic input[type=checkbox]', 1000)) {
+      await waitForElement('.unic button', 1000);
+
+      document.querySelectorAll('.unic input[type=checkbox]').forEach((c: HTMLInputElement) => {
+        if (c.checked) {
+          c.click();
+        }
+      });
+
+      for (const b of <NodeListOf<HTMLButtonElement>>document.querySelectorAll('.unic button')) {
+        const text = b.textContent;
+        for (const pattern of ['Confirm Choices', 'Save Choices', 'Auswahl speichern']) {
+          if (text.includes(pattern)) {
+            b.click();
+            await wait(500); // give it some time to close the popup
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  async optIn() {
+    return waitForThenClick(".unic #unic-agree");
+  }
+
+  async test() {
+    await wait(1000);
+    const res = elementExists(".unic .unic-box,.unic .unic-bar");
+    return !res;
+  }
+}

package/lib/rules.ts

@@ -28,7 +28,8 @@ export type AutoConsentRuleStep = { optional?: boolean } & Partial<
   Partial<WaitForThenClickRule> &
   Partial<WaitRule> &
   Partial<UrlRule> &
-  Partial<HideRule>;
+  Partial<HideRule> &
+  Partial<IfRule>;
 
 export type ElementExistsRule = {
   exists: string;
@@ -80,3 +81,9 @@ export type HideRule = {
   hide: string[];
   method?: HideMethod;
 };
+
+export type IfRule = {
+  if: Partial<ElementExistsRule> & Partial<ElementVisibleRule>;
+  then: AutoConsentRuleStep[];
+  else?: AutoConsentRuleStep[];
+};

package/lib/web.ts

@@ -107,16 +107,46 @@ export default class AutoConsent {
 
   async _start() {
     enableLogs && console.log(`Detecting CMPs on ${window.location.href}`)
-    const cmp = await this.findCmp(this.config.detectRetries);
-    if (cmp) {
-      enableLogs && console.log("detected CMP:", cmp.name, window.location.href);
-      this.sendContentMessage({
-        type: 'cmpDetected',
-        url: location.href,
-        cmp: cmp.name,
-      }); // notify the browser
-      const isOpen = await this.waitForPopup(cmp);
-      if (!isOpen) {
+    const cmps = await this.findCmp(this.config.detectRetries);
+    if (cmps.length > 0) {
+      const popupLookups: Promise<boolean>[] = [];
+      for (const cmp of cmps) {
+        enableLogs && console.log("detected CMP:", cmp.name, window.location.href);
+        this.sendContentMessage({
+          type: 'cmpDetected',
+          url: location.href,
+          cmp: cmp.name,
+        }); // notify the browser
+        popupLookups.push(this.waitForPopup(cmp).then((isOpen) => {
+          if (isOpen) {
+            if (!this.foundCmp) {
+              this.foundCmp = cmp;
+            }
+            this.sendContentMessage({
+              type: 'popupFound',
+              cmp: cmp.name,
+              url: location.href,
+            }); // notify the browser
+            return true;
+          } else {
+            return Promise.reject(`${cmp.name} popup not found`);
+          }
+        }));
+      }
+
+      // could use `somethingOpen = await Promise.any(popupLookups).catch(() => false)`, but Promise.any is often unavailable in polyfilled environments
+      let somethingOpen = false;
+      for (const popupLookup of popupLookups) {
+        try {
+          await popupLookup;
+          somethingOpen = true;
+          break;
+        } catch (e) {
+          continue;
+        }
+      }
+
+      if (!somethingOpen) {
         enableLogs && console.log('no popup found');
         if (this.config.enablePrehide) {
           undoPrehide();
@@ -124,13 +154,6 @@ export default class AutoConsent {
         return false;
       }
 
-      this.foundCmp = cmp;
-      this.sendContentMessage({
-        type: 'popupFound',
-        cmp: cmp.name,
-        url: location.href,
-      }); // notify the browser
-
       if (this.config.autoAction === 'optOut') {
         return await this.doOptOut();
       } else if (this.config.autoAction === 'optIn') {
@@ -148,8 +171,7 @@ export default class AutoConsent {
     }
   }
 
-  async findCmp(retries: number): Promise<AutoCMP> {
-    let foundCmp: AutoCMP = null;
+  async findCmp(retries: number): Promise<AutoCMP[]> {
     const allFoundCmps: AutoCMP[] = [];
 
     for (const cmp of this.rules) {
@@ -161,9 +183,6 @@ export default class AutoConsent {
         if (result) {
           enableLogs && console.log(`Found CMP: ${cmp.name}`);
           allFoundCmps.push(cmp);
-          if (!foundCmp) {
-            foundCmp = cmp;
-          }
         }
       } catch (e) {
         enableLogs && console.warn(`error detecting ${cmp.name}`, e);
@@ -182,7 +201,7 @@ export default class AutoConsent {
       });
     }
 
-    if (!foundCmp && retries > 0) {
+    if (allFoundCmps.length === 0 && retries > 0) {
       return new Promise((resolve) => {
         setTimeout(async () => {
           const result = this.findCmp(retries - 1);
@@ -191,7 +210,7 @@ export default class AutoConsent {
       });
     }
 
-    return foundCmp;
+    return allFoundCmps;
   }
 
   async doOptOut(): Promise<boolean> {
@@ -236,6 +255,7 @@ export default class AutoConsent {
     } else {
       enableLogs && console.log(`CMP ${this.foundCmp.name}: opt in on ${window.location.href}`);
       optInResult = await this.foundCmp.optIn();
+      enableLogs && console.log(`${this.foundCmp.name}: opt in result ${optInResult}`);
     }
 
     if (this.config.enablePrehide) {
@@ -286,7 +306,7 @@ export default class AutoConsent {
     if (!isOpen && retries > 0) {
       return new Promise((resolve) => setTimeout(() => resolve(this.waitForPopup(cmp, retries - 1, interval)), interval));
     }
-    enableLogs && console.log(`popup is ${isOpen ? 'open' : 'not open'}`);
+    enableLogs && console.log(cmp.name, `popup is ${isOpen ? 'open' : 'not open'}`);
     return isOpen;
   }
 
@@ -314,6 +334,9 @@ export default class AutoConsent {
       case 'initResp':
         this.initialize(message.config, message.rules);
         break;
+      case 'optIn':
+        await this.doOptIn();
+        break;
       case 'optOut':
         await this.doOptOut();
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "description": "",
   "main": "dist/autoconsent.cjs.js",
   "module": "dist/autoconsent.esm.js",

package/readme.md

@@ -106,6 +106,17 @@ Returns true if elements returned from `document.querySelectorAll(selector)` are
 ```
 Waits until `selector` exists in the page. After `timeout` ms the step fails.
 
+### Wait for visibility
+
+```json
+{
+  "waitForVisible": "selector",
+  "timeout": 1000,
+  "check": "any" | "all" | "none"
+}
+```
+Waits until element is visible in the page. After `timeout` ms the step fails.
+
 ### Click an element
 ```json
 {
@@ -152,6 +163,24 @@ Hide the elements matched by the selectors. `method` defines how elements are hi
 Evaluates `code` in the context of the page. The rule is considered successful if it *evaluates to a truthy value*.
 Eval rules are not 100% reliable because they can be blocked by a CSP policy on the page. Therefore, they should only be used as a last resort when none of the other rules are sufficient.
 
+### Conditionals
+
+```json
+{
+  "if": { "exists": "selector" },
+  "then": [
+    { "click": ".button1" },
+    { "click": ".button3" }
+  ],
+  "else": [
+    { "click": ".button2" }
+  ]
+}
+```
+
+Allows to do conditional branching in JSON rules. The `if` section can contain either a "visible" or "exists" rule. Depending on the result of that rule, `then` or `else` sequences will be executed. `else` section is optional.
+The "if" rule is considered successful as long as all rules inside the chosen branch are successful. The other branch, as well as the result of the condition itself, do not affect the result of the whole rule.
+
 ### Optional actions
 
 Any rule can include the `"optional": true` to ignore failure.

package/rules/autoconsent/adroll.json

@@ -0,0 +1,11 @@
+{
+  "name": "Adroll",
+  "prehideSelectors": ["#adroll_consent_container"],
+  "detectCmp": [{ "exists": "#adroll_consent_container" }],
+  "detectPopup": [{ "visible": "#adroll_consent_container" }],
+  "optIn": [ { "waitForThenClick": "#adroll_consent_accept" } ],
+  "optOut": [ { "waitForThenClick": "#adroll_consent_reject" } ],
+  "test": [
+    { "eval": "!document.cookie.includes('__adroll_fpc')" }
+  ]
+}

package/rules/autoconsent/aws-amazon.json

@@ -9,7 +9,12 @@
           "click": "button[data-id=awsccc-cb-btn-customize]"
       },
       {
-          "eval": "Array.from(document.querySelectorAll('input[aria-checked=true')).forEach(e => e.click()) || true"
+          "waitFor": "input[aria-checked]"
+      },
+      {
+          "click": "input[aria-checked=true]",
+          "all": true,
+          "optional": true
       },
       {
           "click": "button[data-id=awsccc-cs-btn-save]"

package/rules/autoconsent/axeptio.json

@@ -0,0 +1,41 @@
+{
+    "name": "axeptio",
+    "prehideSelectors": [".axeptio_widget"],
+    "detectCmp": 
+    [
+        { 
+            "exists": ".axeptio_widget" 
+        }
+    ],
+    "detectPopup": 
+    [
+        { 
+            "visible": ".axeptio_widget" 
+        }
+    ],
+    "optIn": 
+    [
+        {
+            "waitFor": ".axeptio-widget--open" 
+        },
+        {
+            "click": "button#axeptio_btn_acceptAll"
+        }
+    ],
+    "optOut": 
+    [
+
+        {
+            "waitFor": ".axeptio-widget--open" 
+        },
+        {
+            "click": "button#axeptio_btn_dismiss"
+        }
+    ],
+    "test": 
+    [
+        {
+            "eval": "document.cookie.includes('axeptio_authorized_vendors=%2C%2C')"
+        }
+    ]
+  }

package/rules/autoconsent/clickio.json

@@ -0,0 +1,18 @@
+{
+  "name": "click.io",
+  "prehideSelectors": ["#cl-consent"],
+  "detectCmp": [{ "exists": "#cl-consent" }],
+  "detectPopup": [{ "visible": "#cl-consent" }],
+  "optIn": [ { "waitForThenClick": "#cl-consent [data-role=\"b_agree\"]" } ],
+  "optOut": [
+    { "waitFor": "#cl-consent [data-role=\"b_options\"]" },
+    { "wait": 500 },
+    { "click": "#cl-consent [data-role=\"b_options\"]" },
+    { "waitFor": ".cl-consent-popup.cl-consent-visible [data-role=\"alloff\"]" },
+    { "click": ".cl-consent-popup.cl-consent-visible [data-role=\"alloff\"]", "all": true },
+    { "click": "[data-role=\"b_save\"]" }
+  ],
+  "test": [
+    { "eval": "document.cookie.includes('__lxG__consent__v2_daisybit=')", "comment": "TODO: this only checks if we interacted at all" }
+  ]
+}

package/rules/autoconsent/complianz-banner.json

@@ -0,0 +1,13 @@
+{
+  "name": "Complianz banner",
+  "prehideSelectors": ["#cmplz-cookiebanner-container"],
+  "detectCmp": [{ "exists": "#cmplz-cookiebanner-container .cmplz-cookiebanner" }],
+  "detectPopup": [{ "visible": "#cmplz-cookiebanner-container .cmplz-cookiebanner", "check": "any" }],
+  "optIn": [
+    { "waitForThenClick": ".cmplz-cookiebanner .cmplz-accept" }
+  ],
+  "optOut": [
+    { "waitForThenClick": ".cmplz-cookiebanner .cmplz-deny" }
+  ],
+  "test": [ { "eval": "document.cookie.includes('cmplz_banner-status=dismissed')" } ]
+}