@a11yfred/neighbor 1.1.2 → 2.0.0

package/lib/content-rules.js

@@ -64,6 +64,8 @@ export const ABLEIST_TERMS = [
   { term: /\blame\b/i, suggest: 'weak / unconvincing (for the non-disability sense)', sources: 'NCDJ, A11y Collective' },
   { term: /\bvegetable[s]?\b/i, suggest: 'person in a persistent vegetative state', sources: 'ADA NN' },
   { term: /\bfreak[s]?\b/i, suggest: '(rewrite)', sources: 'ADA NN' },
+  { term: /\bspastic[s]?\b/i, suggest: 'clumsy / energetic (highly offensive ableist slur in UK)', sources: 'Scope UK' },
+  { term: /\bspaz(zes|zed)?\b/i, suggest: 'clumsy / energetic (highly offensive ableist slur in UK)', sources: 'Scope UK' },
 
   // Condescending euphemisms  -  ≥3 sources each
   { term: /\bspecial needs\b/i, suggest: 'disability / person with a disability', sources: 'NCDJ, AP, ADA NN, APA' },
@@ -791,8 +793,210 @@ export function createNoAmpersandInProseRule() {
   }
 }
 
+
+/**
+ * no-exclusive-language
+ */
+export const EXCLUSIVE_TERMS = [
+  { term: /\bblack[- ]?list[s]?\b/i, suggest: 'denylist / blocklist', sources: 'Google, MS, Prevention.org' },
+  { term: /\bwhite[- ]?list[s]?\b/i, suggest: 'allowlist / safelist', sources: 'Google, MS, Prevention.org' },
+  { term: /\bmaster(?! (node|degree|class))\b/i, suggest: 'primary / main / leader', sources: 'Google, MS, Prevention.org' },
+  { term: /\bslave\b/i, suggest: 'replica / worker / follower', sources: 'Google, MS, Prevention.org' },
+  { term: /\bdummy\b/i, suggest: 'placeholder / mock / sample', sources: 'Google' },
+  { term: /\bsanity check\b/i, suggest: 'quick check / confidence check', sources: 'Google' },
+  { term: /\bspirit animal\b/i, suggest: 'remove / favorite (avoid cultural appropriation)', sources: 'MS, Prevention.org' },
+  { term: /\bpowwow\b/i, suggest: 'meeting / gathering (avoid cultural appropriation)', sources: 'MS, Prevention.org' },
+  { term: /\bninja[s]?\b/i, suggest: 'expert / specialist', sources: 'MS, Prevention.org' },
+  { term: /\bguru[s]?\b/i, suggest: 'expert / leader', sources: 'MS, Prevention.org' },
+  { term: /\btribe\b/i, suggest: 'team / network / community', sources: 'Prevention.org' },
+  { term: /\bguys\b/i, suggest: 'folks / everyone / team', sources: 'Google, MS' },
+  { term: /\bcolou?red people\b/i, suggest: 'people of color (avoid coloured which is highly offensive in the UK)', sources: 'APA, AP Style' },
+  { term: /\boriental[s]?\b/i, suggest: 'Asian / specific descent', sources: 'AP Style, Microsoft' },
+  { term: /\beskimo[s]?\b/i, suggest: 'Alaska Native / Inuit', sources: 'AP Style, Microsoft' },
+  { term: /\bnegro[s]?\b/i, suggest: 'Black / African American / specific descent', sources: 'AP Style, APA' },
+  { term: /\bafro[- ]american[s]?\b/i, suggest: 'Black / African American / specific descent', sources: 'AP Style, APA' },
+  { term: /\bpaki[s]?\b/i, suggest: 'specific descent (highly offensive slur in UK, avoid entirely)', sources: 'UK Gov' },
+]
+
+export function createNoExclusiveLanguageRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow non-inclusive tech jargon and cultural appropriation', url: 'https://github.com/a11yfred/neighbor#no-exclusive-language' }, messages: { exclusive: '"{{term}}" is non-inclusive or culturally appropriated. Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, EXCLUSIVE_TERMS, allow, context, 'exclusive')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, EXCLUSIVE_TERMS, allow, context, 'exclusive') }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * no-colonial-and-violent-language
+ */
+export const VIOLENT_COLONIAL_TERMS = [
+  { term: /\bstakeholder[s]?\b/i, suggest: 'partner / collaborator / contributor / community member', sources: 'SkilledWork' },
+  { term: /\btarget (population|audience)\b/i, suggest: 'group of focus / intended audience / specific population', sources: 'SkilledWork, Prevention.org' },
+  { term: /\b(combat|tackle)\b(?! (the|this) (issue|problem|disease))/i, suggest: 'address / collaborate with / eliminate', sources: 'Prevention.org' }
+]
+
+export function createNoColonialAndViolentLanguageRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow terms rooted in colonialism or violent imagery applied to people', url: 'https://github.com/a11yfred/neighbor#no-colonial-and-violent-language' }, messages: { violentColonial: '"{{term}}" has violent or colonial origins. Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, VIOLENT_COLONIAL_TERMS, allow, context, 'violentColonial')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, VIOLENT_COLONIAL_TERMS, allow, context, 'violentColonial') }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * no-deficit-language
+ */
+export const DEFICIT_TERMS = [
+  { term: /\bthe homeless\b/i, suggest: 'people experiencing homelessness', sources: 'Prevention.org, SkilledWork' },
+  { term: /\b(inmate|felon|convict|ex-con)[s]?\b/i, suggest: 'person with legal system involvement / formerly incarcerated person', sources: 'SkilledWork' },
+  { term: /\boffender[s]?\b/i, suggest: 'person with legal system involvement', sources: 'SkilledWork' },
+  { term: /\baddict[s]?\b/i, suggest: 'person with a substance use disorder', sources: 'Prevention.org' },
+  { term: /\b(drug|substance) abuse\b/i, suggest: 'substance use disorder', sources: 'Prevention.org' },
+  { term: /\bminority\b/i, suggest: 'historically marginalized group / people of color', sources: 'APA, Prevention.org' },
+  { term: /\bat-risk youth\b/i, suggest: 'opportunity youth', sources: 'SkilledWork' },
+  { term: /\b(vulnerable|high-risk) (group|population)[s]?\b/i, suggest: 'groups experiencing vulnerability / historically marginalized communities', sources: 'SkilledWork, Prevention.org' },
+  { term: /\bnon-English speaking\b/i, suggest: 'multilingual learner', sources: 'ACECQA' },
+]
+
+export function createNoDeficitLanguageRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow language that reduces people to their circumstances or behaviors', url: 'https://github.com/a11yfred/neighbor#no-deficit-language' }, messages: { deficit: '"{{term}}" is deficit-based language. Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, DEFICIT_TERMS, allow, context, 'deficit')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, DEFICIT_TERMS, allow, context, 'deficit') }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * no-gendered-language
+ */
+export const GENDERED_PATTERNS = [
+  { term: /\b(he\/she|she\/he|he or she|she or he)\b/i, suggest: 'they / their / you / the user', sources: 'MS, Google' },
+  { term: /\b(his\/her|her\/his|his or her|her or his)\b/i, suggest: 'their / your', sources: 'MS, Google' },
+  { term: /\bmum and dad\b/i, suggest: 'families / parents / carers', sources: 'ACECQA' },
+  { term: /\b(born a man|born a woman)\b/i, suggest: 'assigned male/female at birth', sources: 'UPenn, NAHJ' },
+  { term: /\b(biologically male|biologically female)\b/i, suggest: 'assigned male/female at birth', sources: 'UPenn, NAHJ' },
+  { term: /\b(opposite sex|opposite gender)\b/i, suggest: 'different gender / another sex', sources: 'APA, TJA' },
+  { term: /\b(husband|wife)\b/i, suggest: 'partner / spouse (when gender is unknown)', sources: 'APA, Google, NAHJ' },
+  { term: /\b(boyfriend|girlfriend)\b/i, suggest: 'partner (when gender is unknown)', sources: 'APA, Google, NAHJ' },
+  { term: /\b(male-bodied|female-bodied)\b/i, suggest: 'assigned male/female at birth', sources: 'TJA' },
+  { term: /\b(fireman|policeman|chairman)\b/i, suggest: 'firefighter / police officer / chairperson', sources: 'GOV.UK, Canada' },
+]
+
+export function createNoGenderedLanguageRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow gendered pronoun patterns in generic references', url: 'https://github.com/a11yfred/neighbor#no-gendered-language' }, messages: { gendered: '"{{term}}" is a generic gendered pattern. Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, GENDERED_PATTERNS, allow, context, 'gendered')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, GENDERED_PATTERNS, allow, context, 'gendered') }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * no-device-specific-action
+ */
+export const DEVICE_SPECIFIC_PATTERNS = [
+  { term: /\bclick(ing|ed)? (on|the|this)\b/i, suggest: 'choose / select', sources: 'Apple, Google' },
+  { term: /\btap(ping|ped)? (on|the|this)\b/i, suggest: 'choose / select', sources: 'Apple, Google' },
+  { term: /\bswipe (the|this)\b/i, suggest: 'choose / select / navigate', sources: 'Apple' }
+]
+
+export function createNoDeviceSpecificActionRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow device-specific action verbs', url: 'https://github.com/a11yfred/neighbor#no-device-specific-action' }, messages: { deviceAction: '"{{term}}" assumes a specific input device (mouse, touch screen). Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, DEVICE_SPECIFIC_PATTERNS, allow, context, 'deviceAction')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, DEVICE_SPECIFIC_PATTERNS, allow, context, 'deviceAction') }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * no-anti-lgbtq-language
+ */
+export const ANTI_LGBTQ_TERMS = [
+  { term: /\bhomosexual[s]?\b/i, suggest: 'gay / lesbian / bisexual', sources: 'APA, AP Style, NAHJ' },
+  { term: /\bsexual preference[s]?\b/i, suggest: 'sexual orientation', sources: 'APA, AP Style, NAHJ' },
+  { term: /\btransgendered\b/i, suggest: 'transgender', sources: 'TJA, APA, AP Style' },
+  { term: /\ba transgender\b/i, suggest: 'a transgender person', sources: 'TJA, APA, AP Style' },
+  { term: /\btransgenderism\b/i, suggest: 'transgender people / trans rights', sources: 'TJA' },
+  { term: /\b(trans ideology|gender ideology)\b/i, suggest: 'transgender rights', sources: 'TJA' },
+  { term: /\btrans-identified\b/i, suggest: 'transgender', sources: 'TJA' },
+  { term: /\b(trans male|trans female)\b/i, suggest: 'trans man / trans woman', sources: 'TJA' },
+  { term: /\btransvestite[s]?\b/i, suggest: 'transgender (or use specific terms as preferred)', sources: 'NAHJ, TJA' },
+  { term: /\bcross[- ]dresser[s]?\b/i, suggest: 'transgender (or use specific terms as preferred)', sources: 'NAHJ, TJA' },
+  { term: /\bfaggot[s]?\b/i, suggest: '(highly offensive slur, avoid entirely)', sources: 'AP Style' },
+  { term: /\bfag[s]?\b/i, suggest: '(highly offensive slur, avoid entirely. Note: slang for cigarette in UK but slur in US)', sources: 'AP Style' },
+  { term: /\bqueer\b/i, suggest: '(use only if referring to self-identification, otherwise avoid as it can be a slur)', sources: 'AP Style, UK Gov' },
+]
+
+export function createNoAntiLgbtqLanguageRule() {
+  return {
+    meta: { type: 'suggestion', docs: { description: 'Disallow outdated, pathologizing, or offensive terms regarding sexual orientation and gender identity', url: 'https://github.com/a11yfred/neighbor#no-anti-lgbtq-language' }, messages: { antiLgbtq: '"{{term}}" is outdated or offensive regarding LGBTQ+ identity. Suggestion: {{suggest}}. ({{sources}})' }, schema: [{ type: 'object', properties: { allow: { type: 'array', items: { type: 'string' } } }, additionalProperties: false }] },
+    create(context) {
+      const allow = new Set((context.options[0]?.allow ?? []).map(s => s.toLowerCase()))
+      return {
+        Literal(node) {
+          if (typeof node.value !== 'string') return
+          checkTermList(node, node.value, ANTI_LGBTQ_TERMS, allow, context, 'antiLgbtq')
+        },
+        TemplateLiteral(node) {
+          for (const quasi of node.quasis) { checkTermList(quasi, quasi.value.raw, ANTI_LGBTQ_TERMS, allow, context, 'antiLgbtq') }
+        }
+      }
+    }
+  }
+}
+
 // ─── Rule export map ─────────────────────────────────────────────────────────
 
