@duckduckgo/autoconsent 1.0.8 → 2.0.0

package/lib/cmps/trustarc.ts

@@ -1,147 +0,0 @@
-import AutoConsentBase, { waitFor } from "./base";
-import { TabActor } from "../types";
-
-export default class TrustArc extends AutoConsentBase {
-
-  prehideSelectors = [
-    ".trustarc-banner-container",
-    ".truste_popframe,.truste_overlay,.truste_box_overlay,#truste-consent-track",
-  ]
-
-  constructor() {
-    super("TrustArc");
-  }
-
-  detectFrame(_: TabActor, frame: { url: string }) {
-    return frame.url.startsWith("https://consent-pref.trustarc.com/?");
-  }
-
-  async detectCmp(tab: TabActor) {
-    if (
-      tab.frame &&
-      tab.frame.url.startsWith("https://consent-pref.trustarc.com/?")
-    ) {
-      return true;
-    }
-    return tab.elementExists("#truste-show-consent,#truste-consent-track");
-  }
-
-  async detectPopup(tab: TabActor) {
-    return (
-      (await tab.elementsAreVisible("#truste-consent-content,.truste-consent-content,#trustarc-banner-overlay")) ||
-      (tab.frame &&
-        (await tab.waitForElement(
-          "#defaultpreferencemanager",
-          5000,
-          tab.frame.id
-        )))
-    );
-  }
-
-  async openFrame(tab: TabActor) {
-    if (await tab.elementExists("#truste-show-consent")) {
-      await tab.clickElement("#truste-show-consent");
-    }
-  }
-
-  async navigateToSettings(tab: TabActor, frameId: number) {
-    // wait for it to load
-    await waitFor(
-      async () => {
-        return (
-          (await tab.elementExists(".shp", frameId)) ||
-          (await tab.elementsAreVisible(".advance", "any", frameId)) ||
-          tab.elementExists(".switch span:first-child", frameId)
-        );
-      },
-      10,
-      500
-    );
-    // splash screen -> hit more information
-    if (await tab.elementExists(".shp", frameId)) {
-      await tab.clickElement(".shp", frameId);
-    }
-    await tab.waitForElement(".prefPanel", 5000, frameId);
-    // go to advanced settings if not yet shown
-    if (await tab.elementsAreVisible(".advance", "any", frameId)) {
-      await tab.clickElement(".advance", frameId);
-    }
-    // takes a while to load the opt-in/opt-out buttons
-    return await waitFor(
-      () => tab.elementsAreVisible(".switch span:first-child", "any", frameId),
-      5,
-      1000
-    );
-  }
-
-  async optOut(tab: TabActor) {
-    // await tab.hideElements(['.truste_overlay', '.truste_box_overlay', '.trustarc-banner', '.truste-banner']);
-    if (await tab.elementExists("#truste-consent-required")) {
-      return tab.clickElement("#truste-consent-required");
-    }
-    if (!tab.frame) {
-      await tab.clickElement("#truste-show-consent");
-      await waitFor(
-        async () =>
-          !!tab.frame &&
-          (await tab.elementsAreVisible(".mainContent", "any", tab.frame.id)),
-        50,
-        100
-      );
-    }
-    const frameId = tab.frame!.id;
-    await waitFor(() => tab.eval("document.readyState === 'complete'", frameId), 20, 100);
-    tab.hideElements([".truste_popframe", ".truste_overlay", ".truste_box_overlay", "#truste-consent-track"]);
-    if (await tab.elementExists('.rejectAll', frameId)) {
-      return tab.clickElement('.rejectAll', frameId);
-    }
-    if (await tab.waitForElement('#catDetails0', 1000, frameId)) {
-      await tab.clickElement("#catDetails0", frameId);
-      return tab.clickElement(".submit", frameId);
-    }
-    if (await tab.elementExists(".required", frameId)) {
-      await tab.clickElement(".required", frameId);
-    } else {
-      await this.navigateToSettings(tab, frameId);
-      await tab.clickElements(
-        ".switch span:nth-child(1):not(.active)",
-        frameId
-      );
-      await tab.clickElement(".submit", frameId);
-    }
-    try {
-      await tab.waitForThenClick("#gwt-debug-close_id", 20000, tab.frame.id);
-    } catch (e) {
-      // ignore frame disappearing
-    }
-    return true;
-  }
-
-  async optIn(tab: TabActor) {
-    if (!tab.frame) {
-      await this.openFrame(tab);
-      await waitFor(() => !!tab.frame, 10, 200);
-    }
-    const frameId = tab.frame!.id;
-    await this.navigateToSettings(tab, frameId);
-    await tab.clickElements(".switch span:nth-child(2)", frameId);
-    await tab.clickElement(".submit", frameId);
-    await waitFor(
-      () => tab.elementExists("#gwt-debug-close_id", frameId),
-      300,
-      1000
-    );
-    await tab.clickElement("#gwt-debug-close_id", frameId);
-    return true;
-  }
-
-  async openCmp(tab: TabActor) {
-    await tab.eval("truste.eu.clickListener()");
-    return true;
-  }
-
-  async test() {
-    // TODO: find out how to test TrustArc
-    return true;
-  }
-}

