@duckduckgo/autoconsent 1.0.7 → 2.1.0

package/lib/cmps/consentomatic.ts

@@ -0,0 +1,89 @@
+import { AutoCMP } from "../types";
+import { executeAction, matches } from "../consentomatic";
+import { RunContext } from "../rules";
+import { defaultRunContext } from "./base";
+
+export type DetectorConfig = {
+  presentMatcher: any;
+  showingMatcher: any;
+};
+export type MethodConfig = {
+  action?: any;
+  name: string;
+};
+
+export type ConsentOMaticConfig = {
+  detectors: DetectorConfig[];
+  methods: MethodConfig[];
+};
+
+export class ConsentOMaticCMP implements AutoCMP {
+  methods = new Map<string, any>();
+  hasSelfTest: boolean;
+  runContext: RunContext = defaultRunContext;
+
+  constructor(public name: string, public config: ConsentOMaticConfig) {
+    config.methods.forEach(methodConfig => {
+      if (methodConfig.action) {
+        this.methods.set(methodConfig.name, methodConfig.action);
+      }
+    });
+    this.hasSelfTest = false;
+  }
+
+  get isIntermediate(): boolean {
+    return false; // TODO: support UTILITY rules
+  }
+
+  checkRunContext(): boolean {
+    return true;
+  }
+
+  async detectCmp(): Promise<boolean> {
+    const matchResults = this.config.detectors.map(detectorConfig =>
+      matches(detectorConfig.presentMatcher)
+    )
+    return matchResults.some(r => !!r);
+  }
+
+  async detectPopup(): Promise<boolean> {
+    const matchResults = this.config.detectors.map(detectorConfig =>
+      matches(detectorConfig.showingMatcher)
+    )
+    return matchResults.some(r => !!r);
+  }
+
+  async executeAction(method: string, param?: any) {
+    if (this.methods.has(method)) {
+      return executeAction(this.methods.get(method), param);
+    }
+    return true;
+  }
+
+  async optOut(): Promise<boolean> {
+    await this.executeAction("HIDE_CMP");
+    await this.executeAction("OPEN_OPTIONS");
+    await this.executeAction("HIDE_CMP");
+    await this.executeAction("DO_CONSENT", []);
+    await this.executeAction("SAVE_CONSENT");
+    return true;
+  }
+
+  async optIn(): Promise<boolean> {
+    await this.executeAction("HIDE_CMP");
+    await this.executeAction("OPEN_OPTIONS");
+    await this.executeAction("HIDE_CMP");
+    await this.executeAction("DO_CONSENT", ['D', 'A', 'B', 'E', 'F', 'X']);
+    await this.executeAction("SAVE_CONSENT");
+    return true;
+  }
+  async openCmp(): Promise<boolean> {
+    await this.executeAction("HIDE_CMP");
+    await this.executeAction("OPEN_OPTIONS");
+    return true;
+  }
+
+  async test(): Promise<boolean> {
+    return true;
+  }
+}

package/lib/cmps/cookiebot.ts

@@ -1,81 +1,90 @@
-import AutoConsentBase from './base';
-import { TabActor } from '../types';
+import { click, doEval, elementExists, wait, waitForElement } from '../rule-executors';
+import AutoConsentCMPBase from './base';
 
