axe-core 4.1.2-canary.ec00dc7 → 4.1.2

package/lib/checks/mobile/meta-viewport-scale-evaluate.js

@@ -1,59 +1,59 @@
-function metaViewportScaleEvaluate(node, options, virtualNode) {
-  const { scaleMinimum = 2, lowerBound = false } = options || {};
-
-  const content = virtualNode.attr('content') || '';
-  if (!content) {
-    return true;
-  }
-
-  const result = content.split(/[;,]/).reduce((out, item) => {
-    const contentValue = item.trim();
-    if (!contentValue) {
-      return out;
-    }
-
-    const [key, value] = contentValue.split('=');
-    if (!key || !value) {
-      return out;
-    }
-    const curatedKey = key.toLowerCase().trim();
-    let curatedValue = value.toLowerCase().trim();
-
-    // convert `yes` to `1`
-    if (curatedKey === 'maximum-scale' && curatedValue === 'yes') {
-      curatedValue = 1;
-    }
-    // when negative ignore key
-    if (curatedKey === 'maximum-scale' && parseFloat(curatedValue) < 0) {
-      return out;
-    }
-
-    out[curatedKey] = curatedValue;
-    return out;
-  }, {});
-
-  if (
-    lowerBound &&
-    result['maximum-scale'] &&
-    parseFloat(result['maximum-scale']) < lowerBound
-  ) {
-    return true;
-  }
-
-  if (!lowerBound && result['user-scalable'] === 'no') {
-    this.data('user-scalable=no');
-    return false;
-  }
-
-  if (
-    result['maximum-scale'] &&
-    parseFloat(result['maximum-scale']) < scaleMinimum
-  ) {
-    this.data('maximum-scale');
-    return false;
-  }
-
-  return true;
+function metaViewportScaleEvaluate(node, options) {
+	const { scaleMinimum = 2, lowerBound = false } = options || {};
+
+	const content = node.getAttribute('content') || '';
+	if (!content) {
+		return true;
+	}
+
+	const result = content.split(/[;,]/).reduce((out, item) => {
+		const contentValue = item.trim();
+		if (!contentValue) {
+			return out;
+		}
+
+		const [key, value] = contentValue.split('=');
+		if (!key || !value) {
+			return out;
+		}
+		const curatedKey = key.toLowerCase().trim();
+		let curatedValue = value.toLowerCase().trim();
+
+		// convert `yes` to `1`
+		if (curatedKey === 'maximum-scale' && curatedValue === 'yes') {
+			curatedValue = 1;
+		}
+		// when negative ignore key
+		if (curatedKey === 'maximum-scale' && parseFloat(curatedValue) < 0) {
+			return out;
+		}
+
+		out[curatedKey] = curatedValue;
+		return out;
+	}, {});
+
+	if (
+		lowerBound &&
+		result['maximum-scale'] &&
+		parseFloat(result['maximum-scale']) < lowerBound
+	) {
+		return true;
+	}
+
+	if (!lowerBound && result['user-scalable'] === 'no') {
+		this.data('user-scalable=no');
+		return false;
+	}
+
+	if (
+		result['maximum-scale'] &&
+		parseFloat(result['maximum-scale']) < scaleMinimum
+	) {
+		this.data('maximum-scale');
+		return false;
+	}
+
+	return true;
 }
 
 export default metaViewportScaleEvaluate;

package/lib/checks/mobile/meta-viewport.json

@@ -1,14 +1,14 @@
 {
-  "id": "meta-viewport",
-  "evaluate": "meta-viewport-scale-evaluate",
-  "options": {
-    "scaleMinimum": 2
-  },
-  "metadata": {
-    "impact": "critical",
-    "messages": {
-      "pass": "<meta> tag does not disable zooming on mobile devices",
-      "fail": "${data} on <meta> tag disables zooming on mobile devices"
-    }
-  }
+	"id": "meta-viewport",
+	"evaluate": "meta-viewport-scale-evaluate",
+	"options": {
+		"scaleMinimum": 2
+	},
+	"metadata": {
+		"impact": "critical",
+		"messages": {
+			"pass": "<meta> tag does not disable zooming on mobile devices",
+			"fail": "${data} on <meta> tag disables zooming on mobile devices"
+		}
+	}
 }

package/lib/checks/navigation/header-present.json

@@ -1,15 +1,15 @@
 {
-  "id": "header-present",
-  "evaluate": "has-descendant-evaluate",
-  "after": "has-descendant-after",
-  "options": {
-    "selector": ":is(h1, h2, h3, h4, h5, h6):not([role]), [role=heading]"
-  },
-  "metadata": {
-    "impact": "serious",
-    "messages": {
-      "pass": "Page has a heading",
-      "fail": "Page does not have a heading"
-    }
-  }
+	"id": "header-present",
+	"evaluate": "has-descendant-evaluate",
+	"after": "has-descendant-after",
+	"options": {
+		"selector": "h1:not([role]), h2:not([role]), h3:not([role]), h4:not([role]), h5:not([role]), h6:not([role]), [role=heading]"
+	},
+	"metadata": {
+		"impact": "serious",
+		"messages": {
+			"pass": "Page has a heading",
+			"fail": "Page does not have a heading"
+		}
+	}
 }

package/lib/checks/navigation/heading-order-after.js

@@ -1,141 +1,18 @@
-const joinStr = ' > ';
-
-/**
- * Flatten an ancestry path of an iframe result into a string.
- */
-function getFramePath(ancestry, nodePath) {
-  // remove the last path so we're only left with iframe paths
-  ancestry = ancestry.slice(0, ancestry.length - 1);
-
-  if (nodePath) {
-    ancestry = ancestry.concat(nodePath);
-  }
-
-  return ancestry.join(joinStr);
-}
-
 function headingOrderAfter(results) {
-  if (results.length < 2) {
-    return results;
-  }
-
-  /**
-   * In order to correctly return heading order results (even for
-   * headings that may be out of the current context) we need to
-   * construct an in-order list of all headings on the page,
-   * including headings from iframes.
-   *
-   * To do this we will find all nested headingOrders (i.e. those
-   * from iframes) and then determine where those results fit into
-   * the top-level heading order. once we've put all the heading
-   * orders into their proper place, we can then determine which
-   * headings are not in the correct order.
-   **/
-
-  // start by replacing all array ancestry paths with a flat string
-  // path
-  let headingOrder = results[0].data.headingOrder.map(heading => {
-    return {
-      ...heading,
-      ancestry: getFramePath(results[0].node.ancestry, heading.ancestry)
-    };
-  });
-
-  // find all nested headindOrders
-  const nestedResults = results.filter(result => {
-    return result.data && result.data.headingOrder && result.node._fromFrame;
-  });
-
-  // update the path of nodes to include the iframe path
-  nestedResults.forEach(result => {
-    result.data.headingOrder = result.data.headingOrder.map(heading => {
-      return {
-        ...heading,
-        ancestry: getFramePath(result.node.ancestry, heading.ancestry)
-      };
-    });
-  });
-
-  /**
-   * Determine where the iframe results fit into the top-level
-   * heading order
-   */
-  function getFrameIndex(result) {
-    const path = getFramePath(result.node.ancestry);
-    const heading = headingOrder.find(heading => {
-      return heading.ancestry === path;
-    });
-    return headingOrder.indexOf(heading);
-  }
-
-  /**
-   * Replace an iframe placeholder with its results
-   */
-  function replaceFrameWithResults(index, result) {
-    headingOrder.splice(index, 1, ...result.data.headingOrder);
-  }
-
-  // replace each iframe in the top-level heading order with its
-  // results.
-  // since nested iframe results can appear before their parent
-  // iframe, we will just loop over the nested results and
-  // piece-meal replace each iframe in the top-level heading order
-  // with their results until we no longer have results to replace
-  let replaced = false;
-  while (nestedResults.length) {
-    for (let i = 0; i < nestedResults.length; ) {
-      const nestedResult = nestedResults[i];
-      const index = getFrameIndex(nestedResult);
-
-      if (index !== -1) {
-        replaceFrameWithResults(index, nestedResult);
-        replaced = true;
-
-        // remove the nested result from the list
-        nestedResults.splice(i, 1);
-      } else {
-        i++;
-      }
-    }
-
-    // something went wrong if we can't replace an iframe in
-    // the top-level results
-    if (!replaced) {
-      throw new Error('Unable to find parent iframe of heading-order results');
-    }
-  }
-
-  // replace the ancestry path with information about the result
-  results.forEach(result => {
-    const path = result.node.ancestry.join(joinStr);
-    const heading = headingOrder.find(heading => {
-      return heading.ancestry === path;
-    });
-    const index = headingOrder.indexOf(heading);
-    headingOrder.splice(index, 1, {
-      level: headingOrder[index].level,
-      result
-    });
-  });
+	if (results.length < 2) {
+		return results;
+	}
 
-  // remove any iframes that aren't in context (level == -1)
-  headingOrder = headingOrder.filter(heading => heading.level > 0);
+	var prevLevel = results[0].data;
 
-  // now make sure all headings are in the correct order
-  for (let i = 1; i < results.length; i++) {
-    const result = results[i];
-    const heading = headingOrder.find(heading => {
-      return heading.result === result;
-    });
-    const index = headingOrder.indexOf(heading);
-    const currLevel = headingOrder[index].level;
-    const prevLevel = headingOrder[index - 1].level;
-    if (currLevel - prevLevel > 1) {
-      result.result = false;
-    }
-  }
+	for (var i = 1; i < results.length; i++) {
+		if (results[i].result && results[i].data > prevLevel + 1) {
+			results[i].result = false;
+		}
+		prevLevel = results[i].data;
+	}
 
-  return results;
+	return results;
 }
 
 export default headingOrderAfter;

package/lib/checks/navigation/heading-order-evaluate.js

@@ -1,58 +1,20 @@
-import cache from '../../core/base/cache';
-import { querySelectorAllFilter, getAncestry } from '../../core/utils';
-import { isVisible } from '../../commons/dom';
+function headingOrderEvaluate(node, options, virtualNode) {
+	const ariaHeadingLevel = virtualNode.attr('aria-level');
+	const nodeName = virtualNode.props.nodeName;
 
-function getLevel(vNode) {
-  const role = vNode.attr('role');
-  if (role && role.includes('heading')) {
-    const ariaHeadingLevel = vNode.attr('aria-level');
-    const level = parseInt(ariaHeadingLevel, 10);
+	if (ariaHeadingLevel !== null) {
+		this.data(parseInt(ariaHeadingLevel, 10));
+		return true;
+	}
 
-    // default aria-level for a heading is 2 if it is
-    // not set or set to an incorrect value
-    // @see https://www.w3.org/TR/wai-aria-1.1/#heading
-    if (isNaN(level) || level < 1 || level > 6) {
-      return 2;
-    }
+	const headingLevel = nodeName.toUpperCase().match(/H(\d)/);
 
-    return level;
-  }
+	if (headingLevel) {
+		this.data(parseInt(headingLevel[1], 10));
+		return true;
+	}
 
-  const headingLevel = vNode.props.nodeName.match(/h(\d)/);
-  if (headingLevel) {
-    return parseInt(headingLevel[1], 10);
-  }
-
-  return -1;
-}
-
-function headingOrderEvaluate() {
-  let headingOrder = cache.get('headingOrder');
-  if (headingOrder) {
-    return true;
-  }
-
-  // find all headings, even ones that are outside the current
-  // context. also need to know where iframes are so we can insert
-  // the results of any in-context iframes into their proper order
-  // @see https://github.com/dequelabs/axe-core/issues/728
-  const selector = 'h1, h2, h3, h4, h5, h6, [role=heading], iframe, frame';
-  // TODO: es-modules_tree
-  const vNodes = querySelectorAllFilter(axe._tree[0], selector, vNode =>
-    isVisible(vNode.actualNode, true)
-  );
-
-  headingOrder = vNodes.map(vNode => {
-    // save the path so we can reconstruct the heading order
-    return {
-      ancestry: [getAncestry(vNode.actualNode)],
-      level: getLevel(vNode)
-    };
-  });
-
-  this.data({ headingOrder });
-  cache.set('headingOrder', vNodes);
-  return true;
+	return true;
 }
 
 export default headingOrderEvaluate;

package/lib/checks/navigation/heading-order.json

@@ -1,12 +1,12 @@
 {
-  "id": "heading-order",
-  "evaluate": "heading-order-evaluate",
-  "after": "heading-order-after",
-  "metadata": {
-    "impact": "moderate",
-    "messages": {
-      "pass": "Heading order valid",
-      "fail": "Heading order invalid"
-    }
-  }
+	"id": "heading-order",
+	"evaluate": "heading-order-evaluate",
+	"after": "heading-order-after",
+	"metadata": {
+		"impact": "moderate",
+		"messages": {
+			"pass": "Heading order valid",
+			"fail": "Heading order invalid"
+		}
+	}
 }

package/lib/checks/navigation/identical-links-same-purpose-after.js

@@ -5,102 +5,102 @@
  * @returns {Boolean}
  */
 function isIdenticalObject(a, b) {
-  if (!a || !b) {
-    return false;
-  }
+	if (!a || !b) {
+		return false;
+	}
 
-  const aProps = Object.getOwnPropertyNames(a);
-  const bProps = Object.getOwnPropertyNames(b);
+	const aProps = Object.getOwnPropertyNames(a);
+	const bProps = Object.getOwnPropertyNames(b);
 
-  if (aProps.length !== bProps.length) {
-    return false;
-  }
+	if (aProps.length !== bProps.length) {
+		return false;
+	}
 
-  const result = aProps.every(propName => {
-    const aValue = a[propName];
-    const bValue = b[propName];
+	const result = aProps.every(propName => {
+		const aValue = a[propName];
+		const bValue = b[propName];
 
-    if (typeof aValue !== typeof bValue) {
-      return false;
-    }
+		if (typeof aValue !== typeof bValue) {
+			return false;
+		}
 
-    if (typeof aValue === `object` || typeof bValue === `object`) {
-      return isIdenticalObject(aValue, bValue);
-    }
+		if (typeof aValue === `object` || typeof bValue === `object`) {
+			return isIdenticalObject(aValue, bValue);
+		}
 
-    return aValue === bValue;
-  });
+		return aValue === bValue;
+	});
 
-  return result;
+	return result;
 }
 
 function identicalLinksSamePurposeAfter(results) {
-  /**
-   * Skip, as no results to curate
-   */
-  if (results.length < 2) {
-    return results;
-  }
-
-  /**
-   * Filter results for which `result` is undefined & thus `data`, `relatedNodes` are undefined
-   */
-  const incompleteResults = results.filter(
-    ({ result }) => result !== undefined
-  );
-
-  /**
-   * for each result
-   * - get other results with matching accessible name
-   * - check if same purpose is served
-   * - if not change `result` to `undefined`
-   * - construct a list of unique results with relatedNodes to return
-   */
-  const uniqueResults = [];
-  const nameMap = {};
-
-  for (let index = 0; index < incompleteResults.length; index++) {
-    const currentResult = incompleteResults[index];
-
-    const { name, urlProps } = currentResult.data;
-    /**
-     * This is to avoid duplications in the `nodeMap`
-     */
-    if (nameMap[name]) {
-      continue;
-    }
-
-    const sameNameResults = incompleteResults.filter(
-      ({ data }, resultNum) => data.name === name && resultNum !== index
-    );
-    const isSameUrl = sameNameResults.every(({ data }) =>
-      isIdenticalObject(data.urlProps, urlProps)
-    );
-
-    /**
-     * when identical nodes exists but do not resolve to same url, flag result as `incomplete`
-     */
-    if (sameNameResults.length && !isSameUrl) {
-      currentResult.result = undefined;
-    }
-
-    /**
-     *  -> deduplicate results (for both `pass` or `incomplete`) and add `relatedNodes` if any
-     */
-    currentResult.relatedNodes = [];
-    currentResult.relatedNodes.push(
-      ...sameNameResults.map(node => node.relatedNodes[0])
-    );
-
-    /**
-     * Update `nodeMap` with `sameNameResults`
-     */
-    nameMap[name] = sameNameResults;
-
-    uniqueResults.push(currentResult);
-  }
-
-  return uniqueResults;
+	/**
+	 * Skip, as no results to curate
+	 */
+	if (results.length < 2) {
+		return results;
+	}
+
+	/**
+	 * Filter results for which `result` is undefined & thus `data`, `relatedNodes` are undefined
+	 */
+	const incompleteResults = results.filter(
+		({ result }) => result !== undefined
+	);
+
+	/**
+	 * for each result
+	 * - get other results with matching accessible name
+	 * - check if same purpose is served
+	 * - if not change `result` to `undefined`
+	 * - construct a list of unique results with relatedNodes to return
+	 */
+	const uniqueResults = [];
+	const nameMap = {};
+
+	for (let index = 0; index < incompleteResults.length; index++) {
+		const currentResult = incompleteResults[index];
+
+		const { name, urlProps } = currentResult.data;
+		/**
+		 * This is to avoid duplications in the `nodeMap`
+		 */
+		if (nameMap[name]) {
+			continue;
+		}
+
+		const sameNameResults = incompleteResults.filter(
+			({ data }, resultNum) => data.name === name && resultNum !== index
+		);
+		const isSameUrl = sameNameResults.every(({ data }) =>
+			isIdenticalObject(data.urlProps, urlProps)
+		);
+
+		/**
+		 * when identical nodes exists but do not resolve to same url, flag result as `incomplete`
+		 */
+		if (sameNameResults.length && !isSameUrl) {
+			currentResult.result = undefined;
+		}
+
+		/**
+		 *  -> deduplicate results (for both `pass` or `incomplete`) and add `relatedNodes` if any
+		 */
+		currentResult.relatedNodes = [];
+		currentResult.relatedNodes.push(
+			...sameNameResults.map(node => node.relatedNodes[0])
+		);
+
+		/**
+		 * Update `nodeMap` with `sameNameResults`
+		 */
+		nameMap[name] = sameNameResults;
+
+		uniqueResults.push(currentResult);
+	}
+
+	return uniqueResults;
 }
 
 export default identicalLinksSamePurposeAfter;

package/lib/checks/navigation/identical-links-same-purpose-evaluate.js

@@ -4,32 +4,32 @@ import { dom, text } from '../../commons';
  * Note: `identical-links-same-purpose-after` fn, helps reconcile the results
  */
 function identicalLinksSamePurposeEvaluate(node, options, virtualNode) {
-  const accText = text.accessibleTextVirtual(virtualNode);
-  const name = text
-    .sanitize(
-      text.removeUnicode(accText, {
-        emoji: true,
-        nonBmp: true,
-        punctuations: true
-      })
-    )
-    .toLowerCase();
+	const accText = text.accessibleTextVirtual(virtualNode);
+	const name = text
+		.sanitize(
+			text.removeUnicode(accText, {
+				emoji: true,
+				nonBmp: true,
+				punctuations: true
+			})
+		)
+		.toLowerCase();
 
-  if (!name) {
-    return undefined;
-  }
+	if (!name) {
+		return undefined;
+	}
 
-  /**
-   * Set `data` and `relatedNodes` for use in `after` fn
-   */
-  const afterData = {
-    name,
-    urlProps: dom.urlPropsFromAttribute(node, 'href')
-  };
-  this.data(afterData);
-  this.relatedNodes([node]);
+	/**
+	 * Set `data` and `relatedNodes` for use in `after` fn
+	 */
+	const afterData = {
+		name,
+		urlProps: dom.urlPropsFromAttribute(node, 'href')
+	};
+	this.data(afterData);
+	this.relatedNodes([node]);
 
-  return true;
+	return true;
 }
 
 export default identicalLinksSamePurposeEvaluate;