package/lib/config.js

@@ -1 +0,0 @@
-export const enableLogs = false; // change this to enable debug logs

package/lib/consentomatic/index.js

@@ -1,52 +0,0 @@
-export class ConsentOMaticCMP {
-    constructor(name, config) {
-        this.name = name;
-        this.config = config;
-        this.methods = new Map();
-        config.methods.forEach(methodConfig => {
-            if (methodConfig.action) {
-                this.methods.set(methodConfig.name, methodConfig.action);
-            }
-        });
-        this.hasSelfTest = this.methods.has("TEST_CONSENT");
-    }
-    async detectCmp(tab) {
-        return (await Promise.all(this.config.detectors.map(detectorConfig => tab.matches(detectorConfig.presentMatcher)))).some(matched => matched);
-    }
-    async detectPopup(tab) {
-        return (await Promise.all(this.config.detectors.map(detectorConfig => tab.matches(detectorConfig.showingMatcher)))).some(matched => matched);
-    }
-    async executeAction(tab, method, param) {
-        if (this.methods.has(method)) {
-            return tab.executeAction(this.methods.get(method), param);
-        }
-        return true;
-    }
-    async optOut(tab) {
-        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 optIn(tab) {
-        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 openCmp(tab) {
-        await this.executeAction(tab, "HIDE_CMP");
-        await this.executeAction(tab, "OPEN_OPTIONS");
-        return true;
-    }
-    test(tab) {
-        return this.executeAction(tab, "TEST_CONSENT");
-    }
-    detectFrame(tab, frame) {
-        return false;
-    }
-}

package/lib/detector.js

@@ -1,33 +0,0 @@
-import { enableLogs } from './config';
-export default async function detectDialog(tab, retries, rules) {
-    let breakEarly = false;
-    const found = await new Promise(async (resolve) => {
-        let earlyReturn = false;
-        enableLogs && console.log(`${new Date()} [${tab.id}] Detecting CMPs (${rules.length} rules)`);
-        await Promise.all(rules.map(async (r, index) => {
-            try {
-                if (await r.detectCmp(tab)) {
-                    earlyReturn = true;
-                    enableLogs && console.log(`Found CMP in [${tab.id}]: ${r.name}`);
-                    resolve(index);
-                }
-            }
-            catch (e) {
-                breakEarly = true;
-            }
-        }));
-        if (!earlyReturn) {
-            resolve(-1);
-        }
-    });
-    enableLogs && console.log(`${new Date()} CMP detection finished in [${tab.id}], found rule #${found}`);
-    if (found === -1 && retries > 0 && !breakEarly) {
-        return new Promise((resolve) => {
-            setTimeout(async () => {
-                const result = detectDialog(tab, retries - 1, rules);
-                resolve(result);
-            }, 500);
-        });
-    }
-    return found > -1 ? rules[found] : null;
-}

package/lib/detector.ts

@@ -1,34 +0,0 @@
-import { enableLogs } from './config';
-import { AutoCMP, TabActor } from './types';
-
-export default async function detectDialog(tab: TabActor, retries: number, rules: AutoCMP[]): Promise<AutoCMP> {
-  let breakEarly = false;
-  const found: number = await new Promise(async (resolve) => {
-    let earlyReturn = false;
-    enableLogs && console.log(`${new Date()} [${tab.id}] Detecting CMPs (${rules.length} rules)`);
-    await Promise.all(rules.map(async (r, index) => {
-      try {
-        if (await r.detectCmp(tab)) {
-          earlyReturn = true;
-          enableLogs && console.log(`Found CMP in [${tab.id}]: ${r.name}`);
-          resolve(index)
-        }
-      } catch (e) {
-        breakEarly = true;
-      }
-    }));
-    if (!earlyReturn) {
-      resolve(-1)
-    }
-  })
-  enableLogs && console.log(`${new Date()} CMP detection finished in [${tab.id}], found rule #${found}`);
-  if (found === -1 && retries > 0 && !breakEarly) {
-    return new Promise((resolve) => {
-      setTimeout(async () => {
-        const result = detectDialog(tab, retries - 1, rules);
-        resolve(result);
-      }, 500);
-    });
-  }
-  return found > -1 ? rules[found] : null;
-}

package/lib/hider.js

@@ -1,13 +0,0 @@
-// hide rules not specific to a single CMP rule
-const globalHidden = [
-    "#didomi-popup,.didomi-popup-container,.didomi-popup-notice,.didomi-consent-popup-preferences,#didomi-notice,.didomi-popup-backdrop,.didomi-screen-medium",
-];
-export default async function prehideElements(tab, rules) {
-    const selectors = rules.reduce((selectorList, rule) => {
-        if (rule.prehideSelectors) {
-            return [...selectorList, ...rule.prehideSelectors];
-        }
-        return selectorList;
-    }, globalHidden);
-    await tab.hideElements(selectors, undefined, 'opacity');
-}

package/lib/hider.ts

@@ -1,16 +0,0 @@
-import { AutoCMP, TabActor } from './types';
-
-// hide rules not specific to a single CMP rule
-const globalHidden = [
-  "#didomi-popup,.didomi-popup-container,.didomi-popup-notice,.didomi-consent-popup-preferences,#didomi-notice,.didomi-popup-backdrop,.didomi-screen-medium",
-]
-
-export default async function prehideElements(tab: TabActor, rules: AutoCMP[]): Promise<void> {
-    const selectors = rules.reduce((selectorList, rule) => {
-        if (rule.prehideSelectors) {
-          return [...selectorList, ...rule.prehideSelectors];
-        }
-        return selectorList;
-      }, globalHidden);
-    await tab.hideElements(selectors, undefined, 'opacity');
-}

package/lib/index.js

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

package/lib/messages.d.ts

@@ -1,61 +0,0 @@
-export type ContentScriptMessage =
-  | ClickMessage
-  | ElemExistsMessage
-  | ElemVisibleMessage
-  | GetAttributeMessage
-  | EvalMessage
-  | HideMessage
-  | UndoHideMessage
-  | MatchesMessage
-  | ActionMessage;
-
-export type HideMethod = 'display' | 'opacity';
-
-type ClickMessage = {
-  type: "click";
-  selector: string;
-  all?: boolean;
-};
-
-type ElemExistsMessage = {
-  type: "elemExists";
-  selector: string;
-};
-
-type ElemVisibleMessage = {
-  type: "elemVisible";
-  selector: string;
-  check?: "any" | "none" | "all";
-};
-
-type GetAttributeMessage = {
-  type: "getAttribute";
-  selector: string;
-  attribute: string;
-};
-
-type EvalMessage = {
-  type: "eval";
-  script: string;
-};
-
-type HideMessage = {
-  type: "hide";
-  selectors: string[];
-  method: HideMethod;
-};
-
-type UndoHideMessage = {
-  type: "undohide"
-};
-
-type MatchesMessage = {
-  type: "matches";
-  config: any;
-};
-
-type ActionMessage = {
-  type: "executeAction";
-  config: any;
-  param: any;
-};

package/lib/node.js

@@ -1,35 +0,0 @@
-import Tab from './puppet/tab';
-import detectDialog from './detector';
-import TabConsent from './tabwrapper';
-import prehideElements from './hider';
-export * from './index';
-export { ConsentOMaticCMP } from './consentomatic/index';
-export { Tab, detectDialog, TabConsent, };
-export function attachToPage(page, url, rules, retries = 1, prehide = true) {
-    const frames = {
-        0: page.mainFrame(),
-    };
-    const tab = new Tab(page, url, frames);
-    async function onFrame(frame) {
-        const allFrames = await page.frames();
-        allFrames.forEach((frame, frameId) => {
-            const frameMatch = rules.findIndex(r => r.detectFrame(tab, {
-                url: frame.url(),
-            }));
-            if (frameMatch > -1) {
-                tab.frame = {
-                    type: rules[frameMatch].name,
-                    url: frame.url(),
-                    id: frameId,
-                };
-                frames[frameId] = frame;
-            }
-        });
-    }
-    page.on('framenavigated', onFrame);
-    page.frames().forEach(onFrame);
-    if (prehide) {
-        prehideElements(tab, rules);
-    }
-    return new TabConsent(tab, detectDialog(tab, retries, rules));
-}

package/lib/node.ts

@@ -1,43 +0,0 @@
-import Tab from './puppet/tab';
-import detectDialog from './detector';
-import TabConsent from './tabwrapper';
-import { AutoCMP } from './types';
-import prehideElements from './hider';
-
-export * from './index';
-export { ConsentOMaticCMP } from './consentomatic/index';
-export {
-  Tab,
-  detectDialog,
-  TabConsent,
-}
-
-export function attachToPage(page: any, url: string, rules: AutoCMP[], retries = 1, prehide = true) {
-  const frames: { [id: number]: any } = {
-    0: page.mainFrame(),
-  };
-  const tab = new Tab(page, url, frames);
-
-  async function onFrame(frame: any) {
-    const allFrames: any[] = await page.frames();
-    allFrames.forEach((frame, frameId) => {
-      const frameMatch = rules.findIndex(r => r.detectFrame(tab, {
-        url: frame.url(),
-      }));
-      if (frameMatch > -1) {
-        tab.frame = {
-          type: rules[frameMatch].name,
-          url: frame.url(),
-          id: frameId,
-        };
-        frames[frameId] = frame;
-      }
-    })
-  }
-  page.on('framenavigated', onFrame);
-  page.frames().forEach(onFrame);
-  if (prehide) {
-    prehideElements(tab, rules);
-  }
-  return new TabConsent(tab, detectDialog(tab, retries, rules));
-}

package/lib/puppet/tab.js

@@ -1,121 +0,0 @@
-import { waitFor } from '../cmps/base';
-import Tools from '../web/consentomatic/tools';
-import { matches } from '../web/consentomatic/index';
-import { hideElementsUtil, getStyleElementUtil } from '../web/content-utils';
-const DEBUG = false;
-export default class Tab {
-    constructor(page, url, frames) {
-        // puppeteer doesn't have tab IDs
-        this.id = 1;
-        this.page = page;
-        this.url = url;
-        this.frames = frames;
-        this._utilsSnippet = `
-      ${getStyleElementUtil.toString()}
-      ${hideElementsUtil.toString()}
-    `;
-    }
-    async elementExists(selector, frameId = 0) {
-        const elements = await this.frames[frameId].$$(selector);
-        DEBUG && console.log('[exists]', selector, elements.length > 0);
-        return elements.length > 0;
-    }
-    async clickElement(selector, frameId = 0) {
-        if (await this.elementExists(selector, frameId)) {
-            try {
-                const result = await this.frames[frameId].evaluate((s) => {
-                    try {
-                        document.querySelector(s).click();
-                        return true;
-                    }
-                    catch (e) {
-                        return e.toString();
-                    }
-                }, selector);
-                DEBUG && console.log('[click]', selector, result);
-                return result;
-            }
-            catch (e) {
-                return false;
-            }
-        }
-        return false;
-    }
-    async clickElements(selector, frameId = 0) {
-        const elements = await this.frames[frameId].$$(selector);
-        DEBUG && console.log('[click all]', selector);
-        await this.frames[frameId].evaluate((s) => {
-            const elem = document.querySelectorAll(s);
-            elem.forEach(e => e.click());
-        }, selector);
-        return true;
-    }
-    async elementsAreVisible(selector, check, frameId = 0) {
-        if (!await this.elementExists(selector, frameId)) {
-            return false;
-        }
-        const visible = await this.frames[frameId].$$eval(selector, (nodes) => nodes.map((n) => n.offsetParent !== null || window.getComputedStyle(n).display !== "none"));
-        DEBUG && console.log('[visible]', selector, check, visible);
-        if (visible.length === 0) {
-            return false;
-        }
-        else if (check === 'any') {
-            return visible.some(r => r);
-        }
-        else if (check === 'none') {
-            return visible.every(r => !r);
-        }
-        return visible.every(r => r);
-    }
-    async getAttribute(selector, attribute, frameId = 0) {
-        const elem = await this.frames[frameId].$(selector);
-        if (elem) {
-            return (await elem.getProperty(attribute)).jsonValue();
-        }
-    }
-    async eval(script, frameId = 0) {
-        const result = await this.frames[frameId].evaluate(script);
-        DEBUG && console.log('[eval]', script, result);
-        return result;
-    }
-    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') {
-        return await this.frames[frameId].evaluate(`(() => {
-      ${this._utilsSnippet}
-      return hideElementsUtil(${JSON.stringify(selectors)}, '${method}');
-    })()`);
-    }
-    undoHideElements(frameId) {
-        return Promise.resolve(true);
-    }
-    async goto(url) {
-        return this.page.goto(url);
-    }
-    wait(ms) {
-        return new Promise((resolve) => {
-            setTimeout(() => resolve(true), ms);
-        });
-    }
-    matches(options) {
-        const script = `(() => {
-      const Tools = ${Tools.toString()};
-      const matches = ${matches.toString()};
-      return matches(${JSON.stringify(options)})
-    })();
-    `;
-        return this.frames[0].evaluate(script);
-    }
-    executeAction(config, param) {
-        throw new Error("Method not implemented.");
-    }
-}