-export default class Cookiebot extends AutoConsentBase {
+export default class Cookiebot extends AutoConsentCMPBase {
 
-  prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner"]
+  prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner,#cb-cookieoverlay"]
 
   constructor() {
     super('Cybotcookiebot');
   }
 
-  async detectCmp(tab: TabActor) {
-    try {
-      return await tab.eval('typeof window.CookieConsent === "object" && typeof window.CookieConsent.name === "string"');
-    } catch (e) {
-      return false;
-    }
+  get hasSelfTest(): boolean {
+    return true;
   }
 
-  detectPopup(tab: TabActor) {
-    return tab.elementExists('#CybotCookiebotDialog,#dtcookie-container,#cookiebanner');
+  get isIntermediate(): boolean {
+    return false;
   }
 
-  async optOut(tab: TabActor) {
-    if (await tab.elementExists('.cookie-alert-extended-detail-link')) {
-      await tab.clickElement('.cookie-alert-extended-detail-link');
-      await tab.waitForElement('.cookie-alert-configuration', 1000);
-      await tab.clickElements('.cookie-alert-configuration-input:checked');
-      return tab.clickElement('.cookie-alert-extended-button-secondary');
-    }
-    if (await tab.elementExists('#dtcookie-container')) {
-      return tab.clickElement('.h-dtcookie-decline');
-    }
-    if (await tab.elementExists('.cookiebot__button--settings')) {
-      await tab.clickElement('.cookiebot__button--settings');
-    }
-    if (await tab.elementsAreVisible('#CybotCookiebotDialogBodyButtonDecline', 'all')) {
-      return await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+  async detectCmp() {
+    return elementExists('#CybotCookiebotDialogBodyLevelButtonPreferences');
+  }
+
+  async detectPopup() {
+    return elementExists('#CybotCookiebotDialog,#dtcookie-container,#cookiebanner,#cb-cookiebanner');
+  }
+
+  async optOut() {
+    if (click('.cookie-alert-extended-detail-link')) {
+      await waitForElement('.cookie-alert-configuration', 2000);
+      click('.cookie-alert-configuration-input:checked', true);
+      click('.cookie-alert-extended-button-secondary');
+      return true;
     }
-    if (await tab.elementExists('.cookiebanner__link--details')) {
-      await tab.clickElement('.cookiebanner__link--details')
+
+    if (elementExists('#dtcookie-container')) {
+      return click('.h-dtcookie-decline');
     }
-    await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:checked:enabled,input[id*="CybotCookiebotDialogBodyLevelButton"]:checked:enabled');
-    if (await tab.elementExists('#CybotCookiebotDialogBodyButtonDecline')) {
-      await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+
+    if (click('.cookiebot__button--settings')) {
+      return true;
     }
-    if (await tab.elementExists('input[id^=CybotCookiebotDialogBodyLevelButton]:checked')) {
-      await tab.clickElements('input[id^=CybotCookiebotDialogBodyLevelButton]:checked')
+
+    if (click('#CybotCookiebotDialogBodyButtonDecline')) {
+      return true;
     }
-    if (await tab.elementExists('#CybotCookiebotDialogBodyButtonAcceptSelected')) {
-      await tab.clickElement('#CybotCookiebotDialogBodyButtonAcceptSelected');
+
+    click('.cookiebanner__link--details');
+
+    click('.CybotCookiebotDialogBodyLevelButton:checked:enabled,input[id*="CybotCookiebotDialogBodyLevelButton"]:checked:enabled', true);
+
+    click('#CybotCookiebotDialogBodyButtonDecline');
+
+    click('input[id^=CybotCookiebotDialogBodyLevelButton]:checked', true);
+
+    if (elementExists('#CybotCookiebotDialogBodyButtonAcceptSelected')) {
+      click('#CybotCookiebotDialogBodyButtonAcceptSelected');
     } else {
-      await tab.clickElements('#CybotCookiebotDialogBodyLevelButtonAccept,#CybotCookiebotDialogBodyButtonAccept,#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowallSelection');
+      click('#CybotCookiebotDialogBodyLevelButtonAccept,#CybotCookiebotDialogBodyButtonAccept,#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowallSelection', true);
     }
+
     // some sites have custom submit buttons with no obvious selectors. In this case we just call the submitConsent API.
-    if (await tab.eval('CookieConsent.hasResponse !== true')) {
-      await tab.eval('Cookiebot.dialog.submitConsent() || true');
-      await tab.wait(500);
+    if (await doEval('window.CookieConsent.hasResponse !== true')) {
+      await doEval('window.Cookiebot.dialog.submitConsent()');
+      await wait(500);
     }
-    return true;
-  }
 
-  async optIn(tab: TabActor) {
-    if (await tab.elementExists('#dtcookie-container')) {
-      return tab.clickElement('.h-dtcookie-accept');
+    // site with 3rd confirm settings modal
+    if (elementExists('#cb-confirmedSettings')) {
+      await doEval('endCookieProcess()');
     }
-    await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled');
-    await tab.clickElement('#CybotCookiebotDialogBodyLevelButtonAccept');
-    await tab.clickElement('#CybotCookiebotDialogBodyButtonAccept');
+
     return true;
   }
 
-  async openCmp(tab: TabActor) {
-    await tab.eval('CookieConsent.renew() || true');
-    return tab.waitForElement('#CybotCookiebotDialog', 10000);
+  async optIn() {
+    if (elementExists('#dtcookie-container')) {
+      return click('.h-dtcookie-accept');
+    }
+
+    click('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled', true);
+    click('#CybotCookiebotDialogBodyLevelButtonAccept');
+    click('#CybotCookiebotDialogBodyButtonAccept');
+    return true;
   }
 
-  async test(tab: TabActor) {
-    return tab.eval('CookieConsent.declined === true');
+  async test() {
+    return doEval('window.CookieConsent.declined === true');
   }
 }

package/lib/cmps/evidon.ts

@@ -1,32 +1,43 @@
-import AutoConsentBase from "./base";
-import { TabActor } from "../types";
+import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
+import { getStyleElement, hideElements } from "../utils";
+import AutoConsentCMPBase from "./base";
 
-// Note: JS API is also available:
-// https://help.consentmanager.net/books/cmp/page/javascript-api
-export default class Evidon extends AutoConsentBase {
+export default class Evidon extends AutoConsentCMPBase {
   constructor() {
     super("Evidon");
   }
 
-  detectCmp(tab: TabActor) {
-    return tab.elementExists("#_evidon_banner");
+  get hasSelfTest(): boolean {
+    return false;
   }
 
-  detectPopup(tab: TabActor) {
-    return tab.elementsAreVisible("#_evidon_banner");
+  get isIntermediate(): boolean {
+    return false;
   }
 
-  async optOut(tab: TabActor) {
-    if (await tab.elementExists("#_evidon-decline-button")) {
-      return tab.clickElement("#_evidon-decline-button");
+  async detectCmp() {
+    return elementExists("#_evidon_banner");
+  }
+
+  async detectPopup() {
+    return elementVisible("#_evidon_banner", 'any');
+  }
+
+  async optOut() {
+    if (click("#_evidon-decline-button")) {
+      return true;
     }
-    tab.hideElements(["#evidon-prefdiag-overlay", "#evidon-prefdiag-background"])
-    await tab.clickElement("#_evidon-option-button");
-    await tab.waitForElement("#evidon-prefdiag-overlay", 5000);
-    return tab.clickElement("#evidon-prefdiag-decline");
+
+    hideElements(getStyleElement(), ["#evidon-prefdiag-overlay", "#evidon-prefdiag-background"]);
+    click("#_evidon-option-button");
+
+    await waitForElement("#evidon-prefdiag-overlay", 5000);
+
+    click("#evidon-prefdiag-decline");
+    return true;
   }
 
-  async optIn(tab: TabActor) {
-    return tab.clickElement("#_evidon-accept-button");
+  async optIn() {
+    return click("#_evidon-accept-button");
   }
 }

package/lib/cmps/onetrust.ts

@@ -1,7 +1,8 @@
-import AutoConsentBase, { success, waitFor } from "./base";
-import { TabActor } from "../types";
+import { click, doEval, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
+import { waitFor } from "../utils";
+import AutoConsentCMPBase from "./base";
 
-export default class Onetrust extends AutoConsentBase {
+export default class Onetrust extends AutoConsentCMPBase {
 
   prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.optanon-alert-box-wrapper,.onetrust-pc-dark-filter,.js-consent-banner"]
 
@@ -9,39 +10,50 @@ export default class Onetrust extends AutoConsentBase {
     super("Onetrust");
   }
 
-  detectCmp(tab: TabActor) {
-    return tab.elementExists("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+  get hasSelfTest(): boolean {
+    return true;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
   }
 
-  detectPopup(tab: TabActor) {
-    return tab.elementsAreVisible("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+  async detectCmp() {
+    return elementExists("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
   }
 
-  async optOut(tab: TabActor) {
-    if (await tab.elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
-      await success(tab.clickElement("#onetrust-pc-btn-handler"));
+  async detectPopup() {
+    return elementVisible("#onetrust-banner-sdk,.optanon-alert-box-wrapper", 'all');
+  }
+
+  async optOut() {
+    if (elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
+      click("#onetrust-pc-btn-handler");
     } else { // otherwise look for a generic "show settings" button
-      await success(tab.clickElement(".ot-sdk-show-settings,button.js-cookie-settings"));
+      click(".ot-sdk-show-settings,button.js-cookie-settings");
     }
 
-    await success(tab.waitForElement("#onetrust-consent-sdk", 2000));
-    await success(tab.wait(1000));
-    await tab.clickElements("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked"); // optional step
-    await success(tab.waitForThenClick(".save-preference-btn-handler,.js-consent-save", 1000));
+    await waitForElement('#onetrust-consent-sdk', 2000);
+    await wait(1000);
+    click("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked", true); // optional step
+
+    await waitForElement(".save-preference-btn-handler,.js-consent-save", 2000);
+    click(".save-preference-btn-handler,.js-consent-save");
+
     // popup doesn't disappear immediately
     await waitFor(
-      async () => !(await tab.elementsAreVisible("#onetrust-banner-sdk")),
+      () => elementVisible("#onetrust-banner-sdk", 'none'),
       10,
       500
     );
     return true;
   }
 
-  async optIn(tab: TabActor) {
-    return tab.clickElement("onetrust-accept-btn-handler,js-accept-cookies");
+  async optIn() {
+    return click("#onetrust-accept-btn-handler,.js-accept-cookies");
   }
 
-  async test(tab: TabActor){
-    return tab.eval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
+  async test() {
+    return await doEval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
   }
 }

package/lib/cmps/sourcepoint-frame.ts

@@ -0,0 +1,104 @@
+import { enableLogs } from "../config";
+import { click, elementExists, wait, waitForElement } from "../rule-executors";
+import { RunContext } from "../rules";
+import { waitFor } from "../utils";
+import AutoConsentCMPBase from "./base";
+
+export default class SourcePoint extends AutoConsentCMPBase {
+
+  ccpaMode = false;
+
+  runContext: RunContext = {
+    main: false,
+    frame: true,
+  }
+
+  constructor() {
+    super("Sourcepoint-frame");
+  }
+
+  get hasSelfTest(): boolean {
+    return false; // self-test is done by parent frame
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
+  async detectCmp() {
+    const url = new URL(location.href);
+    if (url.searchParams.has('message_id') && url.hostname === 'ccpa-notice.sp-prod.net') {
+      this.ccpaMode = true;
+      return true;
+    }
+    return (url.pathname === '/index.html' || url.pathname === '/privacy-manager/index.html')
+        && url.searchParams.has('message_id') && url.searchParams.has('requestUUID');
+  }
+
+  async detectPopup() {
+    return true;
+  }
+
+  async optIn() {
+    await waitForElement(".sp_choice_type_11,.sp_choice_type_ACCEPT_ALL", 2000);
+    if (click(".sp_choice_type_11")) {
+      return true;
+    }
+
+    if (click('.sp_choice_type_ACCEPT_ALL')) {
+      return true;
+    }
+    return false;
+  }
+
+  isManagerOpen() {
+    return (new URL(location.href)).pathname === "/privacy-manager/index.html";
+  }
+
+  async optOut() {
+    if (!this.isManagerOpen()) {
+      const actionable = await waitForElement('button.sp_choice_type_12,button.sp_choice_type_13');
+      if (!actionable) {
+        return false;
+      }
+      if (!elementExists("button.sp_choice_type_12")) {
+        // do not sell button
+        return click("button.sp_choice_type_13");
+      }
+
+      click("button.sp_choice_type_12");
+      await waitFor(
+        () => location.pathname === "/privacy-manager/index.html",
+        200,
+        100
+      );
+    }
+
+    await waitForElement('.type-modal', 20000);
+    // reject all button is offered by some sites
+    try {
+      const rejectSelector1 = '.sp_choice_type_REJECT_ALL';
+      const rejectSelector2 = '.reject-toggle';
+      const path = await Promise.race([
+        waitForElement(rejectSelector1, 2000).then(success => success ? 0: -1),
+        waitForElement(rejectSelector2, 2000).then(success => success ? 1: -1),
+        waitForElement('.pm-features', 2000).then(success => success ? 2: -1),
+      ]);
+      if (path === 0) {
+        await wait(1000);
+        return click(rejectSelector1);
+      } else if (path === 1) {
+        return click(rejectSelector2);
+      } else if (path === 2) {
+        // TODO: check if this is still working
+        await waitForElement('.pm-features', 10000);
+        click('.checked > span', true);
+
+        click('.chevron');
+      }
+    } catch (e) {
+      enableLogs && console.warn(e);
+    }
+    return click('.sp_choice_type_SAVE_AND_EXIT');
+  }
+}

package/lib/cmps/sourcepoint-top.ts

@@ -0,0 +1,47 @@
+import { doEval, elementExists, elementVisible } from "../rule-executors";
+import { RunContext } from "../rules";
+import AutoConsentCMPBase from "./base";
+
+export default class SourcePoint extends AutoConsentCMPBase {
+  prehideSelectors = ["div[id^='sp_message_container_'],.message-overlay"]
+
+  constructor() {
+    super("Sourcepoint-top");
+  }
+
+  runContext: RunContext = {
+    main: true,
+    frame: false,
+  }
+
+  get hasSelfTest(): boolean {
+    return true;
+  }
+
+  get isIntermediate(): boolean {
+    return true;
+  }
+
+  async detectCmp() {
+    return elementExists("div[id^='sp_message_container_']");
+  }
+
+  async detectPopup() {
+    return elementVisible("div[id^='sp_message_container_']", 'all');
+  }
+
+  async optIn() {
+    return true;
+  }
+
+  async optOut() {
+    return true;
+  }
+
+  async test() {
+    await doEval("__tcfapi('getTCData', 2, r => window.__rcsResult = r)");
+    return await doEval(
+      "Object.values(window.__rcsResult.purpose.consents).every(c => !c)"
+    );
+  }
+}

package/lib/cmps/trustarc-frame.ts

@@ -0,0 +1,115 @@
+import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
+import { RunContext } from "../rules";
+import { waitFor } from "../utils";
+import AutoConsentCMPBase from "./base";
+
+export default class TrustArcFrame extends AutoConsentCMPBase {
+  constructor() {
+    super("TrustArc-frame");
+  }
+
+  runContext: RunContext = {
+    main: false,
+    frame: true,
+    url: "https://consent-pref.trustarc.com/?",
+  }
+
+  get hasSelfTest(): boolean {
+    return false;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
+  async detectCmp() {
+    return true;
+  }
+
+  async detectPopup() {
+    // we're already inside the popup
+    return elementVisible("#defaultpreferencemanager", 'any') && elementVisible(".mainContent", 'any');
+  }
+
+  async navigateToSettings() {
+    // wait for it to load
+    await waitFor(
+      async () => {
+        return (
+          elementExists(".shp") ||
+          elementVisible(".advance", 'any') ||
+          elementExists(".switch span:first-child")
+        );
+      },
+      10,
+      500
+    );
+    // splash screen -> hit more information
+    if (elementExists(".shp")) {
+      click(".shp");
+    }
+
+    await waitForElement(".prefPanel", 5000);
+
+    // go to advanced settings if not yet shown
+    if (elementVisible(".advance", 'any')) {
+      click(".advance");
+    }
+
+    // takes a while to load the opt-in/opt-out buttons
+    return await waitFor(
+      () => elementVisible(".switch span:first-child", 'any'),
+      5,
+      1000
+    );
+  }
+
+  async optOut() {
+    await waitFor(() => document.readyState === 'complete', 20, 100);
+    await waitForElement(".mainContent[aria-hidden=false]", 5000);
+
+    if (click(".rejectAll")) {
+      return true;
+    }
+
+    if (elementExists('.prefPanel')) {
+      await waitForElement('.prefPanel[style="visibility: visible;"]', 3000);
+    }
+
+    if (click("#catDetails0")) {
+      click(".submit");
+      return true;
+    }
+
+    if (click(".required")) {
+      return true;
+    }
+
+    await this.navigateToSettings();
+
+    click(".switch span:nth-child(1):not(.active)", true);
+
+    click(".submit");
+
+    // at this point, iframe usually closes. Sometimes we need to close manually, but we don't wait for it to report success
+    waitForElement("#gwt-debug-close_id", 300000).then(() => {
+      click("#gwt-debug-close_id");
+    });
+
+    return true;
+  }
+
+  async optIn() {
+    await this.navigateToSettings();
+    click(".switch span:nth-child(2)", true);
+
+    click(".submit");
+
+    // at this point, iframe usually closes. Sometimes we need to close manually, but we don't wait for it to report success
+    waitForElement("#gwt-debug-close_id", 300000).then(() => {
+      click("#gwt-debug-close_id");
+    });
+
+    return true;
+  }
+}