Dual support for custom error schema

Author: mgurgel

special-pages/pages/duckplayer/app/settings.js

@@ -1,26 +1,69 @@
 const DEFAULT_SIGN_IN_REQURED_HREF = '[href*="//support.google.com/youtube/answer/3037019"]';
 
+/**
+ * @typedef {object} CustomErrorSettings
+ * @property {'enabled'|'disabled'} state
+ * @property {object} [settings]
+ * @property {string} [settings.signInRequiredSelector]
+*/
+
 export class Settings {
     /**
      * @param {object} params
      * @param {{name: ImportMeta['platform']}} [params.platform]
      * @param {{state: 'enabled' | 'disabled'}} [params.pip]
      * @param {{state: 'enabled' | 'disabled'}} [params.autoplay]
      * @param {{state: 'enabled' | 'disabled'}} [params.focusMode]
-     * @param {import("../types/duckplayer.js").InitialSetupResponse['settings']['customError']} [params.customError]
+     * @param {import("../types/duckplayer.js").DuckPlayerPageSettings['customError']} [params.customError]
      */
     constructor({
         platform = { name: 'macos' },
         pip = { state: 'disabled' },
         autoplay = { state: 'enabled' },
         focusMode = { state: 'enabled' },
-        customError = { state: 'disabled', signInRequiredSelector: '' },
+        customError = { state: 'disabled', settings: {}, signInRequiredSelector: '' },
     }) {
         this.platform = platform;
         this.pip = pip;
         this.autoplay = autoplay;
         this.focusMode = focusMode;
-        this.customError = customError;
+        this.customError = this.parseLegacyCustomError(customError);
+    }
+
+    /**
+     * Parses custom error settings so that both old and new schemas are accepted.
+     *
+     * Old schema:
+     * {
+     *   state: "enabled",
+     *   signInRequiredSelector: "div"
+     * }
+     *
+     * New schema:
+     * {
+     *   state: "disabled",
+     *   settings: {
+     *     signInRequiredSelector: "div"
+     *   }
+     * }
+     *
+     * @param {import("../types/duckplayer.js").InitialSetupResponse['settings']['customError']} customErrorSettings
+     * @return {CustomErrorSettings}
+     */
+    parseLegacyCustomError(customErrorSettings) {
+        if (!customErrorSettings || customErrorSettings.state !== 'enabled') {
+            return { state: 'disabled'};
+        }
+
+        const { settings, signInRequiredSelector } = customErrorSettings;
+
+        return {
+            state: 'enabled',
+            settings: {
+                ...settings,
+                ...(signInRequiredSelector && { signInRequiredSelector })
+            }
+        };
     }
 
     /**

special-pages/pages/duckplayer/messages/initialSetup.response.json

@@ -42,15 +42,24 @@
         "customError": {
           "type": "object",
           "description": "Configures a custom error message for YouTube errors",
-          "required": ["state", "signInRequiredSelector"],
+          "required": ["state"],
           "properties": {
             "state": {
               "type": "string",
               "enum": ["enabled", "disabled"]
             },
+            "settings": {
+              "type": "object",
+              "description": "Custom error settings",
+              "properties": {
+                "signInRequiredSelector": {
+                  "$ref": "#/definitions/signInRequiredSelector"
+                }
+              }
+            },
             "signInRequiredSelector": {
-              "description": "A selector that, when not empty, indicates a sign-in required error",
-              "type": "string"
+              "$ref": "#/definitions/signInRequiredSelector",
+              "$comment": "This setting is duplicated at the top level until Apple and Windows are migrated to the settings object above"
             }
           }
         }
@@ -77,5 +86,11 @@
       "type": "string",
       "description": "Optional locale-specific strings"
     }
+  },
+  "definitions": {
+    "signInRequiredSelector": {
+      "description": "A selector that, when not empty, indicates a sign-in required error",
+      "type": "string"
+    }
   }
 }

special-pages/pages/duckplayer/types/duckplayer.ts

@@ -134,10 +134,19 @@ export interface DuckPlayerPageSettings {
    */
   customError?: {
     state: "enabled" | "disabled";
+    /**
+     * Custom error settings
+     */
+    settings?: {
+      /**
+       * A selector that, when not empty, indicates a sign-in required error
+       */
+      signInRequiredSelector?: string;
+    };
     /**
      * A selector that, when not empty, indicates a sign-in required error
      */
-    signInRequiredSelector: string;
+    signInRequiredSelector?: string;
   };
 }
 /**

special-pages/pages/duckplayer/unit-tests/settings.mjs

@@ -0,0 +1,78 @@
+import { describe, it } from 'node:test';
+import { deepEqual } from 'node:assert/strict';
+import { Settings } from '../app/settings.js';
+
+describe('parses settings', () => {
+    it('handles disabled custom error schema', () => {
+        const settings = new Settings({
+            customError: {
+                state: 'disabled'
+            }
+        });
+        const expected = {
+            state: 'disabled'
+        };
+
+        deepEqual(settings.customError, expected);
+    });
+    it('handles old custom error schema', () => {
+        const settings = new Settings({
+            customError: {
+                state: 'enabled',
+                signInRequiredSelector: 'div'
+            }
+        });
+        const expected = {
+            state: 'enabled',
+            settings: {
+                signInRequiredSelector: 'div'
+            }
+        };
+
+        deepEqual(settings.customError, expected);
+    });
+    it('handles new custom error schema', () => {
+        const settings = new Settings({
+            customError: {
+                state: 'enabled',
+                settings: {
+                    signInRequiredSelector: 'div'
+                }
+            }
+        });
+        const expected = {
+            state: 'enabled',
+            settings: {
+                signInRequiredSelector: 'div'
+            }
+        };
+
+        deepEqual(settings.customError, expected);
+    });
+    it('handles custom error enabled without settings', () => {
+        const settings = new Settings({
+            customError: {
+                state: 'enabled'
+            }
+        });
+        const expected = {
+            state: 'enabled',
+            settings: {}
+        };
+
+        deepEqual(settings.customError, expected);
+    });
+    it('handles malformed custom error schema', () => {
+        const settings = new Settings({
+            customError: {
+                // @ts-expect-error - Malformed object on purpose
+                status: 'enabled'
+            }
+        });
+        const expected = {
+            state: 'disabled'
+        };
+
+        deepEqual(settings.customError, expected);
+    });
+});