@duckduckgo/autoconsent 2.0.0 → 2.1.2

package/lib/web/consentomatic/index.js

@@ -0,0 +1,188 @@
+import Tools from "./tools";
+export function matches(config) {
+    const result = Tools.find(config);
+    if (config.type === "css") {
+        return !!result.target;
+    }
+    else if (config.type === "checkbox") {
+        return !!result.target && result.target.checked;
+    }
+}
+export async function executeAction(config, param) {
+    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;
+function waitTimeout(timeout) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, timeout);
+    });
+}
+async function clickAction(config) {
+    const result = Tools.find(config);
+    if (result.target != null) {
+        result.target.click();
+    }
+    return waitTimeout(STEP_TIMEOUT);
+}
+async function listAction(config, param) {
+    for (let action of config.actions) {
+        await executeAction(action, param);
+    }
+}
+async function consentAction(config, consentTypes) {
+    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 function ifCssAction(config, param) {
+    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 function waitCssAction(config) {
+    await new Promise(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, param) {
+    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);
+}
+async function hideAction(config) {
+    const result = Tools.find(config);
+    if (result.target) {
+        result.target.classList.add("Autoconsent-Hidden");
+        // result.target.setAttribute("style", "display: none;");
+    }
+}
+async function slideAction(config) {
+    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) {
+    await waitTimeout(config.waitTime);
+}
+async function closeAction(config) {
+    window.close();
+}
+async function evalAction(config) {
+    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/web/consentomatic/tools.js

@@ -0,0 +1,177 @@
+/**
+ * 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 setBase(base) {
+        Tools.base = base;
+    }
+    static findElement(options, parent = null, multiple = false) {
+        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, multiple = false) {
+        let results = [];
+        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];
+        }
+    }
+}
+Tools.base = null;

package/lib/web.ts

@@ -24,6 +24,9 @@ export default class AutoConsent {
     if (config) {
       this.initialize(config, declarativeRules);
     } else {
+      if (declarativeRules) {
+        this.parseRules(declarativeRules);
+      }
       const initMsg: InitMessage = {
         type: "init",
         url: window.location.href,
@@ -39,7 +42,9 @@ export default class AutoConsent {
       return;
     }
 
-    this.parseRules(declarativeRules);
+    if (declarativeRules) {
+      this.parseRules(declarativeRules);
+    }
     if (config.disabledCmps?.length > 0) {
       this.disableCMPs(config.disabledCmps);
     }
@@ -241,7 +246,7 @@ export default class AutoConsent {
       type: 'optInResult',
       cmp: this.foundCmp ? this.foundCmp.name : 'none',
       result: optInResult,
-      scheduleSelfTest: this.foundCmp && this.foundCmp.hasSelfTest,
+      scheduleSelfTest: false, // self-tests are only for opt-out at the moment
       url: location.href,
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "2.0.0",
+  "version": "2.1.2",
   "description": "",
   "main": "dist/autoconsent.cjs.js",
   "module": "dist/autoconsent.esm.js",
@@ -8,7 +8,7 @@
     "lib": "lib"
   },
   "scripts": {
-    "clean": "rm -r dist lib/**/*.js lib/*.js addon/*.js",
+    "clean": "rm -r dist",
     "bundle": "rollup -c",
     "watch": "rollup -c -w",
     "test": "playwright test",
@@ -17,8 +17,8 @@
     "test:chrome": "playwright test --project chrome",
     "fetch-fanboy-list": "wget https://www.fanboy.co.nz/fanboy-cookiemonster.txt",
     "fetch-site-list": "curl https://s3.amazonaws.com/cdn.cliqz.com/re-consent/supported_sites.txt > sites.txt",
-    "build-rules": "node rules/build.js && cp rules/rules.json addon/",
-    "version": "node update_version.js && git add addon/manifest.json",
+    "build-rules": "node rules/build.js",
+    "version": "node update_version.js && git add addon/manifest.*.json",
     "vendor-copy": "mkdir -p addon/vendor && cp node_modules/mocha/mocha.* addon/vendor/ && cp node_modules/chai/chai.js addon/vendor/",
     "prepublish": "npm run build-rules && npm run bundle"
   },
@@ -37,6 +37,7 @@
     "eslint-config-airbnb": "^19.0.4",
     "mocha": "^10.0.0",
     "rollup": "^2.73.0",
+    "rollup-plugin-copy": "^3.4.0",
     "rollup-plugin-terser": "^7.0.2",
     "tslib": "^2.4.0",
     "typescript": "^4.6.4"

package/playwright/content.ts

@@ -11,13 +11,7 @@ declare global {
 }
 
 if (!window.autoconsentReceiveMessage) {
-  const consent = new AutoConsent(window.autoconsentSendMessage, {
-    enabled: true,
-    autoAction: 'optOut',
-    disabledCmps: [],
-    enablePrehide: true,
-    detectRetries: 20,
-  }, <RuleBundle>rules);
+  const consent = new AutoConsent(window.autoconsentSendMessage, null, <RuleBundle>rules);
 
   window.autoconsentReceiveMessage = (message: BackgroundMessage) => {
     return Promise.resolve(consent.receiveMessageCallback(message));

package/playwright/runner.ts

@@ -4,17 +4,20 @@ import { test, expect, Page, Frame } from "@playwright/test";
 import { waitFor } from "../lib/utils";
 import { ContentScriptMessage } from "../lib/messages";
 import { enableLogs } from "../lib/config";
+import { AutoAction } from "../lib/types";
 
 const testRegion = (process.env.REGION || "NA").trim();
 
 type TestOptions = {
   testOptOut: boolean;
   testSelfTest: boolean;
+  testOptIn: boolean;
   skipRegions?: string[];
   onlyRegions?: string[];
 };
 const defaultOptions: TestOptions = {
   testOptOut: true,
+  testOptIn: true,
   testSelfTest: true,
   skipRegions: [],
   onlyRegions: [],
@@ -37,85 +40,113 @@ export async function injectContentScript(page: Page | Frame) {
 export function generateTest(
   url: string,
   expectedCmp: string,
-  options: TestOptions = { testOptOut: true, testSelfTest: true }
+  options: TestOptions = defaultOptions
 ) {
-  test(`${url.split("://")[1]} .${testRegion}`, async ({ page }) => {
-    if (options.onlyRegions && options.onlyRegions.length > 0 && !options.onlyRegions.includes(testRegion)) {
-      test.skip();
-    }
-    if (options.skipRegions && options.skipRegions.includes(testRegion)) {
-      test.skip();
-    }
-    enableLogs && page.on('console', async msg => {
-      console.log(`    page log:`, msg.text());
-    });
-    await page.exposeBinding("autoconsentSendMessage", messageCallback);
-    await page.goto(url, { waitUntil: "commit" });
-
-    // set up a messaging function
-    const received: ContentScriptMessage[] = [];
-
-    function isMessageReceived(msg: Partial<ContentScriptMessage>, partial = true) {
-      return received.some((m) => {
-        const keysMatch = partial || Object.keys(m).length === Object.keys(msg).length;
-        return keysMatch && Object.keys(msg).every(
-          (k) => (<any>m)[k] === (<any>msg)[k]
-        );
+  function genTest(autoAction: AutoAction) {
+    test(`${url.split("://")[1]} .${testRegion} ${autoAction}`, async ({ page }) => {
+      if (options.onlyRegions && options.onlyRegions.length > 0 && !options.onlyRegions.includes(testRegion)) {
+        test.skip();
+      }
+      if (options.skipRegions && options.skipRegions.includes(testRegion)) {
+        test.skip();
+      }
+      enableLogs && page.on('console', async msg => {
+        console.log(`    page log:`, msg.text());
       });
-    }
-
-    let selfTestFrame: Frame = null;
-    async function messageCallback({ frame }: { frame: Frame }, msg: ContentScriptMessage) {
-      enableLogs && msg.type !== 'eval' && console.log(msg);
-      received.push(msg);
-      switch (msg.type) {
-        case 'optInResult':
-        case 'optOutResult': {
-          if (msg.scheduleSelfTest) {
-            selfTestFrame = frame;
+      await page.exposeBinding("autoconsentSendMessage", messageCallback);
+      await page.goto(url, { waitUntil: "commit" });
+
+      // set up a messaging function
+      const received: ContentScriptMessage[] = [];
+
+      function isMessageReceived(msg: Partial<ContentScriptMessage>, partial = true) {
+        return received.some((m) => {
+          const keysMatch = partial || Object.keys(m).length === Object.keys(msg).length;
+          return keysMatch && Object.keys(msg).every(
+            (k) => (<any>m)[k] === (<any>msg)[k]
+          );
+        });
+      }
+
+      let selfTestFrame: Frame = null;
+      async function messageCallback({ frame }: { frame: Frame }, msg: ContentScriptMessage) {
+        enableLogs && msg.type !== 'eval' && console.log(msg);
+        received.push(msg);
+        switch (msg.type) {
+          case 'init': {
+            await frame.evaluate(`autoconsentReceiveMessage({ type: "initResp", config: ${JSON.stringify({
+              enabled: true,
+              autoAction: autoAction,
+              disabledCmps: [],
+              enablePrehide: true,
+              detectRetries: 20,
+            })} })`);
+            break;
           }
-          break;
-        }
-        case 'autoconsentDone': {
-          if (selfTestFrame && options.testSelfTest) {
-            await selfTestFrame.evaluate(`autoconsentReceiveMessage({ type: "selfTest" })`);
+          case 'optInResult':
+          case 'optOutResult': {
+            if (msg.scheduleSelfTest) {
+              selfTestFrame = frame;
+            }
+            break;
+          }
+          case 'autoconsentDone': {
+            if (selfTestFrame && options.testSelfTest) {
+              await selfTestFrame.evaluate(`autoconsentReceiveMessage({ type: "selfTest" })`);
+            }
+            break;
+          }
+          case 'eval': {
+            const result = await frame.evaluate(msg.code);
+            await frame.evaluate(`autoconsentReceiveMessage({ id: "${msg.id}", type: "evalResp", result: ${JSON.stringify(result)} })`);
+            break;
+          }
+          case 'autoconsentError': {
+            console.error(url, msg.details);
+            break;
           }
-          break;
-        }
-        case 'eval': {
-          const result = await frame.evaluate(msg.code);
-          await frame.evaluate(`autoconsentReceiveMessage({ id: "${msg.id}", type: "evalResp", result: ${JSON.stringify(result)} })`);
-          break;
-        }
-        case 'autoconsentError': {
-          console.error(url, msg.details);
-          break;
         }
       }
-    }
-
-    // inject content scripts into every frame
-    await injectContentScript(page);
-    page.frames().forEach(injectContentScript);
-    page.on("framenavigated", injectContentScript);
-
-    // wait for all messages and assertions
-    await waitFor(() => isMessageReceived({ type: "popupFound", cmp: expectedCmp }), 50, 500);
-    expect(isMessageReceived({ type: "popupFound", cmp: expectedCmp })).toBe(true);
-
-    if (options.testOptOut) {
-      await waitFor(() => isMessageReceived({ type: "optOutResult", result: true }), 50, 300);
-      expect(isMessageReceived({ type: "optOutResult", result: true })).toBe(true);
-    }
-    if (options.testSelfTest && selfTestFrame) {
-      await waitFor(() => isMessageReceived({ type: "selfTestResult", result: true }), 50, 300);
-      expect(isMessageReceived({ type: "selfTestResult", result: true })).toBe(true);
-    }
-    await waitFor(() => isMessageReceived({ type: "autoconsentDone" }), 10, 500);
-    expect(isMessageReceived({ type: "autoconsentDone" })).toBe(true);
-
-    expect(isMessageReceived({ type: "autoconsentError" })).toBe(false);
-  });
+
+      // inject content scripts into every frame
+      await injectContentScript(page);
+      page.frames().forEach(injectContentScript);
+      page.on("framenavigated", injectContentScript);
+
+      // wait for all messages and assertions
+      await waitFor(() => isMessageReceived({ type: "popupFound", cmp: expectedCmp }), 50, 500);
+      expect(isMessageReceived({ type: "popupFound", cmp: expectedCmp })).toBe(true);
+
+      if (autoAction === 'optOut') {
+        await waitFor(() => isMessageReceived({ type: "optOutResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "optOutResult", result: true })).toBe(true);
+      }
+      if (autoAction === 'optIn') {
+        await waitFor(() => isMessageReceived({ type: "optInResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "optInResult", result: true })).toBe(true);
+      }
+      if (options.testSelfTest && selfTestFrame) {
+        await waitFor(() => isMessageReceived({ type: "selfTestResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "selfTestResult", result: true })).toBe(true);
+      }
+      await waitFor(() => isMessageReceived({ type: "autoconsentDone" }), 10, 500);
+      expect(isMessageReceived({ type: "autoconsentDone" })).toBe(true);
+
+      expect(isMessageReceived({ type: "autoconsentError" })).toBe(false);
+    })
+  }
+
+  if (!options.testOptIn && !options.testOptOut) {
+    genTest(null);
+  }
+
+  if (options.testOptIn) {
+    genTest('optIn');
+  }
+
+  if (options.testOptOut) {
+    genTest('optOut');
+  }
 }
 
 export default function generateCMPTests(

package/readme.md

@@ -18,7 +18,11 @@ npm run build-rules
 npm run bundle
 ```
 
-The extension-specific code can be found in the `addon` directory and can be [loaded directly from there](https://developer.chrome.com/docs/extensions/mv3/getstarted/#unpacked) in developer mode.
+The extension-specific code can be found in the `addon` directory. There are two versions of the
+addon (found under `dist/addon` after building), one for `mv3` version for Chromium-based browsers, and a `firefox` version for Firefox.
+You can load these in [Chrome](https://developer.chrome.com/docs/extensions/mv3/getstarted/#unpacked)
+in developer mode, and in [Firefox](https://extensionworkshop.com/documentation/develop/temporary-installation-in-firefox/)
+as a tempoary addon.
 
 ## Rules