Change tracker

Author: Stigmatoz

src/tracker.ts

@@ -7,7 +7,7 @@ import { useBadge } from "./compositions/set-badge";
 import { BadgeColor } from "./compositions/types";
 import { INTERVAL_INACTIVITY_DEFAULT, INTERVAL_SAVE_STORAGE_DEFAULT, StorageParams, VIEW_TIME_IN_BADGE_DEFAULT,  } from "./storage/storage-params";
 import { injecStorage } from "./storage/inject-storage";
-import { closeInterval } from "./compositions/daily-intervals";
+import { addInterval, closeInterval } from "./compositions/daily-intervals";
 import { ActiveTab } from "./compositions/activeTab";
 import { isLimitExceeded } from "./compositions/limit-list";
 import { Tab } from "./entity/tab";
@@ -28,48 +28,59 @@ async function trackTime(){
     if (window.focused) {
         const activeTab = window.tabs?.find((t) => t.active === true);
         if (isValidPage(activeTab)) {
-            const activeUrl = extractHostname(activeTab!.url);
-            activeTabInstance.setActiveTab(activeUrl);
+            const activeDomain = extractHostname(activeTab!.url);
 
-            if (await isInBlackList(activeUrl)) {
+            if (await isInBlackList(activeDomain)) {
                 useBadge({
                     tabId: activeTab!.id!,
                     text: "n/a",
                     color: BadgeColor.red,
                 });
             } else {
-                const tab = repo.getTab(activeUrl);
+                let tab = repo.getTab(activeDomain);
                 if (tab == undefined) {
-                    await repo.addTab(activeTab!);
-                } else {
+                    tab = await repo.addTab(activeTab!);
+                }
+                if (tab != undefined){
                     const inactivityInterval = (await storage.getValue(
                         StorageParams.INTERVAL_INACTIVITY,
                         INTERVAL_INACTIVITY_DEFAULT
                     )) as number;
                     const state = await Browser.idle.queryState(inactivityInterval);
-                    mainTracker(state, activeTab!, activeUrl, tab);
+                    mainTracker(state, activeTab!, activeDomain, tab);
                 }
             }
         }
     } else {
-        await closeInterval(activeTabInstance.getActiveTab());
+        await closeInterval(activeTabInstance.getActiveTabDomain());
         activeTabInstance.setActiveTab(null);
     }
 }
 
-async function mainTracker(state: Browser.Idle.IdleState, activeTab: Browser.Tabs.Tab, activeUrl: string, tab: Tab){
+async function mainTracker(state: Browser.Idle.IdleState, activeTab: Browser.Tabs.Tab, activeDomain: string, tab: Tab){
     function isAudible(){
         return state === 'idle' && activeTab.audible;
     }
 
-    if (state === 'active' || isAudible()){
-        if (await isLimitExceeded(activeUrl, tab)){
+    function isActiveTabWasChanged(){
+        return activeDomain != activeTabInstance.getActiveTabDomain();
+    }
+
+    const isAudibleValue = isAudible();
+    if (state === 'active' || isAudibleValue){
+        if (await isLimitExceeded(activeDomain, tab)){
             const summaryTime = tab.days.at(-1)!.summary;
             const summaryCounter = tab.days.at(-1)!.counter;
-            await useBlockPage(activeUrl, summaryTime, summaryCounter);
+            await useBlockPage(activeDomain, summaryTime, summaryCounter);
             return;
         }
 
+        if (isActiveTabWasChanged()){
+            tab.incCounter();
+            await closeInterval(activeTabInstance.getActiveTabDomain());
+            activeTabInstance.setActiveTab(activeTab.url!);
+            await addInterval(activeTabInstance.getActiveTabDomain());
+        }
         tab.incSummaryTime();
 
         const storage = injecStorage();