@duckduckgo/autoconsent 1.0.8 → 2.1.1

package/playwright/runner.ts

@@ -0,0 +1,162 @@
+import fs from "fs";
+import path from 'path';
+import { test, expect, Page, Frame } from "@playwright/test";
+import { waitFor } from "../lib/utils";
+import { ContentScriptMessage } from "../lib/messages";
+import { enableLogs } from "../lib/config";
+import { AutoAction } from "../lib/types";
+
+const testRegion = (process.env.REGION || "NA").trim();
+
+type TestOptions = {
+  testOptOut: boolean;
+  testSelfTest: boolean;
+  testOptIn: boolean;
+  skipRegions?: string[];
+  onlyRegions?: string[];
+};
+const defaultOptions: TestOptions = {
+  testOptOut: true,
+  testOptIn: true,
+  testSelfTest: true,
+  skipRegions: [],
+  onlyRegions: [],
+};
+
+const contentScript = fs.readFileSync(
+  path.join(__dirname, "../dist/autoconsent.playwright.js"),
+  "utf8"
+);
+
+export async function injectContentScript(page: Page | Frame) {
+  try {
+    await page.evaluate(contentScript);
+  } catch (e) {
+    // frame was detached
+    // console.log(e);
+  }
+}
+
+export function generateTest(
+  url: string,
+  expectedCmp: string,
+  options: TestOptions = defaultOptions
+) {
+  function genTest(autoAction: AutoAction) {
+    test(`${url.split("://")[1]} .${testRegion} ${autoAction}`, async ({ page }) => {
+      if (options.onlyRegions && options.onlyRegions.length > 0 && !options.onlyRegions.includes(testRegion)) {
+        test.skip();
+      }
+      if (options.skipRegions && options.skipRegions.includes(testRegion)) {
+        test.skip();
+      }
+      enableLogs && page.on('console', async msg => {
+        console.log(`    page log:`, msg.text());
+      });
+      await page.exposeBinding("autoconsentSendMessage", messageCallback);
+      await page.goto(url, { waitUntil: "commit" });
+
+      // set up a messaging function
+      const received: ContentScriptMessage[] = [];
+
+      function isMessageReceived(msg: Partial<ContentScriptMessage>, partial = true) {
+        return received.some((m) => {
+          const keysMatch = partial || Object.keys(m).length === Object.keys(msg).length;
+          return keysMatch && Object.keys(msg).every(
+            (k) => (<any>m)[k] === (<any>msg)[k]
+          );
+        });
+      }
+
+      let selfTestFrame: Frame = null;
+      async function messageCallback({ frame }: { frame: Frame }, msg: ContentScriptMessage) {
+        enableLogs && msg.type !== 'eval' && console.log(msg);
+        received.push(msg);
+        switch (msg.type) {
+          case 'init': {
+            await frame.evaluate(`autoconsentReceiveMessage({ type: "initResp", config: ${JSON.stringify({
+              enabled: true,
+              autoAction: autoAction,
+              disabledCmps: [],
+              enablePrehide: true,
+              detectRetries: 20,
+            })} })`);
+            break;
+          }
+          case 'optInResult':
+          case 'optOutResult': {
+            if (msg.scheduleSelfTest) {
+              selfTestFrame = frame;
+            }
+            break;
+          }
+          case 'autoconsentDone': {
+            if (selfTestFrame && options.testSelfTest) {
+              await selfTestFrame.evaluate(`autoconsentReceiveMessage({ type: "selfTest" })`);
+            }
+            break;
+          }
+          case 'eval': {
+            const result = await frame.evaluate(msg.code);
+            await frame.evaluate(`autoconsentReceiveMessage({ id: "${msg.id}", type: "evalResp", result: ${JSON.stringify(result)} })`);
+            break;
+          }
+          case 'autoconsentError': {
+            console.error(url, msg.details);
+            break;
+          }
+        }
+      }
+
+      // inject content scripts into every frame
+      await injectContentScript(page);
+      page.frames().forEach(injectContentScript);
+      page.on("framenavigated", injectContentScript);
+
+      // wait for all messages and assertions
+      await waitFor(() => isMessageReceived({ type: "popupFound", cmp: expectedCmp }), 50, 500);
+      expect(isMessageReceived({ type: "popupFound", cmp: expectedCmp })).toBe(true);
+
+      if (autoAction === 'optOut') {
+        await waitFor(() => isMessageReceived({ type: "optOutResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "optOutResult", result: true })).toBe(true);
+      }
+      if (autoAction === 'optIn') {
+        await waitFor(() => isMessageReceived({ type: "optInResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "optInResult", result: true })).toBe(true);
+      }
+      if (options.testSelfTest && selfTestFrame) {
+        await waitFor(() => isMessageReceived({ type: "selfTestResult", result: true }), 50, 300);
+        expect(isMessageReceived({ type: "selfTestResult", result: true })).toBe(true);
+      }
+      await waitFor(() => isMessageReceived({ type: "autoconsentDone" }), 10, 500);
+      expect(isMessageReceived({ type: "autoconsentDone" })).toBe(true);
+
+      expect(isMessageReceived({ type: "autoconsentError" })).toBe(false);
+    })
+  }
+
+  if (!options.testOptIn && !options.testOptOut) {
+    genTest(null);
+  }
+
+  if (options.testOptIn) {
+    genTest('optIn');
+  }
+
+  if (options.testOptOut) {
+    genTest('optOut');
+  }
+}
+
+export default function generateCMPTests(
+  cmp: string,
+  sites: string[],
+  options: Partial<TestOptions> = {}
+) {
+  test.describe(cmp, () => {
+    sites.forEach((url) => {
+      generateTest(url, cmp, Object.assign({}, defaultOptions, options));
+    });
+  });
+}

package/playwright.config.ts

@@ -25,6 +25,13 @@ const config: PlaywrightTestConfig = {
         ...devices['Desktop Firefox'],
         proxy,
       },
+    },
+    {
+      name: 'chrome',
+      use: {
+        ...devices['Desktop Chrome'],
+        proxy,
+      },
     }
   ],
 };

package/readme.md

@@ -1,28 +1,30 @@
-## Autoconsent
+# Autoconsent
 
 This is a library of rules for navigating through common consent popups on the web. These rules
-can be run in a Firefox webextension, or in a puppeteer orchestrated headless browser. Using
+can be run in a Chrome extension, or in a Playwright-orchestrated headless browser. Using
 these rules, opt-in and opt-out options can be selected automatically, without requiring
 user-input.
 
-### Install Standalone
+## Browser extension
 
-The standalone addon can be built with the following steps:
+The web extension can be built with the following steps:
 
 ```bash
 # Download dependencies
 npm ci
-# Build JS bundles
-npm run bundle
 # Build consent ruleset
 npm run build-rules
+# Build JS bundles (rules must be built first)
+npm run bundle
 ```
 
-The standalone addon can be found in the `addon` directory and can be run with `npm start`.
-Alternatively, you can use `web-ext build -s addon/` to generate a packaged addon that can
-be installed in an existing Firefox profile.
+The extension-specific code can be found in the `addon` directory. There are two versions of the
+addon (found under `dist/addon` after building), one for `mv3` version for Chromium-based browsers, and a `firefox` version for Firefox.
+You can load these in [Chrome](https://developer.chrome.com/docs/extensions/mv3/getstarted/#unpacked)
+in developer mode, and in [Firefox](https://extensionworkshop.com/documentation/develop/temporary-installation-in-firefox/)
+as a tempoary addon.
 
-### Rules
+## Rules
 
 The library's functionality is implemented as a set of rules that define how to manage consent on
 a subset of sites. These generally correspond to specific Consent Management Providers (CMPs)
@@ -41,33 +43,50 @@ There are currently three ways of implementing a CMP:
  3. As a [Consent-O-Matic](https://github.com/cavi-au/Consent-O-Matic) rule. The `ConsentOMaticCMP` class implements
  compability with rules written for the Consent-O-Matic extension.
 
-### Rule Syntax
+## Intermediate rules
+
+Sometimes the opt-out process requires actions that span across multiple pages or iframes. In this case it is necessary to define stages (each corresponding to a separate page context) as separate rulesets. Each one, except the very last stage, must be marked as intermediate using the `intermediate: true` flag. If the `intermediate` flag is not set correctly, autoconsent may report a successful opt-out even if it is not yet finished.
+
+## Context filters
+
+By default, rules will be executed in all top-level documents. Some rules are designed for specific contexts (e.g. only nested iframes, or only specific URLs). This can be configured in `runContext` field (see the syntax reference below).
+
+## Rule Syntax Reference
 
 An autoconsent CMP rule can be written as either:
- * a class implementing the `AutoCMP` interface, or
  * a JSON file adhering to the `AutoConsentCMPRule` type.
+ * a class implementing the `AutoCMP` interface, or
+   * common JSON rules are available as reusable functions in [rule-executors.ts](/lib/rule-executors.ts). You can also use existing class-based rules as reference.
 
-In most cases the JSON syntax should be sufficient, unless non-linear logic is required, in which case a class is required.
+In most cases the JSON syntax should be sufficient, unless some complex non-linear logic is required, in which case a class is required.
 
-Both JSON and class implementations require 5 main components:
+Both JSON and class implementations have the following components:
  * `name` - to identify this CMP.
  * `detectCMP` - which determines if this CMP is included on the page.
  * `detectPopup` - which determines if a popup is being shown by the CMP.
- * `optOut` - executes actions to do an 'opt-out' from the popup screen. i.e. denying all consents possible.
- * `optIn` - execut actions for an 'opt-in' from the popup screen.
+ * `optOut` - a list of actions to do an 'opt-out' from the popup screen. i.e. denying all consents possible.
+ * `optIn` - a list of actions for an 'opt-in' from the popup screen.
+ * (optional) `prehideSelectors` - a list of CSS selectors to "pre-hide" early before detecting a CMP. This helps against flickering. Pre-hiding is done using CSS `opacity` and `z-index`, so be it should be used with care to prevent conflicts with the opt-out process.
+ * (optional) `intermediate` - a boolean flag indicating that the ruleset is part of a multi-stage process, see the [Intermediate rules](#intermediate-rules) section. This is `false` by default.
+ * (optional) `runContext` - an object describing when this rule should be tried:
+   * `main` - boolean, set to `true` if the rule should be executed in top-level documents (default: `true`)
+   * `frame` - boolean, set to `true` if the rule should be executed in nested frames (default: `false`)
+   * `url` - string, specifies a string prefix that should match the page URL (default: empty)
+ * (optional) `test` - a list of actions to verify a successful opt-out. This is currently only used in Playwright tests.
 
-Except for `name` this are defined as a set of checks or actions on the page. In the JSON syntax this is a list of `AutoConsentRuleStep` objects. For `detect` checks, we return true for the check if all steps return true. For opt in and out, we execute actions in order, exiting if one fails. The following checks/actions are supported:
 
-#### Element exists
+`detectCMP`, `detectPopup`, `optOut`, `optIn`, and `test` are defined as a set of checks or actions on the page. In the JSON syntax this is a list of `AutoConsentRuleStep` objects. For `detect` checks, we return true for the check if all steps return true. For opt in and out, we execute actions in order, exiting if one fails. The following checks/actions are supported:
+
+### Element exists
 
 ```json
 {
   "exists": "selector"
 }
 ```
-Returns true if `document.querySelect(selector)` returns elements.
+Returns true if `document.querySelector(selector)` returns elements.
 
-#### Element visible
+### Element visible
 
 ```json
 {
@@ -75,18 +94,9 @@ Returns true if `document.querySelect(selector)` returns elements.
   "check": "any" | "all" | "none"
 }
 ```
-Returns true if an element returned from `document.querySelect(selector)` is current visible on the page. If `check` is `all`, every element must be visible. If `check` is `none`, no element should be visible.
+Returns true if elements returned from `document.querySelectorAll(selector)` are currently visible on the page. If `check` is `all`, every element must be visible. If `check` is `none`, no element should be visible. Visibility check is a CSS-based heuristic.
 
-#### Eval
-
-```json
-{
-  "eval": "code"
-}
-```
-Evaluates `code` in the context of the page. NB: the result of this action depends on the truthiness of the evaluated expression, make sure it returns `true` in case of success.
-
-#### Wait for element
+### Wait for element
 
 ```json
 {
@@ -96,25 +106,26 @@ Evaluates `code` in the context of the page. NB: the result of this action depen
 ```
 Waits until `selector` exists in the page. After `timeout` ms the step fails.
 
-#### Click and element
+### Click an element
 ```json
 {
   "click": "selector",
   "all": true | false,
 }
 ```
-Click on an element returned by `selector`. If `all` is `true`, all matching elements are clicked.
+Click on an element returned by `selector`. If `all` is `true`, all matching elements are clicked. If `all` is `false`, only the first returned value is clicked.
 
-#### Wait for then click
+### Wait for then click
 ```json
 {
   "waitForThenClick": "selector",
-  "timeout": 1000
+  "timeout": 1000,
+  "all": true | false
 }
 ```
 Combines `waitFor` and `click`.
 
-#### Wait
+### Unconditional wait
 ```json
 {
   "wait": 1000,
@@ -122,30 +133,33 @@ Combines `waitFor` and `click`.
 ```
 Wait for the specified number of milliseconds.
 
-#### Go to URL
+### Hide
 ```json
 {
-  "goto": "url"
+  "hide": ["selector", ...],
+  "method": "display" | "opacity"
 }
 ```
-Navigate the page to the given URL.
+Hide the elements matched by the selectors. `method` defines how elements are hidden: "display" sets `display: none`, "opacity" sets `opacity: 0`. Method is "display" by default.
+
+### Eval
 
-#### Hide rule
 ```json
 {
-  "hide": ["selector", ...]
+  "eval": "code"
 }
 ```
-Set the elements matched by the selectors to `display: none`.
+Evaluates `code` in the context of the page. The rule is considered successful if it *evaluates to a truthy value*.
+Eval rules are not 100% reliable because they can be blocked by a CSP policy on the page. Therefore, they should only be used as a last resort when none of the other rules are sufficient.
 
-#### Frames
+### Optional actions
 
-In some cases, rules have to interact with `iframes` in the page. The CMP rule defintion can optionally include a `frame` component that should be the _prefix_ of the expected frame URL. Checks and actions can then add `"frame": true` to indicate that the check or action should be done on the iframe's document (rather than main frame).
+Any rule can include the `"optional": true` to ignore failure.
 
-#### Optional actions
+## API
 
-Any rule can include the `"optional": true` to ignore failure. 
+See [this document](/api.md) for more details on internal APIs.
 
-### License
+## License
 
 MPLv2.

package/rollup.config.js

@@ -1,14 +1,19 @@
+import json from '@rollup/plugin-json';
 import typescript from '@rollup/plugin-typescript';
+import copy from 'rollup-plugin-copy';
+import { terser } from "rollup-plugin-terser";
 import pkg from './package.json';
 
 export default [{
-  input: './lib/node.ts',
+  input: './playwright/content.ts',
   output: [{
-    file: 'dist/autoconsent.puppet.js',
-    format: 'cjs'
+    file: 'dist/autoconsent.playwright.js',
+    format: 'iife'
   }],
   plugins: [
+    json(),
     typescript(),
+    terser(),
   ]
 }, {
   input: './lib/web.ts',
@@ -22,33 +27,50 @@ export default [{
   }],
   plugins: [
     typescript(),
-  ]
+    terser(),
+  ],
 }, {
   input: './addon/background.ts',
   output: [{
-    file: './addon/background.bundle.js',
+    file: './dist/addon-mv3/background.bundle.js',
+    format: 'iife',
+  }, {
+    file: './dist/addon-firefox/background.bundle.js',
     format: 'iife',
   }],
   plugins: [
     typescript(),
+    terser(),
+    copy({
+      targets: [
+        {
+          src: ['./addon/icons',  './rules/rules.json'],
+          dest: ['./dist/addon-firefox/', './dist/addon-mv3/']
+        },
+        {
+          src: './addon/manifest.mv3.json',
+          dest: './dist/addon-mv3',
+          rename: 'manifest.json',
+        },
+        {
+          src: './addon/manifest.firefox.json',
+          dest: './dist/addon-firefox',
+          rename: 'manifest.json',
+        },
+      ]
+    })
   ]
 }, {
   input: './addon/content.ts',
   output: [{
-    file: './addon/content.bundle.js',
+    file: './dist/addon-mv3/content.bundle.js',
     format: 'iife',
-  }],
-  plugins: [
-    typescript(),
-  ]
-},  {
-  input: './addon/test.ts',
-  output: [{
-    file: './addon/test.bundle.js',
+  }, {
+    file: './dist/addon-firefox/content.bundle.js',
     format: 'iife',
-    external: ['chai', 'mocha']
   }],
   plugins: [
     typescript(),
-  ]
+    terser(),
+  ],
 }];

package/rules/autoconsent/ausopen.json

@@ -3,5 +3,6 @@
   "isHidingRule": true,
   "detectCmp": [{ "exists": ".gdpr-popup__message" }],
   "detectPopup": [{ "visible": ".gdpr-popup__message" }],
-  "optOut": [{ "hide": [".gdpr-popup__message"]}]
+  "optOut": [{ "hide": [".gdpr-popup__message"]}],
+  "optIn": [{ "click": [".gdpr-popup__message button"]}]
 }

package/rules/autoconsent/baden-wuerttemberg-de.json

@@ -1,9 +1,13 @@
 {
   "name": "baden-wuerttemberg.de",
-  "isHidingRule": true,
   "prehideSelectors": [".cookie-alert.t-dark"],
   "detectCmp": [{ "exists": ".cookie-alert.t-dark" }],
   "detectPopup": [{ "visible": ".cookie-alert.t-dark" }],
-  "optIn": [{ "click": ".cookie-alert__button" }],
-  "optOut": []
+  "optIn": [
+    { "click": ".cookie-alert__form input:not([disabled]):not([checked])" },
+    { "click": ".cookie-alert__button button" }
+  ],
+  "optOut": [
+    { "hide": [".cookie-alert.t-dark"] }
+  ]
 }

package/rules/autoconsent/bundesregierung-de.json

@@ -6,7 +6,11 @@
   "optIn": [{ "click": ".bpa-accept-all-button" }],
   "optOut": [
       {
-          "click": ".bpa-close-button"
+          "wait": 500,
+          "comment": "click is not immediately recognized"
+      },
+      {
+          "waitForThenClick": ".bpa-close-button"
       }
   ],
   "test": [

package/rules/autoconsent/cc-banner.json

@@ -1,7 +1,6 @@
 {
   "name": "cc_banner",
   "prehideSelectors": [".cc_banner-wrapper"],
-  "isHidingRule": true,
   "detectCmp": [{ "exists": ".cc_banner-wrapper" }],
   "detectPopup": [{ "visible": ".cc_banner" }],
   "optIn": [{ "click": ".cc_btn_accept_all" }],

package/rules/autoconsent/cookie-law-info.json

@@ -3,7 +3,7 @@
   "prehideSelectors": ["#cookie-law-info-bar"],
   "detectCmp": [{ "exists": "#cookie-law-info-bar" }],
   "detectPopup": [{ "visible": "#cookie-law-info-bar" }],
-  "optIn": [{ "click": "[data-cli_action=\"accept\"]" }],
+  "optIn": [{ "click": "[data-cli_action=\"accept_all\"]" }],
   "optOut": [
     { "hide": ["#cookie-law-info-bar"] },
     {

package/rules/autoconsent/cookie-notice.json

@@ -1,9 +1,8 @@
 {
   "name": "cookie-notice",
   "prehideSelectors": ["#cookie-notice"],
-  "isHidingRule": true,
   "detectCmp": [{ "exists": "#cookie-notice" }],
   "detectPopup": [{ "visible": "#cookie-notice" }],
-  "optIn": [{ "hide": ["#cn-accept-cookie"] }],
+  "optIn": [{ "click": ["#cn-accept-cookie"] }],
   "optOut": [{ "hide": ["#cookie-notice"] }]
 }

package/rules/autoconsent/cookieconsent.json

@@ -1,9 +1,8 @@
 {
     "name": "cookieconsent",
-    "prehideSelectors": ["[aria-label=\"cookieconsent\"]"],
-    "isHidingRule": true,
-    "detectCmp": [{ "exists": "[aria-label=\"cookieconsent\"]" }],
-    "detectPopup": [{ "visible": "[aria-label=\"cookieconsent\"]" }],
+    "prehideSelectors": ["[aria-label=\"cookieconsent\"][aria-describedby=\"cookieconsent:desc\"]"],
+    "detectCmp": [{ "exists": "[aria-label=\"cookieconsent\"][aria-describedby=\"cookieconsent:desc\"]" }],
+    "detectPopup": [{ "visible": "[aria-label=\"cookieconsent\"][aria-describedby=\"cookieconsent:desc\"]" }],
     "optIn": [{ "click": ".cc-dismiss" }],
-    "optOut": [{ "hide": ["[aria-label=\"cookieconsent\"]"] }]
-  }
+    "optOut": [{ "hide": ["[aria-label=\"cookieconsent\"][aria-describedby=\"cookieconsent:desc\"]"] }]
+}

package/rules/autoconsent/destatis-de.json

@@ -1,8 +1,8 @@
 {
   "name": "destatis.de",
   "prehideSelectors": ["div[aria-labelledby=cookiebannerhead]"],
-  "isHidingRule": true,
   "detectCmp": [{ "exists": ".cookiebannerbox" }],
   "detectPopup": [{ "visible": ".cookiebannerbox" }],
-  "optOut": [{ "hide": [".cookiebannerbox"] }]
+  "optOut": [{ "hide": [".cookiebannerbox"] }],
+  "optIn": [{ "click": [".cookiebannerbox .close"] }]
 }

package/rules/autoconsent/dunelm.json

@@ -3,7 +3,7 @@
   "prehideSelectors": ["div[data-testid=cookie-consent-modal-backdrop]"],
   "detectCmp": [{ "exists": "div[data-testid=cookie-consent-message-contents]"}],
   "detectPopup": [{ "visible": "div[data-testid=cookie-consent-message-contents]" }],
-  "optIn": [{ "click": "" }],
+  "optIn": [{ "click": "[data-testid=\"cookie-consent-allow-all\"]" }],
   "optOut": [
       {
           "click": "button[data-testid=cookie-consent-adjust-settings]"

package/rules/autoconsent/etsy.json

@@ -1,12 +1,13 @@
 {
     "name": "etsy",
+    "prehideSelectors": ["#gdpr-single-choice-overlay", "#gdpr-privacy-settings"],
     "detectCmp": [{ "exists": "#gdpr-single-choice-overlay" }],
     "detectPopup": [{ "visible": "#gdpr-single-choice-overlay" }],
     "optOut": [
-        {"hide": ["#gdpr-single-choice-overlay", "#gdpr-privacy-settings"]},
         {"click": "button[data-gdpr-open-full-settings]"},
-        {"wait": 500},
-        {"eval": "document.querySelectorAll('.gdpr-overlay-body input').forEach(toggle => { toggle.checked = false; }) || true"},
+        {"waitForVisible": ".gdpr-overlay-body input", "timeout": 3000},
+        {"wait": 1000},
+        {"eval": "document.querySelectorAll(\".gdpr-overlay-body input\").forEach(toggle => { toggle.checked = false; }) || true"},
         {"eval": "document.querySelector('.gdpr-overlay-view button[data-wt-overlay-close]').click() || true"}
     ],
     "optIn": [{"click": "button[data-gdpr-single-choice-accept]"}]

package/rules/autoconsent/eu-cookie-compliance.json

@@ -1,6 +1,5 @@
 {
   "name": "eu-cookie-compliance-banner",
-  "isHidingRule": true,
   "detectCmp": [{ "exists": ".eu-cookie-compliance-banner-info" }],
   "detectPopup": [{ "visible": ".eu-cookie-compliance-banner-info" }],
   "optIn": [{ "click": ".agree-button" }],

package/rules/autoconsent/hl-co-uk.json

@@ -1,6 +1,6 @@
 {
- "name": "hl.co.uk",
- "prehideSelectors": [".cookieModalContent", "#cookie-banner-overlay"],
+  "name": "hl.co.uk",
+  "prehideSelectors": [".cookieModalContent", "#cookie-banner-overlay"],
   "detectCmp": [{ "exists": "#cookie-banner-overlay" }],
   "detectPopup": [{ "exists": "#cookie-banner-overlay" }],
   "optIn": [{ "click": "#acceptCookieButton" }],
@@ -12,19 +12,18 @@
           "hide": [".cookieSettingsModal"]
       },
       {
-          "wait": 500
+          "waitFor": "#AOCookieToggle"
       },
       {
-          "click": "#AOCookieToggle"
+          "click": "#AOCookieToggle[aria-pressed=true]",
+          "optional": true
       },
       {
-          "eval": "document.querySelector('#AOCookieToggle').getAttribute('aria-pressed') === 'false'"
+          "waitFor": "#TPCookieToggle"
       },
       {
-          "click": "#TPCookieToggle"
-      },
-      {
-          "eval": "document.querySelector('#TPCookieToggle').getAttribute('aria-pressed') === 'false'"
+          "click": "#TPCookieToggle[aria-pressed=true]",
+          "optional": true
       },
       {
           "click": "#updateCookieButton"

package/rules/autoconsent/johnlewis.json

@@ -6,8 +6,11 @@
     "optOut": [
         {"click": "button[data-test^=manage-cookies]"},
         {"wait": "500"},
-        {"eval": "!!Array.from(document.querySelectorAll('label[data-test^=toggle]')).forEach(e => e.click())", "optional": true },
-        {"eval": "Array.from(document.querySelectorAll('label[data-test^=toggle]')).filter(e => e.className.match('checked') && !e.className.match('disabled')).length === 0"},
+        {
+            "click": "label[data-test^=toggle][class*=checked]:not([class*=disabled])",
+            "all": true,
+            "optional": true
+        },
         {"click": "button[data-test=save-preferences]"}
     ],
     "optIn": [{ "click": "button[data-test=allow-all]"}]

package/rules/autoconsent/marksandspencer.json

@@ -3,5 +3,6 @@
   "isHidingRule": true,
   "detectCmp": [{ "exists": ".navigation-cookiebbanner" }],
   "detectPopup": [{ "visible": ".navigation-cookiebbanner" }],
-  "optOut": [{ "hide": [".navigation-cookiebbanner"]}]
+  "optOut": [{ "hide": [".navigation-cookiebbanner"]}],
+  "optIn": [{ "click": [".navigation-cookiebbanner__submit"]}]
 }