+
 export const CONTENT_RULE_FACTORIES = {
   'no-ableist-language': createNoAbleistLanguageRule,
   'no-disability-metaphor': createNoDisabilityMetaphorRule,
@@ -803,6 +1007,12 @@ export const CONTENT_RULE_FACTORIES = {
   'no-all-caps-prose': createNoAllCapsProse,
   'no-vague-error-message': createNoVagueErrorMessageRule,
   'no-ampersand-in-prose': createNoAmpersandInProseRule,
+  'no-exclusive-language': createNoExclusiveLanguageRule,
+  'no-colonial-and-violent-language': createNoColonialAndViolentLanguageRule,
+  'no-deficit-language': createNoDeficitLanguageRule,
+  'no-gendered-language': createNoGenderedLanguageRule,
+  'no-device-specific-action': createNoDeviceSpecificActionRule,
+  'no-anti-lgbtq-language': createNoAntiLgbtqLanguageRule,
 }
 
 /**
@@ -824,6 +1034,12 @@ export function buildContentRecommendedRules(ns) {
     [`${ns}/no-all-caps-prose`]: 'warn',
     [`${ns}/no-vague-error-message`]: 'warn',
     [`${ns}/no-ampersand-in-prose`]: 'warn',
+    [`${ns}/no-exclusive-language`]: 'warn',
+    [`${ns}/no-colonial-and-violent-language`]: 'warn',
+    [`${ns}/no-deficit-language`]: 'warn',
+    [`${ns}/no-gendered-language`]: 'warn',
+    [`${ns}/no-device-specific-action`]: 'warn',
+    [`${ns}/no-anti-lgbtq-language`]: 'warn',
   }
 }
 

package/lib/framework-rules.js

@@ -0,0 +1,282 @@
+/**
+ * neighbor/lib/framework-rules.js
+ * Framework-specific ESLint rules using standard JS/TS AST visitors.
+ *
+ * Unlike rules.js (which uses template AST visitors via helpers-jsx/vue/angular),
+ * these rules target the JavaScript/TypeScript AST and are scoped to specific
+ * frameworks via their dedicated plugin config files.
+ *
+ * Rules:
+ *   remix-route-title-missing   → neighbor-eslint-remix3.mjs only
+ *   angular-host-a11y           → neighbor-eslint-angular.mjs only (TS files)
+ */
+
+// ─── remix-route-title-missing ───────────────────────────────────────────────
+
+/**
+ * Ensures every Remix v2/v3 route module exports a meta() function
+ * that includes a title property. Without this, navigating to the route
+ * leaves the document title unchanged - screen readers announce nothing.
+ *
+ * Applies only to files matching: app/routes/**
+ */
+export const remixRouteTitleMissing = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require a `title` in the exported `meta` function in Remix route files  -  screen readers announce the document title on navigation.',
+    },
+    messages: {
+      missingMeta:
+        'Remix route is missing an exported `meta` function. Screen readers announce the document title on page navigation  -  add `export const meta = () => [{ title: "Page Name" }]`. (WCAG SC 2.4.2)',
+      missingTitle:
+        'Remix route `meta` export must include a `{ title: "..." }` entry. Screen readers announce the document title on page navigation. (WCAG SC 2.4.2)',
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = context.getFilename?.() ?? context.filename ?? ''
+    // Only apply in Remix route files
+    const isRoute =
+      /[/\\]app[/\\]routes[/\\]/.test(filename) ||
+      /[/\\]routes[/\\]/.test(filename)
+    if (!isRoute) return {}
+
+    let metaExportFound = false
+    let titleFound = false
+
+    function checkObjectHasTitle(node) {
+      if (node.type === 'ObjectExpression') {
+        return node.properties.some(
+          (p) =>
+            p.type === 'Property' &&
+            (p.key?.name === 'title' || p.key?.value === 'title')
+        )
+      }
+      return false
+    }
+
+    function checkForTitle(node) {
+      // Array: return [{ title: "..." }, ...]
+      if (node.type === 'ArrayExpression') {
+        return node.elements.some((el) => el && checkObjectHasTitle(el))
+      }
+      // Object: return { title: "..." }  (Remix v1 compat)
+      if (node.type === 'ObjectExpression') {
+        return checkObjectHasTitle(node)
+      }
+      // Arrow with implicit return: () => [...]
+      if (node.type === 'ArrowFunctionExpression' && node.expression) {
+        return checkForTitle(node.body)
+      }
+      return false
+    }
+
+    return {
+      // export const meta = ...
+      ExportNamedDeclaration(node) {
+        const decl = node.declaration
+        if (!decl || decl.type !== 'VariableDeclaration') return
+        for (const declarator of decl.declarations) {
+          if (declarator.id?.name !== 'meta') continue
+          metaExportFound = true
+          if (declarator.init && checkForTitle(declarator.init)) {
+            titleFound = true
+          }
+        }
+      },
+      // export function meta() { return [...] }
+      'ExportNamedDeclaration > FunctionDeclaration'(node) {
+        if (node.id?.name !== 'meta') return
+        metaExportFound = true
+        // Walk return statements in the function body
+        const body = node.body?.body ?? []
+        for (const stmt of body) {
+          if (
+            stmt.type === 'ReturnStatement' &&
+            stmt.argument &&
+            checkForTitle(stmt.argument)
+          ) {
+            titleFound = true
+          }
+        }
+      },
+      'Program:exit'(node) {
+        if (!metaExportFound) {
+          context.report({ node, messageId: 'missingMeta' })
+        } else if (!titleFound) {
+          context.report({ node, messageId: 'missingTitle' })
+        }
+      },
+    }
+  },
+}
+
+// ─── angular-host-a11y ───────────────────────────────────────────────────────
+
+/**
+ * Ensures Angular @Component({ host: {...} }) decorators don't apply
+ * interactive roles to the host element without also providing tabindex.
+ *
+ * Without tabindex="0", a custom Angular component with role="button" set
+ * in the host binding will appear in the accessibility tree but won't be
+ * reachable via keyboard Tab navigation.
+ */
+
+const INTERACTIVE_HOST_ROLES = new Set([
+  'button', 'link', 'checkbox', 'radio', 'switch', 'tab',
+  'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option',
+  'slider', 'spinbutton', 'treeitem', 'gridcell',
+])
+
+export const angularHostA11y = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow interactive `role` in Angular @Component host bindings without `tabindex`',
+    },
+    messages: {
+      missingTabindex:
+        'Angular @Component host binding has `role="{{ role }}"` but is missing `tabindex: "0"`. Without tabindex, the element will not be reachable via keyboard navigation. (ARIA 1.2 / APG)',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      // Matches: @Component({ host: { role: 'button' } })
+      Decorator(node) {
+        if (
+          node.expression?.type !== 'CallExpression' ||
+          node.expression.callee?.name !== 'Component'
+        ) return
+
+        const args = node.expression.arguments ?? []
+        const configObj = args.find((a) => a.type === 'ObjectExpression')
+        if (!configObj) return
+
+        const hostProp = configObj.properties.find(
+          (p) =>
+            p.type === 'Property' &&
+            (p.key?.name === 'host' || p.key?.value === 'host')
+        )
+        if (!hostProp || hostProp.value?.type !== 'ObjectExpression') return
+
+        const hostProps = hostProp.value.properties
+        let hostRole = null
+        let hasTabindex = false
+
+        for (const prop of hostProps) {
+          const key =
+            prop.key?.name ?? prop.key?.value ?? ''
+          const val =
+            prop.value?.value ?? prop.value?.quasis?.[0]?.value?.raw ?? ''
+
+          if (key === 'role' && INTERACTIVE_HOST_ROLES.has(val)) {
+            hostRole = val
+          }
+          if (key === 'tabindex' || key === 'tabIndex') {
+            hasTabindex = true
+          }
+        }
+
+        if (hostRole && !hasTabindex) {
+          context.report({
+            node: hostProp,
+            messageId: 'missingTabindex',
+            data: { role: hostRole },
+          })
+        }
+      },
+    }
+  },
+}
+
+// ─── angular-router-focus-management ─────────────────────────────────────────
+
+export const angularRouterFocusManagement = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Warn if <router-outlet> is used without focus management.' },
+    messages: {
+      noFocus: 'SPA route transitions via <router-outlet> require manual focus management (e.g., using a skip-link or programmatic focus).'
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      Element(node) {
+        if (node.name === 'router-outlet') {
+          context.report({ node, messageId: 'noFocus' })
+        }
+      }
+    }
+  }
+}
+
+// ─── lit-no-autofocus ────────────────────────────────────────────────────────
+
+export const litNoAutofocus = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Disallow autofocus in Lit templates.' },
+    messages: {
+      noAutofocus: 'The autofocus attribute disrupts focus flow and disorients screen reader users.'
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      TaggedTemplateExpression(node) {
+        if (node.tag && node.tag.name === 'html') {
+          const raw = node.quasi.quasis.map(q => q.value.raw).join('')
+          // Simple regex to catch autofocus attribute
+          if (/\bautofocus\b/.test(raw)) {
+            context.report({ node, messageId: 'noAutofocus' })
+          }
+        }
+      }
+    }
+  }
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+export function buildRemixRules() {
+  return {
+    'remix-route-title-missing': remixRouteTitleMissing,
+  }
+}
+
+export function buildRemixRecommendedRules(ns) {
+  return {
+    [`${ns}/remix-route-title-missing`]: 'error',
+  }
+}
+
+export function buildAngularFrameworkRules() {
+  return {
+    'angular-host-a11y': angularHostA11y,
+    'angular-router-focus-management': angularRouterFocusManagement,
+  }
+}
+
+export function buildAngularHostRecommendedRules(ns) {
+  return {
+    [`${ns}/angular-host-a11y`]: 'error',
+    [`${ns}/angular-router-focus-management`]: 'off',
+  }
+}
+
+export function buildLitRules() {
+  return {
+    'lit-no-autofocus': litNoAutofocus,
+  }
+}
+
+export function buildLitRecommendedRules(ns) {
+  return {
+    [`${ns}/lit-no-autofocus`]: 'error',
+  }
+}

