@duckduckgo/autoconsent 15.0.0 → 16.0.0

package/dist/types/cmps/consentomatic.d.ts

@@ -1,34 +0,0 @@
-import { AutoCMP } from '../types';
-import { RunContext } from '../rules';
-export type DetectorConfig = {
-    presentMatcher: any;
-    showingMatcher: any;
-};
-export type MethodConfig = {
-    action?: any;
-    name: string;
-};
-export type ConsentOMaticConfig = {
-    detectors: DetectorConfig[];
-    methods: MethodConfig[];
-};
-export declare class ConsentOMaticCMP implements AutoCMP {
-    name: string;
-    config: ConsentOMaticConfig;
-    methods: Map<string, any>;
-    hasSelfTest: boolean;
-    runContext: RunContext;
-    isCosmetic: boolean;
-    constructor(name: string, config: ConsentOMaticConfig);
-    get isIntermediate(): boolean;
-    checkRunContext(): boolean;
-    checkFrameContext(isTop: boolean): boolean;
-    hasMatchingUrlPattern(): boolean;
-    detectCmp(): Promise<boolean>;
-    detectPopup(): Promise<boolean>;
-    executeAction(method: string, param?: any): Promise<boolean | void>;
-    optOut(): Promise<boolean>;
-    optIn(): Promise<boolean>;
-    openCmp(): Promise<boolean>;
-    test(): Promise<boolean>;
-}

package/dist/types/consentomatic/index.d.ts

@@ -1,2 +0,0 @@
-export declare function matches(config: any): any;
-export declare function executeAction(config: any, param?: any): Promise<boolean | void>;

package/dist/types/consentomatic/tools.d.ts

@@ -1,10 +0,0 @@
-/**
- * This code is in most parts copied from https://github.com/cavi-au/Consent-O-Matic/blob/master/Extension/Tools.js
- * which is licened under the MIT.
- */
-export default class Tools {
-    static base: HTMLElement;
-    static setBase(base: HTMLElement): void;
-    static findElement(options: any, parent?: any, multiple?: boolean): HTMLElement[] | HTMLElement;
-    static find(options: any, multiple?: boolean): any;
-}

package/dist/types/filterlist-engine.d.ts

@@ -1,2 +0,0 @@
-declare const serializedEngine: Uint8Array<ArrayBuffer>;
-export default serializedEngine;

package/dist/types/filterlist-utils.d.ts

@@ -1,4 +0,0 @@
-import { FiltersEngine } from '@ghostery/adblocker';
-export declare function deserializeFilterList(serializedEngine: Uint8Array): FiltersEngine;
-export declare function getCosmeticStylesheet(engine: FiltersEngine): string;
-export declare function getFilterlistSelectors(styles: string): string;

package/dist/types/web-extra.d.ts

@@ -1,11 +0,0 @@
-import AutoConsent from './web';
-export default class AutoConsentExtra extends AutoConsent {
-    initializeFilterList(): void;
-    undoCosmetics(): void;
-    filterListFallback(): boolean;
-    /**
-     * Apply cosmetic filters
-     * @returns true if the filters were applied, false otherwise
-     */
-    applyCosmeticFilters(styles?: string): Promise<boolean>;
-}

package/lib/cmps/consentomatic.ts

@@ -1,97 +0,0 @@
-import { AutoCMP } from '../types';
-import { executeAction, matches } from '../consentomatic';
-import { RunContext } from '../rules';
-import { defaultRunContext } from './base';
-
-export type DetectorConfig = {
-    presentMatcher: any;
-    showingMatcher: any;
-};
-export type MethodConfig = {
-    action?: any;
-    name: string;
-};
-
-export type ConsentOMaticConfig = {
-    detectors: DetectorConfig[];
-    methods: MethodConfig[];
-};
-
-export class ConsentOMaticCMP implements AutoCMP {
-    methods = new Map<string, any>();
-    hasSelfTest: boolean;
-    runContext: RunContext = defaultRunContext;
-    isCosmetic = false;
-
-    constructor(
-        public name: string,
-        public config: ConsentOMaticConfig,
-    ) {
-        config.methods.forEach((methodConfig) => {
-            if (methodConfig.action) {
-                this.methods.set(methodConfig.name, methodConfig.action);
-            }
-        });
-        this.hasSelfTest = false;
-    }
-
-    get isIntermediate(): boolean {
-        return false; // TODO: support UTILITY rules
-    }
-
-    checkRunContext(): boolean {
-        return true;
-    }
-
-    checkFrameContext(isTop: boolean): boolean {
-        return true;
-    }
-
-    hasMatchingUrlPattern(): boolean {
-        return false;
-    }
-
-    async detectCmp(): Promise<boolean> {
-        const matchResults = this.config.detectors.map((detectorConfig) => matches(detectorConfig.presentMatcher));
-        return matchResults.some((r) => !!r);
-    }
-
-    async detectPopup(): Promise<boolean> {
-        const matchResults = this.config.detectors.map((detectorConfig) => matches(detectorConfig.showingMatcher));
-        return matchResults.some((r) => !!r);
-    }
-
-    async executeAction(method: string, param?: any) {
-        if (this.methods.has(method)) {
-            return executeAction(this.methods.get(method), param);
-        }
-        return true;
-    }
-
-    async optOut(): Promise<boolean> {
-        await this.executeAction('HIDE_CMP');
-        await this.executeAction('OPEN_OPTIONS');
-        await this.executeAction('HIDE_CMP');
-        await this.executeAction('DO_CONSENT', []);
-        await this.executeAction('SAVE_CONSENT');
-        return true;
-    }
-
-    async optIn(): Promise<boolean> {
-        await this.executeAction('HIDE_CMP');
-        await this.executeAction('OPEN_OPTIONS');
-        await this.executeAction('HIDE_CMP');
-        await this.executeAction('DO_CONSENT', ['D', 'A', 'B', 'E', 'F', 'X']);
-        await this.executeAction('SAVE_CONSENT');
-        return true;
-    }
-    async openCmp(): Promise<boolean> {
-        await this.executeAction('HIDE_CMP');
-        await this.executeAction('OPEN_OPTIONS');
-        return true;
-    }
-
-    async test(): Promise<boolean> {
-        return true;
-    }
-}

