@a11yfred/neighbor 1.0.4 → 2.0.0

package/RULES.md

@@ -1,24 +1,25 @@
-# @a11yfred/neighbor  -  Rule Index
+# @a11yfred/neighbor: Rule Index
 
-Neighbor ships rules across three separate domains. Each has its own reference page.
+Neighbor has rules for four different areas. Each area has its own page.
 
-| Domain | Entry point | Rules page |
+| Area | Setup | Rules page |
 | --- | --- | --- |
-| Markup | `@a11yfred/neighbor/eslint`, `/eslint-vue`, `/eslint-angular` | [RULES-MARKUP.md](RULES-MARKUP.md) |
-| CSS | `@a11yfred/neighbor` (default), `@a11yfred/neighbor/stylelint` | [RULES-CSS.md](RULES-CSS.md) |
-| Content | `@a11yfred/neighbor/content` | [RULES-CONTENT.md](RULES-CONTENT.md) |
+| CSS | `@a11yfred/neighbor`, `@a11yfred/neighbor/stylelint` | [RULES-CSS.md](RULES-CSS.md) |
+| HTML / Markup | `@a11yfred/neighbor/eslint`, `/eslint-vue`, `/eslint-angular`, `/webcomponents` | [RULES-MARKUP.md](RULES-MARKUP.md) |
+| Native Mobile | `apps/ios-app`, `apps/android-app` | [iOS Rules](apps/ios-app/README.md) / [Android Rules](apps/android-app/README.md) |
+| Text / Content | `@a11yfred/neighbor/content` | [RULES-CONTENT.md](RULES-CONTENT.md) |
 
 ---
 
-## Markup rules  -  summary
+## Markup rules: summary
 
-ESLint rules that flag bad ARIA patterns, missing accessible names, keyboard traps, and structural errors in JSX, Vue SFCs, and Angular templates. Full reference → [RULES-MARKUP.md](RULES-MARKUP.md)
+ESLint rules that find bad ARIA code, missing names, keyboard traps, and HTML mistakes in React, Vue, Angular, Lit, and plain HTML. Full list → [RULES-MARKUP.md](RULES-MARKUP.md)
 
-**Errors (definite breakage):** `no-aria-label-on-generic`, `no-assertive-live-overuse`, `no-unblocked-aria-disabled`, `no-roles-without-name`, `no-group-without-name`, `no-presentation-on-focusable`, `no-log-with-interactive-children`, `no-aria-hidden-in-link`, `no-redundant-aria-hidden-with-presentation`, `no-aria-owns-on-void`, `no-title-as-label`, `no-tabs-without-structure`, `no-positive-tabindex`, `no-autoplay-without-controls`, `no-heading-inside-interactive`, `no-placeholder-only`, `no-empty-button`, `no-image-role-without-name`, `no-spinbutton-without-range`, `no-slider-without-range`, `no-combobox-without-expanded`, `no-mouse-only-events`, `no-listbox-without-option`, `no-tree-without-treeitem`, `no-feed-without-article`, `no-aria-activedescendant-without-id`, `no-duplicate-id`, `no-summary-without-details`, `no-aria-required-on-non-form`, `no-input-type-invalid`, `no-labelledby-missing-target`, `no-dynamic-content-without-live`, `form-field-multiple-labels`, `no-empty-table-header`
+**Errors (you must fix these):** `no-aria-label-on-generic`, `no-assertive-live-overuse`, `no-unblocked-aria-disabled`, `no-roles-without-name`, `no-group-without-name`, `no-presentation-on-focusable`, `no-log-with-interactive-children`, `no-aria-hidden-in-link`, `no-redundant-aria-hidden-with-presentation`, `no-aria-owns-on-void`, `no-title-as-label`, `no-tabs-without-structure`, `no-positive-tabindex`, `no-autoplay-without-controls`, `no-heading-inside-interactive`, `no-placeholder-only`, `no-empty-button`, `no-image-role-without-name`, `no-spinbutton-without-range`, `no-slider-without-range`, `no-combobox-without-expanded`, `no-mouse-only-events`, `no-listbox-without-option`, `no-tree-without-treeitem`, `no-feed-without-article`, `no-aria-activedescendant-without-id`, `no-duplicate-id`, `no-summary-without-details`, `no-aria-required-on-non-form`, `no-input-type-invalid`, `no-labelledby-missing-target`, `no-dynamic-content-without-live`, `form-field-multiple-labels`, `no-empty-table-header`, `no-disabled-and-aria-disabled`, `prefer-aria-disabled`
 
