send yt detection events

Made-with: Cursor

Author: jdorweiler

injected/integration-test/web-interference-detection-events.spec.js

@@ -27,7 +27,7 @@ test.describe('YouTube detection events via webInterferenceDetection', () => {
             (webEventMessages[0].payload).params;
         expect(params).toEqual({
             type: 'youtube_adBlocker',
-            data: {},
+            data: { loginState: 'unknown' },
         });
     });
 

injected/src/detectors/detections/youtube-ad-detection.js

@@ -29,12 +29,12 @@ export class YouTubeAdDetector {
     /**
      * @param {YouTubeDetectorConfig} config - Configuration from privacy-config (required)
      * @param {{info: Function, warn: Function, error: Function}} [logger] - Optional logger from ContentFeature
-     * @param {(type: string) => void} [onEvent] - Callback fired when a new detection occurs (may be async)
+     * @param {(type: string, data?: Record<string, unknown>) => void} [onEvent] - Callback fired when a new detection occurs (may be async)
      */
     constructor(config, logger, onEvent) {
         // Logger for debug output (only logs when debug mode is enabled)
         this.log = logger || noopLogger;
-        /** @type {(type: string) => void} */
+        /** @type {(type: string, data?: Record<string, unknown>) => void} */
         this.onEvent = onEvent || (() => {});
 
         // All config comes from privacy-config
@@ -134,7 +134,11 @@ export class YouTubeAdDetector {
 
         if (this.config.fireDetectionEvents?.[type]) {
             try {
-                const result = /** @type {any} */ (this.onEvent(`youtube_${type}`));
+                const result = /** @type {any} */ (
+                    this.onEvent(`youtube_${type}`, {
+                        loginState: this.state.loginState?.state || 'unknown',
+                    })
+                );
                 if (result && typeof result.catch === 'function') {
                     // eslint-disable-next-line promise/prefer-await-to-then
                     result.catch(() => {});

injected/src/features/web-interference-detection.js

@@ -20,9 +20,9 @@ export default class WebInterferenceDetection extends ContentFeature {
         // Get settings with conditionalChanges already applied by framework
         const settings = this.getFeatureSetting('interferenceTypes');
 
-        const fireEvent = async (type) => {
+        const fireEvent = async (type, data) => {
             try {
-                const result = await this.callFeatureMethod('webEvents', 'fireEvent', { type });
+                const result = await this.callFeatureMethod('webEvents', 'fireEvent', { type, data });
                 if (result instanceof CallFeatureMethodError && this.isDebug) {
                     this.log.warn('webEvents.fireEvent failed:', result.message);
                 }

injected/unit-test/youtube-ad-detection.js

@@ -26,25 +26,31 @@ const configWithAllEvents = {
 
 describe('YouTubeAdDetector', () => {
     describe('onEvent callback', () => {
-        it('calls onEvent with youtube_ prefix when a new detection occurs', () => {
+        it('calls onEvent with youtube_ prefix and loginState when a new detection occurs', () => {
             const events = [];
-            const detector = new YouTubeAdDetector(configWithAllEvents, undefined, (type) => events.push(type));
+            const detector = new YouTubeAdDetector(configWithAllEvents, undefined, (type, data) => events.push({ type, data }));
 
             detector.reportDetection('adBlocker');
 
-            expect(events).toEqual(['youtube_adBlocker']);
+            expect(events).toEqual([{ type: 'youtube_adBlocker', data: { loginState: 'unknown' } }]);
         });
 
-        it('fires for each detection type', () => {
+        it('fires for each detection type with loginState', () => {
             const events = [];
-            const detector = new YouTubeAdDetector(configWithAllEvents, undefined, (type) => events.push(type));
+            const detector = new YouTubeAdDetector(configWithAllEvents, undefined, (type, data) => events.push({ type, data }));
 
             detector.reportDetection('videoAd');
             detector.reportDetection('playabilityError', { message: 'error' });
             detector.reportDetection('adBlocker');
             detector.reportDetection('staticAd');
 
-            expect(events).toEqual(['youtube_videoAd', 'youtube_playabilityError', 'youtube_adBlocker', 'youtube_staticAd']);
+            expect(events.map((e) => e.type)).toEqual([
+                'youtube_videoAd',
+                'youtube_playabilityError',
+                'youtube_adBlocker',
+                'youtube_staticAd',
+            ]);
+            events.forEach((e) => expect(e.data).toEqual({ loginState: 'unknown' }));
         });
 
         it('does not fire for duplicate detections', () => {