@duckduckgo/autoconsent 1.0.6 → 2.0.0

package/lib/cmps/base.ts

@@ -1,21 +1,9 @@
 /* eslint-disable no-restricted-syntax,no-await-in-loop,no-underscore-dangle */
 
-import { AutoCMP, TabActor } from "../types";
-import { AutoConsentCMPRule, AutoConsentRuleStep } from "../rules";
+import { AutoCMP } from "../types";
+import { AutoConsentCMPRule, AutoConsentRuleStep, RunContext } from "../rules";
 import { enableLogs } from "../config";
-
-export async function waitFor(predicate: () => Promise<boolean> | boolean, maxTimes: number, interval: number): Promise<boolean> {
-  let result = await predicate();
-  if (!result && maxTimes > 0) {
-    return new Promise((resolve) => {
-      setTimeout(async () => {
-        resolve(waitFor(predicate, maxTimes - 1, interval));
-      }, interval);
-    });
-  }
-  return Promise.resolve(result);
-}
-
+import { click, doEval, elementExists, elementVisible, hide, wait, waitForElement, waitForThenClick, waitForVisible } from "../rule-executors";
 
 export async function success(action: Promise<boolean>): Promise<boolean> {
   const result = await action;
@@ -25,124 +13,142 @@ export async function success(action: Promise<boolean>): Promise<boolean> {
   return result
 }
 
+export const defaultRunContext: RunContext = {
+  main: true,
+  frame: false,
+  url: "",
+}
 
-export default class AutoConsentBase implements AutoCMP {
+export default class AutoConsentCMPBase implements AutoCMP {
 
   name: string
-  hasSelfTest = true
+  runContext: RunContext = defaultRunContext;
 
   constructor(name: string) {
     this.name = name;
   }
 
-  detectCmp(tab: TabActor): Promise<boolean>  {
+  get hasSelfTest(): boolean {
     throw new Error('Not Implemented');
   }
 
-  async detectPopup(tab: TabActor) {
-    return false;
+  get isIntermediate(): boolean {
+    throw new Error('Not Implemented');
+  }
+
+  checkRunContext(): boolean {
+    const runCtx: RunContext = {
+      ...defaultRunContext,
+      ...this.runContext,
+    }
+
+    const isTop = window.top === window;
+
+    if (isTop && !runCtx.main) {
+      return false;
+    }
+
+    if (!isTop && !runCtx.frame) {
+      return false;
+    }
+
+    if (runCtx.url && !window.location.href.startsWith(runCtx.url)) {
+      return false;
+    }
+    return true;
   }
 
-  detectFrame(tab: TabActor, frame: { url: string }) {
+  detectCmp(): Promise<boolean>  {
+    throw new Error('Not Implemented');
+  }
+
+  async detectPopup() {
     return false;
   }
 
-  optOut(tab: TabActor): Promise<boolean> {
+  optOut(): Promise<boolean> {
     throw new Error('Not Implemented');
   }
 
-  optIn(tab: TabActor): Promise<boolean> {
+  optIn(): Promise<boolean> {
     throw new Error('Not Implemented');
   }
 
-  openCmp(tab: TabActor): Promise<boolean> {
+  openCmp(): Promise<boolean> {
     throw new Error('Not Implemented');
   }
 
-  async test(tab: TabActor): Promise<boolean> {
+  async test(): Promise<boolean> {
     // try IAB by default
     return Promise.resolve(true);
   }
 }
 
-async function evaluateRule(rule: AutoConsentRuleStep, tab: TabActor) {
-  if (rule.frame && !tab.frame) {
-    await waitFor(() => Promise.resolve(!!tab.frame), 10, 500);
-  }
-  const frameId = rule.frame && tab.frame ? tab.frame.id : undefined;
+async function evaluateRuleStep(rule: AutoConsentRuleStep) {
   const results = [];
   if (rule.exists) {
-    results.push(tab.elementExists(rule.exists, frameId));
+    results.push(elementExists(rule.exists));
   }
   if (rule.visible) {
-    results.push(tab.elementsAreVisible(rule.visible, rule.check, frameId));
+    results.push(elementVisible(rule.visible, rule.check));
   }
   if (rule.eval) {
-    results.push(new Promise(async (resolve) => {
-      // catch eval error silently
-      try {
-        resolve(await tab.eval(rule.eval!, frameId));
-      } catch (e) {
-        resolve(false);
-      }
-    }));
+    const res = doEval(rule.eval)
+    results.push(res);
   }
   if (rule.waitFor) {
-    results.push(tab.waitForElement(rule.waitFor, rule.timeout || 10000, frameId));
+    results.push(waitForElement(rule.waitFor, rule.timeout));
+  }
+  if (rule.waitForVisible) {
+    results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
   }
   if (rule.click) {
-    if (rule.all === true) {
-      results.push(tab.clickElements(rule.click, frameId));
-    } else {
-      results.push(tab.clickElement(rule.click, frameId));
-    }
+    results.push(click(rule.click, rule.all));
   }
   if (rule.waitForThenClick) {
-    results.push(tab.waitForElement(rule.waitForThenClick, rule.timeout || 10000, frameId)
-      .then(() => tab.clickElement(rule.waitForThenClick!, frameId)));
+    results.push(waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
   }
   if (rule.wait) {
-    results.push(tab.wait(rule.wait));
-  }
-  if (rule.goto) {
-    results.push(tab.goto(rule.goto));
+    results.push(wait(rule.wait));
   }
   if (rule.hide) {
-    results.push(tab.hideElements(rule.hide, frameId));
-  }
-  if (rule.undoHide) {
-    results.push(tab.undoHideElements(frameId));
-  }
-  if (rule.waitForFrame) {
-    results.push(waitFor(() => !!tab.frame, 40, 500))
+    results.push(hide(rule.hide, rule.method));
   }
+
   // boolean and of results
-  return (await Promise.all(results)).reduce((a, b) => a && b, true);
+  const all = await Promise.all(results);
+  return all.reduce((a, b) => a && b, true);
 }
 
-export class AutoConsent extends AutoConsentBase {
+export class AutoConsentCMP extends AutoConsentCMPBase {
 
   constructor(public config: AutoConsentCMPRule) {
     super(config.name);
+    this.runContext = config.runContext || defaultRunContext;
   }
 
-  get prehideSelectors(): string[] {
-    return this.config.prehideSelectors;
+  get hasSelfTest(): boolean {
+    return !!this.config.test;
+  }
+
+  get isIntermediate(): boolean {
+    return !!this.config.intermediate;
   }
 
-  get isHidingRule(): boolean {
-    return this.config.isHidingRule;
+  get prehideSelectors(): string[] {
+    return this.config.prehideSelectors;
   }
 
-  async _runRulesParallel(tab: TabActor, rules: AutoConsentRuleStep[]): Promise<boolean> {
-    const detections = await Promise.all(rules.map(rule => evaluateRule(rule, tab)));
+  async _runRulesParallel(rules: AutoConsentRuleStep[]): Promise<boolean> {
+    const results = rules.map(rule => evaluateRuleStep(rule));
+    const detections = await Promise.all(results);
     return detections.every(r => !!r);
   }
 
-  async _runRulesSequentially(tab: TabActor, rules: AutoConsentRuleStep[]): Promise<boolean> {
+  async _runRulesSequentially(rules: AutoConsentRuleStep[]): Promise<boolean> {
     for (const rule of rules) {
-      enableLogs && console.log('Running rule...', rule, tab.id);
-      const result = await evaluateRule(rule, tab);
+      enableLogs && console.log('Running rule...', rule);
+      const result = await evaluateRuleStep(rule);
       enableLogs && console.log('...rule result', result);
       if (!result && !rule.optional) {
         return false;
@@ -151,53 +157,47 @@ export class AutoConsent extends AutoConsentBase {
     return true;
   }
 
-  async detectCmp(tab: TabActor) {
+  async detectCmp() {
     if (this.config.detectCmp) {
-      return this._runRulesParallel(tab, this.config.detectCmp);
+      return this._runRulesParallel(this.config.detectCmp);
     }
     return false;
   }
 
-  async detectPopup(tab: TabActor) {
+  async detectPopup() {
     if (this.config.detectPopup) {
-      return this._runRulesParallel(tab, this.config.detectPopup);
-    }
-    return false;
-  }
-
-  detectFrame(tab: TabActor, frame: { url: string }) {
-    if (this.config.frame) {
-      return frame.url.startsWith(this.config.frame);
+      return this._runRulesParallel(this.config.detectPopup);
     }
     return false;
   }
 
-  async optOut(tab: TabActor) {
+  async optOut() {
     if (this.config.optOut) {
       enableLogs && console.log('Initiated optOut()', this.config.optOut);
-      return this._runRulesSequentially(tab, this.config.optOut);
+      return this._runRulesSequentially(this.config.optOut);
     }
     return false;
   }
 
-  async optIn(tab: TabActor) {
+  async optIn() {
     if (this.config.optIn) {
-      return this._runRulesSequentially(tab, this.config.optIn);
+      enableLogs && console.log('Initiated optIn()', this.config.optIn);
+      return this._runRulesSequentially(this.config.optIn);
     }
     return false;
   }
 
-  async openCmp(tab: TabActor) {
+  async openCmp() {
     if (this.config.openCmp) {
-      return this._runRulesSequentially(tab, this.config.openCmp);
+      return this._runRulesSequentially(this.config.openCmp);
     }
     return false;
   }
 
-  async test(tab: TabActor) {
-    if (this.config.test) {
-      return this._runRulesSequentially(tab, this.config.test);
+  async test() {
+    if (this.hasSelfTest) {
+      return this._runRulesSequentially(this.config.test);
     }
-    return super.test(tab);
+    return super.test();
   }
 }

package/lib/cmps/consentmanager.ts

@@ -1,39 +1,51 @@
-import AutoConsentBase from "./base";
-import { TabActor } from "../types";
+import { click, elementExists, elementVisible, 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 AutoConsentBase {
+export default class ConsentManager extends AutoConsentCMPBase {
 
   prehideSelectors = ["#cmpbox,#cmpbox2"]
 
+  get hasSelfTest(): boolean {
+    return false;
+  }
+
+  get isIntermediate(): boolean {
+    return false;
+  }
+
   constructor() {
     super("consentmanager.net");
   }
 
-  detectCmp(tab: TabActor) {
-    return tab.elementExists("#cmpbox");
+  async detectCmp() {
+    return elementExists("#cmpbox");
   }
 
-  detectPopup(tab: TabActor) {
-    return tab.elementsAreVisible("#cmpbox .cmpmore", "any");
+  async detectPopup() {
+    return elementVisible("#cmpbox .cmpmore", 'any');
   }
 
-  async optOut(tab: TabActor) {
-    if (await tab.elementExists(".cmpboxbtnno")) {
-      return tab.clickElement(".cmpboxbtnno");
+  async optOut() {
+    if (click(".cmpboxbtnno")) {
+      return true;
     }
-    if (await tab.elementExists(".cmpwelcomeprpsbtn")) {
-      await tab.clickElements(".cmpwelcomeprpsbtn > a[aria-checked=true]");
-      return await tab.clickElement(".cmpboxbtnsave");
+
+    if (elementExists(".cmpwelcomeprpsbtn")) {
+      click(".cmpwelcomeprpsbtn > a[aria-checked=true]", true);
+      click(".cmpboxbtnsave");
+      return true;
     }
-    await tab.clickElement(".cmpboxbtncustom");
-    await tab.waitForElement(".cmptblbox", 2000);
-    await tab.clickElements(".cmptdchoice > a[aria-checked=true]");
-    return tab.clickElement(".cmpboxbtnyescustomchoices");
+
+    click(".cmpboxbtncustom");
+    await waitForElement(".cmptblbox", 2000);
+    click(".cmptdchoice > a[aria-checked=true]", true);
+    click(".cmpboxbtnyescustomchoices");
+    return true;
   }
 
-  async optIn(tab: TabActor) {
-    return tab.clickElement(".cmpboxbtnyes");
+  async optIn() {
+    return click(".cmpboxbtnyes");
   }
 }

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");
   }
 }