-**Warnings (on by default):** `no-tooltip-role-misuse`, `no-menu-role-on-nav`, `no-button-type-missing`
+**Warnings (these are usually bad):** `no-tooltip-role-misuse`, `no-menu-role-on-nav`, `no-button-type-missing`
 
-**Off by default (opt in):** `no-application-role`, `no-grid-role`, `no-aria-roledescription`, `no-aria-readonly`, `no-tab-without-controls`, `no-href-hash`, `warn-role-alert`, `prefer-aria-disabled`, `no-target-blank-without-label`, `no-dialog-without-close`
+**Off by default (you can turn these on):** `no-application-role`, `no-grid-role`, `no-aria-roledescription`, `no-aria-readonly`, `no-tab-without-controls`, `no-href-hash`, `warn-role-alert`, `no-target-blank-without-label`, `no-dialog-without-close`
 
 **Vue / Angular only:** `no-anchor-ambiguous-text`, `no-anchor-no-content`, `no-aria-activedescendant-no-tabindex`, `no-invalid-aria-prop-value`, `no-autocomplete-invalid`, `no-heading-no-content`, `no-iframe-no-title`, `no-img-redundant-alt`, `no-access-key`, `no-noninteractive-to-interactive-role`, `no-noninteractive-tabindex`, `prefer-semantic-element`, `no-role-supports-aria-props`, `no-scope-on-td`
 
@@ -26,30 +27,48 @@ ESLint rules that flag bad ARIA patterns, missing accessible names, keyboard tra
 
 ---
 
-## CSS rules  -  summary
+## CSS rules: summary
 
-Stylelint rules that flag CSS that removes focus indicators, opts out of High Contrast Mode, or fails to provide user-preference media query fallbacks. Full reference → [RULES-CSS.md](RULES-CSS.md)
+Stylelint rules that find bad CSS. They check if you hide focus rings, block High Contrast Mode, or ignore user preferences for motion. Full list → [RULES-CSS.md](RULES-CSS.md)
 
-| Rule | What it flags |
+| Rule | What it finds |
 | --- | --- |
+| `neighbor/no-absolute-viewport-text` | Pure viewport units (`vw`, `vh`) for text sizing - this stops browser zoom from working |
+| `neighbor/no-forced-colors-none` | `forced-color-adjust: none` inside `@media (forced-colors)` - this blocks Windows High Contrast Mode |
+| `neighbor/no-outline-none` | `outline: none` outside `:focus` - this removes keyboard focus rings |
+| `neighbor/no-text-justify` | `text-align: justify` - this creates uneven word spacing that is hard for dyslexic users to read |
+| `neighbor/no-user-select-all-none` | `user-select: none` on text - this stops users from highlighting, copying, and translating text |
 | `neighbor/user-preferences` | Animation, motion, and transparency without `@media (prefers-*)` fallbacks |
-| `neighbor/no-outline-none` | `outline: none` outside `:focus` selectors  -  removes keyboard focus ring |
-| `neighbor/no-forced-colors-none` | `forced-color-adjust: none` inside `@media (forced-colors)`  -  opts out of Windows High Contrast Mode |
 
 ---
 
-## Content rules  -  summary
+## Content rules: summary
 
