@duckduckgo/autoconsent 2.1.2 → 2.2.0

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/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/uniconsent.ts

@@ -0,0 +1,70 @@
+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'];
+  }
+
+  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();
+            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,36 @@ 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`);
+          }
+        }));
+      }
+
+      const somethingOpen = await Promise.any(popupLookups).catch(() => false);
+
+      if (!somethingOpen) {
         enableLogs && console.log('no popup found');
         if (this.config.enablePrehide) {
           undoPrehide();
@@ -124,13 +144,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 +161,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 +173,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 +191,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 +200,7 @@ export default class AutoConsent {
       });
     }
 
-    return foundCmp;
+    return allFoundCmps;
   }
 
   async doOptOut(): Promise<boolean> {
@@ -236,6 +245,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 +296,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;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "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')" } ]
+}

package/rules/autoconsent/complianz-categories.json

@@ -0,0 +1,17 @@
+{
+    "name": "Complianz categories",
+    "prehideSelectors": [".cc-type-categories[aria-describedby=\"cookieconsent:desc\"]"],
+    "detectCmp": [{ "exists": ".cc-type-categories[aria-describedby=\"cookieconsent:desc\"]" }],
+    "detectPopup": [{ "visible": ".cc-type-categories[aria-describedby=\"cookieconsent:desc\"]" }],
+    "optIn": [
+        { "click": ".cc-accept-all", "optional": true },
+        { "click": ".cc-allow", "optional": true },
+        { "click": ".cc-dismiss", "optional": true }
+    ],
+    "optOut": [
+        { "click": ".cc-dismiss" }
+    ],
+    "test": [
+        { "eval": "!!document.cookie.match(/cmplz_[^=]+=deny/)" }
+    ]
+}

package/rules/autoconsent/complianz-notice.json

@@ -0,0 +1,14 @@
+{
+    "name": "Complianz notice",
+    "prehideSelectors": [".cc-type-info[aria-describedby=\"cookieconsent:desc\"]"],
+    "detectCmp": [{ "exists": ".cc-type-info[aria-describedby=\"cookieconsent:desc\"]" }],
+    "detectPopup": [{ "visible": ".cc-type-info[aria-describedby=\"cookieconsent:desc\"]" }],
+    "optIn": [
+        { "click": ".cc-accept-all", "optional": true },
+        { "click": ".cc-allow", "optional": true },
+        { "click": ".cc-dismiss", "optional": true }
+    ],
+    "optOut": [
+        { "hide": ["[aria-describedby=\"cookieconsent:desc\"]"] }
+    ]
+}

package/rules/autoconsent/complianz-optin.json

@@ -0,0 +1,20 @@
+{
+    "name": "Complianz optin",
+    "prehideSelectors": [".cc-type-opt-in[aria-describedby=\"cookieconsent:desc\"]"],
+    "detectCmp": [{ "exists": ".cc-type-opt-in[aria-describedby=\"cookieconsent:desc\"]" }],
+    "detectPopup": [{ "visible": ".cc-type-opt-in[aria-describedby=\"cookieconsent:desc\"]" }],
+    "optIn": [
+        { "click": ".cc-accept-all", "optional": true },
+        { "click": ".cc-allow", "optional": true },
+        { "click": ".cc-dismiss", "optional": true }
+    ],
+    "optOut": [
+        { "click": ".cc-settings" },
+        { "waitForVisible": "[aria-label=\"cookies preferences popup\"]" },
+        { "click": "[aria-label=\"cookies preferences popup\"] input[type=checkbox]:not([disabled])", "all": true },
+        { "click": "[aria-label=\"cookies preferences popup\"] [aria-label=\"Accept Selected\"]" }
+    ],
+    "test": [
+        { "eval": "!!document.cookie.match(/cookieconsent_preferences_disabled=[^;]+/)" }
+    ]
+}