testaro 18.2.0 → 18.4.0

package/aslint/utils/text.ts

@@ -0,0 +1,165 @@
+import { ObjectUtility } from './object';
+
+// Note: safeTrim related constants
+
+const SP: string = ' ';
+const TAB: string = '\t';
+const CR: string = '\r';
+const LF: string = '\n';
+const CR_LF = '\r\n';
+const FF: string = '\f';
+const ZERO_WIDTH_SPACE: string = '\v' + // \x0B VT 垂直制表符
+  '\f' + //  \x0C FF 换页符
+  '\u200B\u200C\u200D\u200E\u200F\u000b\u2028\u2029\uFEFF\u202D';
+const OTHER_SPACE: string = '\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000';
+
+const ALL_SPACES: string = SP + TAB + CR + LF + CR_LF + ZERO_WIDTH_SPACE + OTHER_SPACE;
+
+const leftReg: RegExp = new RegExp(`^[${ALL_SPACES}]+`);
+const rightReg: RegExp = new RegExp(`[${ALL_SPACES}]+$`);
+const zeroReg: RegExp = new RegExp(`[${ZERO_WIDTH_SPACE}]+`, 'g');
+const otherReg: RegExp = new RegExp(`[${OTHER_SPACE}]+`, 'g');
+const space: RegExp = new RegExp(`^[${SP+TAB+LF+FF+CR}]+$`);
+const allWhiteSpaces: RegExp = new RegExp(`[${TAB + CR + LF + CR_LF + ZERO_WIDTH_SPACE + OTHER_SPACE}]`, 'g');
+
+export class TextUtility {
+  private static isNativeTrimAvailable: boolean = String.prototype.trim && ObjectUtility.isNativeMethod(String.prototype.trim);
+  private static escapeEntityMap: { [key: string]: string } = {
+    '"': '"',
+    '&': '&',
+    '\'': ''',
+    '/': '/',
+    '<': '&lt;',
+    '=': '&#x3D;',
+    '>': '&gt;',
+    '`': '&#x60;'
+  };
+
+  private static unescapeEntityMap: { [key: string]: string } = {
+    '&#39;': '\'',
+    '&#x2F;': '/',
+    '&#x3D;': '=',
+    '&#x60;': '`',
+    '&amp;': '&',
+    '&gt;': '>',
+    '&lt;': '<',
+    '&quot;': '"'
+  };
+
+  public static trim(text: string): string {
+    if (TextUtility.isNativeTrimAvailable) {
+      return text.trim();
+    }
+
+    return text.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+  }
+
+  public static truncateWords(str: string, numberOfChars?: number): string {
+    const amount: number = numberOfChars ? numberOfChars : 50;
+    const cut: number = str.indexOf(' ', amount);
+
+    if (cut === -1) {
+      return str;
+    }
+
+    return `${str.substring(0, cut)} [...]`;
+  }
+
+  public static truncate(str: string, numberOfChars?: number): string {
+    const amount: number = numberOfChars ? numberOfChars : 50;
+
+    return `${str.substring(0, amount)} [...]`;
+  }
+
+  public static truncateInTheMiddle(text: string, startChars?: number, endChars?: number, maxLength?: number): string {
+    let start: any;
+    let end: any;
+    const charsAtTheBeginning: number = startChars || 70;
+    const charsAtTheEnd: number = endChars || 70;
+    const maximumLength: number = maxLength || 120;
+    const content: string = text.trim();
+
+    if (content.length > maximumLength) {
+      start = content.substring(0, charsAtTheBeginning);
+      end = content.substring(content.length - charsAtTheEnd, content.length);
+
+      return `${start} [...] ${end}`;
+    }
+
+    return text;
+  }
+
+  public static isUpperCase(str: string): boolean {
+    if ((/[^\w]/).test(str)) {
+      return false;
+    }
+
+    if (isNaN(Number(str)) && str.length > 1) {
+      return str === str.toUpperCase();
+    }
+
+    return false;
+  }
+
+  public static containsOnlyWhiteSpaces(str: string): boolean {
+    return (/^\s*$/).test(str);
+  }
+
+  // Note: following by https://www.w3.org/TR/2010/WD-html-markup-20100624/terminology.html#space
+  public static containsSpaceCharacter(str: string): boolean {
+    return space.test(str);
+  }
+
+  public static safeTrim(string: string): string {
+    return string
+      .replace(leftReg, '')
+      .replace(rightReg, '')
+      .replace(new RegExp(TAB, 'g'), '')
+      .replace(new RegExp(CR_LF, 'g'), LF)
+      .replace(new RegExp(CR, 'g'), LF)
+      .replace(zeroReg, '')
+      .replace(otherReg, '')
+      .trim();
+  }
+
+  public static normalizeWhitespaces(string: string): string {
+    return string
+      .replace(allWhiteSpaces, ' ').replace(/\s+/g, ' ');
+  }
+
+  public static escape(str: string): string {
+    const fromEntityMap: any = (s: any): string => {
+      return this.escapeEntityMap[s];
+    };
+
+    return String(str).replace(/[&<>"'`=/]/g, fromEntityMap);
+  }
+
+  public static unescape(str: string): string {
+    const fromEntityMap: any = (s: any): string => {
+      return this.unescapeEntityMap[s];
+    };
+
+    return String(str).replace(/&([^;]+);/g, fromEntityMap);
+  }
+
+  public static convertUnderscoresToDashes(text: string): string {
+    return text.replace(/_/g, '-');
+  }
+
+  public static convertDashesToUnderscores(text: string): string {
+    return text.replace(/-/g, '_');
+  }
+
+  public static replacePlaceholder(text: string, words: string[], placeholder: string = '%'): string {
+    const replaceValue = (result: string, value: string, i: number): string => {
+      return result.replace(`${placeholder}${i}`, String(value));
+    };
+
+    return words.reduce(replaceValue, text);
+  }
+
+  public static areStringsTheSame(str1: string, str2: string): boolean {
+    return str1.toLocaleUpperCase() === str2.toLocaleUpperCase();
+  }
+}

package/aslint/utils/time.test.ts

@@ -0,0 +1,43 @@
+import { Time } from './time';
+
+describe('Utils', () => {
+
+  describe('Time', () => {
+
+    describe('#format', () => {
+
+      it('should return "< 1 ms" when value is 0.1 ms', () => {
+        expect(Time.format(0.1)).toBe('< 1 ms');
+      });
+
+      it('should return seconds and miliseconds formatted when value is 1.0499999999992724 ms', () => {
+        expect(Time.format(1.0499999999992724)).toBe('1ms');
+      });
+
+      it('should return seconds and miliseconds formatted when value is 1300 ms', () => {
+        expect(Time.format(1300)).toBe('1s 300ms');
+      });
+
+      it('should return minutes, seconds and miliseconds formatted when value is 61003 ms', () => {
+        expect(Time.format(61003)).toBe('1m 1s 3ms');
+      });
+
+      it('should return minutes and miliseconds formatted when value is 60300 ms', () => {
+        expect(Time.format(60300)).toBe('1m 300ms');
+      });
+
+      it('should return minutes, seconds and miliseconds formatted when value is 62300 ms', () => {
+        expect(Time.format(62300)).toBe('1m 2s 300ms');
+      });
+
+      it('should return miliseconds formatted when value is 50 ms', () => {
+        expect(Time.format(50)).toBe('50ms');
+      });
+
+      it('should return formatted and rounded milliseconds long number', () => {
+        expect(Time.format(21.1234500000013)).toBe('21ms');
+      });
+    });
+
+  });
+});

package/aslint/utils/time.ts

@@ -0,0 +1,33 @@
+export class Time {
+
+  public static format(duration: any): any {
+    const milliseconds: any = Math.floor(duration % 1000);
+    const seconds: any = Math.floor(duration / 1000 % 60);
+    const minutes: any = Math.floor(duration / (60 * 1000) % 60);
+    const hours: any = Math.floor(duration / (60 * 60 * 1000) % 60);
+    let time: any = '';
+
+    if (duration < 1) {
+      return '< 1 ms';
+    }
+
+    if (hours > 0) {
+      time += `${hours}h `;
+    }
+
+    if (minutes > 0) {
+      time += `${minutes}m `;
+    }
+
+    if (seconds > 0) {
+      time += `${seconds}s `;
+    }
+
+    if (milliseconds > 0) {
+      time += `${milliseconds}ms`;
+    }
+
+    return time;
+  }
+
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "18.2.0",
+  "version": "18.4.0",
   "description": "Run 920 web accessibility tests from 9 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/getSource.js

@@ -0,0 +1,35 @@
+// ########## IMPORTS
+
+// Module to make HTTP requests.
+const fetch = require('node-fetch');
+// Module to process files.
+const fs = require('fs/promises');
+
+// ########## FUNCTIONS
+
+// Gets and returns the source of a document.
+exports.getSource = async page => {
+  const url = page.url();
+  const scheme = url.replace(/:.+/, '');
+  const data = {
+    prevented: false,
+    source: ''
+  };
+  if (scheme === 'file') {
+    const filePath = url.slice(7);
+    const rawPage = await fs.readFile(filePath, 'utf8');
+    data.source = rawPage;
+  }
+  else {
+    try {
+      const rawPageResponse = await fetch(url);
+      const rawPage = await rawPageResponse.text();
+      data.source = rawPage;
+    }
+    catch(error) {
+      console.log(`ERROR getting source of page (${error.message})`);
+      data.prevented = true;
+    }
+  }
+  return data;
+};

package/testaro/dupAtt.js

@@ -5,139 +5,117 @@
 
 // ########## IMPORTS
 
-// Module to make HTTP requests.
-const fetch = require('node-fetch');
-// Module to process files.
-const fs = require('fs/promises');
+// Module to get the document source.
+const {getSource} = require('../procs/getSource');
 
 // ########## FUNCTIONS
 
 // Reports failures.
 exports.reporter = async (page, withItems) => {
-  // Initialize the data.
+  // Initialize the data and standard result.
   const data = {total: 0};
   if (withItems) {
     data.items = [];
   }
-  // Get the page.
-  const url = page.url();
-  const scheme = url.replace(/:.+/, '');
-  let rawPage;
-  if (scheme === 'file') {
-    const filePath = url.slice(7);
-    rawPage = await fs.readFile(filePath, 'utf8');
+  let totals = [];
+  const standardInstances = [];
+  // Get the source.
+  const sourceData = await getSource(page);
+  // If it was not obtained:
+  if (sourceData.prevented) {
+    // Report this.
+    data.prevented = true;
   }
+  // Otherwise, i.e. if it was obtained:
   else {
-    try {
-      const rawPageResponse = await fetch(url);
-      rawPage = await rawPageResponse.text();
-    }
-    catch(error) {
-      console.log(`ERROR getting page for dupAtt test (${error.message})`);
-      data.prevented = true;
-      return {
-        data,
-        totals: [0, 0, 0, 10],
-        standardInstances: [
-          {
-            ruleID: 'dupAtt',
-            what: 'Page prevented this test (treated as 10 instances)',
-            ordinalSeverity: 3,
-            count: 10,
-            tagName: '',
-            id: '',
-            location: {
-              doc: '',
-              type: '',
-              spec: ''
-            },
-            excerpt: ''
+    let rawPage = sourceData.source;
+    // Change any spacing character sequences in it to single spaces.
+    rawPage = rawPage.replace(/\s+/g, ' ');
+    // Delete any spaces adjacent to equal symbols in it.
+    rawPage = rawPage.replace(/ = | =|= /g, '=');
+    // Remove any escaped quotation marks from it.
+    rawPage = rawPage.replace(/\\"|\\'/g, '');
+    // Remove any script code from it.
+    rawPage = rawPage.replace(/<(script [^<>]+)>.*?<\/script>/g, '$1');
+    // Remove any comments from it.
+    rawPage = rawPage.replace(/<!--.*?-->/g, '');
+    // Extract the opening tags of its elements.
+    let elements = rawPage.match(/<[a-zA-Z][^<>]+>/g);
+    // Delete their enclosing angle brackets.
+    elements = elements.map(element => element.replace(/< ?| ?>/g, ''));
+    // Delete the values of any attributes in them.
+    const nvElements = elements.map(element => element.replace(/="[^"]*"/g, ''));
+    // For each element:
+    nvElements.forEach((element, index) => {
+      // Identify its tag name and attributes.
+      const terms = element.split(' ');
+      // If it has 2 or more attributes:
+      if (terms.length > 2) {
+        // If any is duplicated:
+        const tagName = terms[0].toUpperCase();
+        const attributes = terms.slice(1);
+        attributes.sort();
+        const duplicatedAttribute = attributes.find(
+          (current, attIndex) => attributes[attIndex + 1] === current
+        );
+        if (duplicatedAttribute) {
+          // Add data on the element to the data.
+          const id = terms.includes('id')
+            ? elements[index].replace(/^.+id="/, '').replace(/".+/, '')
+            : '';
+          data.total++;
+          if (withItems) {
+            data.items.push({
+              tagName,
+              id,
+              duplicatedAttribute
+            });
           }
-        ]
-      };
-    }
-  }
-  // Change any spacing character sequences in it to single spaces.
-  rawPage = rawPage.replace(/\s+/g, ' ');
-  // Delete any spaces adjacent to equal symbols in it.
-  rawPage = rawPage.replace(/ = | =|= /g, '=');
-  // Remove any escaped quotation marks from it.
-  rawPage = rawPage.replace(/\\"|\\'/g, '');
-  // Remove any script code from it.
-  rawPage = rawPage.replace(/<(script [^<>]+)>.*?<\/script>/g, '$1');
-  // Remove any comments from it.
-  rawPage = rawPage.replace(/<!--.*?-->/g, '');
-  // Extract the opening tags of its elements.
-  let elements = rawPage.match(/<[a-zA-Z][^<>]+>/g);
-  // Delete their enclosing angle brackets.
-  elements = elements.map(element => element.replace(/< ?| ?>/g, ''));
-  // Delete the values of any attributes in them.
-  const nvElements = elements.map(element => element.replace(/="[^"]*"/g, ''));
-  // For each element:
-  nvElements.forEach((element, index) => {
-    // Identify its tag name and attributes.
-    const terms = element.split(' ');
-    // If it has 2 or more attributes:
-    if (terms.length > 2) {
-      // If any is duplicated:
-      const tagName = terms[0].toUpperCase();
-      const attributes = terms.slice(1);
-      attributes.sort();
-      const duplicatedAttribute = attributes.find(
-        (current, attIndex) => attributes[attIndex + 1] === current
-      );
-      if (duplicatedAttribute) {
-        // Add data on the element to the data.
-        const id = terms.includes('id')
-          ? elements[index].replace(/^.+id="/, '').replace(/".+/, '')
-          : '';
-        data.total++;
-        if (withItems) {
-          data.items.push({
-            tagName,
-            id,
-            duplicatedAttribute
-          });
         }
       }
+    });
+    // If itemization is required and there are any instances:
+    if (data.items) {
+      // For each instance:
+      data.items.forEach(item => {
+        // Add it.
+        standardInstances.push({
+          ruleID: 'dupAtt',
+          what: 'Element has 2 attributes with the same name',
+          ordinalSeverity: 2,
+          tagName: item.tagName,
+          id: item.id,
+          location: {
+            doc: item.id ? 'source' : '',
+            type: item.id ? 'selector' : '',
+            spec: `#${item.id}`
+          },
+          excerpt: item.duplicatedAttribute
+        });
+      });
     }
-  });
-  const standardInstances = [];
-  if (data.items) {
-    data.items.forEach(item => {
+    // Otherwise, if there are any instances:
+    else if (data.total) {
+      // Add a summary instance.
       standardInstances.push({
         ruleID: 'dupAtt',
-        what: 'Element has 2 attributes with the same name',
+        what: 'In some elements 2 attributes have the same name',
         ordinalSeverity: 2,
-        tagName: item.tagName,
-        id: item.id,
+        count: data.total,
         location: {
-          doc: item.id ? 'source' : '',
-          type: item.id ? 'selector' : '',
-          spec: `#${item.id}`
+          doc: '',
+          type: '',
+          spec: ''
         },
-        excerpt: item.duplicatedAttribute
+        excerpt: ''
       });
-    });
-  }
-  else if (data.total) {
-    standardInstances.push({
-      ruleID: 'dupAtt',
-      what: 'In some elements 2 attributes have the same name',
-      ordinalSeverity: 2,
-      count: data.total,
-      location: {
-        doc: '',
-        type: '',
-        spec: ''
-      },
-      excerpt: ''
-    });
+    }
+    totals = [0, 0, data.total, 0];
   }
   // Return the data.
   return {
     data,
-    totals: [0, 0, data.total, 0],
+    totals,
     standardInstances
   };
 };

package/testaro/headEl.js

@@ -0,0 +1,83 @@
+/*
+  headEl
+  Related to ASLint rule elements-not-allowed-in-head.
+  This test reports invalid descendants of the head element in the source of the document.
+*/
+
+// ########## IMPORTS
+
+// Module to get the document source.
+const {getSource} = require('../procs/getSource');
+
+// ########## FUNCTIONS
+
+// Performs the test.
+exports.reporter = async page => {
+  // Initialize the data and standard result.
+  const data = {
+    total: 0,
+    badTagNames: []
+  };
+  let totals = [];
+  const standardInstances = [];
+  // Get the source.
+  const sourceData = await getSource(page);
+  // If it was not obtained:
+  if (sourceData.prevented) {
+    // Report this.
+    data.prevented = true;
+  }
+  // Otherwise, i.e. if it was obtained:
+  else {
+    let rawPage = sourceData.source;
+    // Change any spacing character sequences in it to single spaces.
+    rawPage = rawPage.replace(/\s+/g, ' ');
+    // Delete everything in it except the head content.
+    rawPage = rawPage.replace(/^.*<head[^>]*>|<\/head>.*$/g, '');
+    // Get the tag names of the remaining elements.
+    const tags = rawPage.match(/<([a-z]+)/g);
+    const ucTagNames = tags.map(tag => tag.toUpperCase().slice(1));
+    const validTagNames = [
+      'BASE',
+      'LINK',
+      'META',
+      'SCRIPT',
+      'STYLE',
+      'TITLE',
+      'NOSCRIPT',
+      'TEMPLATE'  
+    ];
+    // For each tag name:
+    ucTagNames.forEach(tagName => {
+      // If it is invalid:
+      if (! validTagNames.includes(tagName)) {
+        // Add this to the result.
+        data.total++;
+        data.badTagNames.push(tagName);
+      }
+    });
+    // If there are any instances:
+    if (data.total) {
+      // Add a summary instance.
+      standardInstances.push({
+        ruleID: 'headEl',
+        what: `Invalid elements within the head: ${data.badTagNames.join(', ')}`,
+        ordinalSeverity: 2,
+        count: data.total,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      });
+    }
+    totals = [0, 0, data.total, 0];
+  }
+  // Return the data.
+  return {
+    data,
+    totals,
+    standardInstances
+  };
+};

package/testaro/hrRisk.js

@@ -0,0 +1,67 @@
+/*
+  hrRisk
+  Related to ASLint test horizontal-rule.
+  This test reports the existence of hr elements. Their semantics are inconsistently defined and
+  interpreted and impair accessibility compared with stylistic segmentation.
+*/
+
+// ########## IMPORTS
+
+// Module to get locator data.
+const {getLocatorData} = require('../procs/getLocatorData');
+
+// ########## FUNCTIONS
+
+// Performs the test.
+exports.reporter = async (page, withItems) => {
+  // Initialize the standard result.
+  const data = {};
+  const totals = [0, 0, 0, 0];
+  const standardInstances = [];
+  // Get locators for all applicable elements.
+  const locAll = page.locator('body hr');
+  const locsAll = await locAll.all();
+  // For each of them:
+  for (const loc of locsAll) {
+    // Add to the totals.
+    totals[0]++;
+    // If itemization is required:
+    if (withItems) {
+      // Get data on the element.
+      const elData = await getLocatorData(loc);
+      // Add a standard instance.
+      standardInstances.push({
+        ruleID: 'hrRisk',
+        what: 'Element instead of styling is used for vertical segmentation',
+        ordinalSeverity: 0,
+        tagName: 'HR',
+        id: elData.id,
+        location: elData.location,
+        excerpt: elData.excerpt
+      });
+    }
+  }
+  // If itemization is not required and there are instances:
+  if (! withItems && totals[0]) {
+    // Add a summary instance.
+    standardInstances.push({
+      ruleID: 'hrRisk',
+      what: 'Elements instead of styling are used for vertical segmentation',
+      ordinalSeverity: 0,
+      count: totals[0],
+      tagName: 'HR',
+      id: '',
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals,
+    standardInstances
+  };
+};

package/tests/testaro.js

@@ -21,9 +21,11 @@ const evalRules = {
   focInd: 'missing and nonstandard focus indicators',
   focOp: 'discrepancies between focusability and operability',
   focVis: 'links that are invisible when focused',
+  headEl: 'invalid elements within the head',
   headingAmb: 'same-level sibling headings with identical texts',
   hover: 'hover-caused content changes',
   hovInd: 'hover indication nonstandard',
+  hrRisk: 'hr element instead of styles used for vertical segmentation',
   labClash: 'labeling inconsistencies',
   lineHeight: 'text with a line height less than 1.5 times its font size',
   linkExt: 'links that automatically open new windows',