chore: Refactor a11yText method for readability

lib/commons/text/accessible-text-virtual.js

@@ -30,28 +30,11 @@ text.accessibleTextVirtual = function accessibleTextVirtual(
 	context = {}
 ) {
 	const { actualNode } = virtualNode;
-	if (!context.startNode) {
-		context = { startNode: virtualNode, ...context };
-	}
+	context = prepareContext(virtualNode, context);
 
-	/**
-	 * When `aria-labelledby` directly references a `hidden` element
-	 * the element needs to be included in the accessible name.
-	 *
-	 * When a descendent of the `aria-labelledby` reference is `hidden`
-	 * the element should not be included in the accessible name.
-	 *
-	 * This is done by setting `includeHidden` for the `aria-labelledby` reference.
-	 */
-	if (
-		actualNode.nodeType === 1 &&
-		context.inLabelledByContext &&
-		context.includeHidden === undefined
-	) {
-		context = {
-			includeHidden: !dom.isVisible(actualNode, true),
-			...context
-		};
+	// Step 2A, check visibility
+	if (shouldIgnoreHidden(virtualNode, context)) {
+		return '';
 	}
 
 	const computationSteps = [
@@ -64,18 +47,13 @@ text.accessibleTextVirtual = function accessibleTextVirtual(
 		text.titleText // Step 2I
 	];
 
-	// Step 2A, check visibility
-	if (
-		actualNode.nodeType === 1 &&
-		!context.includeHidden &&
-		!dom.isVisible(actualNode, true)
-	) {
-		return '';
-	}
-
 	// Find the first step that returns a non-empty string
 	let accName = computationSteps.reduce((accName, step) => {
-		return accName || step(virtualNode, context);
+		if (accName !== '') {
+			// yes, whitespace only a11y names halt the algorithm
+			return accName;
+		}
+		return step(virtualNode, context);
 	}, '');
 
 	if (context.startNode === virtualNode) {
@@ -88,13 +66,71 @@ text.accessibleTextVirtual = function accessibleTextVirtual(
 	return accName;
 };
 
+/**
+ * Return the textContent of a node
+ * @param {VirtualNode} element
+ * @return {String} textContent value
+ */
 function textNodeContent({ actualNode }) {
 	if (actualNode.nodeType !== 3) {
 		return '';
 	}
 	return actualNode.textContent;
 }
 
+/**
+ * Check if the
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {VirtualNode[]} processed
+ * @return {Boolean}
+ */
+function shouldIgnoreHidden({ actualNode }, context) {
+	if (
+		// If the parent isn't ignored, the text node should not be either
+		actualNode.nodeType !== 1 ||
+		// If the target of aria-labelledby is hidden, ignore all descendents
+		context.includeHidden
+	) {
+		return false;
+	}
+
+	return !dom.isVisible(actualNode, true);
+}
+
+/**
+ * Apply defaults to the context
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @return {Object} context object with defaults applied
+ */
+function prepareContext(virtualNode, context) {
+	const { actualNode } = virtualNode;
+	if (!context.startNode) {
+		context = { startNode: virtualNode, ...context };
+	}
+	/**
+	 * When `aria-labelledby` directly references a `hidden` element
+	 * the element needs to be included in the accessible name.
+	 *
+	 * When a descendent of the `aria-labelledby` reference is `hidden`
+	 * the element should not be included in the accessible name.
+	 *
+	 * This is done by setting `includeHidden` for the `aria-labelledby` reference.
+	 */
+	if (
+		actualNode.nodeType === 1 &&
+		context.inLabelledByContext &&
+		context.includeHidden === undefined
+	) {
+		context = {
+			includeHidden: !dom.isVisible(actualNode, true),
+			...context
+		};
+	}
+	return context;
+}
+
 /**
  * Check if the node is processed with this context before
  * @param {VirtualNode} element