eslint-plugin-react-a11y 2.1.0

package/src/rules/aria-unsupported-elements.js

@@ -0,0 +1,54 @@
+"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.ariaUnsupportedElements = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.ariaUnsupportedElements = (0, eslint_devkit_2.createRule)({
+    name: 'aria-unsupported-elements',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that elements that don\'t support ARIA roles, states, and properties do not contain them',
+        },
+        messages: {
+            unsupportedAria: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Unsupported ARIA',
+                description: '<{{element}}> should not have ARIA attributes',
+                severity: 'MEDIUM',
+                fix: 'Remove ARIA attributes from this element',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/aria-unsupported-elements.md',
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== 'JSXIdentifier')
+                    return;
+                const element = node.name.name;
+                if (!eslint_devkit_1.ARIA_UNSUPPORTED_ELEMENTS.has(element))
+                    return;
+                const hasAria = node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    (attr.name.name.startsWith('aria-') || attr.name.name === 'role'));
+                if (hasAria) {
+                    context.report({
+                        node,
+                        messageId: 'unsupportedAria',
+                        data: {
+                            element
+                        }
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/autocomplete-valid.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: autocomplete-valid
+ * Enforce that autocomplete attribute has valid value
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/autocomplete-valid.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type Options = {
+    inputComponents?: string[];
+};
+type RuleOptions = [Options?];
+export declare const autocompleteValid: TSESLint.RuleModule<"invalidAutocomplete", RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/autocomplete-valid.js

@@ -0,0 +1,79 @@
+"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.autocompleteValid = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+const VALID_AUTOCOMPLETE_VALUES = new Set([
+    'on', 'off', 'name', 'honorific-prefix', 'given-name', 'additional-name', 'family-name',
+    'honorific-suffix', 'nickname', 'email', 'username', 'new-password', 'current-password',
+    'organization-title', 'organization', 'street-address', 'address-line1', 'address-line2',
+    'address-line3', 'address-level4', 'address-level3', 'address-level2', 'address-level1',
+    'country', 'country-name', 'postal-code', 'cc-name', 'cc-given-name', 'cc-additional-name',
+    'cc-family-name', 'cc-number', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type',
+    'transaction-currency', 'transaction-amount', 'language', 'bday', 'bday-day', 'bday-month',
+    'bday-year', 'sex', 'tel', 'tel-country-code', 'tel-national', 'tel-area-code', 'tel-local',
+    'tel-extension', 'impp', 'url', 'photo'
+]);
+exports.autocompleteValid = (0, eslint_devkit_2.createRule)({
+    name: 'autocomplete-valid',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that autocomplete attribute has valid value',
+        },
+        messages: {
+            invalidAutocomplete: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Invalid Autocomplete',
+                description: 'Invalid autocomplete value',
+                severity: 'MEDIUM',
+                fix: 'Use a valid autocomplete token (e.g., "username", "current-password")',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/autocomplete-valid.md',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    inputComponents: { type: 'array', items: { type: 'string' } }
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { inputComponents = [] } = options ?? {};
+        const inputs = ['input', ...inputComponents];
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== 'JSXIdentifier' || !inputs.includes(node.name.name))
+                    return;
+                const autocomplete = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'autocomplete');
+                if (!autocomplete || autocomplete.type !== 'JSXAttribute' || !autocomplete.value || autocomplete.value.type !== 'Literal' || typeof autocomplete.value.value !== 'string')
+                    return;
+                const value = autocomplete.value.value;
+                // Handle space-separated values
+                const tokens = value.split(/\s+/);
+                for (const token of tokens) {
+                    // Handle optional 'section-' prefix
+                    const effectiveToken = token.startsWith('section-') ? token.replace(/^section-/, '') : token;
+                    if (!VALID_AUTOCOMPLETE_VALUES.has(effectiveToken)) {
+                        context.report({
+                            node: autocomplete,
+                            messageId: 'invalidAutocomplete',
+                        });
+                        break;
+                    }
+                }
+            },
+        };
+    },
+});

package/src/rules/click-events-have-key-events.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: click-events-have-key-events
+ * Enforce that onClick is accompanied by keyboard events
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/click-events-have-key-events.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const clickEventsHaveKeyEvents: TSESLint.RuleModule<"missingKeyboardEvent", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/src/rules/click-events-have-key-events.js

