@duckduckgo/autoconsent 14.97.0 → 15.0.0

package/lib/heuristics.ts

@@ -1,5 +1,12 @@
-import { DETECT_PATTERNS, NEVER_MATCH_PATTERNS, REJECT_PATTERNS } from './heuristic-patterns';
-import { ButtonData, PopupData } from './types';
+import {
+    ACCEPT_PATTERNS,
+    ACKNOWLEDGE_PATTERNS,
+    DETECT_PATTERNS,
+    NEVER_MATCH_PATTERNS,
+    REJECT_PATTERNS,
+    SETTINGS_PATTERNS,
+} from './heuristic-patterns';
+import { ButtonData, ButtonRegexClassification, PopupData, PopupHandlingMode, PopupHandlingModes } from './types';
 import { isElementVisible, isTopFrame } from './utils';
 
 const BUTTON_LIKE_ELEMENT_SELECTOR = 'button, input[type="button"], input[type="submit"], a, [role="button"], [class*="button"]';
@@ -21,52 +28,78 @@ export function checkHeuristicPatterns(allText: string, detectPatterns = DETECT_
     return { patterns, snippets };
 }
 
-export function getActionablePopups(timeout = POPUP_SEARCH_MAX_TIME): PopupData[] {
+export function getActionablePopups(mode: PopupHandlingMode = PopupHandlingModes.Reject, timeout = POPUP_SEARCH_MAX_TIME): PopupData[] {
     const popups = getPotentialPopups(timeout);
     const result = popups.reduce((acc, popup) => {
         const popupText = popup.text?.trim();
         if (popupText) {
             const { patterns } = checkHeuristicPatterns(popupText);
             if (patterns.length > 0) {
-                const { rejectButtons, otherButtons } = classifyButtons(popup.buttons);
-                if (rejectButtons.length > 0) {
-                    acc.push({
-                        ...popup,
-                        rejectButtons,
-                        otherButtons,
-                    });
-                }
+                classifyButtons(popup.buttons);
+                popup.regexClassification = classifyPopup(popup.buttons);
+                acc.push({
+                    ...popup,
+                });
             }
         }
         return acc;
     }, [] as PopupData[]);
-    return result;
+    // popups filtered by mode and sorted so a popup with reject will always win.
+    return result
+        .filter(
+            (popup) =>
+                popup.regexClassification !== undefined &&
+                popup.regexClassification !== PopupHandlingModes.None &&
+                popup.regexClassification <= mode,
+        )
+        .sort((a, b) => (a.regexClassification ?? 0) - (b.regexClassification ?? 0));
 }
 
-export function classifyButtons(buttons: ButtonData[]): { rejectButtons: ButtonData[]; otherButtons: ButtonData[] } {
-    const rejectButtons = [];
-    const otherButtons = [];
+export function classifyButtons(buttons: ButtonData[]) {
     for (const button of buttons) {
-        if (isRejectButton(button.text)) {
-            rejectButtons.push(button);
-        } else {
-            otherButtons.push(button);
-        }
+        button.regexClassification = classifyButtonTextRegex(button.text);
+    }
+}
+
+function classifyPopup(buttons: ButtonData[]): PopupHandlingMode {
+    const { reject, settings, accept, acknowledge } = buttons.reduce(
+        (acc, button) => {
+            if (button.regexClassification && button.regexClassification !== 'other') {
+                acc[button.regexClassification]++;
+            }
+            return acc;
+        },
+        { reject: 0, settings: 0, accept: 0, acknowledge: 0 },
+    );
+    if (reject > 0) {
+        return PopupHandlingModes.Reject;
+    }
+    if (settings > 0) {
+        return PopupHandlingModes.None;
     }
-    return {
-        rejectButtons,
-        otherButtons,
-    };
+    if (acknowledge > 0) {
+        return PopupHandlingModes.Tier1;
+    }
+    if (accept > 0) {
+        return accept === 1 ? PopupHandlingModes.Tier2 : PopupHandlingModes.None;
+    }
+    return PopupHandlingModes.None;
 }
 
-export function isRejectButton(buttonText: string, rejectPatterns = REJECT_PATTERNS, neverMatchPatterns = NEVER_MATCH_PATTERNS): boolean {
+/**
+ * @param {string} buttonText
+ * @param {Array<string|RegExp>} matchPatterns
+ * @param {Array<string|RegExp>} neverMatchPatterns
+ * @returns {boolean}
+ */
+function testButtonMatches(buttonText: string, matchPatterns: (string | RegExp)[], neverMatchPatterns: (string | RegExp)[]): boolean {
     if (!buttonText) {
         return false;
     }
     const cleanedButtonText = cleanButtonText(buttonText);
     return (
-        !neverMatchPatterns.some((p) => p.test(cleanedButtonText)) &&
-        rejectPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText)
+        !neverMatchPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText) &&
+        matchPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText)
     );
 }
 
