fix eslint-errors

src/utils/diskCache.ts

@@ -10,22 +10,22 @@ if (config.diskCache) {
     DiskCache = {
         // constructor(rootPath, options): {};
 
-        init() {},
+        init(): void { return; },
 
-        reset() {},
+        reset(): void { return; },
 
-        has(key) { return false; },
+        has(key: string): boolean { return false; },
 
-        get(key, opts) { return null; },
+        get(key: string, opts): string { return null; },
 
         // Returns size
-        set(key, dataOrSteam) { return new Promise((resolve) => 0); },
+        set(key: string, dataOrSteam): Promise<number> { return new Promise(() => 0); },
 
-        del(key) {},
+        del(key: string): void { return; },
 
-        size() { return 0; },
+        size(): number { return 0; },
 
-        prune() {},
+        prune(): void {return; },
     };
 }
 

src/utils/getFormattedTime.ts

@@ -1,9 +1,9 @@
 /**
  * Converts time in seconds to minutes:seconds
  */
-export function getFormattedTime(totalSeconds: number) {
-    let minutes = Math.floor(totalSeconds / 60);
-    let seconds = totalSeconds - minutes * 60;
+export function getFormattedTime(totalSeconds: number): string {
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds - minutes * 60;
     let secondsDisplay = seconds.toFixed(3);
     if (seconds < 10) {
         //add a zero

src/utils/getHash.ts

@@ -5,7 +5,7 @@ export function getHash<T extends string>(value: T, times = 5000): T & HashedVal
     if (times <= 0) return "" as T & HashedValue;
 
     for (let i = 0; i < times; i++) {
-        let hashCreator = crypto.createHash('sha256');
+        const hashCreator = crypto.createHash('sha256');
         value = hashCreator.update(value).digest('hex') as T;
     }
 

src/utils/getSubmissionUUID.ts

@@ -1,5 +1,6 @@
 import {getHash} from './getHash';
+import { HashedValue } from '../types/hash.model';
 
-export function getSubmissionUUID(videoID: string, category: string, userID: string, startTime: number, endTime: number) {
+export function getSubmissionUUID(videoID: string, category: string, userID: string, startTime: number, endTime: number): HashedValue{
     return getHash('v2-categories' + videoID + startTime + endTime + category + userID, 1);
 }

src/utils/logger.ts

@@ -86,4 +86,4 @@ class Logger {
 const loggerInstance = new Logger();
 export {
     loggerInstance as Logger
-}
+};

src/utils/queryCacher.ts

@@ -22,7 +22,7 @@ async function get<T>(fetchFromDB: () => Promise<T>, key: string): Promise<T> {
     return data;
 }
 
-function clearVideoCache(videoInfo: { videoID: VideoID; hashedVideoID: VideoIDHash; service: Service; userID?: UserID; }) {
+function clearVideoCache(videoInfo: { videoID: VideoID; hashedVideoID: VideoIDHash; service: Service; userID?: UserID; }): void {
     if (videoInfo) {
         redis.delAsync(skipSegmentsKey(videoInfo.videoID, videoInfo.service));
         redis.delAsync(skipSegmentsHashKey(videoInfo.hashedVideoID, videoInfo.service));
@@ -33,4 +33,4 @@ function clearVideoCache(videoInfo: { videoID: VideoID; hashedVideoID: VideoIDHa
 export const QueryCacher = {
     get,
     clearVideoCache
-}
+};

src/utils/redis.ts

@@ -12,12 +12,12 @@ interface RedisSB {
 
 let exportObject: RedisSB = {
     get: (key, callback?) => callback(null, undefined),
-    getAsync: (key) => 
+    getAsync: () => 
         new Promise((resolve) => resolve({err: null, reply: undefined})),
     set: (key, value, callback) => callback(null, undefined),
-    setAsync: (key, value) => 
+    setAsync: () => 
         new Promise((resolve) => resolve({err: null, reply: undefined})),
-    delAsync: (...keys) => 
+    delAsync: () => 
         new Promise((resolve) => resolve(null)),
 };
 

src/utils/webhookUtils.ts

@@ -1,7 +1,6 @@
 import {config} from '../config';
 import {Logger} from '../utils/logger';
 import fetch from 'node-fetch';
-import AbortController from "abort-controller";
 
 function getVoteAuthorRaw(submissionCount: number, isVIP: boolean, isOwnSubmission: boolean): string {
     if (isOwnSubmission) {
@@ -27,15 +26,15 @@ function getVoteAuthor(submissionCount: number, isVIP: boolean, isOwnSubmission:
     return "";
 }
 
-function dispatchEvent(scope: string, data: any): void {
-    let webhooks = config.webhooks;
+function dispatchEvent(scope: string, data: Record<string, unknown>): void {
+    const webhooks = config.webhooks;
     if (webhooks === undefined || webhooks.length === 0) return;
     Logger.debug("Dispatching webhooks");
 
     for (const webhook of webhooks) {
-        let webhookURL = webhook.url;
-        let authKey = webhook.key;
-        let scopes = webhook.scopes || [];
+        const webhookURL = webhook.url;
+        const authKey = webhook.key;
+        const scopes = webhook.scopes || [];
         if (!scopes.includes(scope.toLowerCase())) return;
 
         fetch(webhookURL, {

src/utils/youtubeApi.ts

@@ -17,10 +17,10 @@ export class YouTubeAPI {
 
                 if (data) {
                     Logger.debug("YouTube API: cache used for video information: " + videoID);
-                    return { err: null, data: JSON.parse(data) }
+                    return { err: null, data: JSON.parse(data) };
                 }
             } catch (err) {
-                return { err }
+                return { err };
             }
         }
 
@@ -32,7 +32,7 @@ export class YouTubeAPI {
             if (result.ok) {
                 const data = await result.json();
                 if (data.error) {
-                    Logger.warn("NewLeaf API Error for " + videoID + ": " + data.error)
+                    Logger.warn("NewLeaf API Error for " + videoID + ": " + data.error);
                     return { err: data.error, data: null };
                 }
 
@@ -45,7 +45,7 @@ export class YouTubeAPI {
                 return { err: result.statusText, data: null };
             }
         } catch (err) {
-            return {err, data: null}
+            return {err, data: null};
         }       
     }
 }