@duckduckgo/autoconsent 1.0.2

package/lib/web/consentomatic/tools.ts

@@ -0,0 +1,198 @@
+/**
+ * This code is in most parts copied from https://github.com/cavi-au/Consent-O-Matic/blob/master/Extension/Tools.js
+ * which is licened under the MIT. 
+ */
+export default class Tools {
+  static base: HTMLElement = null;
+
+  static setBase(base: HTMLElement) {
+    Tools.base = base;
+  }
+
+  static findElement(options: any, parent: any = null, multiple = false): HTMLElement[] | HTMLElement {
+    let possibleTargets = null;
+
+    if (parent != null) {
+      possibleTargets = Array.from(parent.querySelectorAll(options.selector));
+    } else {
+      if (Tools.base != null) {
+        possibleTargets = Array.from(
+          Tools.base.querySelectorAll(options.selector)
+        );
+      } else {
+        possibleTargets = Array.from(
+          document.querySelectorAll(options.selector)
+        );
+      }
+    }
+
+    if (options.textFilter != null) {
+      possibleTargets = possibleTargets.filter(possibleTarget => {
+        let textContent = possibleTarget.textContent.toLowerCase();
+
+        if (Array.isArray(options.textFilter)) {
+          let foundText = false;
+
+          for (let text of options.textFilter) {
+            if (textContent.indexOf(text.toLowerCase()) !== -1) {
+              foundText = true;
+              break;
+            }
+          }
+
+          return foundText;
+        } else if (options.textFilter != null) {
+          return textContent.indexOf(options.textFilter.toLowerCase()) !== -1;
+        }
+      });
+    }
+
+    if (options.styleFilters != null) {
+      possibleTargets = possibleTargets.filter(possibleTarget => {
+        let styles = window.getComputedStyle(possibleTarget);
+
+        let keep = true;
+
+        for (let styleFilter of options.styleFilters) {
+          let option = styles[styleFilter.option];
+
+          if (styleFilter.negated) {
+            keep = keep && option !== styleFilter.value;
+          } else {
+            keep = keep && option === styleFilter.value;
+          }
+        }
+
+        return keep;
+      });
+    }
+
+    if (options.displayFilter != null) {
+      possibleTargets = possibleTargets.filter(possibleTarget => {
+        if (options.displayFilter) {
+          //We should be displayed
+          return possibleTarget.offsetHeight !== 0;
+        } else {
+          //We should not be displayed
+          return possibleTarget.offsetHeight === 0;
+        }
+      });
+    }
+
+    if (options.iframeFilter != null) {
+      possibleTargets = possibleTargets.filter(possibleTarget => {
+        if (options.iframeFilter) {
+          //We should be inside an iframe
+          return window.location !== window.parent.location;
+        } else {
+          //We should not be inside an iframe
+          return window.location === window.parent.location;
+        }
+      });
+    }
+
+    if (options.childFilter != null) {
+      possibleTargets = possibleTargets.filter(possibleTarget => {
+        let oldBase = Tools.base;
+        Tools.setBase(possibleTarget);
+        let childResults = Tools.find(options.childFilter);
+        Tools.setBase(oldBase);
+        return childResults.target != null;
+      });
+    }
+
+    if (multiple) {
+      return possibleTargets;
+    } else {
+      if (possibleTargets.length > 1) {
+        console.warn(
+          "Multiple possible targets: ",
+          possibleTargets,
+          options,
+          parent
+        );
+      }
+
+      return possibleTargets[0];
+    }
+  }
+
+  static find(options: any, multiple = false) {
+    let results: any[] = [];
+    if (options.parent != null) {
+      let parent = Tools.findElement(options.parent, null, multiple);
+      if (parent != null) {
+        if (parent instanceof Array) {
+          parent.forEach(p => {
+            let targets = Tools.findElement(options.target, p, multiple);
+            if (targets instanceof Array) {
+              targets.forEach(target => {
+                results.push({
+                  parent: p,
+                  target: target
+                });
+              });
+            } else {
+              results.push({
+                parent: p,
+                target: targets
+              });
+            }
+          });
+
+          return results;
+        } else {
+          let targets = Tools.findElement(options.target, parent, multiple);
+          if (targets instanceof Array) {
+            targets.forEach(target => {
+              results.push({
+                parent: parent,
+                target: target
+              });
+            });
+          } else {
+            results.push({
+              parent: parent,
+              target: targets
+            });
+          }
+        }
+      }
+    } else {
+      let targets = Tools.findElement(options.target, null, multiple);
+      if (targets instanceof Array) {
+        targets.forEach(target => {
+          results.push({
+            parent: null,
+            target: target
+          });
+        });
+      } else {
+        results.push({
+          parent: null,
+          target: targets
+        });
+      }
+    }
+
+    if (results.length === 0) {
+      results.push({
+        parent: null,
+        target: null
+      });
+    }
+
+    if (multiple) {
+      return results;
+    } else {
+      if (results.length !== 1) {
+        console.warn(
+          "Multiple results found, even though multiple false",
+          results
+        );
+      }
+
+      return results[0];
+    }
+  }
+}

