Resolved the comments raised by Copilot

Author: Vamsiindugu

src/data/content_scripts/content.ts

@@ -1,75 +1,71 @@
+// src/data/content_scripts/content.ts
 import { BrowserEmailService } from "../services/browser_email_service";
 import { PageInteractionService } from "../services/page_interaction_service";
 
+let currentAbortController: AbortController | null = null;
+
 // Establish connection with the side panel
 chrome.runtime.onConnect.addListener(function (port) {
   console.assert(port.name === "gmail-port");
   port.postMessage({ message: "Content script connected" });
 
-  let currentAbortController: AbortController | null = null;
-
   port.onMessage.addListener(function (msg) {
     console.log("sidepanel said: ", msg);
 
     if (msg.action === "FETCH_SENDERS") {
-      currentAbortController = fetchSenders(port);
-    } else if (msg.action === "CANCEL_FETCH") {
-      currentAbortController?.abort();
+      fetchSenders(port);
     } else if (msg.action === "DELETE_SENDERS") {
       deleteSenders(port, msg.emails);
     } else if (msg.action === "UNSUBSCRIBE_SENDERS") {
       unsubscribeSenders(port, msg.emails);
     } else if (msg.action === "BLOCK_SENDER") {
       blockSender(port, msg.email);
+    } else if (msg.action === "CANCEL_FETCH") {
+      if (currentAbortController) {
+        currentAbortController.abort();
+        console.log("Fetch cancelled by user");
+      }
     }
   });
 });
 
-function fetchSenders(port: chrome.runtime.Port): AbortController {
-  const abortController = new AbortController();
-
-  (async () => {
-    try {
-      const senders = await BrowserEmailService.fetchSendersFromBrowser({
-        onProgress: (progress) => {
-          // Send progress updates to the side panel
-          port.postMessage({
-            action: "FETCH_PROGRESS",
-            progress,
-          });
-        },
-        batchSize: 10,
-        maxPages: undefined, // Process all pages by default
-        signal: abortController.signal,
-      });
-
-      if (abortController.signal.aborted) {
-        console.log("Fetch was cancelled, not sending final response.");
-        return;
-      }
+async function fetchSenders(port: chrome.runtime.Port) {
+  try {
+    // Create new abort controller for this fetch
+    currentAbortController = new AbortController();
 
-      const serialized = senders.map((sender) => ({
-        email: sender.email,
-        names: Array.from(sender.names), // convert Set -> array
-        emailCount: sender.emailCount,
-      }));
-      port.postMessage({
-        action: "FETCH_SENDERS_RESPONSE",
-        success: true,
-        data: serialized,
-      });
-    } catch (error) {
-      if (!abortController.signal.aborted) {
+    const senders = await BrowserEmailService.fetchSendersFromBrowser({
+      onProgress: (progress) => {
+        // Send progress updates to the side panel
         port.postMessage({
-          action: "FETCH_SENDERS_RESPONSE",
-          success: false,
-          error: (error as Error).message,
+          action: "FETCH_PROGRESS",
+          progress
         });
-      }
-    }
-  })();
+      },
+      batchSize: 10,
+      signal: currentAbortController.signal
+    });
 
-  return abortController;
+    const serialized = senders.map((sender) => ({
+      email: sender.email,
+      names: Array.from(sender.names), // convert Set -> array
+      emailCount: sender.emailCount,
+    }));
+    
+    port.postMessage({
+      action: "FETCH_SENDERS_RESPONSE",
+      success: true,
+      data: serialized,
+    });
+  } catch (error) {
+    port.postMessage({
+      action: "FETCH_SENDERS_RESPONSE",
+      success: false,
+      error: (error as Error).message,
+    });
+  } finally {
+    currentAbortController = null;
+  }
 }
 
 async function deleteSenders(port: chrome.runtime.Port, emails: string[]) {
@@ -149,4 +145,4 @@ chrome.runtime.onMessage.addListener((message) => {
   if (message.action === "CLOSE_TUTORIAL") {
     PageInteractionService.closeTutorial();
   }
-});
+});

src/data/repositories/browser_email_repo.ts

@@ -1,15 +1,22 @@
 import { Sender } from "../../domain/entities/sender";
 import { EmailRepo } from "../../domain/repositories/email_repo";
+import { FetchProgress } from "../../domain/types/progress";
 import { PortManager } from "../ports/port_manager";
