@duckduckgo/autoconsent 1.0.8 → 2.1.1

package/lib/web/content-utils.ts

@@ -1,31 +0,0 @@
-import { HideMethod } from "../messages";
-
-// get or create a style container for CSS overrides
-export function getStyleElementUtil(): HTMLStyleElement {
-  const styleOverrideElementId = "autoconsent-css-rules";
-  const styleSelector = `style#${styleOverrideElementId}`;
-  const existingElement = document.querySelector(styleSelector);
-  if (existingElement && existingElement instanceof HTMLStyleElement) {
-    return existingElement;
-  } else {
-    const parent = document.head ||
-      document.getElementsByTagName("head")[0] ||
-      document.documentElement;
-    const css = document.createElement("style");
-    css.id = styleOverrideElementId;
-    parent.appendChild(css);
-    return css;
-  }
-}
-
-// hide elements with a CSS rule
-export function hideElementsUtil(selectors: string[], method: HideMethod): boolean {
-  const hidingSnippet = method === 'display' ? `display: none` : `opacity: 0`;
-  const rule = `${selectors.join(",")} { ${hidingSnippet} !important; z-index: -1 !important; pointer-events: none !important; } `;
-  const styleEl = getStyleElementUtil();
-  if (styleEl instanceof HTMLStyleElement) {
-    styleEl.innerText += rule;
-    return selectors.length > 0;
-  }
-  return false;
-}

package/lib/web/content.js

@@ -1,89 +0,0 @@
-import { matches, executeAction } from "./consentomatic/index";
-import { hideElementsUtil, getStyleElementUtil } from "./content-utils";
-let actionQueue = Promise.resolve(null);
-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) => {
-            // check for display: none
-            results[i] = false;
-            if (e.offsetParent !== null) {
-                results[i] = true;
-            }
-            else {
-                const css = window.getComputedStyle(e);
-                if (css.position === 'fixed' && css.display !== "none") { // fixed elements may be visible even if the parent is not
-                    results[i] = true;
-                }
-            }
-        });
-        debug && console.log("[visible?]", message.selector, elem, results);
-        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);
-        debug && console.log("[getAttribute]", message.selector, elem);
-        if (!elem) {
-            return false;
-        }
-        return elem.getAttribute(message.attribute);
-    }
-    else if (message.type === "eval") {
-        // TODO: chrome support
-        debug && console.log("about to [eval]", message.script); // this will not show in Webkit console
-        const result = window.eval(message.script); // eslint-disable-line no-eval
-        return result;
-    }
-    else if (message.type === "hide") {
-        debug && console.log("[hide]", message.selectors);
-        return hideElementsUtil(message.selectors, message.method);
-    }
-    else if (message.type === "undohide") {
-        const existingElement = getStyleElementUtil();
-        debug && console.log("[unhide]", !!existingElement);
-        if (existingElement) {
-            existingElement.remove();
-        }
-        return !!existingElement;
-    }
-    else if (message.type === "matches") {
-        const matched = matches(message.config);
-        debug && console.log("[matches?]", message.config.type, JSON.stringify(message.config), matched);
-        return matched;
-    }
-    else if (message.type === "executeAction") {
-        debug && console.log("[executeAction]", message);
-        actionQueue = actionQueue.then(() => executeAction(message.config, message.param));
-        return true;
-    }
-    return null;
-}

package/lib/web/content.ts

@@ -1,80 +0,0 @@
-import { matches, executeAction } from "./consentomatic/index";
-import { ContentScriptMessage } from "../messages";
-import { hideElementsUtil, getStyleElementUtil } from "./content-utils";
-
-let actionQueue = Promise.resolve(null);
-
-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) => {
-      // check for display: none
-      results[i] = false;
-      if (e.offsetParent !== null) {
-        results[i] = true;
-      } else {
-        const css = window.getComputedStyle(e);
-        if (css.position === 'fixed' && css.display !== "none") { // fixed elements may be visible even if the parent is not
-          results[i] = true;
-        }
-      }
-    });
-    debug && console.log("[visible?]", message.selector, elem, results);
-    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);
-    debug && console.log("[getAttribute]", message.selector, elem);
-    if (!elem) {
-      return false;
-    }
-    return elem.getAttribute(message.attribute);
-  } else if (message.type === "eval") {
-    // TODO: chrome support
-    debug && console.log("about to [eval]", message.script); // this will not show in Webkit console
-    const result = window.eval(message.script); // eslint-disable-line no-eval
-    return result;
-  } else if (message.type === "hide") {
-    debug && console.log("[hide]", message.selectors);
-    return hideElementsUtil(message.selectors, message.method);
-  } else if (message.type === "undohide") {
-    const existingElement = getStyleElementUtil();
-    debug && console.log("[unhide]", !!existingElement);
-    if (existingElement) {
-      existingElement.remove();
-    }
-    return !!existingElement
-  } else if (message.type === "matches") {
-    const matched = matches(message.config);
-    debug && console.log("[matches?]", message.config.type, JSON.stringify(message.config), matched);
-    return matched;
-  } else if (message.type === "executeAction") {
-    debug && console.log("[executeAction]", message);
-    actionQueue = actionQueue.then(() => executeAction(message.config, message.param));
-    return true;
-  }
-  return null;
-}

