@duckduckgo/autoconsent 1.0.6 → 2.0.0

package/lib/puppet/tab.ts

@@ -1,146 +0,0 @@
-import { waitFor } from '../cmps/base';
-import { TabActor } from '../types';
-import Tools from '../web/consentomatic/tools';
-import { matches } from '../web/consentomatic/index';
-import { HideMethod } from '../messages';
-import { hideElementsUtil, getStyleElementUtil } from '../web/content-utils';
-
-const DEBUG = false;
-
-export default class Tab implements TabActor {
-  // puppeteer doesn't have tab IDs
-  id = 1
-  page: any
-  url: any
-  frames: { [id: number]: any }
-  frame: {
-    type: string
-    id: number
-    url: string
-  }
-
-  _utilsSnippet: string // serialized RPC functions borrowed from content script
-
-  constructor(page: any, url: string, frames: { [id: number]: any }) {
-    this.page = page;
-    this.url = url;
-    this.frames = frames;
-    this._utilsSnippet = `
-      ${getStyleElementUtil.toString()}
-      ${hideElementsUtil.toString()}
-    `;
-  }
-
-  async elementExists(selector: string, frameId = 0) {
-    const elements = await this.frames[frameId].$$(selector)
-    DEBUG && console.log('[exists]', selector, elements.length > 0);
-    return elements.length > 0;
-  }
-
-  async clickElement(selector: string, frameId = 0) {
-    if (await this.elementExists(selector, frameId)) {
-      try {
-        const result = await this.frames[frameId].evaluate((s: string) => {
-          try {
-            (document.querySelector(s) as HTMLElement).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: string, frameId = 0) {
-    const elements = await this.frames[frameId].$$(selector);
-    DEBUG && console.log('[click all]', selector);
-    await this.frames[frameId].evaluate((s: string) => {
-      const elem = document.querySelectorAll<HTMLElement>(s);
-      elem.forEach(e => e.click());
-    }, selector)
-    return true;
-  }
-
-  async elementsAreVisible(selector: string, check: 'all' | 'any' | 'none', frameId = 0) {
-    if (!await this.elementExists(selector, frameId)) {
-      return false;
-    }
-    const visible: boolean[] = await this.frames[frameId].$$eval(selector, (nodes: any) => nodes.map((n: any) => 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: string, attribute: string, frameId = 0) {
-    const elem = await this.frames[frameId].$(selector);
-    if (elem) {
-      return (await elem.getProperty(attribute)).jsonValue();
-    }
-  }
-
-  async eval(script: string, frameId = 0) {
-    const result = await this.frames[frameId].evaluate(script);
-    DEBUG && console.log('[eval]', script, result);
-    return result
-  }
-
-  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') {
-    return await this.frames[frameId].evaluate(`(() => {
-      ${this._utilsSnippet}
-      return hideElementsUtil(${JSON.stringify(selectors)}, '${method}');
-    })()`);
-  }
-
-  undoHideElements(frameId?: number): Promise<boolean> {
-    return Promise.resolve(true)
-  }
-
-  async goto(url: string) {
-    return this.page.goto(url);
-  }
-
-  wait(ms: number): Promise<true> {
-    return new Promise((resolve) => {
-      setTimeout(() => resolve(true), ms);
-    });
-  }
-
-  matches(options: any): Promise<boolean> {
-    const script = `(() => {
-      const Tools = ${Tools.toString()};
-      const matches = ${matches.toString()};
-      return matches(${JSON.stringify(options)})
-    })();
-    `
-    return this.frames[0].evaluate(script)
-  }
-
-  executeAction(config: any, param?: any): Promise<boolean> {
-    throw new Error("Method not implemented.");
-  }
-}

package/lib/rules.d.ts

@@ -1,80 +0,0 @@
-
-export type AutoConsentCMPRule = {
-  name: string
-  prehideSelectors?: string[]
-  isHidingRule?: boolean
-  detectCmp: AutoConsentRuleStep[]
-  detectPopup: AutoConsentRuleStep[]
-  frame?: string
-  optOut: AutoConsentRuleStep[]
-  optIn: AutoConsentRuleStep[]
-  openCmp?: AutoConsentRuleStep[]
-  test?: AutoConsentRuleStep[]
-}
-
-export type AutoConsentRuleStep = { frame?: boolean; optional?: boolean } & Partial<
-  ElementExistsRule
-> &
-  Partial<ElementVisibleRule> &
-  Partial<EvalRule> &
-  Partial<WaitForRule> &
-  Partial<ClickRule> &
-  Partial<WaitForThenClickRule> &
-  Partial<WaitRule> &
-  Partial<UrlRule> &
-  Partial<GotoUrlRule> &
-  Partial<HideRule> &
-  Partial<UndoHideRule> &
-  Partial<WaitForFrameRule>;
-
-type ElementExistsRule = {
-  exists: string;
-};
-
-type ElementVisibleRule = {
-  visible: string;
-  check?: "any" | "all" | "none";
-};
-
-type EvalRule = {
-  eval: string;
-};
-
-type WaitForRule = {
-  waitFor: string;
-  timeout?: number;
-};
-
-type ClickRule = {
-  click: string;
-  all?: boolean;
-};
-
-type WaitForThenClickRule = {
-  waitForThenClick: string;
-  timeout?: number;
-};
-
-type WaitRule = {
-  wait: number;
-};
-
-type UrlRule = {
-  url: string;
-};
-
-type GotoUrlRule = {
-  goto: string;
-};
-
-type HideRule = {
-  hide: string[];
-};
-
-type UndoHideRule = {
-  undoHide: boolean;
-}
-
-type WaitForFrameRule = {
-  waitForFrame: true
-};

package/lib/tabwrapper.js

@@ -1,67 +0,0 @@
-import { enableLogs } from './config';
-export default class TabConsent {
-    constructor(tab, ruleCheckPromise) {
-        this.tab = tab;
-        this.optOutStatus = null;
-        this.checked = ruleCheckPromise;
-        ruleCheckPromise.then(rule => this.rule = rule);
-    }
-    getCMPName() {
-        if (this.rule) {
-            return this.rule.name;
-        }
-        return null;
-    }
-    async isPopupOpen(retries = 1, interval = 1000) {
-        enableLogs && console.log('checking if popup is open...', this.tab.id, this.rule.name);
-        const isOpen = await this.rule.detectPopup(this.tab);
-        if (!isOpen && retries > 0) {
-            return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
-        }
-        enableLogs && console.log(`popup is ${isOpen ? 'open' : 'not open'}`);
-        return isOpen;
-    }
-    async doOptOut() {
-        try {
-            enableLogs && console.log(`doing opt out ${this.getCMPName()} in tab ${this.tab.id}`);
-            this.optOutStatus = await this.rule.optOut(this.tab);
-            return this.optOutStatus;
-        }
-        catch (e) {
-            console.error('error during opt out', e);
-            this.optOutStatus = e;
-            throw e;
-        }
-        finally {
-            if (!this.rule.isHidingRule) {
-                enableLogs && console.log('unhiding elements');
-                if (this.getCMPName().startsWith('com_')) {
-                    this.tab.wait(5000).then(() => this.tab.undoHideElements());
-                }
-                else {
-                    await this.tab.undoHideElements();
-                }
-            }
-        }
-    }
-    async doOptIn() {
-        try {
-            return this.rule.optIn(this.tab);
-        }
-        finally {
-            if (!this.rule.isHidingRule) {
-                await this.tab.undoHideElements();
-            }
-        }
-    }
-    hasTest() {
-        return !!this.rule.hasSelfTest;
-    }
-    async testOptOutWorked() {
-        return this.rule.test(this.tab);
-    }
-    async applyCosmetics(selectors) {
-        const hidden = await this.tab.hideElements(selectors);
-        return hidden;
-    }
-}

package/lib/tabwrapper.ts

@@ -1,74 +0,0 @@
-import { enableLogs } from './config';
-import { AutoCMP, TabActor } from './types';
-
-export default class TabConsent {
-    checked: Promise<AutoCMP>
-    rule: AutoCMP
-    optOutStatus: boolean | Error = null
-  
-    constructor(public tab: TabActor, ruleCheckPromise: Promise<AutoCMP>) {
-      this.checked = ruleCheckPromise;
-      ruleCheckPromise.then(rule => this.rule = rule);
-    }
-  
-    getCMPName() {
-      if (this.rule) {
-        return this.rule.name;
-      }
-      return null;
-    }
-  
-    async isPopupOpen(retries = 1, interval = 1000): Promise<boolean> {
-      enableLogs && console.log('checking if popup is open...', this.tab.id, this.rule.name);
-      const isOpen = await this.rule.detectPopup(this.tab);
-      if (!isOpen && retries > 0) {
-        return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
-      }
-      enableLogs && console.log(`popup is ${isOpen ? 'open' : 'not open'}`);
-      return isOpen;
-    }
-  
-    async doOptOut() {
-      try {
-        enableLogs && console.log(`doing opt out ${this.getCMPName()} in tab ${this.tab.id}`);
-        this.optOutStatus = await this.rule.optOut(this.tab);
-        return this.optOutStatus;
-      } catch (e) {
-        console.error('error during opt out', e);
-        this.optOutStatus = e;
-        throw e;
-      } finally {
-        if (!this.rule.isHidingRule) {
-          enableLogs && console.log('unhiding elements');
-          if (this.getCMPName().startsWith('com_')) {
-            this.tab.wait(5000).then(() => this.tab.undoHideElements())
-          } else {
-            await this.tab.undoHideElements();
-          }
-        }
-      }
-    }
-  
-    async doOptIn() {
-      try {
-        return this.rule.optIn(this.tab);
-      } finally {
-        if (!this.rule.isHidingRule) {
-          await this.tab.undoHideElements();
-        }
-      }
-    }
-  
-    hasTest() {
-      return !!this.rule.hasSelfTest
-    }
-  
-    async testOptOutWorked() {
-      return this.rule.test(this.tab);
-    }
-  
-    async applyCosmetics(selectors: string[]) {
-      const hidden = await this.tab.hideElements(selectors);
-      return hidden;
-    }
-  }

package/lib/types.d.ts

@@ -1,61 +0,0 @@
-import { ContentScriptMessage, HideMethod } from "./messages";
-
-type Tab = {
-  url: string
-}
-
-type BrowserTabs = {
-  get(tabId: number): Promise<Tab>
-  update(tabId: number, options: any): Promise<void>
-}
-
-export type Browser = {
-  tabs: BrowserTabs,
-}
-
-export interface TabActor {
-  frame?: {
-    id: number
-    url: string
-  }
-  id: number
-  elementExists(selector: string, frameId?: number): Promise<boolean>
-  clickElement(selector: string, frameId?: number): Promise<boolean>
-  clickElements(selector: string, frameId?: number): Promise<boolean>
-  elementsAreVisible(selector: string, check?: 'all' | 'any' | 'none', frameId?: number): Promise<boolean>
-  getAttribute(selector: string, attribute: string, frameId?: number): Promise<string>
-  eval(script: string, frameId?: number): Promise<boolean>
-  waitForElement(selector: string, timeout: number, frameId?: number): Promise<boolean>
-  waitForThenClick(selector: string, timeout?: number, frameId?: number): Promise<boolean>
-  hideElements(selectors: string[], frameId?: number, method?: HideMethod): Promise<boolean>
-  undoHideElements(frameId?: number): Promise<boolean>
-  goto(url: string): Promise<void>
-  wait(ms: number): Promise<true>
-
-  // Consent-O-Matic methods
-  matches(matcherConfig: any): Promise<boolean>
-  executeAction(actionConfig: any, param?: any): Promise<boolean>
-}
-
-export type MessageSender<ResultType = any> = (tabId: number, message: ContentScriptMessage, options?: { frameId: number }) => Promise<ResultType>;
-
-export interface AutoCMP {
-  name: string
-  hasSelfTest: boolean
-  prehideSelectors?: string[]
-  isHidingRule?: boolean
-  detectCmp(tab: TabActor): Promise<boolean>
-  detectPopup(tab: TabActor): Promise<boolean>
-  optOut(tab:TabActor): Promise<boolean>
-  optIn(tab: TabActor): Promise<boolean>
-  openCmp(tab: TabActor): Promise<boolean>
-  test(tab: TabActor): Promise<boolean>
-  detectFrame(tab: TabActor, frame: { url: string }): boolean
-}
-
-type FindResult = {
-  parent?: any
-  target?: {
-    checked: boolean
-  }
-}

package/lib/web/consentomatic/index.js

@@ -1,188 +0,0 @@
-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);
-        }
-    });
-}