-import { FetchProgress } from "../services/browser_email_service";
 
 export class BrowserEmailRepo implements EmailRepo {
   private onProgressCallback?: (progress: FetchProgress) => void;
 
-  setProgressCallback(callback: (progress: FetchProgress) => void) {
+  setProgressCallback(callback: (progress: FetchProgress) => void): void {
     this.onProgressCallback = callback;
   }
 
+  async cancelFetch(): Promise<void> {
+    const port = PortManager.gmailPort;
+    if (!port) return Promise.reject("Port not connected");
+    port.postMessage({ action: "CANCEL_FETCH" });
+    return Promise.resolve();
+  }
+
   async fetchSenders(): Promise<Sender[]> {
     const port = PortManager.gmailPort;
     if (!port) return Promise.reject("Port not connected");
@@ -28,6 +35,9 @@ export class BrowserEmailRepo implements EmailRepo {
             senders.sort((a, b) => b.emailCount - a.emailCount);
             resolve(senders);
           } else {
+            console.error(
+              `Error fetching senders from content script: ${msg.error}`,
+            );            
             reject(new Error(msg.error));
           }
         }
@@ -36,12 +46,6 @@ export class BrowserEmailRepo implements EmailRepo {
     });
   }
 
-  async cancelFetch(): Promise<void> {
-    const port = PortManager.gmailPort;
-    if (!port) return;
-    port.postMessage({ action: "CANCEL_FETCH" });
-  }
-
   async deleteSenders(senderEmailAddresses: string[]): Promise<void> {
     const port = PortManager.gmailPort;
     if (!port) return Promise.reject("Port not connected");

src/data/repositories/mocks/mock_email_repo.ts

@@ -1,13 +1,7 @@
+// src/data/repositories/mocks/mock_email_repo.ts
 import { Sender } from "../../../domain/entities/sender";
 import { EmailRepo } from "../../../domain/repositories/email_repo";
-
-export interface FetchProgress {
-  currentPage: number;
-  totalPages: number;
-  processedEmails: number;
-  totalEmails: number;
-  percentage: number;
-}
+import { FetchProgress } from "../../../domain/types/progress";
 
 export class MockEmailRepo implements EmailRepo {
   private mockSenders: Sender[] = [
@@ -51,59 +45,61 @@ export class MockEmailRepo implements EmailRepo {
     this.failingSenders = senders;
   }
 
-  setProgressCallback(callback: (progress: FetchProgress) => void) {
+  setProgressCallback(callback: (progress: FetchProgress) => void): void {
     this.progressCallback = callback;
   }
 
   setProgressiveLoadEnabled(enabled: boolean) {
     this.isProgressiveLoadEnabled = enabled;
   }
 
+  async cancelFetch(): Promise<void> {
+    console.log("[MOCK] Cancel fetch requested");
+    this.abortController?.abort();
+  }
+
+  // - Mock implementations -
+
   async fetchSenders(): Promise<Sender[]> {
     console.log("[MOCK] Fetching senders...");
-
+    
     if (this.isProgressiveLoadEnabled && this.progressCallback) {
       // Simulate progressive loading
       const totalPages = 5;
       const emailsPerPage = 4;
       const totalEmails = this.mockSenders.length;
-
+      
       this.abortController = new AbortController();
-
+      
       for (let page = 1; page <= totalPages; page++) {
         // Check if cancelled
         if (this.abortController.signal.aborted) {
           console.log("[MOCK] Fetch cancelled");
           throw new Error("Fetch cancelled");
         }
-
+        
         // Simulate page processing delay
-        await new Promise((resolve) => setTimeout(resolve, 200));
-
+        await new Promise(resolve => setTimeout(resolve, 200));
+        
         // Report progress
         const progress: FetchProgress = {
           currentPage: page,
           totalPages: totalPages,
           processedEmails: Math.min(page * emailsPerPage, totalEmails),
           totalEmails: totalEmails,
-          percentage: Math.round((page / totalPages) * 100),
+          percentage: Math.round((page / totalPages) * 100)
         };
         this.progressCallback(progress);
       }
     } else {
       // Original behavior without progress
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      await new Promise(resolve => setTimeout(resolve, 500));
     }
-
+    
     this.mockSenders.sort((a, b) => b.emailCount - a.emailCount);
     return this.mockSenders;
   }
 
-  async cancelFetch(): Promise<void> {
-    console.log("[MOCK] Cancel fetch requested");
-    this.abortController?.abort();
-  }
-
   async deleteSenders(senderEmailAddresses: string[]): Promise<void> {
     console.log("[MOCK] Deleting senders:", senderEmailAddresses);
     this.mockSenders = this.mockSenders.filter(
@@ -127,4 +123,4 @@ export class MockEmailRepo implements EmailRepo {
     );
     return Promise.resolve();
   }
-}
+}