@duckduckgo/autoconsent 1.0.6 → 2.0.0

package/lib/cmps/onetrust.ts

@@ -1,7 +1,8 @@
-import AutoConsentBase, { success } 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,33 +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(
+      () => 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,102 @@
+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() {
+    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()) {
+      if (!elementExists("button.sp_choice_type_12")) {
+        // do not sell button
+        click("button.sp_choice_type_13");
+        return true;
+      }
+
+      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);
+        click(rejectSelector1);
+        return true;
+      } else if (path === 1) {
+        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);
+    }
+    click('.sp_choice_type_SAVE_AND_EXIT');
+    return true;
+  }
+}

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;
+  }
+}

package/lib/cmps/trustarc-top.ts

@@ -0,0 +1,91 @@
+import { click, elementExists, elementVisible } from "../rule-executors";
+import { RunContext } from "../rules";
+import { getStyleElement, hideElements } from "../utils";
+import AutoConsentCMPBase from "./base";
+
+const cookieSettingsButton = "#truste-show-consent";
+const shortcutOptOut = '#truste-consent-required';
+const shortcutOptIn = '#truste-consent-button';
+const popupContent = '#truste-consent-content';
+const bannerOverlay = '#trustarc-banner-overlay';
+const bannerContainer = '#truste-consent-track';
+
+export default class TrustArcTop extends AutoConsentCMPBase {
+
+  prehideSelectors = [
+    ".trustarc-banner-container",
+    `.truste_popframe,.truste_overlay,.truste_box_overlay,${bannerContainer}`,
+  ]
+  runContext: RunContext = {
+    main: true,
+    frame: false,
+  }
+
+  _shortcutButton: HTMLElement;
+
+  constructor() {
+    super("TrustArc-top");
+    this._shortcutButton = null; // indicates if the "reject all" button is detected
+  }
+
+  get hasSelfTest(): boolean {
+    return false;
+  }
+
+  get isIntermediate(): boolean {
+    return !this._shortcutButton;
+  }
+
+  async detectCmp() {
+    const result = elementExists(`${cookieSettingsButton},${bannerContainer}`);
+    if (result) {
+      // additionally detect the opt-out button
+      this._shortcutButton = document.querySelector(shortcutOptOut);
+    }
+    return result;
+  }
+
+  async detectPopup() {
+    // not every element should exist, but if it does, it's a popup
+    return elementVisible(`${popupContent},${bannerOverlay},${bannerContainer}`, 'all');
+  }
+
+  openFrame() {
+    click(cookieSettingsButton);
+  }
+
+  async optOut() {
+    if (this._shortcutButton) {
+      this._shortcutButton.click();
+      return true;
+    }
+
+    // hide elements permanently, so user doesn't see the popup
+    hideElements(
+      getStyleElement(),
+      [".truste_popframe", ".truste_overlay", ".truste_box_overlay", bannerContainer],
+    );
+    click(cookieSettingsButton);
+
+    // schedule cleanup
+    setTimeout(() => {
+      getStyleElement().remove();
+    }, 10000);
+
+    return true;
+  }
+
+  async optIn() {
+    return click(shortcutOptIn);
+  }
+
+  async openCmp() {
+    // await tab.eval("truste.eu.clickListener()");
+    return true;
+  }
+
+  async test() {
+    // TODO: find out how to test TrustArc
+    return true;
+  }
+}