@duckduckgo/autoconsent 1.0.8 → 2.0.0

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));
-        });
-    })
-}