Continuation of tracker changes

Author: Stigmatoz

src/compositions/black-list.ts

@@ -0,0 +1,8 @@
+import { injecStorage } from "../storage/inject-storage";
+import { StorageParams } from "../storage/storage-params";
+
+export async function isInBlackList(url: string): Promise<boolean>{
+    const storage = injecStorage();
+    const blackList = await storage.getValue(StorageParams.BLACK_LIST) as string[];
+    return blackList.indexOf(url) != -1 ? true : false;
+}

src/compositions/valid-page.ts

@@ -1,7 +1,7 @@
 import Browser from 'webextension-polyfill';
 
-export function isValidPage(tab: Browser.Tabs.Tab): boolean{
-    if (tab == null || tab == undefined || !tab.url) return false;
+export function isValidPage(tab: Browser.Tabs.Tab | undefined): boolean{
+    if (tab == null || tab == undefined || !tab.url || !tab.id) return false;
 
     if ((tab.url.indexOf('http:') == -1 && tab.url.indexOf('https:') == -1)
             || tab.url.indexOf('chrome://') !== -1

src/repository/tabs-repository-interface.ts

@@ -2,6 +2,6 @@ import { Tab } from "../storage/tab";
 import Browser from 'webextension-polyfill';
 
 export interface ITabsRepository {
-    getTab(domain:string): Promise<Tab>;
-    addTab(value:Browser.Tabs.Tab): Promise<void>;
+    getTab(domain:string): Tab | undefined;
+    addTab(tab:Browser.Tabs.Tab): Promise<Tab>;
 }

src/repository/tabs-repository.ts

@@ -2,23 +2,53 @@ import { ITabsRepository } from "./tabs-repository-interface";
 import { Tab } from "../storage/tab";
 import Browser from 'webextension-polyfill';
 import { injecStorage } from "../storage/inject-storage";
+import { isValidPage } from '../compositions/valid-page';
+import { isInBlackList } from "../compositions/black-list";
+import { extractHostname } from "../compositions/extract-hostname";
 
 export class TabsRepository implements ITabsRepository {
-    static tabs: Tab[];
+    private tabs: Tab[];
 
-    constructor(){}
+    constructor() {
+        this.tabs = [];
+    }
 
-    static async Create(): Promise<TabsRepository> {
-        const instance = new TabsRepository();
+    async initAsync(){
         this.tabs = await injecStorage().getTabs();
-        return instance;
-      }
+    }
 
-    getTab(domain: string): Promise<Tab> {
-        throw new Error("Method not implemented.");
+    getTab(domain: string): Tab | undefined {
+        const tab = this.tabs?.find(x => x.url === domain);
+        return !tab ? tab : undefined;
     }
 
-    addTab(value: Browser.Tabs.Tab): Promise<void> {
-        throw new Error("Method not implemented.");
+    async addTab(tab: Browser.Tabs.Tab): Promise<Tab> {
+        if (isValidPage(tab)) {
+            if (tab.id && (tab.id != 0)) {
+                tabs = tabs || [];
+                var domain = extractHostname(tab.url);
+                var isDifferentUrl = false;
+                if (currentTab !== tab.url) {
+                    isDifferentUrl = true;
+                }
+
+                if (this.isNewUrl(domain) && !await isInBlackList(domain)) {
+                    var favicon = tab.favIconUrl;
+                    if (favicon === undefined) {
+                        favicon = 'chrome://favicon/' + domain;
+                    }
+                    var newTab = new Tab(domain, favicon);
+                    tabs.push(newTab);
+                }
+
+                if (isDifferentUrl && await !isInBlackList(domain)) {
+                    this.setCurrentActiveTab(domain);
+                    var tabUrl = this.getTab(domain);
+                    if (tabUrl !== undefined)
+                        tabUrl.incCounter();
+                    this.addTimeInterval(domain);
+                }
+            }
+        } else this.closeIntervalForCurrentTab();
     }
 }

src/tracker.ts

@@ -1,36 +1,34 @@
 import Browser from 'webextension-polyfill';
 import { isValidPage } from './compositions/valid-page';
 import { extractHostname } from './compositions/extract-hostname';
+import { injectTabsRepository } from './repository/inject-tabs-repository';
+import { isInBlackList } from './compositions/black-list';
+import { useBadge } from './compositions/set-badge';
+import { BadgeColor } from './compositions/types';
 
 export async function initTracker(){
     const window = await Browser.windows.getLastFocused({ populate: true });
     if (window.focused){
         const activeTab = window.tabs?.find(t => t.active === true);
         if (isValidPage(activeTab)) {
-            var activeUrl = extractHostname(activeTab?.url);
-            var tab = activity.getTab(activeUrl);
-            if (tab === undefined) {
-                activity.addTab(activeTab);
-            }
+            const activeUrl = extractHostname(activeTab!.url);
+
+            if (await isInBlackList(activeUrl)) {
+                useBadge({ tabId: activeTab!.id!, text: 'n/a', color: BadgeColor.green });
+            } else{
+                const repo = await injectTabsRepository();
+                let tab = repo.getTab(activeUrl);
+                if (tab === undefined)
+                    tab = await repo.addTab(activeTab!);
 
-            if (activity.isInBlackList(activeUrl)) {
-                chrome.action.setBadgeBackgroundColor({ color: '#fdb8b8' })
-                chrome.action.setBadgeText({
-                    tabId: activeTab.id,
-                    text: 'n/a'
-                });
-            } else {
-                if (tab !== undefined) {
                     if (currentTab !== tab.url) {
                         activity.setCurrentActiveTab(tab.url);
                     }
-                    chrome.idle.queryState(parseInt(setting_interval_inactivity), function(state) {
+                    const state = await Browser.idle.queryState(parseInt(setting_interval_inactivity));
                         if (state === 'active') {
                             mainTRacker(activeUrl, tab, activeTab);
                         } else checkDOM(state, activeUrl, tab, activeTab);
-                    });
-                }
             }
-        } 
+        }
     } else activity.closeIntervalForCurrentTab(); 
 }