@duckduckgo/autoconsent 1.0.8 → 2.0.0

package/lib/consentomatic/index.ts

@@ -1,86 +1,249 @@
-import { AutoCMP, TabActor } from "../types";
-
-export type DetectorConfig = {
-  presentMatcher: {};
-  showingMatcher: {};
-};
-export type MethodConfig = {
-  action?: any;
-  name: string;
-};
-
-export type ConsentOMaticConfig = {
-  detectors: DetectorConfig[];
-  methods: MethodConfig[];
-};
-
-export class ConsentOMaticCMP implements AutoCMP {
-  methods = new Map<string, {}>();
-  hasSelfTest: boolean;
-
-  constructor(public name: string, public config: ConsentOMaticConfig) {
-    config.methods.forEach(methodConfig => {
-      if (methodConfig.action) {
-        this.methods.set(methodConfig.name, methodConfig.action);
-      }
-    });
-    this.hasSelfTest = this.methods.has("TEST_CONSENT");
+import Tools from "./tools";
+
+export function matches(config: any) {
+  const result = Tools.find(config);
+  if (config.type === "css") {
+    return !!result.target;
+  } else if (config.type === "checkbox") {
+    return !!result.target && result.target.checked;
   }
+}
 
-  async detectCmp(tab: TabActor): Promise<boolean> {
-    return (
-      await Promise.all(
-        this.config.detectors.map(detectorConfig =>
-          tab.matches(detectorConfig.presentMatcher)
-        )
-      )
-    ).some(matched => matched);
+export async function executeAction(config: any, param?: any): Promise<boolean | void> {
+  switch (config.type) {
+    case "click":
+      return clickAction(config);
+    case "list":
+      return listAction(config, param);
+    case "consent":
+      return consentAction(config, param);
+    case "ifcss":
+      return ifCssAction(config, param);
+    case "waitcss":
+      return waitCssAction(config);
+    case "foreach":
+      return forEachAction(config, param);
+    case "hide":
+      return hideAction(config);
+    case "slide":
+      return slideAction(config);
+    case "close":
+      return closeAction(config);
+    case "wait":
+      return waitAction(config);
+    case "eval":
+      return evalAction(config);
+    default:
+      throw "Unknown action type: " + config.type;
   }
+}
+
+const STEP_TIMEOUT = 0;
 
-  async detectPopup(tab: TabActor): Promise<boolean> {
-    return (
-      await Promise.all(
-        this.config.detectors.map(detectorConfig =>
-          tab.matches(detectorConfig.showingMatcher)
-        )
-      )
-    ).some(matched => matched);
+function waitTimeout(timeout: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve();
+    }, timeout);
+  });
+}
+
+async function clickAction(config: any) {
+  const result = Tools.find(config);
+  if (result.target != null) {
+    result.target.click();
   }
+  return waitTimeout(STEP_TIMEOUT);
+}
 