package/lib/web/content.js

@@ -0,0 +1,91 @@
+import { matches, executeAction } from "./consentomatic/index";
+let actionQueue = Promise.resolve(null);
+const styleOverrideElementId = "autoconsent-css-rules";
+const styleSelector = `style#${styleOverrideElementId}`;
+export default function handleMessage(message, debug = false) {
+    if (message.type === "click") {
+        const elem = document.querySelectorAll(message.selector);
+        debug && console.log("[click]", message.selector, elem);
+        if (elem.length > 0) {
+            if (message.all === true) {
+                elem.forEach(e => e.click());
+            }
+            else {
+                elem[0].click();
+            }
+        }
+        return elem.length > 0;
+    }
+    else if (message.type === "elemExists") {
+        const exists = document.querySelector(message.selector) !== null;
+        debug && console.log("[exists?]", message.selector, exists);
+        return exists;
+    }
+    else if (message.type === "elemVisible") {
+        const elem = document.querySelectorAll(message.selector);
+        const results = new Array(elem.length);
+        elem.forEach((e, i) => {
+            results[i] = e.offsetParent !== null || window.getComputedStyle(e).display !== "none" || e.style?.display !== "none";
+        });
+        if (results.length === 0) {
+            return false;
+        }
+        else if (message.check === "any") {
+            return results.some(r => r);
+        }
+        else if (message.check === "none") {
+            return results.every(r => !r);
+        }
+        // all
+        return results.every(r => r);
+    }
+    else if (message.type === "getAttribute") {
+        const elem = document.querySelector(message.selector);
+        if (!elem) {
+            return false;
+        }
+        return elem.getAttribute(message.attribute);
+    }
+    else if (message.type === "eval") {
+        // TODO: chrome support
+        const result = window.eval(message.script); // eslint-disable-line no-eval
+        debug && console.log("[eval]", message.script, result);
+        return result;
+    }
+    else if (message.type === "hide") {
+        const parent = document.head ||
+            document.getElementsByTagName("head")[0] ||
+            document.documentElement;
+        const rule = `${message.selectors.join(",")} { display: none !important; z-index: -1 !important; } `;
+        const existingElement = document.querySelector(styleSelector);
+        debug && console.log("[hide]", message.selectors, !!existingElement);
+        if (existingElement && existingElement instanceof HTMLStyleElement) {
+            existingElement.innerText += rule;
+        }
+        else {
+            const css = document.createElement("style");
+            css.type = "text/css";
+            css.id = styleOverrideElementId;
+            css.appendChild(document.createTextNode(rule));
+            parent.appendChild(css);
+        }
+        return message.selectors.length > 0;
+    }
+    else if (message.type === "undohide") {
+        const existingElement = document.querySelector(styleSelector);
+        debug && console.log("[unhide]", !!existingElement);
+        if (existingElement) {
+            existingElement.remove();
+        }
+        return !!existingElement;
+    }
+    else if (message.type === "matches") {
+        const matched = matches(message.config);
+        return matched;
+    }
+    else if (message.type === "executeAction") {
+        actionQueue = actionQueue.then(() => executeAction(message.config, message.param));
+        return true;
+    }
+    return null;
+}

package/lib/web/content.ts