-ESLint rules that flag accessibility and inclusion problems in string literals and JSX text  -  ableist language, disability metaphors, English idioms, vague link and button text, directional references, unexplained abbreviations, ALL CAPS prose, and vague error messages. All ship as `warn`. Full reference → [RULES-CONTENT.md](RULES-CONTENT.md)
+ESLint rules that find problems in your text. They check for ableist language, hard-to-understand English idioms, confusing links, and unexplained short words. All of these rules are set to `warn`. Full list → [RULES-CONTENT.md](RULES-CONTENT.md)
 
-| Rule | What it flags | WCAG SC |
+| Rule | What it finds | WCAG SC |
 | --- | --- | --- |
-| `no-ableist-language` | Slurs, suffering-framing, condescending euphemisms ("wheelchair-bound", "suffers from", "special needs") | 3.1.1 |
-| `no-disability-metaphor` | Disability used figuratively ("blind spot", "tone deaf", "paralyzed by") | - |
-| `no-english-idiom` | Idioms and sports metaphors opaque to ESL readers ("slam dunk", "boil the ocean", "circle back") | 3.1.5 |
-| `no-vague-cta` | Vague link/button text ("click here", "read more", "here") | 2.4.4 |
-| `no-directional-language` | Position-based instructions ("see above", "in the right sidebar") | 1.3.3 |
-| `no-unexplained-abbreviation` | Acronyms used without prior expansion in the file | 3.1.4 |
-| `no-all-caps-prose` | ALL CAPS words that screen readers may spell out letter-by-letter | - |
-| `no-vague-error-message` | Error messages that don't say what went wrong ("An error occurred") | 3.3.1 |
-| `no-ampersand-in-prose` | `&` in place of "and"  -  announced inconsistently by screen readers | - |
+| `no-ableist-language` | Offensive words about disability or framing disability as suffering ("wheelchair-bound", "suffers from", "special needs") | 3.1.1 |
+| `no-all-caps-prose` | ALL CAPS words (screen readers might read them one letter at a time) | - |
+| `no-ampersand-in-prose` | Using `&` instead of "and" (screen readers read this differently) | - |
+| `no-anti-lgbtq-language` | Old or offensive words about sexual orientation and gender | - |
+| `no-colonial-and-violent-language` | Words based on colonialism or violence (stakeholder, target population, tackle) | - |
+| `no-deficit-language` | Words that reduce people to their bad situations (the homeless, inmate, addict) | - |
+| `no-device-specific-action` | Words that only make sense on a desktop computer ("click here", "press enter") | - |
+| `no-directional-language` | Instructions based on where things are on the screen ("see above", "in the right sidebar") | 1.3.3 |
+| `no-disability-metaphor` | Using disability as a metaphor ("blind spot", "tone deaf", "paralyzed by") | - |
+| `no-english-idiom` | Phrases or sports metaphors that are hard for non-native English speakers to understand ("slam dunk", "boil the ocean", "circle back") | 3.1.5 |
+| `no-exclusive-language` | Tech jargon and culturally insensitive words (blacklist, master/slave, spirit animal) | - |
+| `no-gendered-language` | Gendered pronouns when the gender is unknown (he/she, his or her, mum and dad) | - |
+| `no-unexplained-abbreviation` | Short words or acronyms used before you explain what they mean | 3.1.4 |
+| `no-vague-cta` | Confusing link or button text ("click here", "read more", "here") | 2.4.4 |
+| `no-vague-error-message` | Error messages that do not explain what is wrong ("An error occurred") | 3.3.1 |
+
+---
+
+## Native Mobile: summary
+
+`neighbor` includes strict rule implementations translated directly from our core web libraries for native iOS (SwiftUI) and Android (Jetpack Compose). They flag issues like missing Roles, unscaled text, broken touch targets, and improper semantics directly inside Xcode and Android Studio.
+
+- **[iOS Rules](apps/ios-app/README.md):** 8 Custom SwiftLint Rules for SwiftUI (via `.swiftlint.yml`).
+- **[Android Rules](apps/android-app/README.md):** 17 Custom Android Lint Rules for Jetpack Compose (via standard Gradle module).

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',
+  }
+}