eslint-plugin-react-a11y 2.1.0

package/src/rules/anchor-ambiguous-text.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorAmbiguousText = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+const DEFAULT_AMBIGUOUS_WORDS = ['click here', 'here', 'link', 'a link', 'learn more'];
+const isJSXAttribute = (attr) => attr.type === 'JSXAttribute';
+/**
+ * Extract accessible text from a JSX element
+ */
+function getAccessibleText(element) {
+    // Check for aria-label first
+    const ariaLabel = element.openingElement.attributes.find((attr) => isJSXAttribute(attr) &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === 'aria-label');
+    if (ariaLabel && ariaLabel.type === 'JSXAttribute' && ariaLabel.value && ariaLabel.value.type === 'Literal' && typeof ariaLabel.value.value === 'string') {
+        return ariaLabel.value.value;
+    }
+    // For img elements, use alt text
+    if (element.openingElement.name.type === 'JSXIdentifier' && element.openingElement.name.name === 'img') {
+        const altAttr = element.openingElement.attributes.find((attr) => isJSXAttribute(attr) &&
+            attr.name.type === 'JSXIdentifier' &&
+            attr.name.name === 'alt');
+        if (altAttr && altAttr.type === 'JSXAttribute' && altAttr.value && altAttr.value.type === 'Literal' && typeof altAttr.value.value === 'string') {
+            return altAttr.value.value;
+        }
+    }
+    // Extract text from children
+    return extractTextFromChildren(element.children);
+}
+/**
+ * Extract text content from JSX children
+ */
+function extractTextFromChildren(children) {
+    let text = '';
+    for (const child of children) {
+        if (child.type === 'JSXText') {
+            text += child.value;
+        }
+        else if (child.type === 'JSXElement') {
+            // Check if element has aria-hidden
+            const hasAriaHidden = child.openingElement.attributes.some((attr) => isJSXAttribute(attr) &&
+                attr.name.type === 'JSXIdentifier' &&
+                attr.name.name === 'aria-hidden' &&
+                attr.value !== null &&
+                attr.value.type === 'Literal' &&
+                (attr.value.value === true || attr.value.value === 'true'));
+            if (!hasAriaHidden) {
+                // For img elements in anchor text, use alt
+                if (child.openingElement.name.type === 'JSXIdentifier' && child.openingElement.name.name === 'img') {
+                    const altAttr = child.openingElement.attributes.find((attr) => isJSXAttribute(attr) &&
+                        attr.name.type === 'JSXIdentifier' &&
+                        attr.name.name === 'alt');
+                    if (altAttr && altAttr.type === 'JSXAttribute' && altAttr.value && altAttr.value.type === 'Literal' && typeof altAttr.value.value === 'string') {
+                        text += altAttr.value.value;
+                    }
+                }
+                else {
+                    text += extractTextFromChildren(child.children);
+                }
+            }
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            // Handle JSX expressions like {variable} or {`template literal`}
+            text += `{${extractExpressionText(child.expression)}}`;
+        }
+    }
+    return text.trim();
+}
+/**
+ * Extract text from JSX expression
+ */
+function extractExpressionText(expression) {
+    if (expression.type === 'JSXEmptyExpression') {
+        return '';
+    }
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    else if (expression.type === 'Literal' && typeof expression.value === 'string') {
+        return expression.value;
+    }
+    else if (expression.type === 'TemplateLiteral') {
+        let result = '';
+        for (let i = 0; i < expression.quasis.length; i++) {
+            result += expression.quasis[i].value.raw;
+            if (i < expression.expressions.length) {
+                result += `\${${extractExpressionText(expression.expressions[i])}}`;
+            }
+        }
+        return result;
+    }
+    else if (expression.type === 'BinaryExpression' && expression.operator === '+') {
+        return `${extractExpressionText(expression.left)}+${extractExpressionText(expression.right)}`;
+    }
+    // For other expression types, return a placeholder
+    return '...';
+}
+/**
+ * Normalize text for comparison - only normalize whitespace, preserve punctuation
+ */
+function normalizeText(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, ' '); // Normalize whitespace but preserve punctuation
+}
+exports.anchorAmbiguousText = (0, eslint_devkit_2.createRule)({
+    name: 'anchor-ambiguous-text',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that anchor text is not ambiguous',
+        },
+        messages: {
+            ambiguousText: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Ambiguous Anchor Text',
+                description: 'Anchor text "{{text}}" is ambiguous',
+                severity: 'MEDIUM',
+                fix: 'Use descriptive link text instead of ambiguous phrases',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-ambiguous-text.md',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    words: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { words = DEFAULT_AMBIGUOUS_WORDS } = options ?? {};
+        const ambiguousWords = words.map((word) => normalizeText(word));
+        return {
+            JSXElement(node) {
+                if (node.openingElement.name.type !== 'JSXIdentifier' || node.openingElement.name.name !== 'a') {
+                    return;
+                }
+                const accessibleText = getAccessibleText(node);
+                const normalizedText = normalizeText(accessibleText);
+                const comparisonText = normalizedText.replace(/[,.?¿!‽¡;:]/g, ''); // Remove punctuation for comparison
+                // Check for exact matches (after punctuation removal)
+                const hasAmbiguousText = ambiguousWords.includes(comparisonText);
+                if (hasAmbiguousText) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'ambiguousText',
+                        data: {
+                            text: accessibleText,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/anchor-has-content.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: anchor-has-content
+ * Enforce that anchors have content to be accessible to screen readers
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-has-content.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type Options = {
+    components?: string[];
+};
+type RuleOptions = [Options?];
+export declare const anchorHasContent: TSESLint.RuleModule<"missingContent", RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/anchor-has-content.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorHasContent = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+/**
+ * Check if node has accessible content
+ */
+function hasContent(node, children) {
+    // Check children
+    if (children.length > 0) {
+        return true;
+    }
+    // Check props (dangerouslySetInnerHTML, children prop, aria-label, title)
+    return node.attributes.some((attr) => {
+        if (attr.type !== 'JSXAttribute' || attr.name.type !== 'JSXIdentifier') {
+            return false;
+        }
+        const name = attr.name.name;
+        return (name === 'dangerouslySetInnerHTML' ||
+            name === 'children' ||
+            name === 'aria-label' ||
+            name === 'aria-labelledby' ||
+            name === 'title');
+    });
+}
+exports.anchorHasContent = (0, eslint_devkit_2.createRule)({
+    name: 'anchor-has-content',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that anchors have content',
+        },
+        messages: {
+            missingContent: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Anchor Missing Content',
+                description: 'Anchor must have content',
+                severity: 'CRITICAL',
+                fix: 'Provide text content or aria-label',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-has-content.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    components: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { components = [] } = options ?? {};
+        const anchors = ['a', ...components];
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (openingElement.name.type !== 'JSXIdentifier') {
+                    return;
+                }
+                if (!anchors.includes(openingElement.name.name)) {
+                    return;
+                }
+                if (!hasContent(openingElement, node.children)) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingContent',
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/anchor-is-valid.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: anchor-is-valid
+ * Enforce that anchors are valid, navigable elements
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-is-valid.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'invalidHref' | 'noHref' | 'preferButton';
+type Options = {
+    components?: string[];
+    specialLink?: string[];
+    aspects?: string[];
+};
+type RuleOptions = [Options?];
+export declare const anchorIsValid: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/anchor-is-valid.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorIsValid = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.anchorIsValid = (0, eslint_devkit_2.createRule)({
+    name: 'anchor-is-valid',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that anchors are valid, navigable elements',
+        },
+        messages: {
+            noHref: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Anchor Missing Href',
+                description: 'Anchor missing href attribute',
+                severity: 'HIGH',
+                fix: 'Add href attribute or use <button>',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-is-valid.md',
+            }),
+            invalidHref: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Invalid Href',
+                description: 'Href value is not a valid URL',
+                severity: 'HIGH',
+                fix: 'Provide a valid URL or use <button>',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-is-valid.md',
+            }),
+            preferButton: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Prefer Button',
+                description: 'Anchor used as a button',
+                severity: 'HIGH',
+                fix: 'Use <button> element for actions',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/anchor-is-valid.md',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    components: { type: 'array', items: { type: 'string' } },
+                    specialLink: { type: 'array', items: { type: 'string' } },
+                    aspects: { type: 'array', items: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { components = [], specialLink = [] } = options || {};
+        const anchors = ['a', ...components];
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== 'JSXIdentifier' || !anchors.includes(node.name.name)) {
+                    return;
+                }
+                const href = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'href');
+                const onClick = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'onClick');
+                if (!href) {
+                    // Check for special link props (like 'to' in React Router)
+                    const hasSpecialLink = specialLink.some((prop) => node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                        attr.name.type === 'JSXIdentifier' &&
+                        attr.name.name === prop));
+                    if (!hasSpecialLink) {
+                        if (onClick) {
+                            context.report({ node, messageId: 'preferButton' });
+                        }
+                        else {
+                            context.report({ node, messageId: 'noHref' });
+                        }
+                    }
+                    return;
+                }
+                if (href.value?.type === 'Literal') {
+                    const value = href.value.value;
+                    if (value === '#' || value === 'javascript:void(0)') {
+                        if (onClick) {
+                            context.report({ node, messageId: 'preferButton' });
+                        }
+                        else {
+                            context.report({ node, messageId: 'invalidHref' });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/src/rules/aria-activedescendant-has-tabindex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: aria-activedescendant-has-tabindex
+ * Enforce that elements with aria-activedescendant have proper tabindex
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-activedescendant-has-tabindex.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const ariaActivedescendantHasTabindex: TSESLint.RuleModule<"missingTabIndex", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/src/rules/aria-activedescendant-has-tabindex.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ariaActivedescendantHasTabindex = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+const INHERENTLY_FOCUSABLE = new Set([
+    'input', 'select', 'textarea', 'button', 'a', 'area'
+]);
+exports.ariaActivedescendantHasTabindex = (0, eslint_devkit_2.createRule)({
+    name: 'aria-activedescendant-has-tabindex',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that elements with aria-activedescendant have proper tabindex',
+        },
+        messages: {
+            missingTabIndex: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Missing TabIndex for aria-activedescendant',
+                description: 'Elements with aria-activedescendant must be tabbable',
+                severity: 'HIGH',
+                fix: 'Add tabIndex={0} or tabIndex={-1}',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-activedescendant-has-tabindex.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== 'JSXIdentifier')
+                    return;
+                const element = node.name.name;
+                // Check if element has aria-activedescendant
+                const ariaActivedescendant = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'aria-activedescendant');
+                if (!ariaActivedescendant)
+                    return;
+                // Check if element is inherently focusable
+                if (INHERENTLY_FOCUSABLE.has(element))
+                    return;
+                // Check if element has explicit tabIndex
+                const tabIndex = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'tabIndex');
+                if (!tabIndex) {
+                    context.report({
+                        node: ariaActivedescendant,
+                        messageId: 'missingTabIndex',
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/aria-props.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: aria-props
+ * Enforce that ARIA attributes are valid
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-props.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const ariaProps: TSESLint.RuleModule<"invalidAriaProp", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/src/rules/aria-props.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ariaProps = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.ariaProps = (0, eslint_devkit_2.createRule)({
+    name: 'aria-props',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that ARIA attributes are valid',
+        },
+        messages: {
+            invalidAriaProp: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Invalid ARIA Attribute',
+                description: 'Attribute {{name}} is not a valid ARIA attribute',
+                severity: 'HIGH',
+                fix: 'Use a valid ARIA attribute (e.g., aria-label)',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-props.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXAttribute(node) {
+                if (node.name.type !== 'JSXIdentifier') {
+                    return;
+                }
+                const name = node.name.name;
+                if (name.startsWith('aria-') && !eslint_devkit_1.ARIA_ATTRIBUTES.has(name)) {
+                    context.report({
+                        node,
+                        messageId: 'invalidAriaProp',
+                        data: {
+                            name,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/aria-role.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: aria-role
+ * Enforce that elements with ARIA roles have valid values
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-role.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type Options = {
+    allowedInvalidRoles?: string[];
+    ignoreNonDOM?: boolean;
+};
+type RuleOptions = [Options?];
+export declare const ariaRole: TSESLint.RuleModule<"invalidRole", RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/aria-role.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ariaRole = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.ariaRole = (0, eslint_devkit_2.createRule)({
+    name: 'aria-role',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that elements with ARIA roles have valid values',
+        },
+        messages: {
+            invalidRole: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Invalid ARIA Role',
+                description: 'Role "{{role}}" is not a valid ARIA role',
+                severity: 'HIGH',
+                fix: 'Use a valid ARIA role (e.g., button, alert)',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-role.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowedInvalidRoles: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    ignoreNonDOM: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { allowedInvalidRoles = [] } = options ?? {};
+        return {
+            JSXAttribute(node) {
+                if (node.name.type !== 'JSXIdentifier' || node.name.name !== 'role') {
+                    return;
+                }
+                if (!node.value || node.value.type !== 'Literal' || typeof node.value.value !== 'string') {
+                    // Skip dynamic values or empty values
+                    return;
+                }
+                const roles = node.value.value.split(/\s+/);
+                for (const role of roles) {
+                    if (!eslint_devkit_1.ARIA_ROLES.has(role) && !allowedInvalidRoles.includes(role)) {
+                        context.report({
+                            node,
+                            messageId: 'invalidRole',
+                            data: {
+                                role,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/src/rules/aria-unsupported-elements.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: aria-unsupported-elements
+ * Enforce that elements that don't support ARIA roles, states, and properties do not contain them
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-unsupported-elements.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const ariaUnsupportedElements: TSESLint.RuleModule<"unsupportedAria", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};