@@ -0,0 +1,83 @@
+import { matches, executeAction } from "./consentomatic/index";
+import { ContentScriptMessage } from "../messages";
+
+let actionQueue = Promise.resolve(null);
+const styleOverrideElementId = "autoconsent-css-rules";
+const styleSelector = `style#${styleOverrideElementId}`;
+
+export default function handleMessage(message: ContentScriptMessage, debug = false) {
+  if (message.type === "click") {
+    const elem = document.querySelectorAll<HTMLElement>(message.selector);
+    debug && console.log("[click]", message.selector, elem);
+    if (elem.length > 0) {
+      if (message.all === true) {
+        elem.forEach(e => e.click());
+      } else {
+        elem[0].click();
+      }
+    }
+    return elem.length > 0;
+  } else if (message.type === "elemExists") {
+    const exists = document.querySelector(message.selector) !== null;
+    debug && console.log("[exists?]", message.selector, exists);
+    return exists;
+  } else if (message.type === "elemVisible") {
+    const elem = document.querySelectorAll<HTMLElement>(message.selector);
+    const results = new Array(elem.length);
+    elem.forEach((e, i) => {
+      results[i] = e.offsetParent !== null || window.getComputedStyle(e).display !== "none" || e.style?.display !== "none";
+    });
+    if (results.length === 0) {
+      return false;
+    } else if (message.check === "any") {
+      return results.some(r => r);
+    } else if (message.check === "none") {
+      return results.every(r => !r);
+    }
+    // all
+    return results.every(r => r);
+  } else if (message.type === "getAttribute") {
+    const elem = document.querySelector(message.selector);
+    if (!elem) {
+      return false;
+    }
+    return elem.getAttribute(message.attribute);
+  } else if (message.type === "eval") {
+    // TODO: chrome support
+    const result = window.eval(message.script); // eslint-disable-line no-eval
+    debug && console.log("[eval]", message.script, result);
+    return result;
+  } else if (message.type === "hide") {
+    const parent =
+      document.head ||
+      document.getElementsByTagName("head")[0] ||
+      document.documentElement;
+    const rule = `${message.selectors.join(",")} { display: none !important; z-index: -1 !important; } `;
+    const existingElement = document.querySelector(styleSelector);
+    debug && console.log("[hide]", message.selectors, !!existingElement);
+    if (existingElement && existingElement instanceof HTMLStyleElement) {
+      existingElement.innerText += rule;
+    } else {
+      const css = document.createElement("style");
+      css.type = "text/css";
+      css.id = styleOverrideElementId;
+      css.appendChild(document.createTextNode(rule));
+      parent.appendChild(css);
+    }
+    return message.selectors.length > 0;
+  } else if (message.type === "undohide") {
+    const existingElement = document.querySelector(styleSelector);
+    debug && console.log("[unhide]", !!existingElement);
+    if (existingElement) {
+      existingElement.remove();
+    }
+    return !!existingElement
+  } else if (message.type === "matches") {
+    const matched = matches(message.config);
+    return matched;
+  } else if (message.type === "executeAction") {
+    actionQueue = actionQueue.then(() => executeAction(message.config, message.param));
+    return true;
+  }
+  return null;
+}

package/lib/web/tab.js

@@ -0,0 +1,106 @@
+import { waitFor } from "../cmps/base";
+export default class TabActions {
+    constructor(tabId, frame, sendContentMessage, browser) {
+        this.frame = frame;
+        this.sendContentMessage = sendContentMessage;
+        this.browser = browser;
+        this.id = tabId;
+    }
+    async elementExists(selector, frameId = 0) {
+        console.log(`check for  ${selector} in tab ${this.id}, frame ${frameId}`);
+        return this.sendContentMessage(this.id, {
+            type: "elemExists",
+            selector
+        }, {
+            frameId
+        });
+    }
+    async clickElement(selector, frameId = 0) {
+        console.log(`click element ${selector} in tab ${this.id}`);
+        return this.sendContentMessage(this.id, {
+            type: "click",
+            selector
+        }, {
+            frameId
+        });
+    }
+    async clickElements(selector, frameId = 0) {
+        console.log(`click elements ${selector} in tab ${this.id}`);
+        return this.sendContentMessage(this.id, {
+            type: "click",
+            all: true,
+            selector
+        }, {
+            frameId
+        });
+    }
+    async elementsAreVisible(selector, check, frameId = 0) {
+        return this.sendContentMessage(this.id, {
+            type: "elemVisible",
+            selector,
+            check
+        }, {
+            frameId
+        });
+    }
+    async getAttribute(selector, attribute, frameId = 0) {
+        return this.sendContentMessage(this.id, {
+            type: "getAttribute",
+            selector,
+            attribute
+        }, { frameId });
+    }
+    async eval(script, frameId = 0) {
+        // console.log(`run ${script} in tab ${this.id}`);
+        return await this.sendContentMessage(this.id, {
+            type: "eval",
+            script
+        }, { frameId });
+    }
+    async waitForElement(selector, timeout, frameId = 0) {
+        const interval = 200;
+        const times = Math.ceil(timeout / interval);
+        return waitFor(() => this.elementExists(selector, frameId), times, interval);
+    }
+    async waitForThenClick(selector, timeout, frameId = 0) {
+        if (await this.waitForElement(selector, timeout, frameId)) {
+            return await this.clickElement(selector, frameId);
+        }
+        return false;
+    }
+    async hideElements(selectors, frameId = 0) {
+        return this.sendContentMessage(this.id, {
+            type: "hide",
+            selectors
+        }, { frameId });
+    }
+    async undoHideElements(frameId = 0) {
+        return this.sendContentMessage(this.id, {
+            type: "undohide",
+        }, { frameId });
+    }
+    async getBrowserTab() {
+        return this.browser.tabs.get(this.id);
+    }
+    async goto(url) {
+        return this.browser.tabs.update(this.id, { url });
+    }
+    wait(ms) {
+        return new Promise(resolve => {
+            setTimeout(() => resolve(true), ms);
+        });
+    }
+    matches(matcherConfig) {
+        return this.sendContentMessage(this.id, {
+            type: "matches",
+            config: matcherConfig
+        }, { frameId: 0 });
+    }
+    executeAction(config, param) {
+        return this.sendContentMessage(this.id, {
+            type: "executeAction",
+            config,
+            param
+        }, { frameId: 0 });
+    }
+}