package/lib/helpers-webcomponents.js

@@ -0,0 +1,134 @@
+/**
+ * neighbor/lib/helpers-webcomponents.js
+ * Helpers for Vanilla Web Components and static HTML AST via @html-eslint/parser.
+ *
+ * Parser: @html-eslint/parser provides a generic HTML AST.
+ * Node type for elements: 'Tag'
+ * The node has:
+ *   node.name           - tag name string
+ *   node.attributes     - Attribute[]
+ *   node.children       - Array of Tag | Text
+ *   node.parent         - parent Tag
+ */
+
+import {
+  INTERACTIVE_ELEMENTS,
+  INTERACTIVE_ROLES,
+} from './helpers.js'
+
+export function getAttr(node, name) {
+  return (node.attributes ?? []).find(a => a.key?.value === name) ?? null
+}
+
+export function getAttrStringValue(attr) {
+  if (!attr) return null
+  return typeof attr.value?.value === 'string' ? attr.value.value : null
+}
+
+export function getElementName(node) {
+  const raw = node.name ?? ''
+  if (!raw) return null
+  // HTML tags are case-insensitive, but Web Component tags usually have a dash.
+  return raw.toLowerCase()
+}
+
+export function hasAttr(node, name) {
+  return getAttr(node, name) !== null
+}
+
+export function getRoleValue(node) {
+  return getAttrStringValue(getAttr(node, 'role'))
+}
+
+export function hasAccessibleName(node) {
+  return hasAttr(node, 'aria-label') || hasAttr(node, 'aria-labelledby')
+}
+
+export function isInteractiveElement(node) {
+  const el = getElementName(node)
+  if (el && INTERACTIVE_ELEMENTS.has(el)) return true
+  const role = getRoleValue(node)
+  return !!(role && INTERACTIVE_ROLES.has(role))
+}
+
+export function hasOnlyHiddenChildren(node) {
+  const children = node.children ?? []
+  if (children.length === 0) return false
+  return children.every(child => {
+    if (child.type === 'Text') return (child.value ?? '').trim() === ''
+    if (child.type === 'Tag') {
+      return (child.attributes ?? []).some(a => a.key?.value === 'aria-hidden')
+    }
+    return false
+  })
+}
+
+const NEW_TAB_PATTERN = /new.tab|new.window|opens in/i
+
+function collectHtmlText(node) {
+  if (!node) return ''
+  if (node.type === 'Text') return node.value ?? ''
+  if (node.type === 'Tag') return (node.children ?? []).map(collectHtmlText).join('')
+  return ''
+}
+
+export function hasNewTabWarning(node) {
+  const labelVal = (getAttrStringValue(getAttr(node, 'aria-label')) ?? '').toLowerCase()
+  if (NEW_TAB_PATTERN.test(labelVal)) return true
+  const childText = (node.children ?? []).map(collectHtmlText).join('')
+  return NEW_TAB_PATTERN.test(childText)
+}
+
+export function getParent(node) {
+  return node.parent?.type === 'Tag' ? node.parent : null
+}
+
+export function* getAncestors(node) {
+  let cur = getParent(node)
+  while (cur) {
+    yield cur
+    cur = getParent(cur)
+  }
+}
+
+export function* getChildOpeningElements(node) {
+  for (const child of node.children ?? []) {
+    if (child.type === 'Tag') yield child
+  }
+}
+
+export function getClassName(node) {
+  return getAttrStringValue(getAttr(node, 'class'))
+}
+
+export function getInnerHtmlAttr(node) {
+  // Vanilla HTML has no innerHTML attribute directive
+  return null
+}
+
+export function getInnerHtmlAttrName(_node) {
+  return null
+}
+
+export const h = {
+  getAttr,
+  getAttrStringValue,
+  getElementName,
+  hasAttr,
+  getRoleValue,
+  hasAccessibleName,
+  isInteractiveElement,
+  hasOnlyHiddenChildren,
+  hasNewTabWarning,
+  getParent,
+  getAncestors,
+  getChildOpeningElements,
+  getClassName,
+  getInnerHtmlAttr,
+  getInnerHtmlAttrName,
+  elementVisitor: 'Tag',
+  elementWithChildrenVisitor: 'Tag',
+  getOpeningElement: (node) => node,
+  getChildOpeningElementsFromWrapper: (node) =>
+    (node.children ?? []).filter(c => c.type === 'Tag'),
+}