@govtechsg/oobee 0.10.39 → 0.10.42

package/src/utils.ts

@@ -7,7 +7,10 @@ import constants, {
   destinationPath,
   getIntermediateScreenshotsPath,
 } from './constants/constants.js';
-import { silentLogger } from './logs.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 =>
@@ -178,18 +181,6 @@ export const cleanUp = async pathToDelete => {
   fs.removeSync(pathToDelete);
 };
 
-/* istanbul ignore next */
-// export const getFormattedTime = () =>
-//   new Date().toLocaleTimeString('en-GB', {
-//     year: 'numeric',
-//     month: 'short',
-//     day: 'numeric',
-//     hour12: true,
-//     hour: 'numeric',
-//     minute: '2-digit',
-//     timeZoneName: "longGeneric",
-//   });
-
 export const getWcagPassPercentage = (
   wcagViolations: string[],
   showEnableWcagAaa: boolean
@@ -228,6 +219,291 @@ export const getWcagPassPercentage = (
   };
 };
 
+export interface ScanPagesDetail {
+  oobeeAppVersion?: string;
+  pagesAffected: PageDetail[];
+  pagesNotAffected: PageDetail[];
+  scannedPagesCount: number;
+  pagesNotScanned: PageDetail[];
+  pagesNotScannedCount: number;
+}
+
+export interface PageDetail {
+  pageTitle: string;
+  url: string;
+  totalOccurrencesFailedIncludingNeedsReview: number;
+  totalOccurrencesFailedExcludingNeedsReview: number;
+  totalOccurrencesMustFix?: number;
+  totalOccurrencesGoodToFix?: number;
+  totalOccurrencesNeedsReview: number;
+  totalOccurrencesPassed: number;
+  occurrencesExclusiveToNeedsReview: boolean;
+  typesOfIssuesCount: number;
+  typesOfIssuesExcludingNeedsReviewCount: number;
+  categoriesPresent: IssueCategory[];
+  conformance?: string[]; // WCAG levels as flexible strings
+  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 const getProgressPercentage = (
+  scanPagesDetail: ScanPagesDetail,
+  showEnableWcagAaa: boolean
+): {
+  averageProgressPercentageAA: string;
+  averageProgressPercentageAAandAAA: string;
+} => {
+  const pages = scanPagesDetail.pagesAffected || [];
+  
+  const progressPercentagesAA = pages.map((page: any) => {
+    const violations: string[] = page.conformance;
+    return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAA;
+  });
+  
+  const progressPercentagesAAandAAA = pages.map((page: any) => {
+    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 { 
+    averageProgressPercentageAA: avgAA.toFixed(2),
+    averageProgressPercentageAAandAAA: avgAAandAAA.toFixed(2),
+  };
+};
+
+export const getTotalRulesCount = async (
+  enableWcagAaa: boolean,
+  disableOobee: boolean
+): Promise<{
+  totalRulesMustFix: number;
+  totalRulesGoodToFix: number;
+  totalRulesMustFixAndGoodToFix: number;
+}> => {
+  const axeConfig = getAxeConfiguration({
+    enableWcagAaa,
+    gradingReadabilityFlag: '',
+    disableOobee,
+  });
+
+  // Get default rules from axe-core
+  const defaultRules = await 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);
+    if (customRule) {
+      // Merge properties from customRule into defaultRule (RuleMetadata) to create a Rule
+      return {
+        id: defaultRule.ruleId,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        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
+      };
+    }
+  });
+
+  // Add any custom rules that don't override the default rules
+  axeConfig.rules.forEach(customRule => {
+    if (!mergedRules.some(mergedRule => mergedRule.id === customRule.id)) {
+      // Ensure customRule is of type Rule
+      const rule: Rule = {
+        id: customRule.id,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: customRule.tags,
+        metadata: customRule.metadata,
+        // Add other properties if needed
+      };
+      mergedRules.push(rule);
+    }
+  });
+
+  // Apply the merged configuration to axe-core
+  await axe.configure({ ...axeConfig, rules: mergedRules });
+
+  const rules = await axe.getRules();
+
+  // ... (rest of your logic)
+  let totalRulesMustFix = 0;
+  let totalRulesGoodToFix = 0;
+
+  const wcagRegex = /^wcag\d+a+$/;
+
+  // Use mergedRules instead of rules to check enabled property
+  mergedRules.forEach((rule) => {
+    if (!rule.enabled) {
+      return;
+    }
+
+    if (rule.id === 'frame-tested') return; // Ignore 'frame-tested' rule
+
+    const tags = rule.tags || [];
+
+    // Skip experimental and deprecated rules
+    if (tags.includes('experimental') || tags.includes('deprecated')) {
+      return;
+    }
+
+    let 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])) {
+      conformance.sort((a, b) => {
+        if (wcagRegex.test(a) && !wcagRegex.test(b)) {
+          return -1;
+        }
+        if (!wcagRegex.test(a) && wcagRegex.test(b)) {
+          return 1;
+        }
+        return 0;
+      });
+    }
+
+    if (conformance.includes('best-practice')) {
+      // console.log(`${totalRulesMustFix} Good To Fix: ${rule.id}`);
+
+      totalRulesGoodToFix++; // Categorized as "Good to Fix"
+    } else {
+      // console.log(`${totalRulesMustFix} Must Fix: ${rule.id}`);
+
+      totalRulesMustFix++; // Otherwise, it's "Must Fix"
+    }
+  });
+
+  return {
+    totalRulesMustFix,
+    totalRulesGoodToFix,
+    totalRulesMustFixAndGoodToFix: totalRulesMustFix + totalRulesGoodToFix,
+  };
+};
+
+export const getIssuesPercentage = async (
+  scanPagesDetail: ScanPagesDetail,
+  enableWcagAaa: boolean,
+  disableOobee: boolean
+): Promise<{
+  avgTypesOfIssuesPercentageOfTotalRulesAtMustFix: string;
+  avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix: string;
+  avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix: string;
+  totalRulesMustFix: number;
+  totalRulesGoodToFix: number;
+  totalRulesMustFixAndGoodToFix: number;
+  avgTypesOfIssuesCountAtMustFix: string;
+  avgTypesOfIssuesCountAtGoodToFix: string;
+  avgTypesOfIssuesCountAtMustFixAndGoodToFix: string;
+  pagesAffectedPerRule: Record<string, number>;
+  pagesPercentageAffectedPerRule: Record<string, string>;
+}> => {
+  const pages = scanPagesDetail.pagesAffected || [];
+  const totalPages = pages.length;
+
+  const pagesAffectedPerRule: Record<string, number> = {};
+
+  pages.forEach((page) => {
+    page.typesOfIssues.forEach((issue) => {
+      if ((issue.occurrencesMustFix || issue.occurrencesGoodToFix) > 0) {
+        pagesAffectedPerRule[issue.ruleId] = (pagesAffectedPerRule[issue.ruleId] || 0) + 1;
+      }
+    });
+  });
+
+  const pagesPercentageAffectedPerRule: Record<string, string> = {};
+  for (const [ruleId, count] of Object.entries(pagesAffectedPerRule)) {
+    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 typesOfIssuesCountAtGoodToFix = pages.map((page) =>
+    page.typesOfIssues.filter((issue) => (issue.occurrencesGoodToFix || 0) > 0).length
+  );
+
+  const typesOfIssuesCountSumMustFixAndGoodToFix = pages.map(
+    (_, index) =>
+      (typesOfIssuesCountAtMustFix[index] || 0) +
+      (typesOfIssuesCountAtGoodToFix[index] || 0)
+  );
+
+  const { totalRulesMustFix, totalRulesGoodToFix, totalRulesMustFixAndGoodToFix } = await getTotalRulesCount(
+    enableWcagAaa,
+    disableOobee
+  );
+
+  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 avgMustFixAndGoodToFixPerPage = totalPages > 0
+    ? typesOfIssuesCountSumMustFixAndGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
+    : 0;
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFix =
+    totalRulesMustFix > 0
+      ? ((avgMustFixPerPage / totalRulesMustFix) * 100).toFixed(2)
+      : "0.00";
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix =
+    totalRulesGoodToFix > 0
+      ? ((avgGoodToFixPerPage / totalRulesGoodToFix) * 100).toFixed(2)
+      : "0.00";
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix =
+    totalRulesMustFixAndGoodToFix > 0
+      ? ((avgMustFixAndGoodToFixPerPage / totalRulesMustFixAndGoodToFix) * 100).toFixed(2)
+      : "0.00";
+
+  const avgTypesOfIssuesCountAtMustFix = avgMustFixPerPage.toFixed(2);
+  const avgTypesOfIssuesCountAtGoodToFix = avgGoodToFixPerPage.toFixed(2);
+  const avgTypesOfIssuesCountAtMustFixAndGoodToFix = avgMustFixAndGoodToFixPerPage.toFixed(2);
+
+  return {
+    avgTypesOfIssuesCountAtMustFix,
+    avgTypesOfIssuesCountAtGoodToFix,
+    avgTypesOfIssuesCountAtMustFixAndGoodToFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtMustFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix,
+    totalRulesMustFix,
+    totalRulesGoodToFix,
+    totalRulesMustFixAndGoodToFix,
+    pagesAffectedPerRule,
+    pagesPercentageAffectedPerRule,
+  };
+};
+
 export const getFormattedTime = inputDate => {
   if (inputDate) {
     return inputDate.toLocaleTimeString('en-GB', {