perf: reduce timetable resource consuption and update notification collector

src/plugins/built-in/notificationCollector/index.ts

@@ -3,6 +3,7 @@ import type { Plugin } from "../../core/types";
 interface NotificationCollectorStorage {
   lastNotificationCount: number;
   lastCheckedTime: string;
+  consecutiveErrors: number;
 }
 
 const notificationCollectorPlugin: Plugin<{}, NotificationCollectorStorage> = {
@@ -15,13 +16,24 @@ const notificationCollectorPlugin: Plugin<{}, NotificationCollectorStorage> = {
 
   run: async (api) => {
     let pollInterval: number | null = null;
+    let isVisible = !document.hidden;
+    let baseInterval = 30000; // 30 seconds
+    const maxInterval = 300000; // 5 minutes max
 
     // Store last notification count in storage
     if (!api.storage.lastNotificationCount) {
       api.storage.lastNotificationCount = 0;
     }
+    if (!api.storage.consecutiveErrors) {
+      api.storage.consecutiveErrors = 0;
+    }
 
     const checkNotifications = async () => {
+      // Skip if tab is not visible to save battery
+      if (!isVisible) {
+        return;
+      }
+
       try {
         const alertDiv = document.querySelector(
           "[class*='notifications__bubble___']",
@@ -52,6 +64,9 @@ const notificationCollectorPlugin: Plugin<{}, NotificationCollectorStorage> = {
         api.storage.lastNotificationCount = notificationCount;
         api.storage.lastCheckedTime = new Date().toISOString();
         
+        // Reset error count on success
+        api.storage.consecutiveErrors = 0;
+
         if (alertDiv) {
           alertDiv.textContent = notificationCount.toString();
         } else {
@@ -59,18 +74,37 @@ const notificationCollectorPlugin: Plugin<{}, NotificationCollectorStorage> = {
         }
       } catch (error) {
         console.error("[BetterSEQTA+] Error fetching notifications:", error);
+        api.storage.consecutiveErrors = (api.storage.consecutiveErrors || 0) + 1;
       }
     };
 
+    const getNextInterval = () => {
+      // Exponential backoff on errors, max 5 minutes
+      const errorMultiplier = Math.min(Math.pow(2, api.storage.consecutiveErrors || 0), 10);
+      return Math.min(baseInterval * errorMultiplier, maxInterval);
+    };
+
     const startPolling = () => {
       if (pollInterval) return; // Already polling
       checkNotifications();
-      pollInterval = window.setInterval(checkNotifications, 30000);
+      
+      const scheduleNext = () => {
+        const interval = getNextInterval();
+        pollInterval = window.setTimeout(() => {
+          checkNotifications().then(() => {
+            if (pollInterval) { // Only continue if not stopped
+              scheduleNext();
+            }
+          });
+        }, interval);
+      };
+      
+      scheduleNext();
     };
 
     const stopPolling = () => {
       if (pollInterval) {
-        window.clearInterval(pollInterval);
+        window.clearTimeout(pollInterval);
         pollInterval = null;
         const alertDiv = document.querySelector(
           "[class*='notifications__bubble___']",
@@ -85,12 +119,27 @@ const notificationCollectorPlugin: Plugin<{}, NotificationCollectorStorage> = {
       }
     };
 
+    // Listen for visibility changes to pause/resume polling
+    const handleVisibilityChange = () => {
+      isVisible = !document.hidden;
+      if (isVisible && !pollInterval) {
+        // Resume polling when tab becomes visible
+        const alertDiv = document.querySelector("[class*='notifications__bubble___']");
+        if (alertDiv) {
+          startPolling();
+        }
+      }
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+
     api.seqta.onMount("[class*='notifications__bubble___']", (_) => {
       startPolling();
     });
 
     return () => {
       stopPolling();
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
     };
   },
 };

src/seqta/utils/updateTimetableTimes.ts

@@ -4,7 +4,8 @@ import { waitForElm } from "./waitForElm";
 
 let timetableObserver: MutationObserver | null = null;
 let isOnTimetablePage = false;
-let urlCheckInterval: number | null = null;
+let isInitialized = false;
+let abortController: AbortController | null = null;
 
 function updateTimeElements(): void {
   if (!settingsState.timeFormat || settingsState.timeFormat !== "12") return;
@@ -90,11 +91,7 @@ function stopTimetableMonitoring(): void {
   }
 }
 
-function startUrlMonitoring(): void {
-  if (urlCheckInterval) return;
-
-  // Check URL every 100ms when on timetable page
-  urlCheckInterval = window.setInterval(() => {
+function handleUrlChange(): void {
   const currentlyOnTimetable = checkIfOnTimetablePage();
   
   if (currentlyOnTimetable !== isOnTimetablePage) {
@@ -113,7 +110,35 @@ function startUrlMonitoring(): void {
     // Even if we're still on timetable page, update times in case navigation happened
     updateTimeElements();
   }
-  }, 100);
+}
+
+function startUrlMonitoring(): void {
+  if (isInitialized) return;
+  isInitialized = true;
+
+  // Create abort controller for cleanup
+  abortController = new AbortController();
+  const signal = abortController.signal;
+
+  // Listen for hash changes (more efficient than polling)
+  window.addEventListener('hashchange', handleUrlChange, { signal });
+  window.addEventListener('popstate', handleUrlChange, { signal });
+  
+  // Initial check
+  handleUrlChange();
+}
+
+function stopUrlMonitoring(): void {
+  if (!isInitialized) return;
+  isInitialized = false;
+
+  // Abort all event listeners at once
+  if (abortController) {
+    abortController.abort();
+    abortController = null;
+  }
+  
+  stopTimetableMonitoring();
 }
 
 export async function updateTimetableTimes(): Promise<void> {
@@ -144,3 +169,8 @@ if (typeof window !== "undefined") {
   // Start URL monitoring immediately
   startUrlMonitoring();
 }
+
+// Cleanup function for when the module is unloaded
+export function cleanup(): void {
+  stopUrlMonitoring();
+}