@aishware/react-a11y-rules-web 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aishwarya Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @aishware/react-a11y-rules-web
+
+The web rule pack for [`@aishware/react-a11y`](https://www.npmjs.com/package/@aishware/react-a11y) —
+the WCAG 2.2 criteria, document structure, focus visibility and project-wide
+checks that [`eslint-plugin-jsx-a11y`](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y)
+does **not** cover. Run jsx-a11y in your ESLint config for standard web a11y
+(alt text, ARIA validity, role/element semantics); this pack covers the gaps
+with no overlap, so the two run together cleanly.
+
+Covers: color contrast, target size, label-in-name, pointer cancellation,
+viewport zoom, meta-refresh, reading order, document structure (heading order,
+lists, tables, fieldsets, duplicate landmarks), focus visibility, ARIA
+required-context, the WCAG 2.2 form criteria (accessible authentication, error
+identification, autocomplete-off), and cross-file `htmlFor` ↔ `id` label
+resolution (a project-wide pass).
+
+```ts
+import { analyze } from '@aishware/react-a11y-core';
+import { webRules } from '@aishware/react-a11y-rules-web';
+
+const diagnostics = analyze({ code, filename: 'App.tsx', platform: 'web', rules: webRules });
+```
+
+Most users want the CLI instead:
+[`@aishware/react-a11y`](https://www.npmjs.com/package/@aishware/react-a11y).
+
+Full rule list: <https://github.com/1aishwaryasharma/react-a11y/blob/main/docs/rules/web.md>
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import type { A11yConfig, ProjectPass, Rule } from '@aishware/react-a11y-core';
+import { buttonHasName, labelInName, mediaNoAutoplay } from './rules/names.js';
+import { pointerCancellation, noOutlineNone } from './rules/interactions.js';
+import { inputButtonHasName, accessibleAuthentication, errorIdentification, noAutocompleteOff } from './rules/forms.js';
+import { metaViewportZoomable, noMetaRefresh, titleHasContent } from './rules/document.js';
+import { headingOrder, listStructure, tableHasHeader, fieldsetHasLegend, ariaRequiredContext, meaningfulOrder, noDuplicateMain } from './rules/structure.js';
+import { colorContrast, targetSize } from './rules/contrast.js';
+export { createLabelForPass, formControlHasLabel } from './project/labels.js';
+/**
+ * The project-wide passes the web pack runs (currently the cross-file label
+ * resolution behind `form-control-has-label`). Single source of truth so the
+ * CLI, VS Code, and any future consumer wire the same passes — the registered
+ * `formControlHasLabel` rule is a no-op without this.
+ */
+export declare function webProjectPasses(config: A11yConfig): ProjectPass[];
+export { buttonHasName, labelInName, mediaNoAutoplay, pointerCancellation, noOutlineNone, inputButtonHasName, accessibleAuthentication, errorIdentification, noAutocompleteOff, metaViewportZoomable, noMetaRefresh, titleHasContent, headingOrder, listStructure, tableHasHeader, fieldsetHasLegend, ariaRequiredContext, meaningfulOrder, noDuplicateMain, colorContrast, targetSize, };
+/**
+ * The web rule pack — the WCAG 2.2 criteria, document structure, focus
+ * visibility and project-aware checks that eslint-plugin-jsx-a11y does NOT
+ * cover. Pair this with eslint-plugin-jsx-a11y, which owns the standard web
+ * a11y rules (alt text, ARIA validity, role/element semantics, …).
+ */
+export declare const webRules: Rule[];
+/**
+ * WCAG 2.2 A/AA success criteria that eslint-plugin-jsx-a11y covers. react-a11y
+ * defers these to jsx-a11y (run it in your ESLint config), so the conformance
+ * report can attribute them rather than counting them as gaps.
+ */
+export declare const JSX_A11Y_COVERED_WCAG: string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,EACL,YAAY,EACZ,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,EAAE,CAElE;AAED,OAAO,EACL,aAAa,EACb,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,aAAa,EACb,UAAU,GACX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,IAAI,EAgC1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,EAGzC,CAAC"}

package/dist/index.js

@@ -0,0 +1,66 @@
+import { buttonHasName, labelInName, mediaNoAutoplay } from './rules/names.js';
+import { pointerCancellation, noOutlineNone } from './rules/interactions.js';
+import { inputButtonHasName, accessibleAuthentication, errorIdentification, noAutocompleteOff, } from './rules/forms.js';
+import { metaViewportZoomable, noMetaRefresh, titleHasContent } from './rules/document.js';
+import { headingOrder, listStructure, tableHasHeader, fieldsetHasLegend, ariaRequiredContext, meaningfulOrder, noDuplicateMain, } from './rules/structure.js';
+import { colorContrast, targetSize } from './rules/contrast.js';
+import { createLabelForPass, formControlHasLabel } from './project/labels.js';
+export { createLabelForPass, formControlHasLabel } from './project/labels.js';
+/**
+ * The project-wide passes the web pack runs (currently the cross-file label
+ * resolution behind `form-control-has-label`). Single source of truth so the
+ * CLI, VS Code, and any future consumer wire the same passes — the registered
+ * `formControlHasLabel` rule is a no-op without this.
+ */
+export function webProjectPasses(config) {
+    return [createLabelForPass(config.rules)];
+}
+export { buttonHasName, labelInName, mediaNoAutoplay, pointerCancellation, noOutlineNone, inputButtonHasName, accessibleAuthentication, errorIdentification, noAutocompleteOff, metaViewportZoomable, noMetaRefresh, titleHasContent, headingOrder, listStructure, tableHasHeader, fieldsetHasLegend, ariaRequiredContext, meaningfulOrder, noDuplicateMain, colorContrast, targetSize, };
+/**
+ * The web rule pack — the WCAG 2.2 criteria, document structure, focus
+ * visibility and project-aware checks that eslint-plugin-jsx-a11y does NOT
+ * cover. Pair this with eslint-plugin-jsx-a11y, which owns the standard web
+ * a11y rules (alt text, ARIA validity, role/element semantics, …).
+ */
+export const webRules = [
+    // names jsx-a11y lacks
+    buttonHasName,
+    inputButtonHasName,
+    // document
+    titleHasContent,
+    metaViewportZoomable,
+    noMetaRefresh,
+    // media
+    mediaNoAutoplay,
+    // aria (required-context has no jsx-a11y equivalent)
+    ariaRequiredContext,
+    // structure
+    headingOrder,
+    listStructure,
+    tableHasHeader,
+    fieldsetHasLegend,
+    noDuplicateMain,
+    // cross-file label resolution (project-wide; implemented as a pass)
+    formControlHasLabel,
+    // focus visibility
+    noOutlineNone,
+    // forms (WCAG 2.2)
+    accessibleAuthentication,
+    errorIdentification,
+    noAutocompleteOff,
+    // pointer, contrast, target size, reading order, label-in-name (WCAG 2.1/2.2)
+    labelInName,
+    pointerCancellation,
+    colorContrast,
+    targetSize,
+    meaningfulOrder,
+];
+/**
+ * WCAG 2.2 A/AA success criteria that eslint-plugin-jsx-a11y covers. react-a11y
+ * defers these to jsx-a11y (run it in your ESLint config), so the conformance
+ * report can attribute them rather than counting them as gaps.
+ */
+export const JSX_A11Y_COVERED_WCAG = [
+    '1.1.1', '1.2.2', '1.3.1', '1.3.5', '2.1.1', '2.2.2', '2.4.3', '2.4.4',
+    '2.4.6', '3.1.1', '3.1.2', '3.2.1', '3.3.2', '4.1.2',
+];

package/dist/project/labels.d.ts

@@ -0,0 +1,18 @@
+import { type ProjectPass, type RuleSetting } from '@aishware/react-a11y-core';
+/**
+ * Registration entry for the cross-file label check. The actual work is the
+ * project pass below (`createLabelForPass`); this exists so the rule appears in
+ * `--list-rules` / `--coverage` and so `"form-control-has-label": "off"` is a
+ * visible, documented config key. The per-element visitor is intentionally
+ * empty — the analysis is project-wide, not per-file.
+ */
+export declare const formControlHasLabel: import("@aishware/react-a11y-core").Rule;
+/**
+ * Cross-file resolution of <label htmlFor> ↔ id. The per-file rule gives an
+ * id the benefit of the doubt; this pass closes the loop once the whole
+ * project has been seen: an id no <label htmlFor> ever references is an
+ * unlabeled control. Any *dynamic* htmlFor in the project disables the pass —
+ * it could reference anything.
+ */
+export declare function createLabelForPass(ruleSettings?: Record<string, RuleSetting>): ProjectPass;
+//# sourceMappingURL=labels.d.ts.map

package/dist/project/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/project/labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,WAAW,EAChB,KAAK,WAAW,EAGjB,MAAM,2BAA2B,CAAC;AAKnC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0CAU/B,CAAC;AAmBF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAM,GAAG,WAAW,CAgD9F"}

package/dist/project/labels.js

@@ -0,0 +1,90 @@
+import { attrProvidesValue, findAncestor, isAriaHidden, resolveWcag, staticString, } from '@aishware/react-a11y-core';
+import { defineRule } from '../util.js';
+const RULE_ID = 'form-control-has-label';
+/**
+ * Registration entry for the cross-file label check. The actual work is the
+ * project pass below (`createLabelForPass`); this exists so the rule appears in
+ * `--list-rules` / `--coverage` and so `"form-control-has-label": "off"` is a
+ * visible, documented config key. The per-element visitor is intentionally
+ * empty — the analysis is project-wide, not per-file.
+ */
+export const formControlHasLabel = defineRule({
+    id: RULE_ID,
+    description: 'Form controls must have a programmatically associated label (resolved across files).',
+    severity: 'serious',
+    wcag: ['1.3.1', '3.3.2', '4.1.2'],
+    partial: true,
+    project: true,
+}, () => { });
+const UNLABELED_INPUT_TYPES = new Set(['hidden', 'submit', 'reset', 'button', 'image']);
+function isControl(el) {
+    if (el.isComponent || !['input', 'select', 'textarea'].includes(el.name))
+        return false;
+    if (el.name === 'input') {
+        const type = staticString(el, 'type')?.trim().toLowerCase();
+        if (type && UNLABELED_INPUT_TYPES.has(type))
+            return false;
+    }
+    return true;
+}
+/**
+ * Cross-file resolution of <label htmlFor> ↔ id. The per-file rule gives an
+ * id the benefit of the doubt; this pass closes the loop once the whole
+ * project has been seen: an id no <label htmlFor> ever references is an
+ * unlabeled control. Any *dynamic* htmlFor in the project disables the pass —
+ * it could reference anything.
+ */
+export function createLabelForPass(ruleSettings = {}) {
+    const setting = ruleSettings[RULE_ID];
+    const htmlForIds = new Set();
+    let sawDynamicHtmlFor = false;
+    const candidates = [];
+    return {
+        collect(model, filename) {
+            if (setting === 'off')
+                return;
+            for (const el of model.elements) {
+                // Count htmlFor on DOM <label> and on components (design-system
+                // <Label htmlFor> wrappers forward it to a real label).
+                const attr = el.attrs.get('htmlFor') ?? (!el.isComponent && el.name === 'label' ? el.attrs.get('for') : undefined);
+                if (attr) {
+                    if (attr.kind === 'static' && typeof attr.value === 'string')
+                        htmlForIds.add(attr.value);
+                    else
+                        sawDynamicHtmlFor = true;
+                }
+                if (!isControl(el) || el.hasSpread || isAriaHidden(el))
+                    continue;
+                if (attrProvidesValue(el, 'aria-label') ||
+                    attrProvidesValue(el, 'aria-labelledby') ||
+                    attrProvidesValue(el, 'title'))
+                    continue;
+                if (findAncestor(el, (a) => !a.isComponent && a.name === 'label'))
+                    continue;
+                const id = staticString(el, 'id');
+                if (id === undefined)
+                    continue; // no-id case is reported by the per-file rule
+                candidates.push({ filename, loc: el.loc, id, elName: el.name });
+            }
+        },
+        finalize() {
+            if (setting === 'off' || sawDynamicHtmlFor)
+                return [];
+            const severity = setting ?? 'serious';
+            const wcag = resolveWcag(['1.3.1', '3.3.2', '4.1.2']);
+            return candidates
+                .filter((c) => !htmlForIds.has(c.id))
+                .map((c) => ({
+                ruleId: RULE_ID,
+                message: `<${c.elName} id="${c.id}"> is not referenced by any <label htmlFor="${c.id}"> in the project — the control has no label after all.`,
+                severity,
+                file: c.filename,
+                line: c.loc.line,
+                column: c.loc.column,
+                endLine: c.loc.endLine,
+                endColumn: c.loc.endColumn,
+                wcag,
+            }));
+        },
+    };
+}

package/dist/rules/aria.d.ts

@@ -0,0 +1,24 @@
+/** All aria-* attributes must exist in ARIA 1.2 and use correct (lowercase) casing. */
+export declare const ariaAttrsValid: import("@react-a11y/core").Rule;
+/** role values must be real, non-abstract ARIA roles. */
+export declare const roleValid: import("@react-a11y/core").Rule;
+/** Roles such as checkbox/slider have required ARIA states the author must set. */
+export declare const ariaRequiredAttrs: import("@react-a11y/core").Rule;
+/** aria-hidden="true" on focusable elements creates invisible tab stops. */
+export declare const ariaHiddenFocusable: import("@react-a11y/core").Rule;
+/** Explicit roles that duplicate the implicit role are noise. */
+export declare const noRedundantRoles: import("@react-a11y/core").Rule;
+/** ARIA attributes with invalid values are ignored or misread by screen readers. */
+export declare const ariaAttrValueValid: import("@react-a11y/core").Rule;
+/** ARIA states/properties must be supported by the element's explicit role. */
+export declare const roleSupportsAriaProps: import("@react-a11y/core").Rule;
+/** role and aria-* are silently ignored on elements that do not support them. */
+export declare const ariaUnsupportedElements: import("@react-a11y/core").Rule;
+/**
+ * aria-activedescendant points focus at a child, so the managing element must
+ * itself be focusable — otherwise the active descendant is never reached.
+ */
+export declare const ariaActivedescendantHasTabindex: import("@react-a11y/core").Rule;
+/** scope is only valid on <th>. */
+export declare const scopeOnTh: import("@react-a11y/core").Rule;
+//# sourceMappingURL=aria.d.ts.map

package/dist/rules/aria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria.d.ts","sourceRoot":"","sources":["../../src/rules/aria.ts"],"names":[],"mappings":"AAiBA,uFAAuF;AACvF,eAAO,MAAM,cAAc,iCA8B1B,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,SAAS,iCAkBrB,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,iCAkB7B,CAAC;AAiBF,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,iCAe/B,CAAC;AAuBF,iEAAiE;AACjE,eAAO,MAAM,gBAAgB,iCAqB5B,CAAC;AAgCF,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,iCA4B9B,CAAC;AAmBF,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,iCAqBjC,CAAC;AAQF,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,iCAoBnC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,+BAA+B,iCAgB3C,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,SAAS,iCAgBrB,CAAC"}

package/dist/rules/aria.js

@@ -0,0 +1,310 @@
+import { ABSTRACT_ROLES, ARIA_ATTRS, ROLES, ROLE_REQUIRED_ATTRS, fixRemoveAttr, fixRenameAttr, hasAttr, isAriaHidden, staticString, staticValue, } from '@react-a11y/core';
+import { defineRule } from '../util.js';
+const DEPRECATED_ARIA = new Set(['aria-dropeffect', 'aria-grabbed']);
+/** All aria-* attributes must exist in ARIA 1.2 and use correct (lowercase) casing. */
+export const ariaAttrsValid = defineRule({
+    id: 'aria-attrs-valid',
+    description: 'aria-* attributes must be valid ARIA 1.2 attributes.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+    fixable: true,
+}, (el, ctx) => {
+    for (const name of el.attrs.keys()) {
+        if (!/^aria-/i.test(name))
+            continue;
+        const lower = name.toLowerCase();
+        if (!ARIA_ATTRS.has(lower)) {
+            ctx.report({ el, message: `"${name}" is not a valid ARIA attribute. Check the spelling against ARIA 1.2.` });
+        }
+        else if (name !== lower) {
+            ctx.report({
+                el,
+                message: `ARIA attributes are lowercase: use "${lower}" instead of "${name}".`,
+                fix: fixRenameAttr(el, name, lower),
+            });
+        }
+        else if (DEPRECATED_ARIA.has(lower)) {
+            ctx.report({
+                el,
+                message: `"${lower}" is deprecated in ARIA 1.2 and should be removed.`,
+                severity: 'minor',
+                fix: fixRemoveAttr(el, lower),
+            });
+        }
+    }
+});
+/** role values must be real, non-abstract ARIA roles. */
+export const roleValid = defineRule({
+    id: 'aria-role-valid',
+    description: 'role attributes must use valid, non-abstract ARIA roles.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    const role = staticString(el, 'role');
+    if (role === undefined)
+        return;
+    for (const token of role.trim().split(/\s+/).filter(Boolean)) {
+        if (ABSTRACT_ROLES.has(token)) {
+            ctx.report({ el, message: `"${token}" is an abstract ARIA role and must not be used in content.` });
+        }
+        else if (!ROLES.has(token)) {
+            ctx.report({ el, message: `"${token}" is not a valid ARIA role.` });
+        }
+    }
+});
+/** Roles such as checkbox/slider have required ARIA states the author must set. */
+export const ariaRequiredAttrs = defineRule({
+    id: 'aria-required-attrs',
+    description: 'Elements with ARIA roles must have the states/properties that role requires.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    if (el.hasSpread)
+        return;
+    const role = staticString(el, 'role')?.trim();
+    if (!role)
+        return;
+    const required = ROLE_REQUIRED_ATTRS[role];
+    if (!required)
+        return;
+    const missing = required.filter((attr) => !hasAttr(el, attr));
+    if (missing.length > 0) {
+        ctx.report({ el, message: `role="${role}" requires ${missing.join(' and ')} to be set.` });
+    }
+});
+const ALWAYS_FOCUSABLE = new Set(['button', 'select', 'textarea', 'summary', 'iframe', 'embed']);
+function isFocusable(el) {
+    if (staticValue(el, 'disabled') === true)
+        return false;
+    const tabIndex = staticValue(el, 'tabIndex');
+    if (typeof tabIndex === 'number')
+        return tabIndex >= 0;
+    if (typeof tabIndex === 'string' && tabIndex.trim() !== '')
+        return Number(tabIndex) >= 0;
+    if (el.isComponent)
+        return false;
+    if (ALWAYS_FOCUSABLE.has(el.name))
+        return true;
+    if ((el.name === 'a' || el.name === 'area') && hasAttr(el, 'href'))
+        return true;
+    if (el.name === 'input')
+        return staticString(el, 'type') !== 'hidden';
+    if ((el.name === 'audio' || el.name === 'video') && hasAttr(el, 'controls'))
+        return true;
+    return false;
+}
+/** aria-hidden="true" on focusable elements creates invisible tab stops. */
+export const ariaHiddenFocusable = defineRule({
+    id: 'aria-hidden-focusable',
+    description: 'aria-hidden="true" must not be used on focusable elements.',
+    severity: 'serious',
+    wcag: ['4.1.2', '1.3.1'],
+}, (el, ctx) => {
+    if (!isAriaHidden(el))
+        return;
+    if (!isFocusable(el))
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> is focusable but aria-hidden — keyboard users land on an element screen readers cannot announce. Add tabIndex={-1} or remove aria-hidden.`,
+    });
+});
+const IMPLICIT_ROLES = {
+    button: 'button',
+    img: 'img',
+    nav: 'navigation',
+    main: 'main',
+    aside: 'complementary',
+    header: 'banner',
+    footer: 'contentinfo',
+    ul: 'list',
+    ol: 'list',
+    li: 'listitem',
+    table: 'table',
+    article: 'article',
+    dialog: 'dialog',
+    hr: 'separator',
+    output: 'status',
+    progress: 'progressbar',
+    textarea: 'textbox',
+    h1: 'heading', h2: 'heading', h3: 'heading', h4: 'heading', h5: 'heading', h6: 'heading',
+};
+/** Explicit roles that duplicate the implicit role are noise. */
+export const noRedundantRoles = defineRule({
+    id: 'no-redundant-roles',
+    description: 'Elements should not declare a role identical to their implicit role.',
+    severity: 'minor',
+    wcag: ['4.1.2'],
+    fixable: true,
+}, (el, ctx) => {
+    if (el.isComponent)
+        return;
+    const role = staticString(el, 'role')?.trim();
+    if (!role)
+        return;
+    const implicit = el.name === 'a' && hasAttr(el, 'href') ? 'link' : IMPLICIT_ROLES[el.name];
+    if (implicit === role) {
+        ctx.report({
+            el,
+            message: `role="${role}" is redundant — <${el.name}> already has that implicit role.`,
+            fix: fixRemoveAttr(el, 'role'),
+        });
+    }
+});
+/** Enumerated ARIA attributes and their allowed tokens (ARIA 1.2). */
+const ARIA_ENUM_VALUES = {
+    'aria-atomic': new Set(['true', 'false']),
+    'aria-autocomplete': new Set(['inline', 'list', 'both', 'none']),
+    'aria-busy': new Set(['true', 'false']),
+    'aria-checked': new Set(['true', 'false', 'mixed']),
+    'aria-current': new Set(['page', 'step', 'location', 'date', 'time', 'true', 'false']),
+    'aria-disabled': new Set(['true', 'false']),
+    'aria-expanded': new Set(['true', 'false']),
+    'aria-haspopup': new Set(['false', 'true', 'menu', 'listbox', 'tree', 'grid', 'dialog']),
+    'aria-hidden': new Set(['true', 'false']),
+    'aria-invalid': new Set(['true', 'false', 'grammar', 'spelling']),
+    'aria-live': new Set(['off', 'polite', 'assertive']),
+    'aria-modal': new Set(['true', 'false']),
+    'aria-multiline': new Set(['true', 'false']),
+    'aria-multiselectable': new Set(['true', 'false']),
+    'aria-orientation': new Set(['horizontal', 'vertical', 'undefined']),
+    'aria-pressed': new Set(['true', 'false', 'mixed']),
+    'aria-readonly': new Set(['true', 'false']),
+    'aria-required': new Set(['true', 'false']),
+    'aria-selected': new Set(['true', 'false']),
+    'aria-sort': new Set(['ascending', 'descending', 'none', 'other']),
+};
+const ARIA_NUMERIC = new Set([
+    'aria-level', 'aria-valuemax', 'aria-valuemin', 'aria-valuenow',
+    'aria-colcount', 'aria-colindex', 'aria-colspan', 'aria-rowcount',
+    'aria-rowindex', 'aria-rowspan', 'aria-posinset', 'aria-setsize',
+]);
+/** ARIA attributes with invalid values are ignored or misread by screen readers. */
+export const ariaAttrValueValid = defineRule({
+    id: 'aria-attr-value-valid',
+    description: 'ARIA attribute values must be valid for the attribute type.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    for (const [name, attr] of el.attrs) {
+        if (attr.kind !== 'static')
+            continue;
+        const enums = ARIA_ENUM_VALUES[name];
+        if (enums) {
+            const v = typeof attr.value === 'boolean' ? String(attr.value) : attr.value;
+            if (typeof v !== 'string' || !enums.has(v.trim().toLowerCase())) {
+                ctx.report({
+                    el,
+                    message: `${name}=${JSON.stringify(attr.value)} is not valid — allowed: ${[...enums].join(', ')}.`,
+                });
+            }
+        }
+        else if (ARIA_NUMERIC.has(name)) {
+            const v = attr.value;
+            const ok = typeof v === 'number' || (typeof v === 'string' && v.trim() !== '' && !Number.isNaN(Number(v)));
+            if (!ok) {
+                ctx.report({ el, message: `${name}=${JSON.stringify(v)} must be a number.` });
+            }
+        }
+    }
+});
+/**
+ * Role-specific ARIA states/properties and the roles that support them.
+ * Global states (aria-label, aria-busy, …) are allowed everywhere and omitted.
+ */
+const PROP_ALLOWED_ROLES = {
+    'aria-checked': new Set(['checkbox', 'menuitemcheckbox', 'menuitemradio', 'option', 'radio', 'switch', 'treeitem']),
+    'aria-selected': new Set(['columnheader', 'gridcell', 'option', 'row', 'rowheader', 'tab', 'treeitem']),
+    'aria-pressed': new Set(['button']),
+    'aria-valuenow': new Set(['meter', 'progressbar', 'scrollbar', 'separator', 'slider', 'spinbutton']),
+    'aria-valuemin': new Set(['meter', 'progressbar', 'scrollbar', 'separator', 'slider', 'spinbutton']),
+    'aria-valuemax': new Set(['meter', 'progressbar', 'scrollbar', 'separator', 'slider', 'spinbutton']),
+    'aria-valuetext': new Set(['meter', 'progressbar', 'scrollbar', 'separator', 'slider', 'spinbutton']),
+    'aria-level': new Set(['heading', 'listitem', 'row', 'treeitem']),
+    'aria-sort': new Set(['columnheader', 'rowheader']),
+    'aria-multiline': new Set(['textbox', 'searchbox']),
+};
+/** ARIA states/properties must be supported by the element's explicit role. */
+export const roleSupportsAriaProps = defineRule({
+    id: 'role-supports-aria-props',
+    description: 'ARIA states/properties must be supported by the element role.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    if (el.hasSpread)
+        return;
+    const role = staticString(el, 'role')?.trim();
+    if (!role || !ROLES.has(role))
+        return;
+    for (const name of el.attrs.keys()) {
+        const allowed = PROP_ALLOWED_ROLES[name.toLowerCase()];
+        if (allowed && !allowed.has(role)) {
+            ctx.report({
+                el,
+                message: `${name} is not supported by role="${role}" — it is ignored. Supported on: ${[...allowed].join(', ')}.`,
+            });
+        }
+    }
+});
+/** HTML elements (per HTML-AAM) that do not support role or aria-* at all. */
+const ARIA_RESERVED_TAGS = new Set([
+    'base', 'col', 'colgroup', 'head', 'html', 'link', 'meta', 'noscript',
+    'param', 'script', 'source', 'style', 'title', 'track',
+]);
+/** role and aria-* are silently ignored on elements that do not support them. */
+export const ariaUnsupportedElements = defineRule({
+    id: 'aria-unsupported-elements',
+    description: 'role and aria-* must not be placed on elements that do not support them.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+    fixable: true,
+}, (el, ctx) => {
+    if (el.isComponent || !ARIA_RESERVED_TAGS.has(el.name))
+        return;
+    for (const name of el.attrs.keys()) {
+        if (name === 'role' || /^aria-/i.test(name)) {
+            ctx.report({
+                el,
+                message: `<${el.name}> does not support "${name}" — it is ignored by assistive technology. Remove it.`,
+                fix: fixRemoveAttr(el, name),
+            });
+        }
+    }
+});
+/**
+ * aria-activedescendant points focus at a child, so the managing element must
+ * itself be focusable — otherwise the active descendant is never reached.
+ */
+export const ariaActivedescendantHasTabindex = defineRule({
+    id: 'aria-activedescendant-has-tabindex',
+    description: 'Elements with aria-activedescendant must be focusable.',
+    severity: 'serious',
+    wcag: ['4.1.2', '2.1.1'],
+}, (el, ctx) => {
+    if (el.isComponent || el.hasSpread)
+        return;
+    if (!hasAttr(el, 'aria-activedescendant'))
+        return;
+    if (isFocusable(el) || hasAttr(el, 'tabIndex'))
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> has aria-activedescendant but is not focusable, so the active descendant is unreachable. Add tabIndex={0}.`,
+    });
+});
+/** scope is only valid on <th>. */
+export const scopeOnTh = defineRule({
+    id: 'scope-attr-valid',
+    description: 'The scope attribute is only valid on <th> elements.',
+    severity: 'minor',
+    wcag: ['1.3.1'],
+    fixable: true,
+}, (el, ctx) => {
+    if (el.isComponent || !hasAttr(el, 'scope') || el.name === 'th')
+        return;
+    ctx.report({
+        el,
+        message: `scope has no effect on <${el.name}> — it is only valid on <th>.`,
+        fix: fixRemoveAttr(el, 'scope'),
+    });
+});

package/dist/rules/contrast.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WCAG 1.4.3 contrast for inline styles where both colors are literal.
+ * Below 3:1 fails even for large text → serious. Between 3:1 and 4.5:1 is
+ * only flagged when the font size is also known to be small, so unknown-size
+ * text that might be large never false-positives.
+ */
+export declare const colorContrast: import("@aishware/react-a11y-core").Rule;
+/**
+ * WCAG 2.5.8 (AA, new in 2.2): pointer targets need 24×24 CSS px minimum.
+ * Only statically-sized inline styles are checked.
+ */
+export declare const targetSize: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=contrast.d.ts.map

package/dist/rules/contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.d.ts","sourceRoot":"","sources":["../../src/rules/contrast.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0CAazB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,0CAkCtB,CAAC"}