@duckduckgo/autoconsent 8.1.0 → 9.0.0

package/lib/cmps/airbnb.ts

@@ -1,4 +1,3 @@
-import { elementExists, elementVisible, waitForThenClick } from "../rule-executors";
 import { RunContext } from "../rules";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
@@ -28,25 +27,25 @@ export default class Airbnb extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists('div[data-testid=main-cookies-banner-container]');
+    return this.elementExists('div[data-testid=main-cookies-banner-container]');
   }
 
   async detectPopup() {
-    return elementVisible('div[data-testid=main-cookies-banner-container', 'any');
+    return this.elementVisible('div[data-testid=main-cookies-banner-container', 'any');
   }
 
   async optOut() {
-    await waitForThenClick('div[data-testid=main-cookies-banner-container] button._snbhip0');
+    await this.waitForThenClick('div[data-testid=main-cookies-banner-container] button._snbhip0');
     let check;
     // eslint-disable-next-line no-cond-assign
     while (check = document.querySelector('[data-testid=modal-container] button[aria-checked=true]:not([disabled])') as HTMLElement) { // each click may toggle multiple checkboxes
       check.click();
     }
-    return waitForThenClick('button[data-testid=save-btn]');
+    return this.waitForThenClick('button[data-testid=save-btn]');
   }
 
   async optIn() {
-    return waitForThenClick('div[data-testid=main-cookies-banner-container] button._148dgdpk');
+    return this.waitForThenClick('div[data-testid=main-cookies-banner-container] button._148dgdpk');
   }
 
   async test() {

package/lib/cmps/base.ts

@@ -1,9 +1,7 @@
 /* eslint-disable no-restricted-syntax,no-await-in-loop,no-underscore-dangle */
 
-import { AutoCMP } from "../types";
-import { AutoConsentCMPRule, AutoConsentRuleStep, RunContext } from "../rules";
-import { enableLogs } from "../config";
-import { click, elementExists, elementVisible, hide, wait, waitForElement, waitForThenClick, waitForVisible } from "../rule-executors";
+import { AutoCMP, DomActionsProvider } from "../types";
+import { AutoConsentCMPRule, AutoConsentRuleStep, ElementSelector, HideMethod, RunContext, VisibilityCheck } from "../rules";
 import { requestEval } from "../eval-handler";
 import AutoConsent from "../web";
 import { getFunctionBody, snippets } from "../eval-snippets";
@@ -22,7 +20,7 @@ export const defaultRunContext: RunContext = {
   urlPattern: "",
 }
 
-export default class AutoConsentCMPBase implements AutoCMP {
+export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
   name: string
   runContext: RunContext = defaultRunContext;
   autoconsent: AutoConsent;
@@ -49,23 +47,24 @@ export default class AutoConsentCMPBase implements AutoCMP {
       console.warn('Snippet not found', snippetId);
       return Promise.resolve(false);
     }
+    const logsConfig = this.autoconsent.config.logs;
 
     if (this.autoconsent.config.isMainWorld) {
-      enableLogs && console.log('inline eval:', snippetId, snippet);
+      logsConfig.evals && console.log('inline eval:', snippetId, snippet);
       let result = false;
       try {
         result = !!snippet.call(globalThis);
       } catch (e) {
         // ignore exceptions
-        enableLogs && console.error('error evaluating rule', snippetId, e);
+        logsConfig.evals && console.error('error evaluating rule', snippetId, e);
       }
       return Promise.resolve(result);
     }
 
     const snippetSrc = getFunctionBody(snippet);
-    enableLogs && console.log('async eval:', snippetId, snippetSrc);
+    logsConfig.evals && console.log('async eval:', snippetId, snippetSrc);
     return requestEval(snippetSrc, snippetId).catch((e) => {
-      enableLogs && console.error('error evaluating rule', snippetId, e);
+      logsConfig.evals && console.error('error evaluating rule', snippetId, e);
       return false;
     });
   }
@@ -116,105 +115,161 @@ export default class AutoConsentCMPBase implements AutoCMP {
     // try IAB by default
     return Promise.resolve(true);
   }
+
+  // Implementing DomActionsProvider below:
+  click(selector: ElementSelector, all = false) {
+    return this.autoconsent.domActions.click(selector, all);
+  }
+
+  elementExists(selector: ElementSelector) {
+    return this.autoconsent.domActions.elementExists(selector);
+  }
+
+  elementVisible(selector: ElementSelector, check: VisibilityCheck) {
+    return this.autoconsent.domActions.elementVisible(selector, check);
+  }
+
+  waitForElement(selector: ElementSelector, timeout?: number) {
+    return this.autoconsent.domActions.waitForElement(selector, timeout);
+  }
+
+  waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck) {
+    return this.autoconsent.domActions.waitForVisible(selector, timeout, check);
+  }
+
+  waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean) {
+    return this.autoconsent.domActions.waitForThenClick(selector, timeout, all);
+  }
+
+  wait(ms: number) {
+    return this.autoconsent.domActions.wait(ms);
+  }
+
+  hide(selector: string, method: HideMethod) {
+    return this.autoconsent.domActions.hide(selector, method);
+  }
+
+  prehide(selector: string) {
+    return this.autoconsent.domActions.prehide(selector);
+  }
+
+  undoPrehide() {
+    return this.autoconsent.domActions.undoPrehide();
+  }
+
+  querySingleReplySelector(selector: string, parent?: any) {
+    return this.autoconsent.domActions.querySingleReplySelector(selector, parent);
+  }
+
+  querySelectorChain(selectors: string[]) {
+    return this.autoconsent.domActions.querySelectorChain(selectors);
+  }
+
+  elementSelector(selector: ElementSelector) {
+    return this.autoconsent.domActions.elementSelector(selector);
+  }
 }
 
 export class AutoConsentCMP extends AutoConsentCMPBase {
 
-  constructor(public config: AutoConsentCMPRule, autoconsentInstance: AutoConsent) {
+  constructor(public rule: AutoConsentCMPRule, autoconsentInstance: AutoConsent) {
     super(autoconsentInstance);
-    this.name = config.name;
-    this.runContext = config.runContext || defaultRunContext;
+    this.name = rule.name;
+    this.runContext = rule.runContext || defaultRunContext;
   }
 
   get hasSelfTest(): boolean {
-    return !!this.config.test;
+    return !!this.rule.test;
   }
 
   get isIntermediate(): boolean {
-    return !!this.config.intermediate;
+    return !!this.rule.intermediate;
   }
 
   get isCosmetic(): boolean {
-    return !!this.config.cosmetic;
+    return !!this.rule.cosmetic;
   }
 
   get prehideSelectors(): string[] {
-    return this.config.prehideSelectors;
+    return this.rule.prehideSelectors;
   }
 
   async detectCmp() {
-    if (this.config.detectCmp) {
-      return this._runRulesParallel(this.config.detectCmp);
+    if (this.rule.detectCmp) {
+      return this._runRulesParallel(this.rule.detectCmp);
     }
     return false;
   }
 
   async detectPopup() {
-    if (this.config.detectPopup) {
-      return this._runRulesSequentially(this.config.detectPopup);
+    if (this.rule.detectPopup) {
+      return this._runRulesSequentially(this.rule.detectPopup);
     }
     return false;
   }
 
   async optOut() {
-    if (this.config.optOut) {
-      enableLogs && console.log('Initiated optOut()', this.config.optOut);
-      return this._runRulesSequentially(this.config.optOut);
+    const logsConfig = this.autoconsent.config.logs;
+    if (this.rule.optOut) {
+      logsConfig.lifecycle && console.log('Initiated optOut()', this.rule.optOut);
+      return this._runRulesSequentially(this.rule.optOut);
     }
     return false;
   }
 
   async optIn() {
-    if (this.config.optIn) {
-      enableLogs && console.log('Initiated optIn()', this.config.optIn);
-      return this._runRulesSequentially(this.config.optIn);
+    const logsConfig = this.autoconsent.config.logs;
+    if (this.rule.optIn) {
+      logsConfig.lifecycle && console.log('Initiated optIn()', this.rule.optIn);
+      return this._runRulesSequentially(this.rule.optIn);
     }
     return false;
   }
 
   async openCmp() {
-    if (this.config.openCmp) {
-      return this._runRulesSequentially(this.config.openCmp);
+    if (this.rule.openCmp) {
+      return this._runRulesSequentially(this.rule.openCmp);
     }
     return false;
   }
 
   async test() {
     if (this.hasSelfTest) {
-      return this._runRulesSequentially(this.config.test);
+      return this._runRulesSequentially(this.rule.test);
     }
     return super.test();
   }
 
   async evaluateRuleStep(rule: AutoConsentRuleStep) {
     const results = [];
+    const logsConfig = this.autoconsent.config.logs;
     if (rule.exists) {
-      results.push(elementExists(rule.exists));
+      results.push(this.elementExists(rule.exists));
     }
     if (rule.visible) {
-      results.push(elementVisible(rule.visible, rule.check));
+      results.push(this.elementVisible(rule.visible, rule.check));
     }
     if (rule.eval) {
       const res = this.mainWorldEval(rule.eval)
       results.push(res);
     }
     if (rule.waitFor) {
-      results.push(waitForElement(rule.waitFor, rule.timeout));
+      results.push(this.waitForElement(rule.waitFor, rule.timeout));
     }
     if (rule.waitForVisible) {
-      results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
+      results.push(this.waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
     }
     if (rule.click) {
-      results.push(click(rule.click, rule.all));
+      results.push(this.click(rule.click, rule.all));
     }
     if (rule.waitForThenClick) {
-      results.push(waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
+      results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
     }
     if (rule.wait) {
-      results.push(wait(rule.wait));
+      results.push(this.wait(rule.wait));
     }
     if (rule.hide) {
-      results.push(hide(rule.hide, rule.method));
+      results.push(this.hide(rule.hide, rule.method));
     }
     if (rule.if) {
       if (!rule.if.exists && !rule.if.visible) {
@@ -222,7 +277,7 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
         return false;
       }
       const condition = await this.evaluateRuleStep(rule.if);
-      enableLogs && console.log('Condition is', condition);
+      logsConfig.rulesteps && console.log('Condition is', condition);
       if (condition) {
         results.push(this._runRulesSequentially(rule.then));
       } else if (rule.else) {
@@ -239,7 +294,7 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
     }
   
     if (results.length === 0) {
-      enableLogs && console.warn('Unrecognized rule', rule);
+      logsConfig.errors && console.warn('Unrecognized rule', rule);
       return false;
     }
   
@@ -255,10 +310,11 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
   }
   
   async _runRulesSequentially(rules: AutoConsentRuleStep[]): Promise<boolean> {
+    const logsConfig = this.autoconsent.config.logs;
     for (const rule of rules) {
-      enableLogs && console.log('Running rule...', rule);
+      logsConfig.rulesteps && console.log('Running rule...', rule);
       const result = await this.evaluateRuleStep(rule);
-      enableLogs && console.log('...rule result', result);
+      logsConfig.rulesteps && console.log('...rule result', result);
       if (!result && !rule.optional) {
         return false;
       }

package/lib/cmps/consentmanager.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, wait, waitForElement } from "../rule-executors";
 import AutoConsentCMPBase from "./base";
 
 // Note: JS API is also available:
@@ -24,7 +23,7 @@ export default class ConsentManager extends AutoConsentCMPBase {
   async detectCmp() {
     this.apiAvailable = await this.mainWorldEval('EVAL_CONSENTMANAGER_1');
     if (!this.apiAvailable) {
-      return elementExists("#cmpbox");
+      return this.elementExists("#cmpbox");
     } else {
       return true;
     }
@@ -34,32 +33,32 @@ export default class ConsentManager extends AutoConsentCMPBase {
     if (this.apiAvailable) {
       // wait before making this check because early in the page lifecycle this may incorrectly return
       // true, causing an opt-out when it is not needed.
-      await wait(500);
+      await this.wait(500);
       return await this.mainWorldEval('EVAL_CONSENTMANAGER_2');
     }
-    return elementVisible("#cmpbox .cmpmore", 'any');
+    return this.elementVisible("#cmpbox .cmpmore", 'any');
   }
 
   async optOut() {
-    await wait(500);
+    await this.wait(500);
     if (this.apiAvailable) {
       return await this.mainWorldEval('EVAL_CONSENTMANAGER_3');
     }
 
-    if (click(".cmpboxbtnno")) {
+    if (this.click(".cmpboxbtnno")) {
       return true;
     }
 
-    if (elementExists(".cmpwelcomeprpsbtn")) {
-      click(".cmpwelcomeprpsbtn > a[aria-checked=true]", true);
-      click(".cmpboxbtnsave");
+    if (this.elementExists(".cmpwelcomeprpsbtn")) {
+      this.click(".cmpwelcomeprpsbtn > a[aria-checked=true]", true);
+      this.click(".cmpboxbtnsave");
       return true;
     }
 
-    click(".cmpboxbtncustom");
-    await waitForElement(".cmptblbox", 2000);
-    click(".cmptdchoice > a[aria-checked=true]", true);
-    click(".cmpboxbtnyescustomchoices");
+    this.click(".cmpboxbtncustom");
+    await this.waitForElement(".cmptblbox", 2000);
+    this.click(".cmptdchoice > a[aria-checked=true]", true);
+    this.click(".cmpboxbtnyescustomchoices");
     return true;
   }
 
@@ -67,7 +66,7 @@ export default class ConsentManager extends AutoConsentCMPBase {
     if (this.apiAvailable) {
       return await this.mainWorldEval('EVAL_CONSENTMANAGER_4');
     }
-    return click(".cmpboxbtnyes");
+    return this.click(".cmpboxbtnyes");
   }
 
   async test() {

package/lib/cmps/conversant.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, waitForElement, waitForThenClick } from "../rule-executors";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
 
@@ -20,24 +19,24 @@ export default class Conversant extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists(".cmp-root .cmp-receptacle");
+    return this.elementExists(".cmp-root .cmp-receptacle");
   }
 
   async detectPopup() {
-    return elementVisible(".cmp-root .cmp-receptacle", 'any');
+    return this.elementVisible(".cmp-root .cmp-receptacle", 'any');
   }
 
   async optOut() {
-    if (!(await waitForThenClick(".cmp-main-button:not(.cmp-main-button--primary)"))) {
+    if (!(await this.waitForThenClick(".cmp-main-button:not(.cmp-main-button--primary)"))) {
       return false;
     }
 
-    if (!(await waitForElement(".cmp-view-tab-tabs"))) {
+    if (!(await this.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");
+    await this.waitForThenClick(".cmp-view-tab-tabs > :first-child");
+    await this.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();
@@ -47,12 +46,12 @@ export default class Conversant extends AutoConsentCMPBase {
       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)");
+    await this.click(".cmp-main-button:not(.cmp-main-button--primary)");
     return true;
   }
 
   async optIn() {
-    return waitForThenClick(".cmp-main-button.cmp-main-button--primary");
+    return this.waitForThenClick(".cmp-main-button.cmp-main-button--primary");
   }
 
   async test() {

package/lib/cmps/cookiebot.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, wait } from '../rule-executors';
 import AutoConsentCMPBase from './base';
 
 export default class Cookiebot extends AutoConsentCMPBase {
@@ -26,26 +25,26 @@ export default class Cookiebot extends AutoConsentCMPBase {
   }
 
   async optOut() {
-    await wait(500);
+    await this.wait(500);
     let res = await this.mainWorldEval('EVAL_COOKIEBOT_3'); // withdraw
-    await wait(500); // prevent race conditions
+    await this.wait(500); // prevent race conditions
     res = res && await this.mainWorldEval('EVAL_COOKIEBOT_4'); // hide
     return res;
   }
 
   async optIn() {
-    if (elementExists('#dtcookie-container')) {
-      return click('.h-dtcookie-accept');
+    if (this.elementExists('#dtcookie-container')) {
+      return this.click('.h-dtcookie-accept');
     }
 
-    click('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled', true);
-    click('#CybotCookiebotDialogBodyLevelButtonAccept');
-    click('#CybotCookiebotDialogBodyButtonAccept');
+    this.click('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled', true);
+    this.click('#CybotCookiebotDialogBodyLevelButtonAccept');
+    this.click('#CybotCookiebotDialogBodyButtonAccept');
     return true;
   }
 
   async test() {
-    await wait(500);
+    await this.wait(500);
     return await this.mainWorldEval('EVAL_COOKIEBOT_5');
   }
 }

package/lib/cmps/evidon.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
 import { getStyleElement, hideElements } from "../utils";
 import AutoConsentCMPBase from "./base";
 
@@ -18,28 +17,28 @@ export default class Evidon extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists("#_evidon_banner");
+    return this.elementExists("#_evidon_banner");
   }
 
   async detectPopup() {
-    return elementVisible("#_evidon_banner", 'any');
+    return this.elementVisible("#_evidon_banner", 'any');
   }
 
   async optOut() {
-    if (click("#_evidon-decline-button")) {
+    if (this.click("#_evidon-decline-button")) {
       return true;
     }
 
     hideElements(getStyleElement(), "#evidon-prefdiag-overlay,#evidon-prefdiag-background");
-    click("#_evidon-option-button");
+    this.click("#_evidon-option-button");
 
-    await waitForElement("#evidon-prefdiag-overlay", 5000);
+    await this.waitForElement("#evidon-prefdiag-overlay", 5000);
 
-    click("#evidon-prefdiag-decline");
+    this.click("#evidon-prefdiag-decline");
     return true;
   }
 
   async optIn() {
-    return click("#_evidon-accept-button");
+    return this.click("#_evidon-accept-button");
   }
 }

package/lib/cmps/klaro.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, waitForElement } from "../rule-executors";
 import AutoConsentCMPBase from "./base";
 
 export default class Klaro extends AutoConsentCMPBase {
@@ -19,45 +18,45 @@ export default class Klaro extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    if (elementExists('.klaro > .cookie-modal')) {
+    if (this.elementExists('.klaro > .cookie-modal')) {
       this.settingsOpen = true;
       return true;
     }
-    return elementExists(".klaro > .cookie-notice");
+    return this.elementExists(".klaro > .cookie-notice");
   }
 
   async detectPopup() {
-    return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", 'any');
+    return this.elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", 'any');
   }
 
   async optOut() {
-    if (click('.klaro .cn-decline')) {
+    if (this.click('.klaro .cn-decline')) {
       return true;
     }
 
     if (!this.settingsOpen) {
-      click('.klaro .cn-learn-more');
-      await waitForElement('.klaro > .cookie-modal', 2000);
+      this.click('.klaro .cn-learn-more,.klaro .cm-button-manage');
+      await this.waitForElement('.klaro > .cookie-modal', 2000);
       this.settingsOpen = true;
     }
 
-    if (click('.klaro .cn-decline')) {
+    if (this.click('.klaro .cn-decline')) {
       return true;
     }
 
-    click('.cm-purpose:not(.cm-toggle-all) > input:not(.half-checked)', true);
-    return click('.cm-btn-accept');
+    this.click('.cm-purpose:not(.cm-toggle-all) > input:not(.half-checked,.required,.only-required),.cm-purpose:not(.cm-toggle-all) > div > input:not(.half-checked,.required,.only-required)', true);
+    return this.click('.cm-btn-accept,.cm-button');
   }
 
   async optIn() {
-    if (click('.klaro .cm-btn-accept-all')) {
+    if (this.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');
+      this.click('.cm-purpose:not(.cm-toggle-all) > input.half-checked', true);
+      return this.click('.cm-btn-accept');
     }
-    return click('.klaro .cookie-notice .cm-btn-success');
+    return this.click('.klaro .cookie-notice .cm-btn-success');
   }
 
   async test() {

package/lib/cmps/onetrust.ts

@@ -1,4 +1,3 @@
-import { click, elementExists, elementVisible, wait, waitForElement, waitForVisible } from "../rule-executors";
 import { RunContext } from "../rules";
 import { waitFor } from "../utils";
 import AutoConsentCMPBase from "./base";
@@ -24,39 +23,39 @@ export default class Onetrust extends AutoConsentCMPBase {
   }
 
   async detectCmp() {
-    return elementExists("#onetrust-banner-sdk");
+    return this.elementExists("#onetrust-banner-sdk");
   }
 
   async detectPopup() {
-    return elementVisible("#onetrust-banner-sdk", 'all');
+    return this.elementVisible("#onetrust-banner-sdk", 'all');
   }
 
   async optOut() {
-    if (elementVisible("#onetrust-reject-all-handler,.js-reject-cookies", 'any')) { // 'reject all' shortcut
-      return click("#onetrust-reject-all-handler,.js-reject-cookies");
+    if (this.elementVisible("#onetrust-reject-all-handler,.js-reject-cookies", 'any')) { // 'reject all' shortcut
+      return this.click("#onetrust-reject-all-handler,.js-reject-cookies");
     }
 
-    if (elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
-      click("#onetrust-pc-btn-handler");
+    if (this.elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
+      this.click("#onetrust-pc-btn-handler");
     } else { // otherwise look for a generic "show settings" button
-      click(".ot-sdk-show-settings,button.js-cookie-settings");
+      this.click(".ot-sdk-show-settings,button.js-cookie-settings");
     }
 
-    await waitForElement('#onetrust-consent-sdk', 2000);
-    await wait(1000); // ideally we want to wait for popup visivility, but it's tricky on e.g. stackoverflow.com
-    click("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked", true); // optional step
+    await this.waitForElement('#onetrust-consent-sdk', 2000);
+    await this.wait(1000); // ideally we want to wait for popup visivility, but it's tricky on e.g. stackoverflow.com
+    this.click("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked", true); // optional step
 
-    await wait(1000); // ideally we want to wait for popup visivility, but it's tricky on e.g. stackoverflow.com
-    await waitForElement(".save-preference-btn-handler,.js-consent-save", 2000);
-    click(".save-preference-btn-handler,.js-consent-save");
+    await this.wait(1000); // ideally we want to wait for popup visivility, but it's tricky on e.g. stackoverflow.com
+    await this.waitForElement(".save-preference-btn-handler,.js-consent-save", 2000);
+    this.click(".save-preference-btn-handler,.js-consent-save");
 
     // popup doesn't disappear immediately
-    await waitForVisible("#onetrust-banner-sdk", 5000, 'none');
+    await this.waitForVisible("#onetrust-banner-sdk", 5000, 'none');
     return true;
   }
 
   async optIn() {
-    return click("#onetrust-accept-btn-handler,.js-accept-cookies");
+    return this.click("#onetrust-accept-btn-handler,.js-accept-cookies");
   }
 
   async test() {