testaro 69.1.0 → 69.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "69.1.0",
+  "version": "69.3.0",
   "description": "Run 1000 web accessibility tests from 11 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/catalog.js

@@ -9,6 +9,16 @@
 /*
   catalog
   Creates and returns a catalog of a target.
+
+  A catalog is an object with one property per element in the target. Each property has the element index as its key and has an object as its value, with 7 properties:
+  - tagName
+  - id
+  - startTag
+  - text
+  - textLinkable
+  - boxID
+  - pathID
+  - headingIndex
 */
 
 // IMPORTS
@@ -34,78 +44,90 @@ exports.getCatalog = async report => {
     });
     // If the launch and navigation succeeded:
     if (page) {
-      // Create a catalog of the elements in the page.
+      // Get a catalog of the elements in the page.
       const catalog = await page.evaluate(() => {
-        // Adds an element property to a catalog and returns its value.
-        const addToCatalog = (elementIndex, catalog, propertyName, value) => {
-          if (value) {
-            catalog[propertyName] ??= {};
-            catalog[propertyName][value] ??= [];
-            catalog[propertyName][value].push(elementIndex);
-            return value;
-          }
-          return '';
-        };
         const elements = Array.from(document.querySelectorAll('*'));
         // Initialize a catalog.
-        const cat = {
-          element: {},
-          tagName: {},
-          id: {},
-          startTag: {},
-          text: {},
-          boxID: {},
-          pathID: {}
-        };
+        const cat = {};
+        // Initialize a directory of text fragments.
+        const texts = {};
+        // Initialize the index of the current heading.
+        let headingIndex = '';
         // For each element in the page:
         for (const index in elements) {
           const element = elements[index];
-          // Index it by its properties in the catalog.
-          const tagName = addToCatalog(index, cat, 'tagName', element.tagName || '');
-          const id = addToCatalog(index, cat, 'id', element.id || '');
-          const startTag = addToCatalog(
-            index,
-            cat,
-            'startTag',
-            element.outerHTML?.replace(/^.*?</s, '<').replace(/>.*$/s, '>') ?? ''
-          );
-          const innerText = element.closest('head') ? '' : element.innerText;
-          const segments = innerText?.trim().split('\n');
-          const tidySegments = segments?.map(segment => segment.trim().replace(/\s+/g, ' ')) ?? [];
-          const neededSegments = tidySegments.filter(segment => segment.length);
-          neededSegments.splice(1, neededSegments.length - 2);
-          const text = addToCatalog(index, cat, 'text', neededSegments.join('\n'));
+          // Get its ID and tag name.
+          const {id, tagName} = element;
+          // Get its start tag.
+          const startTag = element.outerHTML?.replace(/^.*?</s, '<').replace(/>.*$/s, '>') ?? '';
+          // Get whether it is eligible for text-fragment acquisition.
+          const isTextable = element.closest('body')
+          && ! element.closest('svg')
+          && ! ['SCRIPT', 'STYLE', 'svg'].includes(element.tagName);
+          const innerText = isTextable
+          ? element.innerText.trim() || (element.parentElement?.innerText?.trim() ?? '')
+          : '';
+          let text = '';
+          // If it is eligible and has an inner text:
+          if (innerText) {
+            const segments = innerText?.split('\n') ?? [];
+            const tidySegments = segments.map(segment => segment.trim().replace(/\s+/g, ' '));
+            const neededSegments = tidySegments.filter(segment => segment.length);
+            neededSegments.splice(1, neededSegments.length - 2);
+            // Get its text fragments.
+            text = neededSegments.join('\n');
+            // Add its index to the directory of text fragments.
+            texts[text] ??= [];
+            texts[text].push(index);
+          }
           const domRect = element.getBoundingClientRect();
-          const boxID = addToCatalog(
-            index,
-            cat,
-            'boxID',
-            domRect
-            ? ['x', 'y', 'width', 'height'].map(key => Math.round(domRect[key])).join(':')
-            : ''
-          );
-          const pathID = addToCatalog(index, cat, 'pathID', window.getXPath(element));
-          // Add an entry for it to the element data in the catalog.
-          cat.element[index] = {
+          // Get its box ID.
+          const boxID = domRect
+          ? ['x', 'y', 'width', 'height'].map(key => Math.round(domRect[key])).join(':')
+          : '';
+          // Get its path ID.
+          const pathID = window.getXPath(element);
+          // If it is a heading that nullifies an existing current heading index:
+          if (
+            headingIndex
+            && ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(tagName)
+            && cat[headingIndex].tagName >= tagName
+          ) {
+            // Nullify the current heading index.
+            headingIndex = '';
+          }
+          // Add an entry for it to the catalog.
+          cat[index] = {
             tagName,
-            id,
+            id: id || '',
             startTag,
             text,
             textLinkable: false,
             boxID,
-            pathID
+            pathID,
+            headingIndex
           };
+          // If the element is a heading:
+          if (['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(tagName)) {
+            // Assign its index to the current heading index.
+            headingIndex = index;
+          }
+          // If the element has a path ID:
+          if (pathID) {
+            // Add it to the temporary path ID directory in the catalog.
+            cat.pathID ??= {};
+            cat.pathID[pathID] = index;
+          }
         }
         // For each text in the catalog:
-        Object.keys(cat.text).forEach(text => {
-          const textElementIndexes = cat.text[text];
-          // If every element that has it is in the same subtree, so is page-unique:
+        Object.keys(texts).forEach(text => {
+          const textElementIndexes = texts[text].sort((a, b) => Number(a) - Number(b));
+          // If every element that has it is in the same subtree, so the text is page-unique:
           if (
             textElementIndexes.slice(0, -1).every(
-              (elementIndex, index) => cat
-              .element[textElementIndexes[index + 1]]
+              (elementIndex, index) => cat[textElementIndexes[index + 1]]
               .pathID
-              .startsWith(cat.element[elementIndex].pathID)
+              .startsWith(cat[elementIndex].pathID)
             )
           ) {
             // For each element that has it:
@@ -113,10 +135,10 @@ exports.getCatalog = async report => {
               // If it is not in the head, a script, a style, or a noscript element:
               if (
                 ! ['/head[1]', '/script[', '/style[', '/noscript[']
-                .some(excluder => cat.element[index].pathID.includes(excluder))
+                .some(excluder => cat[index].pathID.includes(excluder))
               ) {
                 // Mark it as linkable in the element data in the catalog.
-                cat.element[index].textLinkable = true;
+                cat[index].textLinkable = true;
               }
             });
           }
@@ -136,9 +158,9 @@ exports.getCatalog = async report => {
   console.log('ERROR: Job omits browser ID or target URL, preventing catalog creation');
   return {};
 };
-// Prunes an elements-only catalog.
+// Prunes a catalog.
 exports.pruneCatalog = report => {
-  const {acts} = report;
+  const {acts, catalog} = report;
   const citedElementIndexes = new Set();
   // For each act in the report:
   acts.forEach(act => {
@@ -152,22 +174,26 @@ exports.pruneCatalog = report => {
         if (catalogIndex) {
           // Ensure the index is classified as cited.
           citedElementIndexes.add(catalogIndex);
+          const {headingIndex} = catalog[catalogIndex];
+          // If the catalog item has a heading index:
+          if (headingIndex) {
+            // Ensure it, too, is classified as cited.
+            citedElementIndexes.add(headingIndex);
+          }
         }
       });
     }
   });
-  const prunedCatalog = {};
+  // Delete the temporary path ID directory.
+  delete catalog.pathID;
   // For each element in the catalog:
-  const {catalog} = report;
   Object.keys(catalog).forEach(elementIndex => {
-    // If it is cited by at least 1 instance:
-    if (citedElementIndexes.has(elementIndex)) {
-      // Add it to the pruned catalog.
-      prunedCatalog[elementIndex] = catalog[elementIndex];
+    // If it is not cited by any instance or by any cited element:
+    if (! citedElementIndexes.has(elementIndex)) {
+      // Delete it in the catalog.
+      delete catalog[elementIndex];
     }
   });
-  // Replace the catalog with the pruned catalog.
-  report.catalog = prunedCatalog;
 };
 // Adds a catalog index or, if necessary, an XPath to a proto-instance.
 exports.addCatalogIndex = async (protoInstance, locator, catalog) => {

package/procs/doActs.js

@@ -1150,8 +1150,6 @@ exports.doActs = async (report, opts = {}) => {
   console.log('Acts completed');
   // If the results were standardized:
   if (['also', 'only'].includes(standard)) {
-    // Reassign the element property of the catalog to the catalog, deleting the rest.
-    localReport.catalog = localReport.catalog.element;
     // If the native results are not to be included in the report:
     if (standard === 'only') {
       // Remove them.

package/procs/xPath.js

@@ -57,6 +57,6 @@ exports.getAttributeXPath = html => {
 };
 // Gets a catalog index as a string from an XPath.
 exports.getXPathCatalogIndex = (catalog, xPath) => {
-  const index = catalog.pathID[xPath]?.[0] ?? '';
+  const index = catalog.pathID[xPath] ?? '';
   return index;
 };

package/tests/axe.js

@@ -151,6 +151,8 @@ exports.reporter = async (page, report, actIndex) => {
                 // Get the ordinal severity of the suspicion.
                 const ordinalSeverity = severityWeights[node.impact]
                 + (certainty === 'violations' ? 2 : 0);
+                // Increment the standard total.
+                standardResult.totals[ordinalSeverity]++;
                 // Get the XPath of the suspected element from its data-xpath attribute.
                 const xPath = getAttributeXPath(node.html);
                 // Get the catalog index of the suspected element from its XPath.