@@ -89,6 +122,22 @@ export function cleanButtonText(buttonText: string): string {
     return result;
 }
 
+export function classifyButtonTextRegex(buttonText: string): ButtonRegexClassification {
+    if (testButtonMatches(buttonText, REJECT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'reject';
+    }
+    if (testButtonMatches(buttonText, SETTINGS_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'settings';
+    }
+    if (testButtonMatches(buttonText, ACCEPT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'accept';
+    }
+    if (testButtonMatches(buttonText, ACKNOWLEDGE_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'acknowledge';
+    }
+    return 'other';
+}
+
 function getPotentialPopups(timeout = POPUP_SEARCH_MAX_TIME) {
     const isFramed = !isTopFrame();
     // do not inspect frames that are more than one level deep

package/lib/types.ts

@@ -78,6 +78,7 @@ export type Config = {
     };
     performanceLoggingEnabled: boolean;
     heuristicPopupSearchTimeout: number;
+    heuristicMode: PopupHandlingMode; // controls the behavior of the heuristic popup detection. Has no effect if enableHeuristicDetection is false.
 };
 
 export type LifecycleState =
@@ -114,15 +115,32 @@ export type ConsentState = {
     performance?: Record<string, number[]>;
 };
 
+export type ButtonRegexClassification = 'reject' | 'settings' | 'accept' | 'acknowledge' | 'other';
+
 export interface ButtonData {
     text: string;
     element: HTMLElement;
+    regexClassification?: ButtonRegexClassification;
 }
 
 export interface PopupData {
     text: string;
     element: HTMLElement;
     buttons: ButtonData[];
-    rejectButtons?: ButtonData[];
-    otherButtons?: ButtonData[];
+    regexClassification?: PopupHandlingMode;
 }
+
+/**
+ * Controls the behavior of the heuristic popup detection.
+ *  - Reject: Will click the reject button on a popup if it exists.
+ *  - Tier1: Will also click the acknowledge button on a popup if it exists, and no Reject button exists.
+ *  - Tier2: Will also click the accept button on a popup if it exists, and no Reject or Acknowledge button exists.
+ *  - None: Disabled
+ */
+export const PopupHandlingModes = {
+    None: -1,
+    Reject: 0,
+    Tier1: 1,
+    Tier2: 2,
+} as const;
+export type PopupHandlingMode = (typeof PopupHandlingModes)[keyof typeof PopupHandlingModes];

package/lib/utils.ts

@@ -1,5 +1,5 @@
 import { HideMethod } from './rules';
-import { Config } from './types';
+import { Config, PopupHandlingModes } from './types';
 
 // get or create a style container for CSS overrides
 export function getStyleElement(styleOverrideElementId = 'autoconsent-css-rules'): HTMLStyleElement {
@@ -95,6 +95,7 @@ export function normalizeConfig(providedConfig: any): Config {
         },
         performanceLoggingEnabled: false,
         heuristicPopupSearchTimeout: 100,
+        heuristicMode: PopupHandlingModes.Reject,
     };
     const updatedConfig: Config = copyObject(defaultConfig);
     // filter out any unknown entries

package/lib/web.ts

@@ -296,7 +296,9 @@ export default class AutoConsent {
         });
         // heuristic CMP is only run in the top frame and only if heuristic action is enabled and retries is odd
         const heuristicRules =
-            isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0 ? [new AutoConsentHeuristicCMP(this)] : [];
+            isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0
+                ? [new AutoConsentHeuristicCMP(this, this.config.heuristicMode)]
+                : [];
 
         const rulesPriorityStages: [string, AutoCMP[]][] = [
             ['site-specific', siteSpecificRules],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "14.97.0",
+  "version": "15.0.0",
   "description": "",
   "types": "./dist/types/web.d.ts",
   "exports": {

package/rules/autoconsent/twitch.json

@@ -1,7 +1,7 @@
 {
     "name": "twitch.tv",
     "runContext": {
-        "urlPattern": "^https?://(www\\.)?twitch\\.tv"
+        "urlPattern": "^https?://([\\w-]+\\.)?twitch\\.tv"
     },
     "prehideSelectors": [
         "div:has(> .consent-banner .consent-banner__content--gdpr-v2),.ReactModalPortal:has([data-a-target=consent-modal-save])"