@duckduckgo/autoconsent 14.3.0 → 14.4.0

package/lib/encoding.ts

@@ -137,11 +137,29 @@ export function decodeRules(encoded: CompactCMPRuleset): AutoConsentCMPRule[] {
     if (encoded.v > 1) {
         throw new Error('Unsupported rule format.');
     }
-    function decodeRuleStep(step: CompactCMPRuleStep): AutoConsentRuleStep {
+    return encoded.r.filter((r) => r[0] <= SUPPORTED_RULE_STEP_VERSION).map((rule) => new CompactedCMPRule(rule, encoded.s));
+}
+
+class CompactedCMPRule implements AutoConsentCMPRule {
+    r: CompactCMPRule;
+    s: string[];
+    intermediate = false;
+    optIn = [];
+
+    constructor(rule: CompactCMPRule, strings: string[]) {
+        this.r = rule;
+        this.s = strings;
+        if (this.r[10] && this.r[10].intermediate) {
+            this.intermediate = this.r[10].intermediate;
+        }
+    }
+
+    _decodeRuleStep(step: CompactCMPRuleStep): AutoConsentRuleStep {
         const clonedStep: CompactCMPRuleStep = { ...step };
+        const decodeRuleStep = this._decodeRuleStep.bind(this);
         for (const [longKey, shortKey] of compactedRuleSteps) {
             if (clonedStep[shortKey] !== undefined) {
-                clonedStep[longKey] = encoded.s[clonedStep[shortKey]];
+                clonedStep[longKey] = this.s[clonedStep[shortKey]];
                 delete clonedStep[shortKey];
             }
         }
@@ -157,48 +175,50 @@ export function decodeRules(encoded: CompactCMPRuleset): AutoConsentCMPRule[] {
         }
         return { ...clonedStep };
     }
-    return encoded.r
-        .filter((r) => r[0] <= SUPPORTED_RULE_STEP_VERSION)
-        .map((rule) => {
-            const [
-                minimumRuleStepVersion,
-                name,
-                cosmetic,
-                urlPattern,
-                mainFrame,
-                prehideSelectors,
-                detectCmp,
-                detectPopup,
-                optOut,
-                test,
-                extra,
-            ] = rule;
-            const optIn: AutoConsentRuleStep[] = [];
-            const runContext: RunContext = {};
-            const runInMainFrame = decodeNullableBoolean((Math.floor(mainFrame / 10) % 10) as CompactNullableBoolean);
-            const runInSubFrame = decodeNullableBoolean((mainFrame % 10) as CompactNullableBoolean);
-            if (runInMainFrame !== undefined) {
-                runContext.main = runInMainFrame;
-            }
-            if (runInSubFrame !== undefined) {
-                runContext.frame = runInSubFrame;
-            }
-            if (urlPattern !== '') {
-                runContext.urlPattern = urlPattern;
-            }
 
-            return {
-                name,
-                cosmetic: decodeNullableBoolean(cosmetic),
-                runContext,
-                prehideSelectors: prehideSelectors.map((i) => encoded.s[i].toString()),
-                detectCmp: detectCmp.map(decodeRuleStep),
-                detectPopup: detectPopup.map(decodeRuleStep),
-                optOut: optOut.map(decodeRuleStep),
-                optIn,
-                test: test?.map(decodeRuleStep),
-                minimumRuleStepVersion: minimumRuleStepVersion || undefined,
-                ...extra,
-            };
-        });
+    get name() {
+        return this.r[1];
+    }
+
+    get cosmetic() {
+        return decodeNullableBoolean(this.r[2]);
+    }
+
+    get runContext() {
+        const runContext: RunContext = {};
+        const urlPattern = this.r[3];
+        const mainFrame = this.r[4];
+        const runInMainFrame = decodeNullableBoolean((Math.floor(mainFrame / 10) % 10) as CompactNullableBoolean);
+        const runInSubFrame = decodeNullableBoolean((mainFrame % 10) as CompactNullableBoolean);
+        if (runInMainFrame !== undefined) {
+            runContext.main = runInMainFrame;
+        }
+        if (runInSubFrame !== undefined) {
+            runContext.frame = runInSubFrame;
+        }
+        if (urlPattern !== '') {
+            runContext.urlPattern = urlPattern;
+        }
+        return runContext;
+    }
+
+    get prehideSelectors() {
+        return this.r[5].map((i) => this.s[i].toString());
+    }
+
+    get detectCmp() {
+        return this.r[6].map(this._decodeRuleStep.bind(this));
+    }
+
+    get detectPopup() {
+        return this.r[7].map(this._decodeRuleStep.bind(this));
+    }
+
+    get optOut() {
+        return this.r[8].map(this._decodeRuleStep.bind(this));
+    }
+
+    get test() {
+        return this.r[9].map(this._decodeRuleStep.bind(this));
+    }
 }

package/lib/rules.ts

@@ -4,20 +4,20 @@ import { snippets } from './eval-snippets';
 export const SUPPORTED_RULE_STEP_VERSION = 1;
 
 export type AutoConsentCMPRule = {
-    name: string;
-    vendorUrl?: string;
-    prehideSelectors?: string[];
-    runContext?: RunContext;
-    intermediate?: boolean;
-    cosmetic?: boolean;
-    detectCmp: AutoConsentRuleStep[];
-    detectPopup: AutoConsentRuleStep[];
-    optOut: AutoConsentRuleStep[];
-    optIn: AutoConsentRuleStep[];
-    openCmp?: AutoConsentRuleStep[];
-    test?: AutoConsentRuleStep[];
-    comment?: string;
-    minimumRuleStepVersion?: number;
+    readonly name: string;
+    readonly vendorUrl?: string;
+    readonly prehideSelectors?: string[];
+    readonly runContext?: RunContext;
+    readonly intermediate?: boolean;
+    readonly cosmetic?: boolean;
+    readonly detectCmp: AutoConsentRuleStep[];
+    readonly detectPopup: AutoConsentRuleStep[];
+    readonly optOut: AutoConsentRuleStep[];
+    readonly optIn: AutoConsentRuleStep[];
+    readonly openCmp?: AutoConsentRuleStep[];
+    readonly test?: AutoConsentRuleStep[];
+    readonly comment?: string;
+    readonly minimumRuleStepVersion?: number;
 };
 
 export type RunContext = {

package/lib/types.ts

@@ -54,6 +54,7 @@ export type Config = {
     disabledCmps: string[];
     enablePrehide: boolean;
     enableCosmeticRules: boolean;
+    enableGeneratedRules: boolean;
     detectRetries: number;
     isMainWorld: boolean;
     prehideTimeout: number;

package/lib/utils.ts

@@ -75,6 +75,7 @@ export function normalizeConfig(providedConfig: any): Config {
         disabledCmps: [],
         enablePrehide: true,
         enableCosmeticRules: true,
+        enableGeneratedRules: true,
         enableHeuristicDetection: false,
         detectRetries: 20,
         isMainWorld: false,

package/lib/web.ts

@@ -20,7 +20,8 @@ function filterCMPs(rules: AutoCMP[], config: Config) {
     return rules.filter((cmp) => {
         return (
             (!config.disabledCmps || !config.disabledCmps.includes(cmp.name)) && // CMP is not disabled
-            (config.enableCosmeticRules || !cmp.isCosmetic) // CMP is not cosmetic or cosmetic rules are enabled
+            (config.enableCosmeticRules || !cmp.isCosmetic) && // CMP is not cosmetic or cosmetic rules are enabled
+            (config.enableGeneratedRules || !cmp.name.startsWith('auto_')) // CMP is not generated or generated rules are enabled
         );
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "14.3.0",
+  "version": "14.4.0",
   "description": "",
   "exports": {
     ".": {

package/rules/autoconsent/cookieyes.json

@@ -13,11 +13,17 @@
                     "if": { "exists": ".cky-consent-container [data-cky-tag=settings-button]" },
                     "then": [
                         { "click": ".cky-consent-container [data-cky-tag=settings-button]" },
-                        { "waitFor": ".cky-modal-open input[type=checkbox]" },
-                        { "click": ".cky-modal-open input[type=checkbox]:checked", "all": true, "optional": true },
-                        { "waitForThenClick": ".cky-modal [data-cky-tag=detail-save-button]" }
+                        { "waitFor": ".cky-modal-open input[type=checkbox],.cky-consent-bar-expand input[type=checkbox]" },
+                        {
+                            "click": ".cky-modal-open input[type=checkbox]:checked,.cky-consent-bar-expand input[type=checkbox]:checked",
+                            "all": true,
+                            "optional": true
+                        },
+                        {
+                            "waitForThenClick": ".cky-modal [data-cky-tag=detail-save-button],.cky-consent-bar-expand [data-cky-tag=detail-save-button]"
+                        }
                     ],
-                    "else": [{ "hide": ".cky-consent-container,.cky-overlay" }]
+                    "else": [{ "hide": ".cky-consent-container,.cky-overlay,.cky-consent-bar-expand" }]
                 }
             ]
         }

package/rules/autoconsent/ct-ultimate-gdpr.json

@@ -20,8 +20,8 @@
     ],
     "optOut": [
         {
-            "if": { "visible": "#ct_ultimate-gdpr-cookie-reject a" },
-            "then": [{ "click": "#ct_ultimate-gdpr-cookie-reject a" }],
+            "if": { "visible": "#ct_ultimate-gdpr-cookie-reject a,#ct-ultimate-gdpr-cookie-reject" },
+            "then": [{ "click": "#ct_ultimate-gdpr-cookie-reject a,#ct-ultimate-gdpr-cookie-reject" }],
             "else": [
                 {
                     "if": { "visible": "#ct-ultimate-gdpr-cookie-change-settings" },