Release build 4.11.2 [ci release]

Author: jonathanKingston

.eslintrc

@@ -1,9 +1,12 @@
 {
-    "extends": "standard",
+    "extends": ["standard", "plugin:@typescript-eslint/recommended"],
     "root": true,
     "parserOptions": {
       "ecmaVersion": "latest",
+      "project": "./tsconfig.json"
     },
+    "parser": "@typescript-eslint/parser",
+    "plugins": ["promise","@typescript-eslint"],
     "globals": {
         "$USER_PREFERENCES$": "readonly",
         "$USER_UNPROTECTED_DOMAINS$": "readonly",
@@ -12,7 +15,10 @@
         "$BUNDLED_CONFIG$": "readonly"
     },
     "rules": {
-        "indent": ["error", 4]
+        "indent": ["error", 4],
+        "require-await": ["error"],
+        "promise/prefer-await-to-then": ["error"],
+        "@typescript-eslint/await-thenable": "error"
     },
     "env": {
         "webextensions": true,

Sources/ContentScopeScripts/dist/contentScope.js

@@ -430,19 +430,77 @@
     /**
      * @typedef {object} Platform
      * @property {'ios' | 'macos' | 'extension' | 'android' | 'windows'} name
-     * @property {string} [version]
+     * @property {string | number } [version]
      */
 
     /**
      * @typedef {object} UserPreferences
      * @property {Platform} platform
      * @property {boolean} [debug]
      * @property {boolean} [globalPrivacyControl]
+     * @property {number} [versionNumber] - Android version number only
+     * @property {string} [versionString] - Non Android version string
      * @property {string} sessionKey
      */
 
     /**
-     * @param {{ features: Record<string, { state: string; settings: any; exceptions: string[] }>; unprotectedTemporary: string; }} data
+     * Expansion point to add platform specific versioning logic
+     * @param {UserPreferences} preferences
+     * @returns {string | number | undefined}
+     */
+    function getPlatformVersion (preferences) {
+        if (preferences.versionNumber) {
+            return preferences.versionNumber
+        }
+        if (preferences.versionString) {
+            return preferences.versionString
+        }
+        return undefined
+    }
+
+    function parseVersionString (versionString) {
+        const [major = 0, minor = 0, patch = 0] = versionString.split('.').map(Number);
+        return {
+            major,
+            minor,
+            patch
+        }
+    }
+
+    /**
+     * @param {string} minVersionString
+     * @param {string} applicationVersionString
+     * @returns {boolean}
+     */
+    function satisfiesMinVersion (minVersionString, applicationVersionString) {
+        const { major: minMajor, minor: minMinor, patch: minPatch } = parseVersionString(minVersionString);
+        const { major, minor, patch } = parseVersionString(applicationVersionString);
+
+        return (major > minMajor ||
+                (major >= minMajor && minor > minMinor) ||
+                (major >= minMajor && minor >= minMinor && patch >= minPatch))
+    }
+
+    /**
+     * @param {string | number | undefined} minSupportedVersion
+     * @param {string | number | undefined} currentVersion
+     * @returns {boolean}
+     */
+    function isSupportedVersion (minSupportedVersion, currentVersion) {
+        if (typeof currentVersion === 'string' && typeof minSupportedVersion === 'string') {
+            if (satisfiesMinVersion(minSupportedVersion, currentVersion)) {
+                return true
+            }
+        } else if (typeof currentVersion === 'number' && typeof minSupportedVersion === 'number') {
+            if (minSupportedVersion <= currentVersion) {
+                return true
+            }
+        }
+        return false
+    }
+
+    /**
+     * @param {{ features: Record<string, { state: string; settings: any; exceptions: string[], minSupportedVersion?: string|number }>; unprotectedTemporary: string[]; }} data
      * @param {string[]} userList
      * @param {UserPreferences} preferences
      * @param {string[]} platformSpecificFeatures
@@ -452,13 +510,25 @@
         const allowlisted = userList.filter(domain => domain === topLevelHostname).length > 0;
         const remoteFeatureNames = Object.keys(data.features);
         const platformSpecificFeaturesNotInRemoteConfig = platformSpecificFeatures.filter((featureName) => !remoteFeatureNames.includes(featureName));
+        /** @type {Record<string, any>} */
+        const output = { ...preferences };
+        if (output.platform) {
+            const version = getPlatformVersion(preferences);
+            if (version) {
+                output.platform.version = version;
+            }
+        }
         const enabledFeatures = remoteFeatureNames.filter((featureName) => {
             const feature = data.features[featureName];
+            // Check that the platform supports minSupportedVersion checks and that the feature has a minSupportedVersion
+            if (feature.minSupportedVersion && preferences.platform?.version) {
+                if (!isSupportedVersion(feature.minSupportedVersion, preferences.platform.version)) {
+                    return false
+                }
+            }
             return feature.state === 'enabled' && !isUnprotectedDomain(topLevelHostname, feature.exceptions)
         }).concat(platformSpecificFeaturesNotInRemoteConfig); // only disable platform specific features if it's explicitly disabled in remote config
         const isBroken = isUnprotectedDomain(topLevelHostname, data.unprotectedTemporary);
-        /** @type {Record<string, any>} */
-        const output = { ...preferences };
         output.site = {
             domain: topLevelHostname,
             isBroken,
@@ -518,7 +588,8 @@
         'fingerprintingTemporaryStorage',
         'navigatorInterface',
         'clickToLoad',
-        'elementHiding'
+        'elementHiding',
+        'exceptionHandler'
     ];
 
     /**
@@ -577,6 +648,7 @@
          case './features/click-to-play.js': return Promise.resolve().then(function () { return clickToPlay; });
          case './features/cookie.js': return Promise.resolve().then(function () { return cookie; });
          case './features/element-hiding.js': return Promise.resolve().then(function () { return elementHiding; });
+         case './features/exception-handler.js': return Promise.resolve().then(function () { return exceptionHandler; });
          case './features/fingerprinting-audio.js': return Promise.resolve().then(function () { return fingerprintingAudio; });
          case './features/fingerprinting-battery.js': return Promise.resolve().then(function () { return fingerprintingBattery; });
          case './features/fingerprinting-canvas.js': return Promise.resolve().then(function () { return fingerprintingCanvas; });
@@ -624,14 +696,15 @@
     /**
      * @param {LoadArgs} args
      */
-    async function load (args) {
+    function load (args) {
         const mark = performanceMonitor.mark('load');
         if (!shouldRun()) {
             return
         }
 
         for (const featureName of featureNames) {
             const filename = featureName.replace(/([a-zA-Z])(?=[A-Z0-9])/g, '$1-').toLowerCase();
+            // eslint-disable-next-line promise/prefer-await-to-then
             const feature = __variableDynamicImportRuntime0__(`./features/${filename}.js`).then((exported) => {
                 const ContentFeature = exported.default;
                 const featureInstance = new ContentFeature(featureName);
@@ -2273,6 +2346,7 @@
             })
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
         init (args) {
         }
 
@@ -2285,6 +2359,7 @@
             this.measure();
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
         load (args) {
         }
 
@@ -2302,11 +2377,12 @@
             }
         }
 
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
         update () {
         }
     }
 
-    // @ts-nocheck
+    // TODO - Remove these comments to enable full linting.
 
     let devMode$1 = false;
     let isYoutubePreviewsEnabled$1 = false;
@@ -2530,13 +2606,13 @@
         }
 
         /*
-            * Fades out the given element. Returns a promise that resolves when the fade is complete.
-            * @param {Element} element - the element to fade in or out
-            * @param {int} interval - frequency of opacity updates (ms)
-            * @param {bool} fadeIn - true if the element should fade in instead of out
-            */
+         * Fades out the given element. Returns a promise that resolves when the fade is complete.
+         * @param {Element} element - the element to fade in or out
+         * @param {int} interval - frequency of opacity updates (ms)
+         * @param {boolean} fadeIn - true if the element should fade in instead of out
+         */
         fadeElement (element, interval, fadeIn) {
-            return new Promise((resolve, reject) => {
+            return new Promise(resolve => {
                 let opacity = fadeIn ? 0 : 1;
                 const originStyle = element.style.cssText;
                 const fadeOut = setInterval(function () {
@@ -2560,7 +2636,7 @@
 
         clickFunction (originalElement, replacementElement) {
             let clicked = false;
-            const handleClick = async function handleClick (e) {
+            const handleClick = function handleClick (e) {
                 // Ensure that the click is created by a user event & prevent double clicks from adding more animations
                 if (e.isTrusted && !clicked) {
                     this.isUnblocked = true;
@@ -2633,15 +2709,13 @@
                         parent.replaceChild(fbContainer, replacementElement);
                         fbContainer.appendChild(replacementElement);
                         fadeIn.appendChild(fbElement);
-                        fbElement.addEventListener('load', () => {
-                            this.fadeOutElement(replacementElement)
-                                .then(v => {
-                                    fbContainer.replaceWith(fbElement);
-                                    this.dispatchEvent(fbElement, 'ddg-ctp-placeholder-clicked');
-                                    this.fadeInElement(fadeIn).then(() => {
-                                        fbElement.focus(); // focus on new element for screen readers
-                                    });
-                                });
+                        fbElement.addEventListener('load', async () => {
+                            await this.fadeOutElement(replacementElement);
+                            fbContainer.replaceWith(fbElement);
+                            this.dispatchEvent(fbElement, 'ddg-ctp-placeholder-clicked');
+                            await this.fadeInElement(fadeIn);
+                            // Focus on new element for screen readers.
+                            fbElement.focus();
                         }, { once: true });
                         // Note: This event only fires on Firefox, on Chrome the frame's
                         //       load event will always fire.
@@ -2840,7 +2914,7 @@
      * @typedef unblockClickToLoadContentRequest
      * @property {string} entity
      *   The entity to unblock requests for (e.g. "Facebook, Inc.").
-     * @property {bool} [isLogin=false]
+     * @property {boolean} [isLogin=false]
      *   True if we should "allow social login", defaults to false.
      * @property {string} action
      *   The Click to Load blocklist rule action (e.g. "block-ctl-fb") that should
@@ -2853,7 +2927,7 @@
      * Send a message to the background to unblock requests for the given entity for
      * the page.
      * @param {unblockClickToLoadContentRequest} message
-     * @see {@event ddg-ctp-unblockClickToLoadContent-complete} for the response handler.
+     * @see {@link ddg-ctp-unblockClickToLoadContent-complete} for the response handler.
      */
     function unblockClickToLoadContent$1 (message) {
         sendMessage('unblockClickToLoadContent', message);
@@ -6185,13 +6259,13 @@
         }
 
         getExpiry () {
-            // @ts-ignore
+            // @ts-expect-error expires is not defined in the type definition
             if (!this.maxAge && !this.expires) {
                 return NaN
             }
             const expiry = this.maxAge
                 ? parseInt(this.maxAge)
-                // @ts-ignore
+                // @ts-expect-error expires is not defined in the type definition
                 : (new Date(this.expires) - new Date()) / 1000;
             return expiry
         }
@@ -6745,6 +6819,28 @@
         default: ElementHiding
     });
 
+    class ExceptionHandler extends ContentFeature {
+        init () {
+            // Report to the debugger panel if an uncaught exception occurs
+            function handleUncaughtException (e) {
+                postDebugMessage('jsException', {
+                    documentUrl: document.location.href,
+                    message: e.message,
+                    filename: e.filename,
+                    lineno: e.lineno,
+                    colno: e.colno,
+                    stack: e.error.stack
+                });
+            }
+            globalThis.addEventListener('error', handleUncaughtException);
+        }
+    }
+
+    var exceptionHandler = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        default: ExceptionHandler
+    });
+
     // @ts-nocheck
         const sjcl = (() => {
     /*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
@@ -8968,6 +9064,7 @@
         try {
             defineProperty(globalThis, property, {
                 get: () => value,
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
                 set: () => {},
                 configurable: true
             });
@@ -10279,6 +10376,7 @@
                             return Promise.reject(new DOMException('Pan-tilt-zoom is not supported'))
                         }
 
+                        // eslint-disable-next-line promise/prefer-await-to-then
                         return DDGReflect.apply(target, thisArg, args).then(function (stream) {
                             console.debug(`User stream ${stream.id} has been acquired`);
                             userMediaStreams.add(stream);

build-output.eslintrc

@@ -1,11 +1,12 @@
 {
     "root": true,
-    "plugins": ["@typescript-eslint"],
+    "plugins": ["promise", "@typescript-eslint"],
     "parserOptions": {
       "ecmaVersion": "latest",
     },
     "rules": {
         "no-implicit-globals": "error",
-        "typescript-eslint/ban-ts-comment": "off"
+        "typescript-eslint/ban-ts-comment": "off",
+        "promise/prefer-await-to-then": "off",
     }
 }