@@ -0,0 +1,60 @@
+"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.clickEventsHaveKeyEvents = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.clickEventsHaveKeyEvents = (0, eslint_devkit_2.createRule)({
+    name: 'click-events-have-key-events',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that onClick is accompanied by keyboard events',
+        },
+        messages: {
+            missingKeyboardEvent: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Missing Keyboard Listener',
+                description: 'onClick must be accompanied by onKeyUp, onKeyDown, or onKeyPress',
+                severity: 'MEDIUM',
+                fix: 'Add onKeyDown/onKeyUp handler',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/click-events-have-key-events.md',
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                const hasOnClick = node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'onClick');
+                if (!hasOnClick)
+                    return;
+                const hasKeyboardEvent = node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    ['onKeyUp', 'onKeyDown', 'onKeyPress'].includes(attr.name.name));
+                // Exception: hidden inputs or non-interactive elements that shouldn't have click?
+                // Actually, if it has click, it should have keyboard support.
+                // But if it's a button or link, it's native.
+                const tagName = node.name.type === 'JSXIdentifier' ? node.name.name : null;
+                const isInteractive = ['button', 'a', 'input', 'select', 'textarea', 'option'].includes(tagName || '');
+                // Native interactive elements handle keyboard click automatically.
+                // But if it's a div/span with onClick, it needs keyboard listener.
+                if (isInteractive)
+                    return;
+                if (!hasKeyboardEvent) {
+                    context.report({
+                        node,
+                        messageId: 'missingKeyboardEvent',
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/control-has-associated-label.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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: control-has-associated-label
+ * Enforce that controls (interactive elements) have associated labels
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/control-has-associated-label.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type Options = {
+    labelAttributes?: string[];
+    controlComponents?: string[];
+    ignoreElements?: string[];
+    ignoreRoles?: string[];
+    depth?: number;
+};
+type RuleOptions = [Options?];
+export declare const controlHasAssociatedLabel: TSESLint.RuleModule<"missingLabel", RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/control-has-associated-label.js

@@ -0,0 +1,178 @@
+"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.controlHasAssociatedLabel = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+const DEFAULT_IGNORE_ELEMENTS = [
+    'audio', 'canvas', 'embed', 'tr', 'video'
+];
+const DEFAULT_IGNORE_ROLES = [
+    'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'row', 'tablist', 'toolbar', 'tree', 'treegrid'
+];
+/**
+ * Check if element has accessible text content
+ */
+function hasAccessibleText(node, depth, labelAttributes) {
+    // Check aria-label
+    const ariaLabel = node.openingElement.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === 'aria-label');
+    if (ariaLabel && ariaLabel.type === 'JSXAttribute' && ariaLabel.value)
+        return true;
+    // Check aria-labelledby
+    const ariaLabelledby = node.openingElement.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === 'aria-labelledby');
+    if (ariaLabelledby && ariaLabelledby.type === 'JSXAttribute' && ariaLabelledby.value)
+        return true;
+    // Check custom label attributes
+    for (const attr of labelAttributes) {
+        const labelAttr = node.openingElement.attributes.find((a) => a.type === 'JSXAttribute' &&
+            a.name.type === 'JSXIdentifier' &&
+            a.name.name === attr);
+        if (labelAttr && labelAttr.type === 'JSXAttribute' && labelAttr.value)
+            return true;
+    }
+    // For img elements and input type="image", check alt
+    if (node.openingElement.name.type === 'JSXIdentifier') {
+        if (node.openingElement.name.name === 'img') {
+            const altAttr = node.openingElement.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                attr.name.type === 'JSXIdentifier' &&
+                attr.name.name === 'alt');
+            if (altAttr && altAttr.type === 'JSXAttribute' && altAttr.value)
+                return true;
+        }
+        else if (node.openingElement.name.name === 'input') {
+            // Check if it's an image input with alt
+            const typeAttr = node.openingElement.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                attr.name.type === 'JSXIdentifier' &&
+                attr.name.name === 'type');
+            if (typeAttr && typeAttr.type === 'JSXAttribute' && typeAttr.value && typeAttr.value.type === 'Literal' && typeAttr.value.value === 'image') {
+                const altAttr = node.openingElement.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'alt');
+                if (altAttr && altAttr.type === 'JSXAttribute' && altAttr.value)
+                    return true;
+            }
+        }
+    }
+    // Check text content in children (up to specified depth)
+    return hasTextInChildren(node.children, depth);
+}
+/**
+ * Check if children contain text content
+ */
+function hasTextInChildren(children, depth) {
+    if (depth <= 0)
+        return false;
+    for (const child of children) {
+        if (child.type === 'JSXText') {
+            if (child.value.trim())
+                return true;
+        }
+        else if (child.type === 'JSXElement') {
+            if (hasAccessibleText(child, depth - 1, []))
+                return true;
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            // Assume expressions might contain labels
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if element is a control component
+ */
+function isControlComponent(elementName, controlComponents) {
+    const controls = ['button', 'input', 'select', 'textarea', 'a', ...controlComponents];
+    return controls.includes(elementName);
+}
+/**
+ * Check if element has an interactive role
+ */
+function hasInteractiveRole(node, ignoreRoles) {
+    const roleAttr = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === 'role');
+    if (!roleAttr || roleAttr.type !== 'JSXAttribute' || !roleAttr.value || roleAttr.value.type !== 'Literal')
+        return false;
+    const role = roleAttr.value.value;
+    if (typeof role !== 'string')
+        return false;
+    // Interactive roles that require labels
+    const interactiveRoles = [
+        'button', 'checkbox', 'link', 'menuitem', 'menuitemcheckbox', 'menuitemradio',
+        'option', 'radio', 'switch', 'tab', 'textbox', 'combobox', 'listbox', 'searchbox',
+        'slider', 'spinbutton', 'progressbar'
+    ];
+    return interactiveRoles.includes(role) && !ignoreRoles.includes(role);
+}
+exports.controlHasAssociatedLabel = (0, eslint_devkit_2.createRule)({
+    name: 'control-has-associated-label',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that controls (interactive elements) have associated labels',
+        },
+        messages: {
+            missingLabel: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Control Missing Label',
+                description: '<{{element}}> must have an accessible label',
+                severity: 'HIGH',
+                fix: 'Add text content, aria-label, or aria-labelledby',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/control-has-associated-label.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    labelAttributes: { type: 'array', items: { type: 'string' } },
+                    controlComponents: { type: 'array', items: { type: 'string' } },
+                    ignoreElements: { type: 'array', items: { type: 'string' } },
+                    ignoreRoles: { type: 'array', items: { type: 'string' } },
+                    depth: { type: 'integer', minimum: 1, maximum: 25 },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [options = {}]) {
+        const { labelAttributes = [], controlComponents = [], ignoreElements = DEFAULT_IGNORE_ELEMENTS, ignoreRoles = DEFAULT_IGNORE_ROLES, depth = 2, } = options ?? {};
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (openingElement.name.type !== 'JSXIdentifier')
+                    return;
+                const elementName = openingElement.name.name;
+                // Skip ignored elements
+                if (ignoreElements.includes(elementName))
+                    return;
+                // Check if it's a control component or has interactive role
+                const isControl = isControlComponent(elementName, controlComponents);
+                const hasInteractiveRoleAttr = hasInteractiveRole(openingElement, ignoreRoles);
+                if (!isControl && !hasInteractiveRoleAttr)
+                    return;
+                // Check if it has accessible text
+                if (!hasAccessibleText(node, depth, labelAttributes)) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingLabel',
+                        data: {
+                            element: elementName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/heading-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: heading-has-content
+ * Enforce that headings have content
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/heading-has-content.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type Options = {
+    components?: string[];
+};
+type RuleOptions = [Options?];
+export declare const headingHasContent: TSESLint.RuleModule<"missingContent", RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/heading-has-content.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.headingHasContent = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+function hasContent(node, children) {
+    if (children.length > 0)
+        return true;
+    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 === 'title'
+        // Headings don't typically use aria-label as primary content source, but usually accepted if no text
+        );
+    });
+}
+exports.headingHasContent = (0, eslint_devkit_2.createRule)({
+    name: 'heading-has-content',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that headings have content',
+        },
+        messages: {
+            missingContent: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Heading Missing Content',
+                description: 'Heading elements must have accessible content',
+                severity: 'HIGH',
+                fix: 'Provide text content for the heading',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/heading-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 headings = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', ...components];
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (openingElement.name.type !== 'JSXIdentifier' || !headings.includes(openingElement.name.name)) {
+                    return;
+                }
+                if (!hasContent(openingElement, node.children)) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingContent',
+                    });
+                }
+            },
+        };
+    },
+});