package/lib/consentomatic/index.ts

@@ -1,252 +0,0 @@
-import Tools from "./tools";
-
-export function matches(config: any) {
-  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: any, param?: any): Promise<boolean | void> {
-  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();
-    case "wait":
-      return waitAction(config);
-    case "eval":
-      return evalAction(config);
-    default:
-      throw new Error("Unknown action type: " + config.type);
-  }
-}
-
-const STEP_TIMEOUT = 0;
-
-function waitTimeout(timeout: number): Promise<void> {
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve();
-    }, timeout);
-  });
-}
-
-async function clickAction(config: any) {
-  const result = Tools.find(config);
-  if (result.target != null) {
-    result.target.click();
-  }
-  return waitTimeout(STEP_TIMEOUT);
-}
-
-async function listAction(config: any, param: any) {
-  for (const action of config.actions) {
-    await executeAction(action, param);
-  }
-}
-
-async function consentAction(config: any, consentTypes: any) {
-  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: any, param: any) {
-  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: any) {
-  await new Promise<void>(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: any, param: any) {
-  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: any) {
-  const result = Tools.find(config);
-  if (result.target) {
-    result.target.classList.add("Autoconsent-Hidden");
-    // result.target.setAttribute("style", "display: none;");
-  }
-}
-
-async function slideAction(config: any) {
-  const result = Tools.find(config);
-  const dragResult = Tools.find(config.dragTarget);
-  if (result.target) {
-    const targetBounds = result.target.getBoundingClientRect();
-    const 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;
-    }
-
-    const screenX = window.screenX + targetBounds.left + targetBounds.width / 2.0;
-    const screenY = window.screenY + targetBounds.top + targetBounds.height / 2.0;
-    const clientX = targetBounds.left + targetBounds.width / 2.0;
-    const clientY = targetBounds.top + targetBounds.height / 2.0;
-
-    const mouseDown = document.createEvent("MouseEvents");
-    mouseDown.initMouseEvent(
-      "mousedown",
-      true,
-      true,
-      window,
-      0,
-      screenX,
-      screenY,
-      clientX,
-      clientY,
-      false,
-      false,
-      false,
-      false,
-      0,
-      result.target
-    );
-    const 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
-    );
-    const 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: any) {
-  await waitTimeout(config.waitTime);
-}
-
-async function closeAction() {
-  window.close();
-}
-
-async function evalAction(config: any): Promise<boolean> {
-  console.log("eval!", config.code);
-  return new Promise(resolve => {
-    try {
-      if (config.async) {
-        // eslint-disable-next-line no-eval
-        window.eval(config.code);
-        setTimeout(() => {
-          // eslint-disable-next-line no-eval
-          resolve(window.eval("window.__consentCheckResult"));
-        }, config.timeout || 250);
-      } else {
-        // eslint-disable-next-line no-eval
-        resolve(window.eval(config.code));
-      }
-    } catch (e) {
-      console.warn("eval error", e, config.code);
-      resolve(false);
-    }
-  });
-}

package/lib/consentomatic/tools.ts