-  async executeAction(tab: TabActor, method: string, param?: any) {
-    if (this.methods.has(method)) {
-      return tab.executeAction(this.methods.get(method), param);
-    }
-    return true;
+async function listAction(config: any, param: any) {
+  for (let action of config.actions) {
+    await executeAction(action, param);
   }
+}
 
-  async optOut(tab: TabActor): Promise<boolean> {
-    await this.executeAction(tab, "HIDE_CMP");
-    await this.executeAction(tab, "OPEN_OPTIONS");
-    await this.executeAction(tab, "HIDE_CMP");
-    await this.executeAction(tab, "DO_CONSENT", []);
-    await this.executeAction(tab, "SAVE_CONSENT");
-    return true;
+async function consentAction(config: any, consentTypes: any) {
+  for (const consentConfig of config.consents) {
+    const shouldEnable = consentTypes.indexOf(consentConfig.type) !== -1;
+    if (consentConfig.matcher && consentConfig.toggleAction) {
+      const isEnabled = matches(consentConfig.matcher);
+      if (isEnabled !== shouldEnable) {
+        await executeAction(consentConfig.toggleAction);
+      }
+    } else {
+      if (shouldEnable) {
+        await executeAction(consentConfig.trueAction);
+      } else {
+        await executeAction(consentConfig.falseAction);
+      }
+    }
   }
+}
 
-  async optIn(tab: TabActor): Promise<boolean> {
-    await this.executeAction(tab, "HIDE_CMP");
-    await this.executeAction(tab, "OPEN_OPTIONS");
-    await this.executeAction(tab, "HIDE_CMP");
-    await this.executeAction(tab, "DO_CONSENT", ['D', 'A', 'B', 'E', 'F', 'X']);
-    await this.executeAction(tab, "SAVE_CONSENT");
-    return true;
+async function ifCssAction(config: any, param: any) {
+  const result = Tools.find(config);
+  if (!result.target) {
+    if (config.trueAction) {
+      await executeAction(config.trueAction, param);
+    }
+  } else {
+    if (config.falseAction) {
+      await executeAction(config.falseAction, param);
+    }
   }
-  async openCmp(tab: TabActor): Promise<boolean> {
-    await this.executeAction(tab, "HIDE_CMP");
-    await this.executeAction(tab, "OPEN_OPTIONS");
-    return true;
+}
+
+async function waitCssAction(config: any) {
+  await new Promise<void>(resolve => {
+    let numRetries = config.retries || 10;
+    const waitTime = config.waitTime || 250;
+    const checkCss = () => {
+      const result = Tools.find(config);
+      if (
+        (config.negated && result.target) ||
+        (!config.negated && !result.target)
+      ) {
+        if (numRetries > 0) {
+          numRetries -= 1;
+          setTimeout(checkCss, waitTime);
+        } else {
+          resolve();
+        }
+      } else {
+        resolve();
+      }
+    };
+    checkCss();
+  });
+}
+
+async function forEachAction(config: any, param: any) {
+  const results = Tools.find(config, true);
+  const oldBase = Tools.base;
+  for (const result of results) {
+    if (result.target) {
+      Tools.setBase(result.target);
+      await executeAction(config.action, param);
+    }
   }
+  Tools.setBase(oldBase);
+}
 
-  test(tab: TabActor): Promise<boolean> {
-    return this.executeAction(tab, "TEST_CONSENT");
+async function hideAction(config: any) {
+  const result = Tools.find(config);
+  if (result.target) {
+    result.target.classList.add("Autoconsent-Hidden");
+    // result.target.setAttribute("style", "display: none;");
   }
-  detectFrame(tab: TabActor, frame: { url: string }): boolean {
-    return false;
+}
+
+async function slideAction(config: any) {
+  const result = Tools.find(config);
+  const dragResult = Tools.find(config.dragTarget);
+  if (result.target) {
+    let targetBounds = result.target.getBoundingClientRect();
+    let dragTargetBounds = dragResult.target.getBoundingClientRect();
+
+    let yDiff = dragTargetBounds.top - targetBounds.top;
+    let xDiff = dragTargetBounds.left - targetBounds.left;
+
+    if (this.config.axis.toLowerCase() === "y") {
+      xDiff = 0;
+    }
+    if (this.config.axis.toLowerCase() === "x") {
+      yDiff = 0;
+    }
+
+    let screenX = window.screenX + targetBounds.left + targetBounds.width / 2.0;
+    let screenY = window.screenY + targetBounds.top + targetBounds.height / 2.0;
+    let clientX = targetBounds.left + targetBounds.width / 2.0;
+    let clientY = targetBounds.top + targetBounds.height / 2.0;
+
+    let mouseDown = document.createEvent("MouseEvents");
+    mouseDown.initMouseEvent(
+      "mousedown",
+      true,
+      true,
+      window,
+      0,
+      screenX,
+      screenY,
+      clientX,
+      clientY,
+      false,
+      false,
+      false,
+      false,
+      0,
+      result.target
+    );
+    let mouseMove = document.createEvent("MouseEvents");
+    mouseMove.initMouseEvent(
+      "mousemove",
+      true,
+      true,
+      window,
+      0,
+      screenX + xDiff,
+      screenY + yDiff,
+      clientX + xDiff,
+      clientY + yDiff,
+      false,
+      false,
+      false,
+      false,
+      0,
+      result.target
+    );
+    let mouseUp = document.createEvent("MouseEvents");
+    mouseUp.initMouseEvent(
+      "mouseup",
+      true,
+      true,
+      window,
+      0,
+      screenX + xDiff,
+      screenY + yDiff,
+      clientX + xDiff,
+      clientY + yDiff,
+      false,
+      false,
+      false,
+      false,
+      0,
+      result.target
+    );
+    result.target.dispatchEvent(mouseDown);
+    await this.waitTimeout(10);
+    result.target.dispatchEvent(mouseMove);
+    await this.waitTimeout(10);
+    result.target.dispatchEvent(mouseUp);
   }
 }
+
+async function waitAction(config: any) {
+  await waitTimeout(config.waitTime);
+}
+
+async function closeAction(config: any) {
+  window.close();
+}
+
+async function evalAction(config: any): Promise<boolean> {
+  console.log("eval!", config.code);
+  return new Promise(resolve => {
+    try {
+      if (config.async) {
+        window.eval(config.code);
+        setTimeout(() => {
+          resolve(window.eval("window.__consentCheckResult"));
+        }, config.timeout || 250);
+      } else {
+        resolve(window.eval(config.code));
+      }
+    } catch (e) {
+      console.warn("eval error", e, config.code);
+      resolve(false);
+    }
+  });
+}

package/lib/eval-handler.ts

@@ -0,0 +1,58 @@
+import { ContentScriptMessage } from "./messages";
+
+class Deferred<T> {
+  id: string;
+  promise: Promise<T>;
+  resolve: (value?: T) => void;
+  reject: (reason?: any) => void;
+  timer: number;
+
+  constructor(id: string, timeout = 1000) {
+    this.id = id;
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+    this.timer = window.setTimeout(() => {
+      this.reject(new Error("timeout"));
+    }, timeout);
+  }
+}
+
+type EvalState = {
+  pending: Map<string, Deferred<boolean>>;
+  sendContentMessage: (message: ContentScriptMessage) => void;
+}
+
+export const evalState: EvalState = {
+  pending: new Map(),
+  sendContentMessage: null,
+}
+
+export function requestEval(code: string): Promise<boolean> {
+  let id;
+  if (crypto && typeof crypto.randomUUID !== 'undefined') {
+    id = crypto.randomUUID();
+  } else {
+    id = Math.random().toString();
+  }
+  evalState.sendContentMessage({
+    type: 'eval',
+    id,
+    code,
+  });
+  const deferred = new Deferred<boolean>(id);
+  evalState.pending.set(deferred.id, deferred);
+  return deferred.promise;
+}
+
+export function resolveEval(id: string, value: boolean) {
+  const deferred = evalState.pending.get(id);
+  if (deferred) {
+    evalState.pending.delete(id);
+    deferred.timer && window.clearTimeout(deferred.timer);
+    deferred.resolve(value);
+  } else {
+    console.warn('no eval #', id);
+  }
+}

package/lib/index.ts

@@ -1,6 +1,4 @@
 import _rules, { createAutoCMP } from './cmps/all';
 
-export { waitFor } from './cmps/base';
-
 export { createAutoCMP };
 export const rules = _rules;

package/lib/messages.ts

@@ -0,0 +1,100 @@
+import { Config, RuleBundle } from "./types";
+
+export type BackgroundMessage =
+  InitResponseMessage
+  | EvalResponseMessage
+  | OptOutMessage
+  | OptInMessage
+  | SelfTestMessage;
+
+export type ContentScriptMessage =
+  InitMessage
+  | EvalMessage
+  | DetectedMessage
+  | FoundMessage
+  | OptOutResultMessage
+  | OptInResultMessage
+  | SelfTestResultMessage
+  | DoneMessage
+  | ErrorMessage;
+
+export type InitMessage = {
+  type: "init";
+  url: string;
+};
+
+export type EvalMessage = {
+  type: "eval";
+  id: string;
+  code: string;
+};
+
+export type DetectedMessage = {
+  type: "cmpDetected";
+  cmp: string;
+  url: string;
+}
+
+export type FoundMessage = {
+  type: "popupFound";
+  cmp: string;
+  url: string;
+}
+
+export type OptOutResultMessage = {
+  type: "optOutResult";
+  cmp: string;
+  result: boolean;
+  scheduleSelfTest: boolean;
+  url: string;
+};
+
+export type OptInResultMessage = {
+  type: "optInResult";
+  cmp: string;
+  result: boolean;
+  scheduleSelfTest: boolean;
+  url: string;
+};
+
+export type SelfTestResultMessage = {
+  type: "selfTestResult";
+  cmp: string;
+  result: boolean;
+  url: string;
+};
+
+export type DoneMessage = {
+  type: "autoconsentDone";
+  cmp: string;
+  url: string;
+}
+
+export type ErrorMessage = {
+  type: "autoconsentError";
+  details: any;
+}
+
+export type InitResponseMessage = {
+  type: "initResp";
+  rules: RuleBundle;
+  config: Config;
+}
+
+export type EvalResponseMessage = {
+  type: "evalResp";
+  id: string;
+  result: any;
+}
+
+export type OptOutMessage = {
+  type: "optOut";
+}
+
+export type OptInMessage = {
+  type: "optIn";
+}
+
+export type SelfTestMessage = {
+  type: "selfTest";
+}

package/lib/rule-executors.ts

@@ -0,0 +1,108 @@
+import { enableLogs } from "./config";
+import { requestEval } from "./eval-handler";
+import { HideMethod, VisibilityCheck } from "./rules";
+import { getStyleElement, hideElements, isElementVisible, waitFor } from "./utils";
+
+export function doEval(expr: string): Promise<boolean> {
+  return requestEval(expr).catch((e) => {
+    enableLogs && console.error('error evaluating rule', expr, e);
+    return false;
+  });
+}
+
+export function click(selector: string, all = false): boolean {
+  const elem = document.querySelectorAll<HTMLElement>(selector);
+  enableLogs && 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;
+}
+
+export function elementExists(selector: string): boolean {
+  const exists = document.querySelector(selector) !== null;
+  // enableLogs && console.log("[exists?]", selector, exists);
+  return exists;
+}
+
+export function elementVisible(selector: string, check: VisibilityCheck): boolean {
+  const elem = document.querySelectorAll<HTMLElement>(selector);
+    const results = new Array(elem.length);
+    elem.forEach((e, i) => {
+      // check for display: none
+      results[i] = isElementVisible(e);
+    });
+    // enableLogs && console.log("[visible?]", selector, check, elem, results);
+    if (results.length === 0) {
+      return false;
+    } else if (check === "any") {
+      return results.some(r => r);
+    } else if (check === "none") {
+      return results.every(r => !r);
+    }
+    // all
+    return results.every(r => r);
+}
+
+export function waitForElement(selector: string, timeout = 10000): Promise<boolean> {
+  const interval = 200;
+  const times = Math.ceil((timeout) / interval);
+  // enableLogs && console.log("[waitFor]", ruleStep.waitFor);
+  return waitFor(
+    () => document.querySelector(selector) !== null,
+    times,
+    interval
+  );
+}
+
+export function waitForVisible(selector: string, timeout = 10000, check: VisibilityCheck = 'any'): Promise<boolean> {
+  const interval = 200;
+  const times = Math.ceil((timeout) / interval);
+  // enableLogs && console.log("[waitForVisible]", ruleStep.waitFor);
+  return waitFor(
+    () => elementVisible(selector, check),
+    times,
+    interval
+  );
+}
+
+export async function waitForThenClick(selector: string, timeout = 10000, all = false): Promise<boolean> {
+  // enableLogs && console.log("[waitForThenClick]", ruleStep.waitForThenClick);
+  await waitForElement(selector, timeout);
+  return click(selector, all);
+}
+
+export function wait(ms: number): Promise<true> {
+  // enableLogs && console.log(`waiting for ${ruleStep.wait}ms`);
+  return new Promise(resolve => {
+    setTimeout(() => {
+      // enableLogs && console.log(`done waiting`);
+      resolve(true);
+    }, ms);
+  });
+}
+
+export function hide(selectors: string[], method: HideMethod): boolean {
+  // enableLogs && console.log("[hide]", ruleStep.hide, ruleStep.method);
+  const styleEl = getStyleElement();
+  return hideElements(styleEl, selectors, method);
+}
+
+export function prehide(selectors: string[]): boolean {
+  const styleEl = getStyleElement('autoconsent-prehide');
+  enableLogs && console.log("[prehide]", styleEl, location.href);
+  return hideElements(styleEl, selectors, "opacity");
+}
+
+export function undoPrehide(): boolean {
+  const existingElement = getStyleElement('autoconsent-prehide');
+  enableLogs && console.log("[undoprehide]", existingElement, location.href);
+  if (existingElement) {
+    existingElement.remove();
+  }
+  return !!existingElement;
+}

package/lib/rules.ts

@@ -0,0 +1,82 @@
+export type AutoConsentCMPRule = {
+  name: string
+  prehideSelectors?: string[]
+  runContext?: RunContext,
+  intermediate?: boolean
+  detectCmp: AutoConsentRuleStep[]
+  detectPopup: AutoConsentRuleStep[]
+  optOut: AutoConsentRuleStep[]
+  optIn: AutoConsentRuleStep[]
+  openCmp?: AutoConsentRuleStep[]
+  test?: AutoConsentRuleStep[]
+}
+
+export type RunContext = {
+  main?: boolean,
+  frame?: boolean,
+  url?: string,
+}
+
+export type AutoConsentRuleStep = { optional?: boolean } & Partial<
+  ElementExistsRule
+> &
+  Partial<ElementVisibleRule> &
+  Partial<EvalRule> &
+  Partial<WaitForRule> &
+  Partial<WaitForVisibleRule> &
+  Partial<ClickRule> &
+  Partial<WaitForThenClickRule> &
+  Partial<WaitRule> &
+  Partial<UrlRule> &
+  Partial<HideRule>;
+
+export type ElementExistsRule = {
+  exists: string;
+};
+
+export type VisibilityCheck = "any" | "all" | "none";
+
+export type ElementVisibleRule = {
+  visible: string;
+  check?: VisibilityCheck;
+};
+
+export type EvalRule = {
+  eval: string;
+};
+
+export type WaitForRule = {
+  waitFor: string;
+  timeout?: number;
+};
+
+export type WaitForVisibleRule = {
+  waitForVisible: string;
+  timeout?: number;
+  check?: VisibilityCheck;
+};
+
+export type ClickRule = {
+  click: string;
+  all?: boolean;
+};
+
+export type WaitForThenClickRule = {
+  waitForThenClick: string;
+  timeout?: number;
+};
+
+export type WaitRule = {
+  wait: number;
+};
+
+export type UrlRule = {
+  url: string;
+};
+
+export type HideMethod = 'display' | 'opacity';
+
+export type HideRule = {
+  hide: string[];
+  method?: HideMethod;
+};