@govtechsg/oobee 0.10.42 → 0.10.45

package/src/utils.ts

@@ -2,6 +2,7 @@ import { execSync, spawnSync } from 'child_process';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
+import axe, { Rule } from 'axe-core';
 import constants, {
   BrowserTypes,
   destinationPath,
@@ -9,25 +10,23 @@ import constants, {
 } from './constants/constants.js';
 import { consoleLogger, silentLogger } from './logs.js';
 import { getAxeConfiguration } from './crawlers/custom/getAxeConfiguration.js';
-import axe from 'axe-core';
-import { Rule, RuleMetadata } from 'axe-core';
 
 export const getVersion = () => {
-  const loadJSON = filePath =>
+  const loadJSON = (filePath: string): { version: string } =>
     JSON.parse(fs.readFileSync(new URL(filePath, import.meta.url)).toString());
   const versionNum = loadJSON('../package.json').version;
 
   return versionNum;
 };
 
-export const getHost = url => new URL(url).host;
+export const getHost = (url: string): string => new URL(url).host;
 
 export const getCurrentDate = () => {
   const date = new Date();
   return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
 };
 
-export const isWhitelistedContentType = contentType => {
+export const isWhitelistedContentType = (contentType: string): boolean => {
   const whitelist = ['text/html'];
   return whitelist.filter(type => contentType.trim().startsWith(type)).length === 1;
 };
@@ -45,7 +44,7 @@ export const getStoragePath = (randomToken: string): string => {
   return `${constants.exportDirectory}/${randomToken}`;
 };
 
-export const createDetailsAndLogs = async randomToken => {
+export const createDetailsAndLogs = async (randomToken: string): Promise<void> => {
   const storagePath = getStoragePath(randomToken);
   const logPath = `logs/${randomToken}`;
   try {
@@ -59,20 +58,24 @@ export const createDetailsAndLogs = async randomToken => {
           await fs.copy('errors.txt', `${logPath}/${randomToken}.txt`);
         } catch (error) {
           if (error.code === 'EBUSY') {
-            console.log(
+            consoleLogger.error(
               `Unable to copy the file from 'errors.txt' to '${logPath}/${randomToken}.txt' because it is currently in use.`,
             );
-            console.log(
+            consoleLogger.error(
               'Please close any applications that might be using this file and try again.',
             );
           } else {
-            console.log(`An unexpected error occurred while copying the file: ${error.message}`);
+            consoleLogger.error(
+              `An unexpected error occurred while copying the file: ${error.message}`,
+            );
           }
         }
       }
     });
   } catch (error) {
-    console.log(`An error occurred while setting up storage or log directories: ${error.message}`);
+    consoleLogger.error(
+      `An error occurred while setting up storage or log directories: ${error.message}`,
+    );
   }
 };
 
@@ -99,7 +102,7 @@ export const getUserDataTxt = () => {
   return null;
 };
 
-export const writeToUserDataTxt = async (key, value) => {
+export const writeToUserDataTxt = async (key: string, value: string): Promise<void> => {
   const textFilePath = getUserDataFilePath();
 
   // Create file if it doesn't exist
@@ -116,25 +119,27 @@ export const writeToUserDataTxt = async (key, value) => {
   }
 };
 
-export const createAndUpdateResultsFolders = async randomToken => {
+export const createAndUpdateResultsFolders = async (randomToken: string): Promise<void> => {
   const storagePath = getStoragePath(randomToken);
   await fs.ensureDir(`${storagePath}`);
 
   const intermediatePdfResultsPath = `${randomToken}/${constants.pdfScanResultFileName}`;
 
-  const transferResults = async (intermPath, resultFile) => {
+  const transferResults = async (intermPath: string, resultFile: string): Promise<void> => {
     try {
       if (fs.existsSync(intermPath)) {
         await fs.copy(intermPath, `${storagePath}/${resultFile}`);
       }
     } catch (error) {
       if (error.code === 'EBUSY') {
-        console.log(
+        consoleLogger.error(
           `Unable to copy the file from ${intermPath} to ${storagePath}/${resultFile} because it is currently in use.`,
         );
-        console.log('Please close any applications that might be using this file and try again.');
+        consoleLogger.error(
+          'Please close any applications that might be using this file and try again.',
+        );
       } else {
-        console.log(
+        consoleLogger.error(
           `An unexpected error occurred while copying the file from ${intermPath} to ${storagePath}/${resultFile}: ${error.message}`,
         );
       }
@@ -144,20 +149,20 @@ export const createAndUpdateResultsFolders = async randomToken => {
   await Promise.all([transferResults(intermediatePdfResultsPath, constants.pdfScanResultFileName)]);
 };
 
-export const createScreenshotsFolder = randomToken => {
+export const createScreenshotsFolder = (randomToken: string): void => {
   const storagePath = getStoragePath(randomToken);
   const intermediateScreenshotsPath = getIntermediateScreenshotsPath(randomToken);
   if (fs.existsSync(intermediateScreenshotsPath)) {
     fs.readdir(intermediateScreenshotsPath, (err, files) => {
       if (err) {
-        console.log(`Screenshots were not moved successfully: ${err.message}`);
+        consoleLogger.error(`Screenshots were not moved successfully: ${err.message}`);
       }
 
       if (!fs.existsSync(destinationPath(storagePath))) {
         try {
           fs.mkdirSync(destinationPath(storagePath), { recursive: true });
         } catch (error) {
-          console.error('Screenshots folder was not created successfully:', error);
+          consoleLogger.error('Screenshots folder was not created successfully:', error);
         }
       }
 
@@ -170,20 +175,20 @@ export const createScreenshotsFolder = randomToken => {
 
       fs.rmdir(intermediateScreenshotsPath, rmdirErr => {
         if (rmdirErr) {
-          console.log(rmdirErr);
+          consoleLogger.error(rmdirErr);
         }
       });
     });
   }
 };
 
-export const cleanUp = async pathToDelete => {
+export const cleanUp = (pathToDelete: string): void => {
   fs.removeSync(pathToDelete);
 };
 
 export const getWcagPassPercentage = (
   wcagViolations: string[],
-  showEnableWcagAaa: boolean
+  showEnableWcagAaa: boolean,
 ): {
   passPercentageAA: string;
   totalWcagChecksAA: number;
@@ -192,20 +197,28 @@ export const getWcagPassPercentage = (
   totalWcagChecksAAandAAA: number;
   totalWcagViolationsAAandAAA: number;
 } => {
-
   // These AAA rules should not be counted as WCAG Pass Percentage only contains A and AA
   const wcagAAALinks = ['WCAG 1.4.6', 'WCAG 2.2.4', 'WCAG 2.4.9', 'WCAG 3.1.5', 'WCAG 3.2.5'];
   const wcagAAA = ['wcag146', 'wcag224', 'wcag249', 'wcag315', 'wcag325'];
-  
+
   const wcagLinksAAandAAA = constants.wcagLinks;
-  
+
   const wcagViolationsAAandAAA = showEnableWcagAaa ? wcagViolations.length : null;
   const totalChecksAAandAAA = showEnableWcagAaa ? Object.keys(wcagLinksAAandAAA).length : null;
-  const passedChecksAAandAAA = showEnableWcagAaa ? totalChecksAAandAAA - wcagViolationsAAandAAA : null;
-  const passPercentageAAandAAA = showEnableWcagAaa ? (totalChecksAAandAAA === 0 ? 0 : (passedChecksAAandAAA / totalChecksAAandAAA) * 100) : null;
+  const passedChecksAAandAAA = showEnableWcagAaa
+    ? totalChecksAAandAAA - wcagViolationsAAandAAA
+    : null;
+  // eslint-disable-next-line no-nested-ternary
+  const passPercentageAAandAAA = showEnableWcagAaa
+    ? totalChecksAAandAAA === 0
+      ? 0
+      : (passedChecksAAandAAA / totalChecksAAandAAA) * 100
+    : null;
 
   const wcagViolationsAA = wcagViolations.filter(violation => !wcagAAA.includes(violation)).length;
-  const totalChecksAA = Object.keys(wcagLinksAAandAAA).filter(key => !wcagAAALinks.includes(key)).length;
+  const totalChecksAA = Object.keys(wcagLinksAAandAAA).filter(
+    key => !wcagAAALinks.includes(key),
+  ).length;
   const passedChecksAA = totalChecksAA - wcagViolationsAA;
   const passPercentageAA = totalChecksAA === 0 ? 0 : (passedChecksAA / totalChecksAA) * 100;
 
@@ -219,13 +232,15 @@ export const getWcagPassPercentage = (
   };
 };
 
-export interface ScanPagesDetail {
-  oobeeAppVersion?: string;
-  pagesAffected: PageDetail[];
-  pagesNotAffected: PageDetail[];
-  scannedPagesCount: number;
-  pagesNotScanned: PageDetail[];
-  pagesNotScannedCount: number;
+export type IssueCategory = 'mustFix' | 'goodToFix' | 'needsReview' | 'passed';
+
+export interface IssueDetail {
+  ruleId: string;
+  wcagConformance: string[];
+  occurrencesMustFix?: number;
+  occurrencesGoodToFix?: number;
+  occurrencesNeedsReview?: number;
+  occurrencesPassed: number;
 }
 
 export interface PageDetail {
@@ -245,43 +260,43 @@ export interface PageDetail {
   typesOfIssues: IssueDetail[];
 }
 
-export type IssueCategory = "mustFix" | "goodToFix" | "needsReview" | "passed";
-
-export interface IssueDetail {
-  ruleId: string;
-  wcagConformance: string[];
-  occurrencesMustFix?: number;
-  occurrencesGoodToFix?: number;
-  occurrencesNeedsReview?: number;
-  occurrencesPassed: number;
+export interface ScanPagesDetail {
+  oobeeAppVersion?: string;
+  pagesAffected: PageDetail[];
+  pagesNotAffected: PageDetail[];
+  scannedPagesCount: number;
+  pagesNotScanned: PageDetail[];
+  pagesNotScannedCount: number;
 }
 
 export const getProgressPercentage = (
   scanPagesDetail: ScanPagesDetail,
-  showEnableWcagAaa: boolean
+  showEnableWcagAaa: boolean,
 ): {
   averageProgressPercentageAA: string;
   averageProgressPercentageAAandAAA: string;
 } => {
   const pages = scanPagesDetail.pagesAffected || [];
-  
-  const progressPercentagesAA = pages.map((page: any) => {
+
+  const progressPercentagesAA = pages.map((page: PageDetail) => {
     const violations: string[] = page.conformance;
     return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAA;
   });
-  
-  const progressPercentagesAAandAAA = pages.map((page: any) => {
+
+  const progressPercentagesAAandAAA = pages.map((page: PageDetail) => {
     const violations: string[] = page.conformance;
     return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAAandAAA;
   });
-  
+
   const totalAA = progressPercentagesAA.reduce((sum, p) => sum + parseFloat(p), 0);
   const avgAA = progressPercentagesAA.length ? totalAA / progressPercentagesAA.length : 0;
 
   const totalAAandAAA = progressPercentagesAAandAAA.reduce((sum, p) => sum + parseFloat(p), 0);
-  const avgAAandAAA = progressPercentagesAAandAAA.length ? totalAAandAAA / progressPercentagesAAandAAA.length : 0;
-  
-  return { 
+  const avgAAandAAA = progressPercentagesAAandAAA.length
+    ? totalAAandAAA / progressPercentagesAAandAAA.length
+    : 0;
+
+  return {
     averageProgressPercentageAA: avgAA.toFixed(2),
     averageProgressPercentageAAandAAA: avgAAandAAA.toFixed(2),
   };
@@ -289,7 +304,7 @@ export const getProgressPercentage = (
 
 export const getTotalRulesCount = async (
   enableWcagAaa: boolean,
-  disableOobee: boolean
+  disableOobee: boolean,
 ): Promise<{
   totalRulesMustFix: number;
   totalRulesGoodToFix: number;
@@ -302,11 +317,11 @@ export const getTotalRulesCount = async (
   });
 
   // Get default rules from axe-core
-  const defaultRules = await axe.getRules();
+  const defaultRules = axe.getRules();
 
   // Merge custom rules with default rules, converting RuleMetadata to Rule
-  const mergedRules: Rule[] = defaultRules.map((defaultRule) => {
-    const customRule = axeConfig.rules.find((r) => r.id === defaultRule.ruleId);
+  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
+    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
     if (customRule) {
       // Merge properties from customRule into defaultRule (RuleMetadata) to create a Rule
       return {
@@ -317,15 +332,14 @@ export const getTotalRulesCount = async (
         tags: defaultRule.tags,
         metadata: customRule.metadata, // Use custom metadata if it exists
       };
-    } else {
-      // Convert defaultRule (RuleMetadata) to Rule
-      return {
-        id: defaultRule.ruleId,
-        enabled: true, // Default to true if not overridden
-        tags: defaultRule.tags,
-        // No metadata here, since defaultRule.metadata might not exist
-      };
     }
+    // Convert defaultRule (RuleMetadata) to Rule
+    return {
+      id: defaultRule.ruleId,
+      enabled: true, // Default to true if not overridden
+      tags: defaultRule.tags,
+      // No metadata here, since defaultRule.metadata might not exist
+    };
   });
 
   // Add any custom rules that don't override the default rules
@@ -346,9 +360,7 @@ export const getTotalRulesCount = async (
   });
 
   // Apply the merged configuration to axe-core
-  await axe.configure({ ...axeConfig, rules: mergedRules });
-
-  const rules = await axe.getRules();
+  axe.configure({ ...axeConfig, rules: mergedRules });
 
   // ... (rest of your logic)
   let totalRulesMustFix = 0;
@@ -357,7 +369,7 @@ export const getTotalRulesCount = async (
   const wcagRegex = /^wcag\d+a+$/;
 
   // Use mergedRules instead of rules to check enabled property
-  mergedRules.forEach((rule) => {
+  mergedRules.forEach(rule => {
     if (!rule.enabled) {
       return;
     }
@@ -371,10 +383,14 @@ export const getTotalRulesCount = async (
       return;
     }
 
-    let conformance = tags.filter(tag => tag.startsWith('wcag') || tag === 'best-practice');
+    const conformance = tags.filter(tag => tag.startsWith('wcag') || tag === 'best-practice');
 
     // Ensure conformance level is sorted correctly
-    if (conformance.length > 0 && conformance[0] !== 'best-practice' && !wcagRegex.test(conformance[0])) {
+    if (
+      conformance.length > 0 &&
+      conformance[0] !== 'best-practice' &&
+      !wcagRegex.test(conformance[0])
+    ) {
       conformance.sort((a, b) => {
         if (wcagRegex.test(a) && !wcagRegex.test(b)) {
           return -1;
@@ -389,11 +405,11 @@ export const getTotalRulesCount = async (
     if (conformance.includes('best-practice')) {
       // console.log(`${totalRulesMustFix} Good To Fix: ${rule.id}`);
 
-      totalRulesGoodToFix++; // Categorized as "Good to Fix"
+      totalRulesGoodToFix += 1; // Categorized as "Good to Fix"
     } else {
       // console.log(`${totalRulesMustFix} Must Fix: ${rule.id}`);
 
-      totalRulesMustFix++; // Otherwise, it's "Must Fix"
+      totalRulesMustFix += 1; // Otherwise, it's "Must Fix"
     }
   });
 
@@ -404,10 +420,136 @@ export const getTotalRulesCount = async (
   };
 };
 
+/**
+ * Dynamically generates a map of WCAG criteria IDs to their details (name and level)
+ * Reuses the rule processing logic from getTotalRulesCount
+ */
+export const getWcagCriteriaMap = async (
+  enableWcagAaa: boolean = true,
+  disableOobee: boolean = false
+): Promise<Record<string, { name: string; level: string }>> => {
+  // Reuse the configuration setup from getTotalRulesCount
+  const axeConfig = getAxeConfiguration({
+    enableWcagAaa,
+    gradingReadabilityFlag: '',
+    disableOobee,
+  });
+
+  // Get default rules from axe-core
+  const defaultRules = axe.getRules();
+
+  // Merge custom rules with default rules
+  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
+    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
+    if (customRule) {
+      return {
+        id: defaultRule.ruleId,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: defaultRule.tags,
+        metadata: customRule.metadata,
+      };
+    }
+    return {
+      id: defaultRule.ruleId,
+      enabled: true,
+      tags: defaultRule.tags,
+    };
+  });
+
+  // Add custom rules that don't override default rules
+  axeConfig.rules.forEach(customRule => {
+    if (!mergedRules.some(rule => rule.id === customRule.id)) {
+      mergedRules.push({
+        id: customRule.id,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: customRule.tags,
+        metadata: customRule.metadata,
+      });
+    }
+  });
+
+  // Apply configuration
+  axe.configure({ ...axeConfig, rules: mergedRules });
+
+  // Build WCAG criteria map
+  const wcagCriteriaMap: Record<string, { name: string; level: string }> = {};
+  
+  // Process rules to extract WCAG information
+  mergedRules.forEach(rule => {
+    if (!rule.enabled) return;
+    if (rule.id === 'frame-tested') return;
+    
+    const tags = rule.tags || [];
+    if (tags.includes('experimental') || tags.includes('deprecated')) return;
+    
+    // Look for WCAG criteria tags (format: wcag111, wcag143, etc.)
+    tags.forEach(tag => {
+      const wcagMatch = tag.match(/^wcag(\d+)$/);
+      if (wcagMatch) {
+        const wcagId = tag;
+        
+        // Default values
+        let level = 'a';
+        let name = '';
+        
+        // Try to extract better info from metadata if available
+        const metadata = rule.metadata as any;
+        if (metadata && metadata.wcag) {
+          const wcagInfo = metadata.wcag as any;
+          
+          // Find matching criterion in metadata
+          for (const key in wcagInfo) {
+            const criterion = wcagInfo[key];
+            if (criterion && 
+                criterion.num && 
+                `wcag${criterion.num.replace(/\./g, '')}` === wcagId) {
+              
+              // Extract level
+              if (criterion.level) {
+                level = String(criterion.level).toLowerCase();
+              }
+              
+              // Extract name
+              if (criterion.handle) {
+                name = String(criterion.handle);
+              } else if (criterion.id) {
+                name = String(criterion.id);
+              } else if (criterion.num) {
+                name = `wcag-${String(criterion.num).replace(/\./g, '-')}`;
+              }
+              
+              break;
+            }
+          }
+        }
+        
+        // Generate fallback name if none found
+        if (!name) {
+          const numStr = wcagMatch[1];
+          const formattedNum = numStr.replace(/(\d)(\d)(\d+)?/, '$1.$2.$3');
+          name = `wcag-${formattedNum.replace(/\./g, '-')}`;
+        }
+        
+        // Store in map
+        wcagCriteriaMap[wcagId] = { 
+          name: name.toLowerCase().replace(/_/g, '-'),
+          level
+        };
+      }
+    });
+  });
+  
+  return wcagCriteriaMap;
+};
+
 export const getIssuesPercentage = async (
   scanPagesDetail: ScanPagesDetail,
   enableWcagAaa: boolean,
-  disableOobee: boolean
+  disableOobee: boolean,
 ): Promise<{
   avgTypesOfIssuesPercentageOfTotalRulesAtMustFix: string;
   avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix: string;
@@ -426,8 +568,8 @@ export const getIssuesPercentage = async (
 
   const pagesAffectedPerRule: Record<string, number> = {};
 
-  pages.forEach((page) => {
-    page.typesOfIssues.forEach((issue) => {
+  pages.forEach(page => {
+    page.typesOfIssues.forEach(issue => {
       if ((issue.occurrencesMustFix || issue.occurrencesGoodToFix) > 0) {
         pagesAffectedPerRule[issue.ruleId] = (pagesAffectedPerRule[issue.ruleId] || 0) + 1;
       }
@@ -435,55 +577,54 @@ export const getIssuesPercentage = async (
   });
 
   const pagesPercentageAffectedPerRule: Record<string, string> = {};
-  for (const [ruleId, count] of Object.entries(pagesAffectedPerRule)) {
-    pagesPercentageAffectedPerRule[ruleId] = totalPages > 0 ? ((count / totalPages) * 100).toFixed(2) : "0.00";
-  }
+  Object.entries(pagesAffectedPerRule).forEach(([ruleId, count]) => {
+    pagesPercentageAffectedPerRule[ruleId] =
+      totalPages > 0 ? ((count / totalPages) * 100).toFixed(2) : '0.00';
+  });
 
-  const typesOfIssuesCountAtMustFix = pages.map((page) =>
-    page.typesOfIssues.filter((issue) => (issue.occurrencesMustFix || 0) > 0).length
+  const typesOfIssuesCountAtMustFix = pages.map(
+    page => page.typesOfIssues.filter(issue => (issue.occurrencesMustFix || 0) > 0).length,
   );
 
-  const typesOfIssuesCountAtGoodToFix = pages.map((page) =>
-    page.typesOfIssues.filter((issue) => (issue.occurrencesGoodToFix || 0) > 0).length
+  const typesOfIssuesCountAtGoodToFix = pages.map(
+    page => page.typesOfIssues.filter(issue => (issue.occurrencesGoodToFix || 0) > 0).length,
   );
 
   const typesOfIssuesCountSumMustFixAndGoodToFix = pages.map(
     (_, index) =>
-      (typesOfIssuesCountAtMustFix[index] || 0) +
-      (typesOfIssuesCountAtGoodToFix[index] || 0)
+      (typesOfIssuesCountAtMustFix[index] || 0) + (typesOfIssuesCountAtGoodToFix[index] || 0),
   );
 
-  const { totalRulesMustFix, totalRulesGoodToFix, totalRulesMustFixAndGoodToFix } = await getTotalRulesCount(
-    enableWcagAaa,
-    disableOobee
-  );
+  const { totalRulesMustFix, totalRulesGoodToFix, totalRulesMustFixAndGoodToFix } =
+    await getTotalRulesCount(enableWcagAaa, disableOobee);
 
-  const avgMustFixPerPage = totalPages > 0
-    ? typesOfIssuesCountAtMustFix.reduce((sum, count) => sum + count, 0) / totalPages
-    : 0;
+  const avgMustFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountAtMustFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
 
-  const avgGoodToFixPerPage = totalPages > 0
-    ? typesOfIssuesCountAtGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
-    : 0;
+  const avgGoodToFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountAtGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
 
-  const avgMustFixAndGoodToFixPerPage = totalPages > 0
-    ? typesOfIssuesCountSumMustFixAndGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
-    : 0;
+  const avgMustFixAndGoodToFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountSumMustFixAndGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
 
   const avgTypesOfIssuesPercentageOfTotalRulesAtMustFix =
-    totalRulesMustFix > 0
-      ? ((avgMustFixPerPage / totalRulesMustFix) * 100).toFixed(2)
-      : "0.00";
+    totalRulesMustFix > 0 ? ((avgMustFixPerPage / totalRulesMustFix) * 100).toFixed(2) : '0.00';
 
   const avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix =
     totalRulesGoodToFix > 0
       ? ((avgGoodToFixPerPage / totalRulesGoodToFix) * 100).toFixed(2)
-      : "0.00";
+      : '0.00';
 
   const avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix =
     totalRulesMustFixAndGoodToFix > 0
       ? ((avgMustFixAndGoodToFixPerPage / totalRulesMustFixAndGoodToFix) * 100).toFixed(2)
-      : "0.00";
+      : '0.00';
 
   const avgTypesOfIssuesCountAtMustFix = avgMustFixPerPage.toFixed(2);
   const avgTypesOfIssuesCountAtGoodToFix = avgGoodToFixPerPage.toFixed(2);
@@ -504,7 +645,7 @@ export const getIssuesPercentage = async (
   };
 };
 
-export const getFormattedTime = inputDate => {
+export const getFormattedTime = (inputDate: Date): string => {
   if (inputDate) {
     return inputDate.toLocaleTimeString('en-GB', {
       year: 'numeric',
@@ -526,7 +667,7 @@ export const getFormattedTime = inputDate => {
   });
 };
 
-export const formatDateTimeForMassScanner = date => {
+export const formatDateTimeForMassScanner = (date: Date): string => {
   // Format date and time parts separately
   const year = date.getFullYear().toString().slice(-2); // Get the last two digits of the year
   const month = `0${date.getMonth() + 1}`.slice(-2); // Month is zero-indexed
@@ -547,14 +688,13 @@ export const setHeadlessMode = (browser: string, isHeadless: boolean): void => {
   } else {
     process.env.CRAWLEE_HEADLESS = '0';
   }
-
 };
 
-export const setThresholdLimits = setWarnLevel => {
+export const setThresholdLimits = (setWarnLevel: string): void => {
   process.env.WARN_LEVEL = setWarnLevel;
 };
 
-export const zipResults = (zipName, resultsPath) => {
+export const zipResults = (zipName: string, resultsPath: string): void => {
   // Check prior zip file exist and remove
   if (fs.existsSync(zipName)) {
     fs.unlinkSync(zipName);
@@ -585,9 +725,9 @@ export const zipResults = (zipName, resultsPath) => {
 
 // areLinksEqual compares 2 string URLs and ignores comparison of 'www.' and url protocol
 // i.e. 'http://google.com' and 'https://www.google.com' returns true
-export const areLinksEqual = (link1, link2) => {
+export const areLinksEqual = (link1: string, link2: string): boolean => {
   try {
-    const format = link => {
+    const format = (link: string): URL => {
       return new URL(link.replace(/www\./, ''));
     };
     const l1 = format(link1);
@@ -612,7 +752,7 @@ export const randomThreeDigitNumberString = () => {
   return String(threeDigitNumber);
 };
 
-export const isFollowStrategy = (link1, link2, rule) => {
+export const isFollowStrategy = (link1: string, link2: string, rule: string): boolean => {
   const parsedLink1 = new URL(link1);
   const parsedLink2 = new URL(link2);
   if (rule === 'same-domain') {
@@ -623,17 +763,17 @@ export const isFollowStrategy = (link1, link2, rule) => {
   return parsedLink1.hostname === parsedLink2.hostname;
 };
 
-/* eslint-disable no-await-in-loop */
-export const retryFunction = async (func, maxAttempt) => {
+export const retryFunction = async <T>(func: () => Promise<T>, maxAttempt: number): Promise<T> => {
   let attemptCount = 0;
   while (attemptCount < maxAttempt) {
     attemptCount += 1;
     try {
+      // eslint-disable-next-line no-await-in-loop
       const result = await func();
       return result;
     } catch (error) {
       silentLogger.error(`(Attempt count: ${attemptCount} of ${maxAttempt}) ${error}`);
     }
   }
+  throw new Error('Maximum number of attempts reached');
 };
-/* eslint-enable no-await-in-loop */