QOL: Move source code under the src directory. (#1318)

src/plugins/adblocker/.gitignore

@@ -0,0 +1 @@
+/ad-blocker-engine.bin

src/plugins/adblocker/back.ts

@@ -0,0 +1,19 @@
+import { BrowserWindow } from 'electron';
+
+import { loadAdBlockerEngine } from './blocker';
+import { shouldUseBlocklists } from './config';
+
+import type { ConfigType } from '../../config/dynamic';
+
+type AdBlockOptions = ConfigType<'adblocker'>;
+
+export default async (win: BrowserWindow, options: AdBlockOptions) => {
+  if (shouldUseBlocklists()) {
+    await loadAdBlockerEngine(
+      win.webContents.session,
+      options.cache,
+      options.additionalBlockLists,
+      options.disableDefaultLists,
+    );
+  }
+};

src/plugins/adblocker/blocker-types.ts

@@ -0,0 +1,4 @@
+export const blockers = {
+  WithBlocklists: 'With blocklists',
+  InPlayer: 'In player',
+} as const;

src/plugins/adblocker/blocker.ts

@@ -0,0 +1,67 @@
+// Used for caching
+import path from 'node:path';
+import fs, { promises } from 'node:fs';
+
+import { ElectronBlocker } from '@cliqz/adblocker-electron';
+import { app, net } from 'electron';
+
+const SOURCES = [
+  'https://raw.githubusercontent.com/kbinani/adblock-youtube-ads/master/signed.txt',
+  // UBlock Origin
+  'https://raw.githubusercontent.com/uBlockOrigin/uAssets/master/filters/filters.txt',
+  'https://raw.githubusercontent.com/uBlockOrigin/uAssets/master/filters/filters-2020.txt',
+  'https://raw.githubusercontent.com/uBlockOrigin/uAssets/master/filters/filters-2021.txt',
+  'https://raw.githubusercontent.com/uBlockOrigin/uAssets/master/filters/filters-2022.txt',
+  'https://raw.githubusercontent.com/uBlockOrigin/uAssets/master/filters/filters-2023.txt',
+  // Fanboy Annoyances
+  'https://secure.fanboy.co.nz/fanboy-annoyance_ubo.txt',
+];
+
+export const loadAdBlockerEngine = async (
+  session: Electron.Session | undefined = undefined,
+  cache = true,
+  additionalBlockLists = [],
+  disableDefaultLists: boolean | unknown[] = false,
+) => {
+  // Only use cache if no additional blocklists are passed
+  const cacheDirectory = path.join(app.getPath('userData'), 'adblock_cache');
+  if (!fs.existsSync(cacheDirectory)) {
+    fs.mkdirSync(cacheDirectory);
+  }
+  const cachingOptions
+    = cache && additionalBlockLists.length === 0
+    ? {
+      path: path.join(cacheDirectory, 'adblocker-engine.bin'),
+      read: promises.readFile,
+      write: promises.writeFile,
+    }
+    : undefined;
+  const lists = [
+    ...(
+      (disableDefaultLists && !Array.isArray(disableDefaultLists)) ||
+      (Array.isArray(disableDefaultLists) && disableDefaultLists.length > 0) ? [] : SOURCES
+    ),
+    ...additionalBlockLists,
+  ];
+
+  try {
+    const blocker = await ElectronBlocker.fromLists(
+      (url: string) => net.fetch(url),
+      lists,
+      {
+        // When generating the engine for caching, do not load network filters
+        // So that enhancing the session works as expected
+        // Allowing to define multiple webRequest listeners
+        loadNetworkFilters: session !== undefined,
+      },
+      cachingOptions,
+    );
+    if (session) {
+      blocker.enableBlockingInSession(session);
+    }
+  } catch (error) {
+    console.log('Error loading adBlocker engine', error);
+  }
+};
+
+export default { loadAdBlockerEngine };

src/plugins/adblocker/config.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/await-thenable */
+/* renderer */
+
+import { blockers } from './blocker-types';
+
+import { PluginConfig } from '../../config/dynamic';
+
+const config = new PluginConfig('adblocker', { enableFront: true });
+
+export const shouldUseBlocklists = () => config.get('blocker') !== blockers.InPlayer;
+
+export default Object.assign(config, {
+  shouldUseBlocklists,
+  blockers,
+});

src/plugins/adblocker/inject-cliqz-preload.ts

@@ -0,0 +1,3 @@
+export default async () => {
+  await import('@cliqz/adblocker-electron-preload');
+};

src/plugins/adblocker/inject.d.ts

@@ -0,0 +1,3 @@
+const inject: () => void;
+
+export default inject;

src/plugins/adblocker/inject.js

@@ -0,0 +1,435 @@
+/* eslint-disable */
+
+// Source: https://addons.mozilla.org/en-US/firefox/addon/adblock-for-youtube/
+// https://robwu.nl/crxviewer/?crx=https%3A%2F%2Faddons.mozilla.org%2Fen-US%2Ffirefox%2Faddon%2Fadblock-for-youtube%2F
+
+/*
+  Parts of this code is derived from set-constant.js:
+  https://github.com/gorhill/uBlock/blob/5de0ce975753b7565759ac40983d31978d1f84ca/assets/resources/scriptlets.js#L704
+  */
+module.exports = () => {
+  {
+    const pruner = function (o) {
+      delete o.playerAds;
+      delete o.adPlacements;
+      //
+      if (o.playerResponse) {
+        delete o.playerResponse.playerAds;
+        delete o.playerResponse.adPlacements;
+      }
+
+      //
+      return o;
+    };
+
+    JSON.parse = new Proxy(JSON.parse, {
+      apply() {
+        return pruner(Reflect.apply(...arguments));
+      },
+    });
+
+    Response.prototype.json = new Proxy(Response.prototype.json, {
+      apply() {
+        return Reflect.apply(...arguments).then((o) => pruner(o));
+      },
+    });
+  }
+
+  (function () {
+    let cValue = 'undefined';
+    const chain = 'playerResponse.adPlacements';
+    const thisScript = document.currentScript;
+    //
+    switch (cValue) {
+      case 'null': {
+        cValue = null;
+        break;
+      }
+
+      case "''": {
+        cValue = '';
+        break;
+      }
+
+      case 'true': {
+        cValue = true;
+        break;
+      }
+
+      case 'false': {
+        cValue = false;
+        break;
+      }
+
+      case 'undefined': {
+        cValue = undefined;
+        break;
+      }
+
+      case 'noopFunc': {
+        cValue = function () {
+        };
+
+        break;
+      }
+
+      case 'trueFunc': {
+        cValue = function () {
+          return true;
+        };
+
+        break;
+      }
+
+      case 'falseFunc': {
+        cValue = function () {
+          return false;
+        };
+
+        break;
+      }
+
+      default: {
+        if (/^\d+$/.test(cValue)) {
+          cValue = Number.parseFloat(cValue);
+          //
+          if (isNaN(cValue)) {
+            return;
+          }
+
+          if (Math.abs(cValue) > 0x7F_FF) {
+            return;
+          }
+        } else {
+          return;
+        }
+      }
+    }
+
+    //
+    let aborted = false;
+    const mustAbort = function (v) {
+      if (aborted) {
+        return true;
+      }
+
+      aborted
+        = v !== undefined
+        && v !== null
+        && cValue !== undefined
+        && cValue !== null
+        && typeof v !== typeof cValue;
+      return aborted;
+    };
+
+    /*
+    Support multiple trappers for the same property:
+    https://github.com/uBlockOrigin/uBlock-issues/issues/156
+    */
+
+    const trapProp = function (owner, prop, configurable, handler) {
+      if (handler.init(owner[prop]) === false) {
+        return;
+      }
+
+      //
+      const odesc = Object.getOwnPropertyDescriptor(owner, prop);
+      let previousGetter;
+      let previousSetter;
+      if (odesc instanceof Object) {
+        if (odesc.configurable === false) {
+          return;
+        }
+
+        if (odesc.get instanceof Function) {
+          previousGetter = odesc.get;
+        }
+
+        if (odesc.set instanceof Function) {
+          previousSetter = odesc.set;
+        }
+      }
+
+      //
+      Object.defineProperty(owner, prop, {
+        configurable,
+        get() {
+          if (previousGetter !== undefined) {
+            previousGetter();
+          }
+
+          //
+          return handler.getter();
+        },
+        set(a) {
+          if (previousSetter !== undefined) {
+            previousSetter(a);
+          }
+
+          //
+          handler.setter(a);
+        },
+      });
+    };
+
+    const trapChain = function (owner, chain) {
+      const pos = chain.indexOf('.');
+      if (pos === -1) {
+        trapProp(owner, chain, false, {
+          v: undefined,
+          getter() {
+            return document.currentScript === thisScript ? this.v : cValue;
+          },
+          setter(a) {
+            if (mustAbort(a) === false) {
+              return;
+            }
+
+            cValue = a;
+          },
+          init(v) {
+            if (mustAbort(v)) {
+              return false;
+            }
+
+            //
+            this.v = v;
+            return true;
+          },
+        });
+        //
+        return;
+      }
+
+      //
+      const prop = chain.slice(0, pos);
+      const v = owner[prop];
+      //
+      chain = chain.slice(pos + 1);
+      if (v instanceof Object || (typeof v === 'object' && v !== null)) {
+        trapChain(v, chain);
+        return;
+      }
+
+      //
+      trapProp(owner, prop, true, {
+        v: undefined,
+        getter() {
+          return this.v;
+        },
+        setter(a) {
+          this.v = a;
+          if (a instanceof Object) {
+            trapChain(a, chain);
+          }
+        },
+        init(v) {
+          this.v = v;
+          return true;
+        },
+      });
+    };
+
+    //
+    trapChain(window, chain);
+  })();
+
+  (function () {
+    let cValue = 'undefined';
+    const thisScript = document.currentScript;
+    const chain = 'ytInitialPlayerResponse.adPlacements';
+    //
+    switch (cValue) {
+      case 'null': {
+        cValue = null;
+        break;
+      }
+
+      case "''": {
+        cValue = '';
+        break;
+      }
+
+      case 'true': {
+        cValue = true;
+        break;
+      }
+
+      case 'false': {
+        cValue = false;
+        break;
+      }
+
+      case 'undefined': {
+        cValue = undefined;
+        break;
+      }
+
+      case 'noopFunc': {
+        cValue = function () {
+        };
+
+        break;
+      }
+
+      case 'trueFunc': {
+        cValue = function () {
+          return true;
+        };
+
+        break;
+      }
+
+      case 'falseFunc': {
+        cValue = function () {
+          return false;
+        };
+
+        break;
+      }
+
+      default: {
+        if (/^\d+$/.test(cValue)) {
+          cValue = Number.parseFloat(cValue);
+          //
+          if (isNaN(cValue)) {
+            return;
+          }
+
+          if (Math.abs(cValue) > 0x7F_FF) {
+            return;
+          }
+        } else {
+          return;
+        }
+      }
+    }
+
+    //
+    let aborted = false;
+    const mustAbort = function (v) {
+      if (aborted) {
+        return true;
+      }
+
+      aborted
+        = v !== undefined
+        && v !== null
+        && cValue !== undefined
+        && cValue !== null
+        && typeof v !== typeof cValue;
+      return aborted;
+    };
+
+    /*
+    Support multiple trappers for the same property:
+    https://github.com/uBlockOrigin/uBlock-issues/issues/156
+    */
+
+    const trapProp = function (owner, prop, configurable, handler) {
+      if (handler.init(owner[prop]) === false) {
+        return;
+      }
+
+      //
+      const odesc = Object.getOwnPropertyDescriptor(owner, prop);
+      let previousGetter;
+      let previousSetter;
+      if (odesc instanceof Object) {
+        if (odesc.configurable === false) {
+          return;
+        }
+
+        if (odesc.get instanceof Function) {
+          previousGetter = odesc.get;
+        }
+
+        if (odesc.set instanceof Function) {
+          previousSetter = odesc.set;
+        }
+      }
+
+      //
+      Object.defineProperty(owner, prop, {
+        configurable,
+        get() {
+          if (previousGetter !== undefined) {
+            previousGetter();
+          }
+
+          //
+          return handler.getter();
+        },
+        set(a) {
+          if (previousSetter !== undefined) {
+            previousSetter(a);
+          }
+
+          //
+          handler.setter(a);
+        },
+      });
+    };
+
+    const trapChain = function (owner, chain) {
+      const pos = chain.indexOf('.');
+      if (pos === -1) {
+        trapProp(owner, chain, false, {
+          v: undefined,
+          getter() {
+            return document.currentScript === thisScript ? this.v : cValue;
+          },
+          setter(a) {
+            if (mustAbort(a) === false) {
+              return;
+            }
+
+            cValue = a;
+          },
+          init(v) {
+            if (mustAbort(v)) {
+              return false;
+            }
+
+            //
+            this.v = v;
+            return true;
+          },
+        });
+        //
+        return;
+      }
+
+      //
+      const prop = chain.slice(0, pos);
+      const v = owner[prop];
+      //
+      chain = chain.slice(pos + 1);
+      if (v instanceof Object || (typeof v === 'object' && v !== null)) {
+        trapChain(v, chain);
+        return;
+      }
+
+      //
+      trapProp(owner, prop, true, {
+        v: undefined,
+        getter() {
+          return this.v;
+        },
+        setter(a) {
+          this.v = a;
+          if (a instanceof Object) {
+            trapChain(a, chain);
+          }
+        },
+        init(v) {
+          this.v = v;
+          return true;
+        },
+      });
+    };
+
+    //
+    trapChain(window, chain);
+  })();
+};

src/plugins/adblocker/menu.ts

@@ -0,0 +1,21 @@
+import config from './config';
+
+import { blockers } from './blocker-types';
+
+import { MenuTemplate } from '../../menu';
+
+export default (): MenuTemplate => {
+  return [
+    {
+      label: 'Blocker',
+      submenu: Object.values(blockers).map((blocker: string) => ({
+        label: blocker,
+        type: 'radio',
+        checked: (config.get('blocker') || blockers.WithBlocklists) === blocker,
+        click() {
+          config.set('blocker', blocker);
+        },
+      })),
+    },
+  ];
+};

src/plugins/adblocker/preload.ts

@@ -0,0 +1,15 @@
+import config, { shouldUseBlocklists } from './config';
+import inject from './inject';
+import injectCliqzPreload from './inject-cliqz-preload';
+
+import { blockers } from './blocker-types';
+
+export default async () => {
+  if (shouldUseBlocklists()) {
+    // Preload adblocker to inject scripts/styles
+    await injectCliqzPreload();
+    // eslint-disable-next-line @typescript-eslint/await-thenable
+  } else if ((config.get('blocker')) === blockers.InPlayer) {
+    inject();
+  }
+};