package/src/rules/html-has-lang.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: html-has-lang
+ * Enforce that html element has lang attribute
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/html-has-lang.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const htmlHasLang: TSESLint.RuleModule<"missingLang", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/src/rules/html-has-lang.js

@@ -0,0 +1,50 @@
+"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.htmlHasLang = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.htmlHasLang = (0, eslint_devkit_2.createRule)({
+    name: 'html-has-lang',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that html element has lang attribute',
+        },
+        messages: {
+            missingLang: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Missing Lang Attribute',
+                description: '<html> element must have a lang attribute',
+                severity: 'CRITICAL',
+                fix: 'Add lang="en" (or appropriate language code)',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/html-has-lang.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type === 'JSXIdentifier' && node.name.name === 'html') {
+                    const hasLang = node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                        attr.name.type === 'JSXIdentifier' &&
+                        attr.name.name === 'lang' &&
+                        attr.value?.type === 'Literal');
+                    if (!hasLang) {
+                        context.report({
+                            node,
+                            messageId: 'missingLang',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/src/rules/iframe-has-title.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: iframe-has-title
+ * Enforce that iframes have a title attribute
+ *
+ * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/iframe-has-title.md
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const iframeHasTitle: TSESLint.RuleModule<"missingTitle", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/src/rules/iframe-has-title.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.iframeHasTitle = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.iframeHasTitle = (0, eslint_devkit_2.createRule)({
+    name: 'iframe-has-title',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that iframes have a title attribute',
+        },
+        messages: {
+            missingTitle: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.ACCESSIBILITY,
+                issueName: 'Iframe Missing Title',
+                description: '<iframe> must have a unique title property',
+                severity: 'CRITICAL',
+                fix: 'Add title="Description of content"',
+                documentationLink: 'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/iframe-has-title.md',
+                cwe: 'CWE-252'
+            }),
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== 'JSXIdentifier' || node.name.name !== 'iframe') {
+                    return;
+                }
+                const hasTitle = node.attributes.some((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'title' &&
+                    attr.value?.type === 'Literal');
+                if (!hasTitle) {
+                    context.report({
+                        node,
+                        messageId: 'missingTitle',
+                    });
+                }
+            },
+        };
+    },
+});