@duckduckgo/autoconsent 5.0.0 → 5.0.1

package/dist/addon-firefox/background.bundle.js

@@ -1,320 +1,316 @@
-(function () {
-    'use strict';
+(() => {
+  // lib/config.ts
+  var enableLogs = false;
 
-    const manifestVersion = chrome.runtime.getManifest().manifest_version;
-    // Storage abstraction: MV2 keeps everything in memory, MV3 uses chrome.storage
-    const storage = {};
-    async function storageSet(obj) {
-        if (manifestVersion === 2) {
-            Object.assign(storage, obj);
-            return;
-        }
-        return chrome.storage.local.set(obj);
+  // addon/mv-compat.ts
+  var manifestVersion = chrome.runtime.getManifest().manifest_version;
+  var storage = {};
+  async function storageSet(obj) {
+    if (manifestVersion === 2) {
+      Object.assign(storage, obj);
+      return;
     }
-    async function storageGet(key) {
-        if (key === null) {
-            if (manifestVersion === 2) {
-                return storage;
-            }
-            return await chrome.storage.local.get(null);
-        }
-        if (manifestVersion === 2) {
-            return storage[key];
-        }
-        return (await chrome.storage.local.get(key))?.[key];
+    return chrome.storage.local.set(obj);
+  }
+  async function storageGet(key) {
+    if (key === null) {
+      if (manifestVersion === 2) {
+        return storage;
+      }
+      return await chrome.storage.local.get(null);
     }
-    async function storageRemove(key) {
-        if (manifestVersion === 2) {
-            delete storage[key];
-            return;
-        }
-        return chrome.storage.local.remove(key);
+    if (manifestVersion === 2) {
+      return storage[key];
     }
-
-    async function showOptOutStatus(tabId, status, cmp = '') {
-        let title = "";
-        let icon = "icons/cookie-idle.png";
-        if (status === "success") {
-            title = `Opt out successful! (${cmp})`;
-            icon = "icons/party.png";
-        }
-        else if (status === "complete") {
-            title = `Opt out complete! (${cmp})`;
-            icon = "icons/tick.png";
-        }
-        else if (status === "working") {
-            title = `Processing... (${cmp})`;
-            icon = "icons/cog.png";
-        }
-        else if (status === "verified") {
-            title = `Verified (${cmp})`;
-            icon = "icons/verified.png";
-        }
-        else if (status === "idle") {
-            title = "Idle";
-            icon = "icons/cookie-idle.png";
-        }
-        else if (status === "available") {
-            title = `Click to opt out (${cmp})`;
-            icon = "icons/cookie.png";
-        }
-        const action = chrome.action || chrome.pageAction;
-        if (chrome.pageAction) {
-            chrome.pageAction.show(tabId);
-        }
-        await action.setTitle({
-            tabId,
-            title,
-        });
-        await action.setIcon({
-            tabId,
-            path: icon,
-        });
+    return (await chrome.storage.local.get(key))?.[key];
+  }
+  async function storageRemove(key) {
+    if (manifestVersion === 2) {
+      delete storage[key];
+      return;
     }
+    return chrome.storage.local.remove(key);
+  }
 
-    /**
-     * Mapping of tabIds to Port connections to open devtools panels.
-     * This is kept in memory, as the values are only relevant while the background service worker is
-     * alive. Once the service worker stops, Ports to devtools will be severed, and the panel will
-     * reestablish the connection.
-     */
-    const openDevToolsPanels = new Map();
-    async function loadRules() {
-        const res = await fetch("./rules.json");
-        storageSet({
-            rules: await res.json(),
-        });
+  // addon/utils.ts
+  async function showOptOutStatus(tabId, status, cmp = "") {
+    let title = "";
+    let icon = "icons/cookie-idle.png";
+    if (status === "success") {
+      title = `Opt out successful! (${cmp})`;
+      icon = "icons/party.png";
+    } else if (status === "complete") {
+      title = `Opt out complete! (${cmp})`;
+      icon = "icons/tick.png";
+    } else if (status === "working") {
+      title = `Processing... (${cmp})`;
+      icon = "icons/cog.png";
+    } else if (status === "verified") {
+      title = `Verified (${cmp})`;
+      icon = "icons/verified.png";
+    } else if (status === "idle") {
+      title = "Idle";
+      icon = "icons/cookie-idle.png";
+    } else if (status === "available") {
+      title = `Click to opt out (${cmp})`;
+      icon = "icons/cookie.png";
     }
-    async function initConfig() {
-        console.log('init sw');
-        const storedConfig = await storageGet('config');
-        console.log('storedConfig', storedConfig);
-        const defaultConfig = {
-            enabled: true,
-            autoAction: 'optOut',
-            disabledCmps: [],
-            enablePrehide: true,
-            enableCosmeticRules: true,
-            detectRetries: 20,
-            prehideTimeout: 2000,
-        };
-        if (!storedConfig) {
-            console.log('init config');
-            await storageSet({
-                config: defaultConfig,
-            });
-        }
-        else { // clean up the old stored config in case there are new fields
-            const updatedConfig = structuredClone(defaultConfig);
-            for (const key of Object.keys(defaultConfig)) {
-                if (typeof storedConfig[key] !== 'undefined') {
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore - TS doesn't know that we've checked for undefined
-                    updatedConfig[key] = storedConfig[key];
-                }
-            }
-            await storageSet({
-                config: updatedConfig,
-            });
-        }
+    enableLogs && console.log("Setting action state to", status);
+    const action = chrome.action || chrome.pageAction;
+    if (chrome.pageAction) {
+      chrome.pageAction.show(tabId);
     }
-    async function evalInTab(tabId, frameId, code) {
-        if (manifestVersion === 2) {
-            return new Promise((resolve) => {
-                chrome.tabs.executeScript(tabId, {
-                    frameId,
-                    code: `!!window.eval(decodeURIComponent("${encodeURIComponent(code)}"))`
-                }, (resultArr) => {
-                    resolve([{
-                            result: resultArr[0],
-                            frameId,
-                        }]);
-                });
-            });
+    await action.setTitle({
+      tabId,
+      title
+    });
+    await action.setIcon({
+      tabId,
+      path: icon
+    });
+  }
+
+  // addon/background.ts
+  var openDevToolsPanels = /* @__PURE__ */ new Map();
+  async function loadRules() {
+    const res = await fetch("./rules.json");
+    storageSet({
+      rules: await res.json()
+    });
+  }
+  async function initConfig() {
+    console.log("init sw");
+    const storedConfig = await storageGet("config");
+    console.log("storedConfig", storedConfig);
+    const defaultConfig = {
+      enabled: true,
+      autoAction: "optOut",
+      // if falsy, the extension will wait for an explicit user signal before opting in/out
+      disabledCmps: [],
+      enablePrehide: true,
+      enableCosmeticRules: true,
+      detectRetries: 20,
+      prehideTimeout: 2e3
+    };
+    if (!storedConfig) {
+      console.log("init config");
+      await storageSet({
+        config: defaultConfig
+      });
+    } else {
+      const updatedConfig = structuredClone(defaultConfig);
+      for (const key of Object.keys(defaultConfig)) {
+        if (typeof storedConfig[key] !== "undefined") {
+          updatedConfig[key] = storedConfig[key];
         }
-        return chrome.scripting.executeScript({
-            target: {
-                tabId,
-                frameIds: [frameId],
-            },
-            world: "MAIN",
-            args: [code],
-            func: (code) => {
-                try {
-                    return window.eval(code);
-                }
-                catch (e) {
-                    // ignore CSP errors
-                    console.warn('eval error', code, e);
-                    return;
-                }
-            },
-        });
-    }
-    async function getTabReports(tabId) {
-        const storageKey = `reports-${tabId}`;
-        return (await chrome.storage.session.get(storageKey))[storageKey] || {};
+      }
+      await storageSet({
+        config: updatedConfig
+      });
     }
-    async function updateTabReports(tabId, frameId, msg) {
-        const reportsForTab = await getTabReports(tabId);
-        reportsForTab[frameId] = msg;
-        await chrome.storage.session.set({ [`reports-${tabId}`]: reportsForTab });
-    }
-    chrome.runtime.onInstalled.addListener(() => {
-        loadRules();
-        initConfig();
-    });
+  }
+  async function evalInTab(tabId, frameId, code) {
     if (manifestVersion === 2) {
-        // always load rules on startup in MV2
-        loadRules();
-        initConfig();
+      return new Promise((resolve) => {
+        chrome.tabs.executeScript(tabId, {
+          frameId,
+          code: `!!window.eval(decodeURIComponent("${encodeURIComponent(code)}"))`
+        }, (resultArr) => {
+          resolve([{
+            result: resultArr[0],
+            frameId
+          }]);
+        });
+      });
     }
-    chrome.tabs.onRemoved.addListener((tabId) => {
-        storageRemove(`detected${tabId}`);
-    });
-    chrome.runtime.onMessage.addListener(async (msg, sender) => {
-        const tabId = sender.tab.id;
-        const frameId = sender.frameId;
-        const rules = await storageGet("rules");
-        const autoconsentConfig = await storageGet('config');
-        switch (msg.type) {
-            case "init":
-                if (frameId === 0) {
-                    await showOptOutStatus(tabId, 'idle');
-                }
-                chrome.tabs.sendMessage(tabId, {
-                    type: "initResp",
-                    rules,
-                    config: autoconsentConfig,
-                }, {
-                    frameId,
-                });
-                break;
-            case "eval":
-                evalInTab(tabId, frameId, msg.code).then(([result]) => {
-                    chrome.tabs.sendMessage(tabId, {
-                        id: msg.id,
-                        type: "evalResp",
-                        result: result.result,
-                    }, {
-                        frameId,
-                    });
-                });
-                break;
-            case "popupFound":
-                await showOptOutStatus(tabId, "available", msg.cmp);
-                storageSet({
-                    [`detected${tabId}`]: frameId,
-                });
-                break;
-            case "optOutResult":
-            case "optInResult":
-                if (msg.result) {
-                    await showOptOutStatus(tabId, "working", msg.cmp);
-                    if (msg.scheduleSelfTest) {
-                        await storageSet({
-                            [`selfTest${tabId}`]: frameId,
-                        });
-                    }
-                }
-                break;
-            case "selfTestResult":
-                if (msg.result) {
-                    await showOptOutStatus(tabId, "verified", msg.cmp);
-                }
-                break;
-            case "autoconsentDone": {
-                await showOptOutStatus(tabId, "success", msg.cmp);
-                // sometimes self-test needs to be done in another frame
-                const selfTestKey = `selfTest${tabId}`;
-                const selfTestFrameId = (await chrome.storage.local.get(selfTestKey))?.[selfTestKey];
-                if (typeof selfTestFrameId === 'number') {
-                    storageRemove(selfTestKey);
-                    chrome.tabs.sendMessage(tabId, {
-                        type: "selfTest",
-                    }, {
-                        frameId: selfTestFrameId,
-                    });
-                }
-                break;
-            }
-            case "autoconsentError":
-                console.error('Error:', msg.details);
-                break;
-            case "report":
-                if (sender.tab && openDevToolsPanels.has(sender.tab.id)) {
-                    openDevToolsPanels.get(sender.tab.id).postMessage({
-                        tabId: sender.tab.id,
-                        frameId: sender.frameId,
-                        ...msg,
-                    });
-                }
-                updateTabReports(sender.tab.id, sender.frameId, msg);
-                break;
+    return chrome.scripting.executeScript({
+      target: {
+        tabId,
+        frameIds: [frameId]
+      },
+      world: "MAIN",
+      args: [code],
+      func: (code2) => {
+        try {
+          return window.eval(code2);
+        } catch (e) {
+          console.warn("eval error", code2, e);
+          return;
         }
+      }
     });
-    if (manifestVersion === 2) { // MV3 handles this inside the popup
-        chrome.pageAction.onClicked.addListener(async (tab) => {
-            const tabId = tab.id;
-            const detectedKey = `detected${tabId}`;
-            const frameId = await storageGet(detectedKey);
-            if (typeof frameId === 'number') {
-                storageRemove(detectedKey);
-                await showOptOutStatus(tabId, "working");
-                chrome.tabs.sendMessage(tabId, {
-                    type: "optOut",
-                }, {
-                    frameId,
-                });
+  }
+  async function getTabReports(tabId) {
+    const storageKey = `reports-${tabId}`;
+    return (await chrome.storage.session.get(storageKey))[storageKey] || {};
+  }
+  async function updateTabReports(tabId, frameId, msg) {
+    const reportsForTab = await getTabReports(tabId);
+    reportsForTab[frameId] = msg;
+    await chrome.storage.session.set({ [`reports-${tabId}`]: reportsForTab });
+  }
+  chrome.runtime.onInstalled.addListener(() => {
+    loadRules();
+    initConfig();
+  });
+  if (manifestVersion === 2) {
+    loadRules();
+    initConfig();
+  }
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    storageRemove(`detected${tabId}`);
+  });
+  chrome.runtime.onMessage.addListener(
+    async (msg, sender) => {
+      const tabId = sender.tab.id;
+      const frameId = sender.frameId;
+      if (enableLogs) {
+        console.groupCollapsed(`${msg.type} from ${sender.origin || sender.url}`);
+        console.log(msg, sender);
+        console.groupEnd();
+      }
+      const rules = await storageGet("rules");
+      const autoconsentConfig = await storageGet("config");
+      enableLogs && console.log("got config", autoconsentConfig);
+      switch (msg.type) {
+        case "init":
+          if (frameId === 0) {
+            await showOptOutStatus(tabId, "idle");
+          }
+          chrome.tabs.sendMessage(tabId, {
+            type: "initResp",
+            rules,
+            config: autoconsentConfig
+          }, {
+            frameId
+          });
+          break;
+        case "eval":
+          evalInTab(tabId, frameId, msg.code).then(([result]) => {
+            if (enableLogs) {
+              console.groupCollapsed(`eval result for ${sender.origin || sender.url}`);
+              console.log(msg.code, result.result);
+              console.groupEnd();
             }
-        });
-    }
-    // Communicate with devtools panels
-    chrome.runtime.onConnect.addListener(function (devToolsConnection) {
-        if (devToolsConnection.name.startsWith('instance-')) {
-            // connection from an autoconsent instance - used to detect frame destruction
-            const tabId = devToolsConnection.sender?.tab?.id;
-            const instanceId = devToolsConnection.name.slice('instance-'.length);
-            if (tabId && instanceId) {
-                devToolsConnection.onDisconnect.addListener(() => {
-                    if (openDevToolsPanels.has(tabId)) {
-                        openDevToolsPanels.get(tabId).postMessage({
-                            type: 'instanceTerminated',
-                            tabId,
-                            instanceId,
-                        });
-                    }
-                    // remove stored frame data
-                    updateTabReports(tabId, devToolsConnection.sender.frameId, undefined);
-                });
+            chrome.tabs.sendMessage(tabId, {
+              id: msg.id,
+              type: "evalResp",
+              result: result.result
+            }, {
+              frameId
+            });
+          });
+          break;
+        case "popupFound":
+          await showOptOutStatus(tabId, "available", msg.cmp);
+          storageSet({
+            [`detected${tabId}`]: frameId
+          });
+          break;
+        case "optOutResult":
+        case "optInResult":
+          if (msg.result) {
+            await showOptOutStatus(tabId, "working", msg.cmp);
+            if (msg.scheduleSelfTest) {
+              await storageSet({
+                [`selfTest${tabId}`]: frameId
+              });
             }
+          }
+          break;
+        case "selfTestResult":
+          if (msg.result) {
+            await showOptOutStatus(tabId, "verified", msg.cmp);
+          }
+          break;
+        case "autoconsentDone": {
+          await showOptOutStatus(tabId, "success", msg.cmp);
+          const selfTestKey = `selfTest${tabId}`;
+          const selfTestFrameId = (await chrome.storage.local.get(selfTestKey))?.[selfTestKey];
+          if (typeof selfTestFrameId === "number") {
+            enableLogs && console.log(`Requesting self-test in ${selfTestFrameId}`);
+            storageRemove(selfTestKey);
+            chrome.tabs.sendMessage(tabId, {
+              type: "selfTest"
+            }, {
+              frameId: selfTestFrameId
+            });
+          } else {
+            enableLogs && console.log(`No self-test scheduled`);
+          }
+          break;
         }
-        else if (devToolsConnection.name === 'devtools-panel') {
-            let tabId = -1;
-            // add the listener
-            devToolsConnection.onMessage.addListener(async (message) => {
-                tabId = message.tabId;
-                if (message.type === 'init') {
-                    // save the message channel for this tab
-                    openDevToolsPanels.set(tabId, devToolsConnection);
-                    // dump data cached in bg to the panel
-                    const reportsForTab = await getTabReports(tabId);
-                    Object.keys(reportsForTab || {}).forEach((frameId) => {
-                        devToolsConnection.postMessage({
-                            tabId,
-                            frameId,
-                            ...reportsForTab[parseInt(frameId, 10)]
-                        });
-                    });
-                }
+        case "autoconsentError":
+          console.error("Error:", msg.details);
+          break;
+        case "report":
+          if (sender.tab && openDevToolsPanels.has(sender.tab.id)) {
+            openDevToolsPanels.get(sender.tab.id).postMessage({
+              tabId: sender.tab.id,
+              frameId: sender.frameId,
+              ...msg
+            });
+          }
+          updateTabReports(sender.tab.id, sender.frameId, msg);
+          break;
+      }
+    }
+  );
+  if (manifestVersion === 2) {
+    chrome.pageAction.onClicked.addListener(async (tab) => {
+      const tabId = tab.id;
+      const detectedKey = `detected${tabId}`;
+      const frameId = await storageGet(detectedKey);
+      if (typeof frameId === "number") {
+        storageRemove(detectedKey);
+        enableLogs && console.log("action.onClicked", tabId, frameId);
+        await showOptOutStatus(tabId, "working");
+        chrome.tabs.sendMessage(tabId, {
+          type: "optOut"
+        }, {
+          frameId
+        });
+      }
+    });
+  }
+  chrome.runtime.onConnect.addListener(function(devToolsConnection) {
+    if (devToolsConnection.name.startsWith("instance-")) {
+      const tabId = devToolsConnection.sender?.tab?.id;
+      const instanceId = devToolsConnection.name.slice("instance-".length);
+      if (tabId && instanceId) {
+        devToolsConnection.onDisconnect.addListener(() => {
+          if (openDevToolsPanels.has(tabId)) {
+            openDevToolsPanels.get(tabId).postMessage({
+              type: "instanceTerminated",
+              tabId,
+              instanceId
             });
-            devToolsConnection.onDisconnect.addListener(function () {
-                openDevToolsPanels.delete(tabId);
+          }
+          updateTabReports(tabId, devToolsConnection.sender.frameId, void 0);
+        });
+      }
+    } else if (devToolsConnection.name === "devtools-panel") {
+      let tabId = -1;
+      devToolsConnection.onMessage.addListener(async (message) => {
+        tabId = message.tabId;
+        if (message.type === "init") {
+          openDevToolsPanels.set(tabId, devToolsConnection);
+          const reportsForTab = await getTabReports(tabId);
+          Object.keys(reportsForTab || {}).forEach((frameId) => {
+            devToolsConnection.postMessage({
+              tabId,
+              frameId,
+              ...reportsForTab[parseInt(frameId, 10)]
             });
+          });
         }
-    });
-    chrome.tabs.onRemoved.addListener((tabId) => {
-        chrome.storage.session.remove(`reports-${tabId}`);
-    });
-
+      });
+      devToolsConnection.onDisconnect.addListener(function() {
+        openDevToolsPanels.delete(tabId);
+      });
+    }
+  });
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    chrome.storage.session.remove(`reports-${tabId}`);
+  });
 })();