package/lib/web/tab.ts

@@ -0,0 +1,171 @@
+import { waitFor } from "../cmps/base";
+import { TabActor, MessageSender, Browser } from "../types";
+
+export default class TabActions implements TabActor {
+  id: number;
+
+  constructor(
+    tabId: number,
+    public frame: any,
+    private sendContentMessage: MessageSender,
+    private browser: Browser
+  ) {
+    this.id = tabId;
+  }
+
+  async elementExists(selector: string, frameId = 0) {
+    console.log(`check for  ${selector} in tab ${this.id}, frame ${frameId}`);
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "elemExists",
+        selector
+      },
+      {
+        frameId
+      }
+    );
+  }
+
+  async clickElement(selector: string, frameId = 0) {
+    console.log(`click element ${selector} in tab ${this.id}`);
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "click",
+        selector
+      },
+      {
+        frameId
+      }
+    );
+  }
+
+  async clickElements(selector: string, frameId = 0) {
+    console.log(`click elements ${selector} in tab ${this.id}`);
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "click",
+        all: true,
+        selector
+      },
+      {
+        frameId
+      }
+    );
+  }
+
+  async elementsAreVisible(selector: string, check?: 'all' | 'any' | 'none', frameId = 0) {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "elemVisible",
+        selector,
+        check
+      },
+      {
+        frameId
+      }
+    );
+  }
+
+  async getAttribute(selector: string, attribute: string, frameId = 0) {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "getAttribute",
+        selector,
+        attribute
+      },
+      { frameId }
+    );
+  }
+
+  async eval(script: string, frameId = 0) {
+    // console.log(`run ${script} in tab ${this.id}`);
+    return await this.sendContentMessage(
+      this.id,
+      {
+        type: "eval",
+        script
+      },
+      { frameId }
+    );
+  }
+
+  async waitForElement(selector: string, timeout: number, frameId = 0) {
+    const interval = 200;
+    const times = Math.ceil(timeout / interval);
+    return waitFor(
+      () => this.elementExists(selector, frameId),
+      times,
+      interval
+    );
+  }
+
+  async waitForThenClick(selector: string, timeout: number, frameId = 0) {
+    if (await this.waitForElement(selector, timeout, frameId)) {
+      return await this.clickElement(selector, frameId);
+    }
+    return false;
+  }
+
+  async hideElements(selectors: string[], frameId = 0) {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "hide",
+        selectors
+      },
+      { frameId }
+    );
+  }
+
+  async undoHideElements(frameId = 0): Promise<boolean> {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "undohide",
+      },
+      { frameId }
+    );
+  }
+
+  async getBrowserTab() {
+    return this.browser.tabs.get(this.id);
+  }
+
+  async goto(url: string) {
+    return this.browser.tabs.update(this.id, { url });
+  }
+
+  wait(ms: number): Promise<true> {
+    return new Promise(resolve => {
+      setTimeout(() => resolve(true), ms);
+    });
+  }
+
+  matches(matcherConfig: any) {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "matches",
+        config: matcherConfig
+      },
+      { frameId: 0 }
+    );
+  }
+
+  executeAction(config: any, param?: any): Promise<boolean> {
+    return this.sendContentMessage(
+      this.id,
+      {
+        type: "executeAction",
+        config,
+        param
+      },
+      { frameId: 0 }
+    );
+  }
+}