@duckduckgo/autoconsent 8.2.0 → 9.0.0

package/lib/cmps/sourcepoint-frame.ts

@@ -1,5 +1,3 @@
-import { enableLogs } from "../config";
-import { click, elementExists, wait, waitForElement, waitForThenClick } from "../rule-executors";
 import { RunContext } from "../rules";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
@@ -47,20 +45,20 @@ export default class SourcePoint extends AutoConsentCMPBase {
       return true;
     }
     if (this.ccpaPopup) {
-      return await waitForElement('.priv-save-btn', 2000);
+      return await this.waitForElement('.priv-save-btn', 2000);
     }
     // check for the paywall button, and bail if it exists to prevent broken opt out
-    await waitForElement(".sp_choice_type_11,.sp_choice_type_12,.sp_choice_type_13,.sp_choice_type_ACCEPT_ALL,.sp_choice_type_SAVE_AND_EXIT", 2000);
-    return !elementExists('.sp_choice_type_9');
+    await this.waitForElement(".sp_choice_type_11,.sp_choice_type_12,.sp_choice_type_13,.sp_choice_type_ACCEPT_ALL,.sp_choice_type_SAVE_AND_EXIT", 2000);
+    return !this.elementExists('.sp_choice_type_9');
   }
 
   async optIn() {
-    await waitForElement(".sp_choice_type_11,.sp_choice_type_ACCEPT_ALL", 2000);
-    if (click(".sp_choice_type_11")) {
+    await this.waitForElement(".sp_choice_type_11,.sp_choice_type_ACCEPT_ALL", 2000);
+    if (this.click(".sp_choice_type_11")) {
       return true;
     }
 
-    if (click('.sp_choice_type_ACCEPT_ALL')) {
+    if (this.click('.sp_choice_type_ACCEPT_ALL')) {
       return true;
     }
     return false;
@@ -71,6 +69,7 @@ export default class SourcePoint extends AutoConsentCMPBase {
   }
 
   async optOut() {
+    const logsConfig = this.autoconsent.config.logs;
     if (this.ccpaPopup) {
       // toggles with 2 buttons
       const toggles = document.querySelectorAll('.priv-purpose-container .sp-switch-arrow-block a.neutral.on .right') as NodeListOf<HTMLElement>;
@@ -82,19 +81,19 @@ export default class SourcePoint extends AutoConsentCMPBase {
       for (const t of switches) {
         t.click()
       }
-      return click('.priv-save-btn');
+      return this.click('.priv-save-btn');
     }
     if (!this.isManagerOpen()) {
-      const actionable = await waitForElement('.sp_choice_type_12,.sp_choice_type_13');
+      const actionable = await this.waitForElement('.sp_choice_type_12,.sp_choice_type_13');
       if (!actionable) {
         return false;
       }
-      if (!elementExists(".sp_choice_type_12")) {
+      if (!this.elementExists(".sp_choice_type_12")) {
         // do not sell button
-        return click(".sp_choice_type_13");
+        return this.click(".sp_choice_type_13");
       }
 
-      click(".sp_choice_type_12");
+      this.click(".sp_choice_type_12");
       // the page may navigate at this point but that's okay
       await waitFor(
         () => this.isManagerOpen(),
@@ -103,35 +102,35 @@ export default class SourcePoint extends AutoConsentCMPBase {
       );
     }
 
-    await waitForElement('.type-modal', 20000);
+    await this.waitForElement('.type-modal', 20000);
 
     // check "Do Not Sell" (CCPA) toggle if it exists
-    waitForThenClick('.ccpa-stack .pm-switch[aria-checked=true] .slider', 500, true); // the UI is reversed: "unchecked" switch displays as an enabled toggle
+    this.waitForThenClick('.ccpa-stack .pm-switch[aria-checked=true] .slider', 500, true); // the UI is reversed: "unchecked" switch displays as an enabled toggle
 
     // 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),
+        this.waitForElement(rejectSelector1, 2000).then(success => success ? 0: -1),
+        this.waitForElement(rejectSelector2, 2000).then(success => success ? 1: -1),
+        this.waitForElement('.pm-features', 2000).then(success => success ? 2: -1),
       ]);
       if (path === 0) {
-        await wait(1000);
-        return click(rejectSelector1);
+        await this.wait(1000);
+        return this.click(rejectSelector1);
       } else if (path === 1) {
-        click(rejectSelector2);
+        this.click(rejectSelector2);
       } else if (path === 2) {
-        await waitForElement('.pm-features', 10000);
-        click('.checked > span', true);
+        await this.waitForElement('.pm-features', 10000);
+        this.click('.checked > span', true);
 
-        click('.chevron');
+        this.click('.chevron');
       }
     } catch (e) {
-      enableLogs && console.warn(e);
+      logsConfig.errors && console.warn(e);
     }
     // TODO: race condition: if the reject button was clicked, the popup disappears very quickly, so the background script may not receive a success report.
-    return click('.sp_choice_type_SAVE_AND_EXIT');
+    return this.click('.sp_choice_type_SAVE_AND_EXIT');
   }
 }

package/lib/cmps/tiktok.ts

@@ -1,5 +1,3 @@
-import { enableLogs } from "../config";
-import { elementExists } from "../rule-executors";
 import { RunContext } from "../rules";
 import { isElementVisible } from "../utils";
 import AutoConsentCMPBase from "./base";
@@ -32,7 +30,7 @@ export default class Tiktok extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists("tiktok-cookie-banner");
+    return this.elementExists("tiktok-cookie-banner");
   }
 
   async detectPopup() {
@@ -41,25 +39,27 @@ export default class Tiktok extends AutoConsentCMPBase {
   }
 
   async optOut() {
+    const logsConfig = this.autoconsent.config.logs;
     const declineButton = this.getShadowRoot().querySelector('.button-wrapper button:first-child') as HTMLElement;
     if (declineButton) {
-      enableLogs && console.log("[clicking]", declineButton);
+      logsConfig.rulesteps && console.log("[clicking]", declineButton);
       declineButton.click();
       return true;
     } else {
-      enableLogs && console.log("no decline button found");
+      logsConfig.errors && console.log("no decline button found");
       return false;
     }
   }
 
   async optIn() {
+    const logsConfig = this.autoconsent.config.logs;
     const acceptButton = this.getShadowRoot().querySelector('.button-wrapper button:last-child') as HTMLElement;
     if (acceptButton) {
-      enableLogs && console.log("[clicking]", acceptButton);
+      logsConfig.rulesteps && console.log("[clicking]", acceptButton);
       acceptButton.click();
       return true;
     } else {
-      enableLogs && console.log("no accept button found");
+      logsConfig.errors && console.log("no accept button found");
       return false;
     }
   }

package/lib/cmps/trustarc-frame.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
 import { RunContext } from "../rules";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
@@ -30,7 +29,7 @@ export default class TrustArcFrame extends AutoConsentCMPBase {
 
   async detectPopup() {
     // we're already inside the popup
-    return elementVisible("#defaultpreferencemanager", 'any') && elementVisible(".mainContent", 'any');
+    return this.elementVisible("#defaultpreferencemanager", 'any') && this.elementVisible(".mainContent", 'any');
   }
 
   async navigateToSettings() {
@@ -38,29 +37,29 @@ export default class TrustArcFrame extends AutoConsentCMPBase {
     await waitFor(
       async () => {
         return (
-          elementExists(".shp") ||
-          elementVisible(".advance", 'any') ||
-          elementExists(".switch span:first-child")
+          this.elementExists(".shp") ||
+          this.elementVisible(".advance", 'any') ||
+          this.elementExists(".switch span:first-child")
         );
       },
       10,
       500
     );
     // splash screen -> hit more information
-    if (elementExists(".shp")) {
-      click(".shp");
+    if (this.elementExists(".shp")) {
+      this.click(".shp");
     }
 
-    await waitForElement(".prefPanel", 5000);
+    await this.waitForElement(".prefPanel", 5000);
 
     // go to advanced settings if not yet shown
-    if (elementVisible(".advance", 'any')) {
-      click(".advance");
+    if (this.elementVisible(".advance", 'any')) {
+      this.click(".advance");
     }
 
     // takes a while to load the opt-in/opt-out buttons
     return await waitFor(
-      () => elementVisible(".switch span:first-child", 'any'),
+      () => this.elementVisible(".switch span:first-child", 'any'),
       5,
       1000
     );
@@ -68,51 +67,51 @@ export default class TrustArcFrame extends AutoConsentCMPBase {
 
   async optOut() {
     await waitFor(() => document.readyState === 'complete', 20, 100);
-    await waitForElement(".mainContent[aria-hidden=false]", 5000);
+    await this.waitForElement(".mainContent[aria-hidden=false]", 5000);
 
-    if (click(".rejectAll")) {
+    if (this.click(".rejectAll")) {
       return true;
     }
 
-    if (elementExists('.prefPanel')) {
-      await waitForElement('.prefPanel[style="visibility: visible;"]', 3000);
+    if (this.elementExists('.prefPanel')) {
+      await this.waitForElement('.prefPanel[style="visibility: visible;"]', 3000);
     }
 
-    if (click("#catDetails0")) {
-      click(".submit");
-      waitForThenClick("#gwt-debug-close_id", 5000);
+    if (this.click("#catDetails0")) {
+      this.click(".submit");
+      this.waitForThenClick("#gwt-debug-close_id", 5000);
       return true;
     }
 
-    if (click(".required")) {
-      waitForThenClick("#gwt-debug-close_id", 5000);
+    if (this.click(".required")) {
+      this.waitForThenClick("#gwt-debug-close_id", 5000);
       return true;
     }
 
     await this.navigateToSettings();
 
-    click(".switch span:nth-child(1):not(.active)", true);
+    this.click(".switch span:nth-child(1):not(.active)", true);
 
-    click(".submit");
+    this.click(".submit");
 
     // at this point, iframe usually closes. Sometimes we need to close manually, but we don't wait for it to report success
-    waitForThenClick("#gwt-debug-close_id", 300000);
+    this.waitForThenClick("#gwt-debug-close_id", 300000);
 
     return true;
   }
 
   async optIn() {
-    if (click('.call')) {
+    if (this.click('.call')) {
       return true;
     }
     await this.navigateToSettings();
-    click(".switch span:nth-child(2)", true);
+    this.click(".switch span:nth-child(2)", true);
 
-    click(".submit");
+    this.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");
+    this.waitForElement("#gwt-debug-close_id", 300000).then(() => {
+      this.click("#gwt-debug-close_id");
     });
 
     return true;

package/lib/cmps/trustarc-top.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible } from "../rule-executors";
 import { RunContext } from "../rules";
 import { getStyleElement, hideElements } from "../utils";
 import AutoConsent from "../web";
@@ -47,7 +46,7 @@ export default class TrustArcTop extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    const result = elementExists(`${cookieSettingsButton},${bannerContainer}`);
+    const result = this.elementExists(`${cookieSettingsButton},${bannerContainer}`);
     if (result) {
       // additionally detect the opt-out button
       this._shortcutButton = document.querySelector(shortcutOptOut);
@@ -57,11 +56,11 @@ export default class TrustArcTop extends AutoConsentCMPBase {
 
   async detectPopup() {
     // not every element should exist, but if it does, it's a popup
-    return elementVisible(`${popupContent},${bannerOverlay},${bannerContainer}`, 'all');
+    return this.elementVisible(`${popupContent},${bannerOverlay},${bannerContainer}`, 'all');
   }
 
   openFrame() {
-    click(cookieSettingsButton);
+    this.click(cookieSettingsButton);
   }
 
   async optOut() {
@@ -75,7 +74,7 @@ export default class TrustArcTop extends AutoConsentCMPBase {
       getStyleElement(),
       `.truste_popframe, .truste_overlay, .truste_box_overlay, ${bannerContainer}`,
     );
-    click(cookieSettingsButton);
+    this.click(cookieSettingsButton);
 
     // schedule cleanup
     setTimeout(() => {
@@ -87,7 +86,7 @@ export default class TrustArcTop extends AutoConsentCMPBase {
 
   async optIn() {
     this._optInDone = true; // just a hack to force autoconsentDone
-    return click(shortcutOptIn);
+    return this.click(shortcutOptIn);
   }
 
   async openCmp() {

package/lib/cmps/uniconsent.ts

@@ -1,4 +1,3 @@
-import { elementExists, elementVisible, wait, waitForElement, waitForThenClick } from "../rule-executors";
 import AutoConsentCMPBase from "./base";
 
 export default class Uniconsent extends AutoConsentCMPBase {
@@ -21,15 +20,15 @@ export default class Uniconsent extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists(".unic .unic-box,.unic .unic-bar");
+    return this.elementExists(".unic .unic-box,.unic .unic-bar");
   }
 
   async detectPopup() {
-    return elementVisible(".unic .unic-box,.unic .unic-bar", 'any');
+    return this.elementVisible(".unic .unic-box,.unic .unic-bar", 'any');
   }
 
   async optOut() {
-    await waitForElement(".unic button", 1000);
+    await this.waitForElement(".unic button", 1000);
     document.querySelectorAll(".unic button").forEach((button: HTMLButtonElement) => {
       const text = button.textContent;
       if (text.includes('Manage Options') || text.includes('Optionen verwalten')) {
@@ -37,8 +36,8 @@ export default class Uniconsent extends AutoConsentCMPBase {
       }
     });
 
-    if (await waitForElement('.unic input[type=checkbox]', 1000)) {
-      await waitForElement('.unic button', 1000);
+    if (await this.waitForElement('.unic input[type=checkbox]', 1000)) {
+      await this.waitForElement('.unic button', 1000);
 
       document.querySelectorAll('.unic input[type=checkbox]').forEach((c: HTMLInputElement) => {
         if (c.checked) {
@@ -51,7 +50,7 @@ export default class Uniconsent extends AutoConsentCMPBase {
         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
+            await this.wait(500); // give it some time to close the popup
             return true;
           }
         }
@@ -62,12 +61,12 @@ export default class Uniconsent extends AutoConsentCMPBase {
   }
 
   async optIn() {
-    return waitForThenClick(".unic #unic-agree");
+    return this.waitForThenClick(".unic #unic-agree");
   }
 
   async test() {
-    await wait(1000);
-    const res = elementExists(".unic .unic-box,.unic .unic-bar");
+    await this.wait(1000);
+    const res = this.elementExists(".unic .unic-box,.unic .unic-bar");
     return !res;
   }
 }

package/lib/dom-actions.ts

@@ -0,0 +1,145 @@
+import { ElementSelector, HideMethod, VisibilityCheck } from "./rules";
+import { DomActionsProvider } from "./types";
+import { getStyleElement, hideElements, isElementVisible, waitFor } from "./utils";
+import AutoConsent from "./web";
+
+export class DomActions implements DomActionsProvider {
+  constructor(public autoconsentInstance: AutoConsent) { }
+
+  click(selector: ElementSelector, all = false): boolean {
+    const elem = this.elementSelector(selector)
+    this.autoconsentInstance.config.logs.rulesteps && console.log("[click]", selector, all, elem);
+    if (elem.length > 0) {
+      if (all) {
+        elem.forEach((e) => e.click());
+      } else {
+        elem[0].click();
+      }
+    }
+    return elem.length > 0;
+  }
+
+  elementExists(selector: ElementSelector): boolean {
+    const exists = this.elementSelector(selector).length > 0;
+    return exists;
+  }
+
+  elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean {
+    const elem = this.elementSelector(selector);
+    const results = new Array(elem.length);
+    elem.forEach((e, i) => {
+      // check for display: none
+      results[i] = isElementVisible(e);
+    });
+    if (check === "none") {
+      return results.every(r => !r);
+    } else if (results.length === 0) {
+      return false;
+    } else if (check === "any") {
+      return results.some(r => r);
+    }
+    // all
+    return results.every(r => r);
+  }
+
+  waitForElement(selector: ElementSelector, timeout = 10000): Promise<boolean> {
+    const interval = 200;
+    const times = Math.ceil((timeout) / interval);
+    this.autoconsentInstance.config.logs.rulesteps && console.log("[waitForElement]", selector);
+    return waitFor(
+      () => this.elementSelector(selector).length > 0,
+      times,
+      interval
+    );
+  }
+
+  waitForVisible(selector: ElementSelector, timeout = 10000, check: VisibilityCheck = 'any'): Promise<boolean> {
+    const interval = 200;
+    const times = Math.ceil((timeout) / interval);
+    return waitFor(
+      () => this.elementVisible(selector, check),
+      times,
+      interval
+    );
+  }
+
+  async waitForThenClick(selector: ElementSelector, timeout = 10000, all = false): Promise<boolean> {
+    await this.waitForElement(selector, timeout);
+    return this.click(selector, all);
+  }
+
+  wait(ms: number): Promise<true> {
+    return new Promise(resolve => {
+      setTimeout(() => {
+        resolve(true);
+      }, ms);
+    });
+  }
+
+  hide(selector: string, method: HideMethod): boolean {
+    const styleEl = getStyleElement();
+    return hideElements(styleEl, selector, method);
+  }
+
+  prehide(selector: string): boolean {
+    const styleEl = getStyleElement('autoconsent-prehide');
+    this.autoconsentInstance.config.logs.lifecycle && console.log("[prehide]", styleEl, location.href);
+    return hideElements(styleEl, selector, "opacity");
+  }
+
+  undoPrehide(): boolean {
+    const existingElement = getStyleElement('autoconsent-prehide');
+    this.autoconsentInstance.config.logs.lifecycle && console.log("[undoprehide]", existingElement, location.href);
+    if (existingElement) {
+      existingElement.remove();
+    }
+    return !!existingElement;
+  }
+
+  querySingleReplySelector(selector: string, parent: any = document): HTMLElement[] {
+    if (selector.startsWith('aria/')) {
+      return []
+    }
+    if (selector.startsWith('xpath/')) {
+      const xpath = selector.slice(6)
+      const result = document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null)
+      let node: Node = null
+      const elements: HTMLElement[] = []
+      // eslint-disable-next-line no-cond-assign
+      while (node = result.iterateNext()) {
+        elements.push(node as HTMLElement)
+      }
+      return elements
+    }
+    if (selector.startsWith('text/')) {
+      return []
+    }
+    if (selector.startsWith('pierce/')) {
+      return []
+    }
+    if (parent.shadowRoot) {
+      return Array.from(parent.shadowRoot.querySelectorAll(selector))
+    }
+    return Array.from(parent.querySelectorAll(selector))
+  }
+
+  querySelectorChain(selectors: string[]): HTMLElement[] {
+    let parent: ParentNode = document
+    let matches: HTMLElement[]
+    for (const selector of selectors) {
+      matches = this.querySingleReplySelector(selector, parent)
+      if (matches.length === 0) {
+        return []
+      }
+      parent = matches[0]
+    }
+    return matches;
+  }
+
+  elementSelector(selector: ElementSelector): HTMLElement[] {
+    if (typeof selector === 'string') {
+      return this.querySingleReplySelector(selector)
+    }
+    return this.querySelectorChain(selector)
+  }
+}

package/lib/types.ts

@@ -1,6 +1,6 @@
 import { ContentScriptMessage } from "./messages";
 import { ConsentOMaticConfig } from "./cmps/consentomatic";
-import { AutoConsentCMPRule, RunContext } from "./rules";
+import { AutoConsentCMPRule, ElementSelector, HideMethod, RunContext, VisibilityCheck } from "./rules";
 
 export type MessageSender = (message: ContentScriptMessage) => Promise<void>;
 
@@ -20,6 +20,22 @@ export interface AutoCMP {
   test(): Promise<boolean>
 }
 
+export interface DomActionsProvider {
+  click(selector: ElementSelector, all: boolean): boolean;
+  elementExists(selector: ElementSelector): boolean;
+  elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean;
+  waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
+  waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
+  waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+  wait(ms: number): Promise<true>;
+  hide(selector: string, method: HideMethod): boolean;
+  prehide(selector: string): boolean;
+  undoPrehide(): boolean;
+  querySingleReplySelector(selector: string, parent?: any): HTMLElement[];
+  querySelectorChain(selectors: string[]): HTMLElement[];
+  elementSelector(selector: ElementSelector): HTMLElement[];
+}
+
 export type RuleBundle = {
   autoconsent: AutoConsentCMPRule[];
   consentomatic: { [name: string]: ConsentOMaticConfig };
@@ -36,6 +52,13 @@ export type Config = {
   detectRetries: number;
   isMainWorld: boolean;
   prehideTimeout: number;
+  logs: {
+    lifecycle: boolean;
+    rulesteps: boolean;
+    evals: boolean;
+    errors: boolean;
+    messages: boolean;
+  };
 }
 
 export type LifecycleState = 'loading' |

package/lib/utils.ts

@@ -1,4 +1,5 @@
 import { HideMethod } from "./rules";
+import { Config } from "./types";
 
 // get or create a style container for CSS overrides
 export function getStyleElement(styleOverrideElementId = "autoconsent-css-rules"): HTMLStyleElement {
@@ -59,4 +60,34 @@ export function isElementVisible(elem: HTMLElement): boolean {
     }
   }
   return false;
-}
+}
+
+export function normalizeConfig(providedConfig: any): Config {
+  const defaultConfig: Config = {
+    enabled: true,
+    autoAction: 'optOut', // if falsy, the extension will wait for an explicit user signal before opting in/out
+    disabledCmps: [],
+    enablePrehide: true,
+    enableCosmeticRules: true,
+    detectRetries: 20,
+    isMainWorld: false,
+    prehideTimeout: 2000,
+    logs: {
+      lifecycle: false,
+      rulesteps: false,
+      evals: false,
+      errors: true,
+      messages: false,
+    },
+  };
+  const updatedConfig: Config = structuredClone(defaultConfig);
+  // filter out any unknown entries
+  for (const key of Object.keys(defaultConfig)) {
+    if (typeof providedConfig[key] !== 'undefined') {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error - TS doesn't know that we've checked for undefined
+      updatedConfig[key] = providedConfig[key];
+    }
+  }
+  return updatedConfig;
+}