@duckduckgo/autoconsent 16.28.0 → 16.30.0

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

@@ -29,7 +29,7 @@ export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
     elementVisible(selector: ElementSelector, check?: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method?: HideMethod): boolean;
     stylesheet(cssRule: string, stylesheetId?: string): boolean;

package/dist/types/dom-actions.d.ts

@@ -1,6 +1,7 @@
 import { ElementSelector, HideMethod, VisibilityCheck } from './rules';
 import { DomActionsProvider } from './types';
 import AutoConsent from './web';
+export declare const DEFAULT_CLICK_RETRY_INTERVAL = 300;
 export declare class DomActions implements DomActionsProvider {
     autoconsentInstance: AutoConsent;
     constructor(autoconsentInstance: AutoConsent);
@@ -10,7 +11,7 @@ export declare class DomActions implements DomActionsProvider {
     elementVisible(selector: ElementSelector, check?: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     cookieContains(substring: string): boolean;
     hide(selector: string, method?: HideMethod): boolean;

package/dist/types/rules.d.ts

@@ -68,6 +68,16 @@ export type WaitForThenClickRule = {
     waitForThenClick: ElementSelector;
     timeout?: number;
     all?: boolean;
+    /**
+     * Number of additional click attempts if the element is still visible after the first click.
+     * Defaults to 0 (no retries). Only use this on elements that are expected to disappear once the
+     * click is handled, otherwise the extra clicks are wasted (or harmful).
+     */
+    retry?: number;
+    /**
+     * How long to wait (in ms) for the element to disappear before clicking it again.
+     */
+    retryInterval?: number;
 };
 export type WaitRule = {
     wait: number;

package/dist/types/types.d.ts

@@ -26,7 +26,7 @@ export interface DomActionsProvider {
     elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method: HideMethod): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;

package/docs/rule-syntax.md

@@ -103,11 +103,22 @@ Click on an element returned by `selector`. If `all` is `true`, all matching ele
 {
   "waitForThenClick": ElementSelector,
   "timeout": 1000,
-  "all": true | false
+  "all": true | false,
+  "retry": 0,
+  "retryInterval": 300
 }
 ```
 Combines `waitFor` and `click`.
 
+`retry` is the number of extra click attempts if the element is still visible after the click, `0` by
+default. It works around CMPs that insert a button before its click handler is attached.
+Between attempts the step waits up to `retryInterval` ms (300 by default) for the element to
+disappear, and stops retrying as soon as it does. Prefer this over an unconditional `wait` before the
+click: nothing is added to the step's duration when the first click works.
+
+**Only use `retry` on elements that are expected to go away** once the click is handled — a button that
+stays visible (e.g. a toggle) would be clicked repeatedly.
+
 ## Unconditional wait
 ```javascript
 {

package/lib/cmps/base.ts

@@ -180,12 +180,12 @@ export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
         return this.autoconsent.domActions.waitForVisible(selector, timeout, check);
     }
 
-    async waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean) {
+    async waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number) {
         if (this.autoconsent.config.visualTest) {
             await this.highlightElements(this.elementSelector(selector), all);
         }
         this.autoconsent.updateState({ clicks: this.autoconsent.state.clicks + 1 });
-        return this.autoconsent.domActions.waitForThenClick(selector, timeout, all);
+        return this.autoconsent.domActions.waitForThenClick(selector, timeout, all, retries, retryInterval);
     }
 
     wait(ms: number) {
@@ -336,7 +336,7 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
             results.push(this.click(rule.click, rule.all));
         }
         if (rule.waitForThenClick) {
-            results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
+            results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all, rule.retry, rule.retryInterval));
         }
         if (rule.wait) {
             results.push(this.wait(rule.wait));

package/lib/dom-actions.ts

@@ -3,6 +3,11 @@ import { DomActionsProvider } from './types';
 import { getStyleElement, hideElements, appendStylesheetRule, isElementVisible, waitFor } from './utils';
 import AutoConsent from './web';
 
+// Default for the `retryInterval` option of `waitForThenClick`.
+export const DEFAULT_CLICK_RETRY_INTERVAL = 300;
+// How often we check if the element is gone while waiting out a `retryInterval`.
+const CLICK_RETRY_POLL_INTERVAL = 50;
+
 export class DomActions implements DomActionsProvider {
     constructor(public autoconsentInstance: AutoConsent) {}
 
@@ -66,9 +71,28 @@ export class DomActions implements DomActionsProvider {
         return waitFor(() => this.elementVisible(selector, check), times, interval);
     }
 
-    async waitForThenClick(selector: ElementSelector, timeout = 10000, all = false): Promise<boolean> {
+    async waitForThenClick(
+        selector: ElementSelector,
+        timeout = 10000,
+        all = false,
+        retries = 0,
+        retryInterval = DEFAULT_CLICK_RETRY_INTERVAL,
+    ): Promise<boolean> {
         await this.waitForElement(selector, timeout);
-        return await this.click(selector, all);
+        let clicked = await this.click(selector, all);
+        // Some CMPs insert the button before its click handler is attached, so the first click is
+        // silently dropped. There is usually no DOM signal for this, but a click that was handled
+        // makes the element go away: if it is still visible, we assume the click was lost and repeat it.
+        for (let attempt = 0; clicked && attempt < retries; attempt++) {
+            const pollTimes = Math.ceil(retryInterval / CLICK_RETRY_POLL_INTERVAL);
+            const isGone = await waitFor(() => !this.elementVisible(selector, 'any'), pollTimes, CLICK_RETRY_POLL_INTERVAL);
+            if (isGone) {
+                break;
+            }
+            this.autoconsentInstance.config.logs.rulesteps && console.log('[waitForThenClick] retrying click', selector);
+            clicked = await this.click(selector, all);
+        }
+        return clicked;
     }
 
     wait(ms: number): Promise<true> {

package/lib/rules.ts

@@ -99,6 +99,16 @@ export type WaitForThenClickRule = {
     waitForThenClick: ElementSelector;
     timeout?: number;
     all?: boolean;
+    /**
+     * Number of additional click attempts if the element is still visible after the first click.
+     * Defaults to 0 (no retries). Only use this on elements that are expected to disappear once the
+     * click is handled, otherwise the extra clicks are wasted (or harmful).
+     */
+    retry?: number;
+    /**
+     * How long to wait (in ms) for the element to disappear before clicking it again.
+     */
+    retryInterval?: number;
 };
 
 export type WaitRule = {

package/lib/types.ts

@@ -29,7 +29,13 @@ export interface DomActionsProvider {
     elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(
+        selector: ElementSelector,
+        timeout?: number,
+        all?: boolean,
+        retries?: number,
+        retryInterval?: number,
+    ): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method: HideMethod): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;

package/package.json

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

package/rules/autoconsent/bankmillennium-pl.json

@@ -0,0 +1,26 @@
+{
+    "name": "bankmillennium.pl",
+    "runContext": {
+        "urlPattern": "^https?://(www\\.)?bankmillennium\\.pl/"
+    },
+    "prehideSelectors": ["#cookie_modal_placeholder dialog.bm-modal--cookie"],
+    "detectCmp": [{ "exists": "#cookie_modal_placeholder dialog.bm-modal--cookie" }],
+    "detectPopup": [{ "visible": "#cookie_modal_placeholder dialog.bm-modal--cookie" }],
+    "optIn": [
+        {
+            "waitForThenClick": [
+                "#cookie_modal_placeholder dialog.bm-modal--cookie",
+                "xpath///button[contains(normalize-space(.), 'Potwierd')]"
+            ]
+        }
+    ],
+    "optOut": [
+        {
+            "waitForThenClick": [
+                "#cookie_modal_placeholder dialog.bm-modal--cookie",
+                "xpath///button[contains(normalize-space(.), 'Odrzu')]"
+            ]
+        }
+    ],
+    "test": [{ "cookieContains": "Analytics_consent=2" }, { "cookieContains": "Marketing_consent=2" }]
+}

package/rules/autoconsent/bibliotheek-nl.json

@@ -0,0 +1,33 @@
+{
+    "name": "bibliotheek-nl",
+    "_metadata": {
+        "vendorUrl": "https://www.bibliotheek.nl/"
+    },
+    "cosmetic": false,
+    "runContext": {
+        "main": true,
+        "frame": false,
+        "urlPattern": "^https?://(?:www\\.)?(?:onlinebibliotheek|bibliotheek)\\.nl/"
+    },
+    "prehideSelectors": [".modalwindow-container.bar .modalwindow"],
+    "detectCmp": [
+        {
+            "exists": "#bibliotheek-nl-page"
+        }
+    ],
+    "detectPopup": [
+        {
+            "visible": ".modalwindow-container.bar .modalwindow"
+        }
+    ],
+    "optIn": [
+        {
+            "waitForThenClick": ".modalwindow-container.bar .modalwindow button.button.primary.ok"
+        }
+    ],
+    "optOut": [
+        {
+            "waitForThenClick": ".modalwindow-container.bar .modalwindow button.button.primary.notok"
+        }
+    ]
+}

package/rules/autoconsent/ecbeing.json

@@ -0,0 +1,10 @@
+{
+    "name": "ecbeing",
+    "vendorUrl": "https://www.ecbeing.net/",
+    "cosmetic": true,
+    "prehideSelectors": ["#cookieBox .block-cookie-consent"],
+    "detectCmp": [{ "exists": "#cookieBox #consentButton.block-cookie-consent--btn" }],
+    "detectPopup": [{ "visible": "#cookieBox" }],
+    "optIn": [{ "waitForThenClick": "#cookieBox #consentButton" }],
+    "optOut": [{ "hide": "#cookieBox" }]
+}

package/rules/autoconsent/r42-cookiebar.json

@@ -0,0 +1,37 @@
+{
+    "name": "r42-cookiebar",
+    "cosmetic": false,
+    "runContext": {
+        "main": true,
+        "frame": false
+    },
+    "prehideSelectors": ["#r42CookieBar"],
+    "detectCmp": [
+        {
+            "exists": "#r42CookieBar .cw-deny"
+        }
+    ],
+    "detectPopup": [
+        {
+            "visible": "#r42CookieBar[open] .cw-deny"
+        }
+    ],
+    "optIn": [
+        {
+            "waitForThenClick": "#r42CookieBar .cw-accept"
+        }
+    ],
+    "optOut": [
+        {
+            "waitForThenClick": "#r42CookieBar .cw-deny",
+            "comment": "Weigeren"
+        }
+    ],
+    "test": [
+        {
+            "waitForVisible": "#r42CookieBar .cw-deny",
+            "timeout": 1000,
+            "check": "none"
+        }
+    ]
+}

package/rules/autoconsent/stright.json

@@ -0,0 +1,29 @@
+{
+    "name": "stright",
+    "prehideSelectors": ["#controlled_banner-cookie_consent-consent_banner", "#controlled_banner-cookie_consent-privacy_setting_banner"],
+    "detectCmp": [{ "exists": "#controlled_banner-cookie_consent-consent_banner" }],
+    "detectPopup": [{ "visible": "#controlled_banner-cookie_consent-consent_banner" }],
+    "optIn": [{ "waitForThenClick": "#controlled_submit-cookie_consent-consent_banner-accept_all" }],
+    "optOut": [
+        {
+            "if": {
+                "visible": "#controlled_banner-cookie_consent-consent_banner [data-search-key-button=reject_all_text]"
+            },
+            "then": [
+                {
+                    "waitForThenClick": "#controlled_banner-cookie_consent-consent_banner [data-search-key-button=reject_all_text]"
+                }
+            ],
+            "else": [
+                {
+                    "waitForThenClick": "#controlled_submit-cookie_consent-consent_banner-privacy_setting_banner_link"
+                },
+                {
+                    "waitForThenClick": "#controlled_banner-cookie_consent-privacy_setting_banner [data-search-key-button=reject_all_text]"
+                }
+            ]
+        },
+        { "waitForVisible": "#controlled_banner-cookie_consent-consent_banner", "check": "none" }
+    ],
+    "test": [{ "visible": "#controlled_banner-cookie_consent-consent_banner", "check": "none" }]
+}