PR Feedback

Author: NullVoxPopuli

docs/rules/template-no-invalid-link-text.md

@@ -72,4 +72,4 @@ Examples of **correct** code for this rule:
 
 - [WebAIM: Link Text and Appearance](https://webaim.org/techniques/hypertext/link_text)
 - [WCAG 2.4.4: Link Purpose (In Context)](https://www.w3.org/WAI/WCAG21/Understanding/link-purpose-in-context.html)
-- [eslint-plugin-ember template-no-invalid-link-text](https://github.com/ember-cli/eslint-plugin-ember/blob/master/docs/rules/template-no-invalid-link-text.md)
+- [ember-template-lint: no-invalid-link-text](https://github.com/ember-template-lint/ember-template-lint/blob/main/docs/rule/no-invalid-link-text.md)

lib/rules/template-no-invalid-link-text.js

@@ -22,53 +22,49 @@ function getTextContentResult(node) {
   return { text: '', hasDynamic: false };
 }
 
+function isDynamicValue(value) {
+  return value?.type === 'GlimmerMustacheStatement' || value?.type === 'GlimmerConcatStatement';
+}
+
 /**
- * Check if the node has a valid aria-label or aria-labelledby that
- * exempts it from link text validation.
+ * Checks aria-labelledby and aria-label attributes.
+ * Returns:
+ *   { skip: true }                          — has valid accessible name, skip element
+ *   { report: true, text: string }          — aria-label is itself a disallowed text, report it
+ *   { skip: false }                         — no valid aria override, check text content
  */
-function hasValidAriaLabelOrLabelledby(node) {
-  const attrs = node.attributes || [];
-
-  // Check aria-labelledby
+function checkAriaAttributes(attrs) {
   const ariaLabelledby = attrs.find((a) => a.name === 'aria-labelledby');
   if (ariaLabelledby) {
-    if (ariaLabelledby.value && ariaLabelledby.value.type === 'GlimmerTextNode') {
-      const val = ariaLabelledby.value.chars.trim();
-      // Only valid if non-empty
-      return val.length > 0;
+    if (isDynamicValue(ariaLabelledby.value)) {
+      return { skip: true };
     }
-    // Dynamic value — assume valid
-    if (
-      ariaLabelledby.value &&
-      (ariaLabelledby.value.type === 'GlimmerMustacheStatement' ||
-        ariaLabelledby.value.type === 'GlimmerConcatStatement')
-    ) {
-      return true;
+    if (ariaLabelledby.value?.type === 'GlimmerTextNode') {
+      if (ariaLabelledby.value.chars.trim().length > 0) {
+        return { skip: true }; // valid non-empty labelledby
+      }
     }
-    // No value or empty — not valid
-    return false;
+    // empty aria-labelledby → fall through
+    return { skip: false };
   }
 
-  // Check aria-label
   const ariaLabel = attrs.find((a) => a.name === 'aria-label');
   if (ariaLabel) {
-    // Dynamic value — assume valid
-    if (
-      ariaLabel.value &&
-      (ariaLabel.value.type === 'GlimmerMustacheStatement' ||
-        ariaLabel.value.type === 'GlimmerConcatStatement')
-    ) {
-      return true;
+    if (isDynamicValue(ariaLabel.value)) {
+      return { skip: true };
     }
-    if (ariaLabel.value && ariaLabel.value.type === 'GlimmerTextNode') {
+    if (ariaLabel.value?.type === 'GlimmerTextNode') {
       const val = ariaLabel.value.chars.replaceAll(' ', ' ').toLowerCase().trim();
-      // aria-label itself must not be disallowed text
-      return val.length > 0 && !DISALLOWED_LINK_TEXTS.has(val);
+      if (val.length > 0 && !DISALLOWED_LINK_TEXTS.has(val)) {
+        return { skip: true }; // valid aria-label
+      }
+      if (val.length > 0) {
+        return { skip: true, report: true, text: val }; // aria-label itself is disallowed
+      }
     }
-    return false;
   }
 
-  return false;
+  return { skip: false };
 }
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -108,28 +104,46 @@ module.exports = {
     const options = context.options[0] || {};
     const allowEmptyLinks = options.allowEmptyLinks || false;
     const customLinkComponents = options.linkComponents || [];
-    const linkTags = new Set(['a', 'LinkTo', ...customLinkComponents]);
+
+    const filename = context.filename ?? context.getFilename();
+    const isStrictMode = filename.endsWith('.gjs') || filename.endsWith('.gts');
+
+    // In HBS, LinkTo always refers to Ember's router link component.
+    // In GJS/GTS, LinkTo must be explicitly imported from '@ember/routing'.
+    // local alias → true (any truthy value marks it as a tracked link component)
+    const importedLinkComponents = new Map();
+
+    const linkTags = new Set(['a', ...customLinkComponents]);
+    if (!isStrictMode) {
+      linkTags.add('LinkTo');
+    }
 
     function checkLinkContent(node, children) {
-      // Skip if has aria-hidden
-      const ariaHidden = (node.attributes || []).find((a) => a.name === 'aria-hidden');
+      const attrs = node.attributes || [];
+
+      // Skip if aria-hidden="true"
+      const ariaHidden = attrs.find((a) => a.name === 'aria-hidden');
       if (ariaHidden?.value?.type === 'GlimmerTextNode' && ariaHidden.value.chars === 'true') {
         return;
       }
 
-      // Skip if has hidden attribute
-      if ((node.attributes || []).some((a) => a.name === 'hidden')) {
+      // Skip if hidden attribute present
+      if (attrs.some((a) => a.name === 'hidden')) {
         return;
       }
 
-      // Check aria-label / aria-labelledby
-      if (hasValidAriaLabelOrLabelledby(node)) {
+      const ariaResult = checkAriaAttributes(attrs);
+      if (ariaResult.report) {
+        context.report({ node, messageId: 'invalidText', data: { text: ariaResult.text } });
+        return;
+      }
+      if (ariaResult.skip) {
         return;
       }
 
+      // Check text content
       let fullText = '';
       let hasDynamic = false;
-
       for (const child of children || []) {
         const result = getTextContentResult(child);
         fullText += result.text;
@@ -138,50 +152,46 @@ module.exports = {
         }
       }
 
-      // If there's dynamic content, skip (can't validate)
       if (hasDynamic) {
-        return;
+        return; // can't validate dynamic content
       }
 
       const normalized = fullText.trim().toLowerCase().replaceAll(/\s+/g, ' ');
 
-      // Empty link check
       if (!normalized.replaceAll(' ', '')) {
         if (!allowEmptyLinks) {
-          context.report({
-            node,
-            messageId: 'invalidText',
-            data: { text: '(empty)' },
-          });
+          context.report({ node, messageId: 'invalidText', data: { text: '(empty)' } });
         }
         return;
       }
 
       if (DISALLOWED_LINK_TEXTS.has(normalized)) {
-        context.report({
-          node,
-          messageId: 'invalidText',
-          data: { text: normalized },
-        });
+        context.report({ node, messageId: 'invalidText', data: { text: normalized } });
       }
     }
 
     return {
+      ImportDeclaration(node) {
+        if (node.source.value === '@ember/routing') {
+          for (const specifier of node.specifiers) {
+            if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'LinkTo') {
+              importedLinkComponents.set(specifier.local.name, true);
+              linkTags.add(specifier.local.name);
+            }
+          }
+        }
+      },
+
       GlimmerElementNode(node) {
         if (!linkTags.has(node.tag)) {
           return;
         }
-
         checkLinkContent(node, node.children);
       },
 
       GlimmerBlockStatement(node) {
-        if (
-          node.path &&
-          node.path.type === 'GlimmerPathExpression' &&
-          node.path.original === 'link-to'
-        ) {
-          checkLinkContent(node, node.program && node.program.body);
+        if (node.path?.type === 'GlimmerPathExpression' && node.path.original === 'link-to') {
+          checkLinkContent(node, node.program?.body);
         }
       },
     };