@@ -1,199 +0,0 @@
-/**
- * This code is in most parts copied from https://github.com/cavi-au/Consent-O-Matic/blob/master/Extension/Tools.js
- * which is licened under the MIT. 
- */
-export default class Tools {
-  static base: HTMLElement = null;
-
-  static setBase(base: HTMLElement) {
-    Tools.base = base;
-  }
-
-  static findElement(options: any, parent: any = null, multiple = false): HTMLElement[] | HTMLElement {
-    let possibleTargets = null;
-
-    if (parent != null) {
-      possibleTargets = Array.from(parent.querySelectorAll(options.selector));
-    } else {
-      if (Tools.base != null) {
-        possibleTargets = Array.from(
-          Tools.base.querySelectorAll(options.selector)
-        );
-      } else {
-        possibleTargets = Array.from(
-          document.querySelectorAll(options.selector)
-        );
-      }
-    }
-
-    if (options.textFilter != null) {
-      possibleTargets = possibleTargets.filter(possibleTarget => {
-        const textContent = possibleTarget.textContent.toLowerCase();
-
-        if (Array.isArray(options.textFilter)) {
-          let foundText = false;
-
-          for (const text of options.textFilter) {
-            if (textContent.indexOf(text.toLowerCase()) !== -1) {
-              foundText = true;
-              break;
-            }
-          }
-
-          return foundText;
-        } else if (options.textFilter != null) {
-          return textContent.indexOf(options.textFilter.toLowerCase()) !== -1;
-        }
-        return false;
-      });
-    }
-
-    if (options.styleFilters != null) {
-      possibleTargets = possibleTargets.filter(possibleTarget => {
-        const styles = window.getComputedStyle(possibleTarget);
-
-        let keep = true;
-
-        for (const styleFilter of options.styleFilters) {
-          const option = styles[styleFilter.option];
-
-          if (styleFilter.negated) {
-            keep = keep && option !== styleFilter.value;
-          } else {
-            keep = keep && option === styleFilter.value;
-          }
-        }
-
-        return keep;
-      });
-    }
-
-    if (options.displayFilter != null) {
-      possibleTargets = possibleTargets.filter(possibleTarget => {
-        if (options.displayFilter) {
-          // We should be displayed
-          return possibleTarget.offsetHeight !== 0;
-        } else {
-          // We should not be displayed
-          return possibleTarget.offsetHeight === 0;
-        }
-      });
-    }
-
-    if (options.iframeFilter != null) {
-      possibleTargets = possibleTargets.filter((/* possibleTarget */) => {
-        if (options.iframeFilter) {
-          // We should be inside an iframe
-          return window.location !== window.parent.location;
-        } else {
-          // We should not be inside an iframe
-          return window.location === window.parent.location;
-        }
-      });
-    }
-
-    if (options.childFilter != null) {
-      possibleTargets = possibleTargets.filter(possibleTarget => {
-        const oldBase = Tools.base;
-        Tools.setBase(possibleTarget);
-        const childResults = Tools.find(options.childFilter);
-        Tools.setBase(oldBase);
-        return childResults.target != null;
-      });
-    }
-
-    if (multiple) {
-      return possibleTargets;
-    } else {
-      if (possibleTargets.length > 1) {
-        console.warn(
-          "Multiple possible targets: ",
-          possibleTargets,
-          options,
-          parent
-        );
-      }
-
-      return possibleTargets[0];
-    }
-  }
-
-  static find(options: any, multiple = false) {
-    const results: any[] = [];
-    if (options.parent != null) {
-      const parent = Tools.findElement(options.parent, null, multiple);
-      if (parent != null) {
-        if (parent instanceof Array) {
-          parent.forEach(p => {
-            const targets = Tools.findElement(options.target, p, multiple);
-            if (targets instanceof Array) {
-              targets.forEach(target => {
-                results.push({
-                  parent: p,
-                  target
-                });
-              });
-            } else {
-              results.push({
-                parent: p,
-                target: targets
-              });
-            }
-          });
-
-          return results;
-        } else {
-          const targets = Tools.findElement(options.target, parent, multiple);
-          if (targets instanceof Array) {
-            targets.forEach(target => {
-              results.push({
-                parent,
-                target
-              });
-            });
-          } else {
-            results.push({
-              parent,
-              target: targets
-            });
-          }
-        }
-      }
-    } else {
-      const targets = Tools.findElement(options.target, null, multiple);
-      if (targets instanceof Array) {
-        targets.forEach(target => {
-          results.push({
-            parent: null,
-            target
-          });
-        });
-      } else {
-        results.push({
-          parent: null,
-          target: targets
-        });
-      }
-    }
-
-    if (results.length === 0) {
-      results.push({
-        parent: null,
-        target: null
-      });
-    }
-
-    if (multiple) {
-      return results;
-    } else {
-      if (results.length !== 1) {
-        console.warn(
-          "Multiple results found, even though multiple false",
-          results
-        );
-      }
-
-      return results[0];
-    }
-  }
-}