@duckduckgo/autoconsent 1.0.2

package/lib/messages.d.ts

@@ -0,0 +1,58 @@
+export type ContentScriptMessage =
+  | ClickMessage
+  | ElemExistsMessage
+  | ElemVisibleMessage
+  | GetAttributeMessage
+  | EvalMessage
+  | HideMessage
+  | UndoHideMessage
+  | MatchesMessage
+  | ActionMessage;
+
+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[];
+};
+
+type UndoHideMessage = {
+  type: "undohide"
+};
+
+type MatchesMessage = {
+  type: "matches";
+  config: any;
+};
+
+type ActionMessage = {
+  type: "executeAction";
+  config: any;
+  param: any;
+};

package/lib/node.js

@@ -0,0 +1,30 @@
+import Tab from './puppet/tab';
+import detectDialog from './detector';
+import TabConsent from './tabwrapper';
+export * from './index';
+export { ConsentOMaticCMP } from './consentomatic/index';
+export { Tab, detectDialog, TabConsent, };
+export function attachToPage(page, url, rules, retries = 1) {
+    const frames = {};
+    const tab = new Tab(page, url, frames);
+    frames[0] = page.mainFrame();
+    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);
+    return new TabConsent(tab, detectDialog(tab, retries, rules));
+}

package/lib/node.ts

@@ -0,0 +1,38 @@
+import Tab from './puppet/tab';
+import detectDialog from './detector';
+import TabConsent from './tabwrapper';
+import { AutoCMP } from './types';
+
+export * from './index';
+export { ConsentOMaticCMP } from './consentomatic/index';
+export {
+  Tab,
+  detectDialog,
+  TabConsent,
+}
+
+export function attachToPage(page: any, url: string, rules: AutoCMP[], retries = 1) {
+  const frames: { [id: number]: any } = {};
+  const tab = new Tab(page, url, frames);
+  frames[0] = page.mainFrame();
+  
+  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);
+  return new TabConsent(tab, detectDialog(tab, retries, rules))
+}

package/lib/puppet/tab.js

@@ -0,0 +1,114 @@
+import { waitFor } from '../cmps/base';
+import Tools from '../web/consentomatic/tools';
+import { matches } from '../web/consentomatic/index';
+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;
+    }
+    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) {
+        // TODO implement this
+        return Promise.resolve(true);
+    }
+    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.");
+    }
+}

package/lib/puppet/tab.ts

@@ -0,0 +1,136 @@
+import { waitFor } from '../cmps/base';
+import { TabActor } from '../types';
+import Tools from '../web/consentomatic/tools';
+import { matches } from '../web/consentomatic/index';
+
+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
+  }
+
+  constructor(page: any, url: string, frames: { [id: number]: any }) {
+    this.page = page;
+    this.url = url;
+    this.frames = frames;
+  }
+
+  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) {
+    // TODO implement this
+    return Promise.resolve(true)
+  }
+
+  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

@@ -0,0 +1,80 @@
+
+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

@@ -0,0 +1,61 @@
+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) {
+        const isOpen = await this.rule.detectPopup(this.tab);
+        if (!isOpen && retries > 0) {
+            return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
+        }
+        return isOpen;
+    }
+    async doOptOut() {
+        try {
+            this.optOutStatus = await this.rule.optOut(this.tab);
+            return this.optOutStatus;
+        }
+        catch (e) {
+            this.optOutStatus = e;
+            throw e;
+        }
+        finally {
+            if (!this.rule.isHidingRule) {
+                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

@@ -0,0 +1,68 @@
+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> {
+      const isOpen = await this.rule.detectPopup(this.tab);
+      if (!isOpen && retries > 0) {
+        return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
+      }
+      return isOpen;
+    }
+  
+    async doOptOut() {
+      try {
+        this.optOutStatus = await this.rule.optOut(this.tab);
+        return this.optOutStatus;
+      } catch (e) {
+        this.optOutStatus = e;
+        throw e;
+      } finally {
+        if (!this.rule.isHidingRule) {
+          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

@@ -0,0 +1,61 @@
+import { ContentScriptMessage } 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): 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
+  }
+}