package/lib/web/tab.js

@@ -1,112 +0,0 @@
-import { waitFor } from "../cmps/base";
-import { enableLogs } from "../config";
-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) {
-        return this.sendContentMessage(this.id, {
-            type: "elemExists",
-            selector
-        }, {
-            frameId
-        });
-    }
-    async clickElement(selector, frameId = 0) {
-        enableLogs && console.log(`click element ${selector} in tab ${this.id}`);
-        return this.sendContentMessage(this.id, {
-            type: "click",
-            selector
-        }, {
-            frameId
-        });
-    }
-    async clickElements(selector, frameId = 0) {
-        enableLogs && 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, method = 'display') {
-        enableLogs && console.log('Sending hide elements to', this.id, selectors);
-        return this.sendContentMessage(this.id, {
-            type: "hide",
-            selectors,
-            method,
-        }, { 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) {
-        enableLogs && console.log(`waiting for ${ms}ms in tab ${this.id}`);
-        return new Promise(resolve => {
-            setTimeout(() => {
-                enableLogs && console.log(`done waiting in tab ${this.id}`);
-                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

@@ -1,178 +0,0 @@
-import { waitFor } from "../cmps/base";
-import { enableLogs } from "../config";
-import { HideMethod } from "../messages";
-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) {
-    return this.sendContentMessage(
-      this.id,
-      {
-        type: "elemExists",
-        selector
-      },
-      {
-        frameId
-      }
-    );
-  }
-
-  async clickElement(selector: string, frameId = 0) {
-    enableLogs && console.log(`click element ${selector} in tab ${this.id}`);
-    return this.sendContentMessage(
-      this.id,
-      {
-        type: "click",
-        selector
-      },
-      {
-        frameId
-      }
-    );
-  }
-
-  async clickElements(selector: string, frameId = 0) {
-    enableLogs && 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, method: HideMethod = 'display') {
-    enableLogs && console.log('Sending hide elements to', this.id, selectors);
-    return this.sendContentMessage(
-      this.id,
-      {
-        type: "hide",
-        selectors,
-        method,
-      },
-      { 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> {
-    enableLogs && console.log(`waiting for ${ms}ms in tab ${this.id}`);
-    return new Promise(resolve => {
-      setTimeout(() => {
-        enableLogs && console.log(`done waiting in tab ${this.id}`);
-        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 }
-    );
-  }
-}

package/lib/web.js

@@ -1,95 +0,0 @@
-import Tab from './web/tab';
-import handleContentMessage from './web/content';
-import TabConsent from './tabwrapper';
-import detectDialog from './detector';
-import { rules, createAutoCMP } from './index';
-import { ConsentOMaticCMP } from './consentomatic/index';
-import prehideElements from './hider';
-import { enableLogs } from './config';
-export * from './index';
-export { Tab, handleContentMessage, };
-export default class AutoConsent {
-    constructor(browser, sendContentMessage) {
-        this.browser = browser;
-        this.sendContentMessage = sendContentMessage;
-        this.consentFrames = new Map();
-        this.tabCmps = new Map();
-        this.sendContentMessage = sendContentMessage;
-        this.rules = [...rules];
-    }
-    addCMP(config) {
-        this.rules.push(createAutoCMP(config));
-    }
-    disableCMPs(cmpNames) {
-        this.rules = this.rules.filter((cmp) => !cmpNames.includes(cmp.name));
-    }
-    addConsentomaticCMP(name, config) {
-        this.rules.push(new ConsentOMaticCMP(`com_${name}`, config));
-    }
-    createTab(tabId) {
-        return new Tab(tabId, this.consentFrames.get(tabId), this.sendContentMessage, this.browser);
-    }
-    async checkTab(tabId, prehide = true) {
-        enableLogs && console.log('checking tab', tabId, this.consentFrames, this.tabCmps);
-        const tab = this.createTab(tabId);
-        if (prehide) {
-            this.prehideElements(tab);
-        }
-        const consent = new TabConsent(tab, this.detectDialog(tab, 20));
-        this.tabCmps.set(tabId, consent);
-        // check tabs
-        consent.checked.then((rule) => {
-            if (this.consentFrames.has(tabId) && rule) {
-                const frame = this.consentFrames.get(tabId);
-                enableLogs && console.log(`Found ${rule.name} in a nested iframe ${frame.id} inside tab ${tabId}`);
-                if (frame.type === rule.name) {
-                    consent.tab.frame = frame;
-                }
-            }
-            enableLogs && console.log('finished checking tab', tabId, this.consentFrames, this.tabCmps);
-            // no CMP detected, undo hiding
-            if (!rule && prehide) {
-                enableLogs && console.log('no CMP detected, undo hiding');
-                tab.undoHideElements();
-            }
-        });
-        return this.tabCmps.get(tabId);
-    }
-    removeTab(tabId) {
-        this.tabCmps.delete(tabId);
-        this.consentFrames.delete(tabId);
-    }
-    onFrame({ tabId, url, frameId }) {
-        // ignore main frames
-        if (frameId === 0) {
-            return;
-        }
-        try {
-            const frame = {
-                id: frameId,
-                url: url,
-            };
-            const tab = this.createTab(tabId);
-            const frameMatch = this.rules.findIndex(r => r.detectFrame(tab, frame));
-            if (frameMatch > -1) {
-                this.consentFrames.set(tabId, {
-                    type: this.rules[frameMatch].name,
-                    url,
-                    id: frameId,
-                });
-                if (this.tabCmps.has(tabId)) {
-                    this.tabCmps.get(tabId).tab.frame = this.consentFrames.get(tabId);
-                }
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-    async detectDialog(tab, retries) {
-        return detectDialog(tab, retries, this.rules);
-    }
-    async prehideElements(tab) {
-        return prehideElements(tab, this.rules);
-    }
-}

package/tests/runner.ts

@@ -1,61 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { test, expect } from '@playwright/test';
-import * as autoconsent from '../dist/autoconsent.puppet';
-import * as extraRules from '../rules/rules.json';
-
-const consentomatic = extraRules.consentomatic;
-const rules = [
-    ...autoconsent.rules,
-    ...Object.keys(consentomatic).map(name => new autoconsent.ConsentOMaticCMP(`com_${name}`, consentomatic[name])),
-    ...extraRules.autoconsent.map(spec => autoconsent.createAutoCMP(spec)),
-];
-const screenshotDir = `./screenshots`;
-const testRegion = (process.env.REGION || 'NA').trim();
-
-async function ensureScreenshotDir() {
-    try {
-        await fs.stat(screenshotDir);
-    } catch(e) {
-        await fs.mkdir(screenshotDir);
-    }
-}
-
-type TestOptions = {
-    testOptOut: boolean;
-    testSelfTest: boolean;
-    skipRegions?: string[];
-}
-const defaultOptions: TestOptions = {
-    testOptOut: true,
-    testSelfTest: true,
-    skipRegions: [],
-}
-
-export function generateTest(url: string, expectedCmp: string, options: TestOptions = { testOptOut: true, testSelfTest: true }) {
-    test(`${url.split('://')[1]} .${testRegion}`, async ({ page }) => {
-        if (options.skipRegions && options.skipRegions.indexOf(testRegion) !== -1) {
-            test.skip();
-        }
-        await page.goto(url, { waitUntil: 'commit' });
-
-        const tab = autoconsent.attachToPage(page, url, rules, 20, true);
-        await tab.checked;
-        expect(tab.getCMPName()).toBe(expectedCmp);
-        expect(await tab.isPopupOpen(50, 100)).toBeTruthy();
-        if (options.testOptOut) {
-            expect(await tab.doOptOut()).toBeTruthy();
-        }
-        if (options.testSelfTest) {
-            expect(await tab.testOptOutWorked()).toBeTruthy();
-        }
-    });
-}
-
-export default function generateCMPTests(cmp: string, sites: string[], options: Partial<TestOptions> = {}) {
-    test.describe(cmp, () => {
-        sites.forEach((url) => {
-            generateTest(url, cmp, Object.assign({}, defaultOptions, options));
-        });
-    })
-}