@flint.fyi/jsx 0.0.0

package/lib/rules/ariaActiveDescendantTabIndex.js

@@ -0,0 +1,56 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaActiveDescendantTabIndex.ts
+const inherentlyTabbableElements = new Set([
+	"a",
+	"area",
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
+var ariaActiveDescendantTabIndex_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements with aria-activedescendant without tabIndex.",
+		id: "ariaActiveDescendantTabIndex",
+		presets: ["logical"]
+	},
+	messages: { missingTabIndex: {
+		primary: "This element with `aria-activedescendant` is missing a `tabIndex` attribute to manage focus state.",
+		secondary: [
+			"aria-activedescendant is used to manage focus within a composite widget.",
+			"The element must be tabbable, either with an inherent tabIndex or explicit tabIndex attribute.",
+			"Without it, keyboard users cannot reach the element."
+		],
+		suggestions: ["Add tabIndex=\"0\" to make the element tabbable", "Add tabIndex=\"-1\" to make it programmatically focusable"]
+	} },
+	setup(context) {
+		function checkElement({ attributes, tagName }, { sourceFile }) {
+			if (tagName.kind === SyntaxKind.Identifier) {
+				const firstCharacter = tagName.text.charAt(0);
+				if (firstCharacter === firstCharacter.toUpperCase() && firstCharacter !== firstCharacter.toLowerCase()) return;
+			}
+			if (!attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-activedescendant" && property.initializer)) return;
+			if (tagName.kind === SyntaxKind.Identifier) {
+				if (inherentlyTabbableElements.has(tagName.text.toLowerCase())) return;
+			}
+			if (!attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "tabindex")) {
+				const ariaProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-activedescendant");
+				if (ariaProperty && ariaProperty.kind === SyntaxKind.JsxAttribute) context.report({
+					message: "missingTabIndex",
+					range: getTSNodeRange(ariaProperty, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+
+//#endregion
+export { ariaActiveDescendantTabIndex_default as default };
+//# sourceMappingURL=ariaActiveDescendantTabIndex.js.map

package/lib/rules/ariaHiddenFocusables.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "ariaHiddenFocusable", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=ariaHiddenFocusables.d.ts.map

package/lib/rules/ariaHiddenFocusables.js

@@ -0,0 +1,70 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaHiddenFocusables.ts
+const focusableElements = new Set([
+	"a",
+	"audio",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"video"
+]);
+var ariaHiddenFocusables_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements with aria-hidden='true' that are focusable.",
+		id: "ariaHiddenFocusables",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { ariaHiddenFocusable: {
+		primary: "This element has `aria-hidden=\"true\"` but is focusable, which is misleading to users navigating with keyboards.",
+		secondary: ["Elements with aria-hidden='true' should not be reachable via keyboard navigation.", "This creates confusion when users can focus elements they cannot perceive with a screen reader."],
+		suggestions: [
+			"Remove aria-hidden=\"true\"",
+			"Add tabIndex=\"-1\" to remove from focus order",
+			"Use a non-focusable element"
+		]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			const { attributes, tagName } = node;
+			if (tagName.kind !== SyntaxKind.Identifier) return;
+			const ariaHiddenProperty = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "aria-hidden");
+			if (!ariaHiddenProperty || ariaHiddenProperty.kind !== SyntaxKind.JsxAttribute || !isAriaHiddenTrue(ariaHiddenProperty)) return;
+			const tabIndexValue = findTabIndexValue(node);
+			if (tabIndexValue === -1) return;
+			if (focusableElements.has(tagName.text.toLowerCase()) || tabIndexValue !== void 0 && tabIndexValue >= 0) context.report({
+				message: "ariaHiddenFocusable",
+				range: getTSNodeRange(ariaHiddenProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+function findTabIndexValue(node) {
+	const tabIndexProperty = node.attributes.properties.find((property) => property.kind == SyntaxKind.JsxAttribute && property.name.kind == SyntaxKind.Identifier && property.name.text.toLowerCase() === "tabindex");
+	if (!tabIndexProperty?.initializer) return;
+	if (tabIndexProperty.initializer.kind == SyntaxKind.JsxExpression) {
+		const expression = tabIndexProperty.initializer.expression;
+		if (expression && expression.kind == SyntaxKind.NumericLiteral) return Number(expression.text);
+	}
+	if (tabIndexProperty.initializer.kind == SyntaxKind.StringLiteral) return Number(tabIndexProperty.initializer.text);
+}
+function isAriaHiddenTrue(ariaHiddenProperty) {
+	if (!ariaHiddenProperty.initializer) return false;
+	if (ariaHiddenProperty.initializer.kind === SyntaxKind.StringLiteral) return ariaHiddenProperty.initializer.text === "true";
+	if (ariaHiddenProperty.initializer.kind === SyntaxKind.JsxExpression) {
+		const expression = ariaHiddenProperty.initializer.expression;
+		if (expression && expression.kind === SyntaxKind.TrueKeyword) return true;
+	}
+	return false;
+}
+
+//#endregion
+export { ariaHiddenFocusables_default as default };
+//# sourceMappingURL=ariaHiddenFocusables.js.map

package/lib/rules/ariaPropTypes.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "invalidPropType", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=ariaPropTypes.d.ts.map

package/lib/rules/ariaPropTypes.js

@@ -0,0 +1,227 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaPropTypes.ts
+const ariaPropertyTypes = {
+	"aria-activedescendant": "id",
+	"aria-atomic": "boolean",
+	"aria-autocomplete": "token",
+	"aria-busy": "boolean",
+	"aria-checked": "tristate",
+	"aria-colcount": "integer",
+	"aria-colindex": "integer",
+	"aria-colspan": "integer",
+	"aria-controls": "idlist",
+	"aria-current": "token",
+	"aria-describedby": "idlist",
+	"aria-details": "id",
+	"aria-disabled": "boolean",
+	"aria-dropeffect": "token",
+	"aria-errormessage": "id",
+	"aria-expanded": "tristate",
+	"aria-flowto": "idlist",
+	"aria-grabbed": "tristate",
+	"aria-haspopup": "token",
+	"aria-hidden": "tristate",
+	"aria-invalid": "token",
+	"aria-keyshortcuts": "string",
+	"aria-label": "string",
+	"aria-labelledby": "idlist",
+	"aria-level": "integer",
+	"aria-live": "token",
+	"aria-modal": "boolean",
+	"aria-multiline": "boolean",
+	"aria-multiselectable": "boolean",
+	"aria-orientation": "token",
+	"aria-owns": "idlist",
+	"aria-placeholder": "string",
+	"aria-posinset": "integer",
+	"aria-pressed": "tristate",
+	"aria-readonly": "boolean",
+	"aria-relevant": "token",
+	"aria-required": "boolean",
+	"aria-roledescription": "string",
+	"aria-rowcount": "integer",
+	"aria-rowindex": "integer",
+	"aria-rowspan": "integer",
+	"aria-selected": "tristate",
+	"aria-setsize": "integer",
+	"aria-sort": "token",
+	"aria-valuemax": "number",
+	"aria-valuemin": "number",
+	"aria-valuenow": "number",
+	"aria-valuetext": "string"
+};
+const tokenValues = {
+	"aria-autocomplete": new Set([
+		"both",
+		"inline",
+		"list",
+		"none"
+	]),
+	"aria-current": new Set([
+		"date",
+		"false",
+		"location",
+		"page",
+		"step",
+		"time",
+		"true"
+	]),
+	"aria-dropeffect": new Set([
+		"copy",
+		"execute",
+		"link",
+		"move",
+		"none",
+		"popup"
+	]),
+	"aria-haspopup": new Set([
+		"dialog",
+		"false",
+		"grid",
+		"listbox",
+		"menu",
+		"tree",
+		"true"
+	]),
+	"aria-invalid": new Set([
+		"false",
+		"grammar",
+		"spelling",
+		"true"
+	]),
+	"aria-live": new Set([
+		"assertive",
+		"off",
+		"polite"
+	]),
+	"aria-orientation": new Set([
+		"horizontal",
+		"undefined",
+		"vertical"
+	]),
+	"aria-relevant": new Set([
+		"additions",
+		"additions text",
+		"all",
+		"removals",
+		"text"
+	]),
+	"aria-sort": new Set([
+		"ascending",
+		"descending",
+		"none",
+		"other"
+	])
+};
+function getAttributeValue(property) {
+	if (!property.initializer) return true;
+	if (property.initializer.kind === SyntaxKind.StringLiteral) return property.initializer.text;
+	if (property.initializer.kind === SyntaxKind.JsxExpression) {
+		const expression = property.initializer.expression;
+		if (!expression) return;
+		if (expression.kind === SyntaxKind.TrueKeyword) return true;
+		if (expression.kind === SyntaxKind.FalseKeyword) return false;
+		if (expression.kind === SyntaxKind.NumericLiteral) return Number(expression.text);
+		if (expression.kind === SyntaxKind.StringLiteral) return expression.text;
+	}
+}
+function getExpectedValueDescription(propertyName, expectedType) {
+	switch (expectedType) {
+		case "boolean": return "true or false";
+		case "id": return "an ID reference";
+		case "idlist": return "a space-separated list of IDs";
+		case "integer": return "an integer";
+		case "number": return "a number";
+		case "string": return "a string";
+		case "token": {
+			const validTokens = tokenValues[propertyName];
+			if (validTokens !== void 0) {
+				const tokens = Array.from(validTokens).sort();
+				return tokens.length > 4 ? `one of: ${tokens.slice(0, 4).join(", ")}, ...` : `one of: ${tokens.join(", ")}`;
+			}
+			return "a valid token value";
+		}
+		case "tristate": return "true, false, or mixed";
+		default: return "a valid value";
+	}
+}
+function isValidPropertyValue(propertyName, value, expectedType) {
+	if (value === void 0) return true;
+	switch (expectedType) {
+		case "boolean": return value === "true" || value === "false" || typeof value === "boolean";
+		case "id": return typeof value === "string" && value.length > 0;
+		case "idlist": return typeof value === "string" && value.trim().length > 0;
+		case "integer":
+			if (typeof value === "number") return Number.isInteger(value);
+			if (typeof value === "string") {
+				const num = Number(value);
+				return !Number.isNaN(num) && Number.isInteger(num);
+			}
+			return false;
+		case "number":
+			if (typeof value === "number") return !Number.isNaN(value);
+			if (typeof value === "string") {
+				const num = Number(value);
+				return !Number.isNaN(num);
+			}
+			return false;
+		case "string": return typeof value === "string";
+		case "token": {
+			if (typeof value !== "string") return false;
+			const validTokens = tokenValues[propertyName];
+			return validTokens !== void 0 ? validTokens.has(value.toLowerCase()) : true;
+		}
+		case "tristate": return value === "true" || value === "false" || value === "mixed" || typeof value === "boolean";
+		default: return true;
+	}
+}
+var ariaPropTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA properties with invalid value types.",
+		id: "ariaPropTypes",
+		presets: ["logical"]
+	},
+	messages: { invalidPropType: {
+		primary: "`{{ prop }}` should have a value of {{ expected }}, but received `{{ actual }}`.",
+		secondary: [
+			"ARIA properties must have values that match their expected type according to the WAI-ARIA specification.",
+			"Invalid property values can confuse assistive technologies and lead to accessibility issues.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Provide a value that matches the expected type for this ARIA property."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text.toLowerCase();
+				if (!propertyName.startsWith("aria-")) continue;
+				const expectedType = ariaPropertyTypes[propertyName];
+				if (expectedType === void 0) continue;
+				const value = getAttributeValue(property);
+				if (isValidPropertyValue(propertyName, value, expectedType)) return;
+				const expected = getExpectedValueDescription(propertyName, expectedType);
+				context.report({
+					data: {
+						actual: String(value),
+						expected,
+						prop: propertyName
+					},
+					message: "invalidPropType",
+					range: property.initializer ? getTSNodeRange(property.initializer, sourceFile) : getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+
+//#endregion
+export { ariaPropTypes_default as default };
+//# sourceMappingURL=ariaPropTypes.js.map

package/lib/rules/ariaProps.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "invalidAriaProp", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=ariaProps.d.ts.map

package/lib/rules/ariaProps.js

@@ -0,0 +1,93 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaProps.ts
+const validAriaProps = new Set([
+	"aria-activedescendant",
+	"aria-atomic",
+	"aria-autocomplete",
+	"aria-busy",
+	"aria-checked",
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colspan",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-details",
+	"aria-disabled",
+	"aria-dropeffect",
+	"aria-errormessage",
+	"aria-expanded",
+	"aria-flowto",
+	"aria-grabbed",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-level",
+	"aria-live",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-orientation",
+	"aria-owns",
+	"aria-placeholder",
+	"aria-posinset",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-relevant",
+	"aria-required",
+	"aria-roledescription",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowspan",
+	"aria-selected",
+	"aria-setsize",
+	"aria-sort",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow",
+	"aria-valuetext"
+]);
+var ariaProps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid ARIA properties.",
+		id: "ariaProps",
+		presets: ["logical"]
+	},
+	messages: { invalidAriaProp: {
+		primary: "`{{ prop }}` is not a valid ARIA property and so has no effect on the browser.",
+		secondary: [
+			"This aria-* attribute is not a valid ARIA property according to the WAI-ARIA spec.",
+			"Check the spelling of the property name.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Use a valid property from the WAI-ARIA specification."]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			for (const property of node.attributes.properties) {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
+				const propertyName = property.name.text;
+				if (!propertyName.startsWith("aria-")) continue;
+				if (!validAriaProps.has(propertyName.toLowerCase())) context.report({
+					data: { prop: propertyName },
+					message: "invalidAriaProp",
+					range: getTSNodeRange(property.name, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+
+//#endregion
+export { ariaProps_default as default };
+//# sourceMappingURL=ariaProps.js.map

package/lib/rules/ariaRoleValidity.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "invalidRole", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=ariaRoleValidity.d.ts.map

package/lib/rules/ariaRoleValidity.js

@@ -0,0 +1,114 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaRoleValidity.ts
+const validAriaRoles = new Set([
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"button",
+	"cell",
+	"checkbox",
+	"columnheader",
+	"combobox",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"dialog",
+	"directory",
+	"document",
+	"feed",
+	"figure",
+	"form",
+	"grid",
+	"gridcell",
+	"group",
+	"heading",
+	"img",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"navigation",
+	"none",
+	"note",
+	"option",
+	"presentation",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"region",
+	"row",
+	"rowgroup",
+	"rowheader",
+	"scrollbar",
+	"search",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"status",
+	"switch",
+	"tab",
+	"table",
+	"tablist",
+	"tabpanel",
+	"term",
+	"textbox",
+	"timer",
+	"toolbar",
+	"tooltip",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+var ariaRoleValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid or abstract ARIA roles.",
+		id: "ariaRoleValidity",
+		presets: ["logical"]
+	},
+	messages: { invalidRole: {
+		primary: "Invalid ARIA role '{{ role }}'. Use a valid, non-abstract role.",
+		secondary: [
+			"ARIA roles must be valid according to the WAI-ARIA specification.",
+			"Abstract roles cannot be used directly in HTML.",
+			"Required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Use a valid ARIA role from the WAI-ARIA specification", "Remove the role attribute if not needed"]
+	} },
+	setup(context) {
+		function checkRole(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
+			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier);
+			if (!roleProperty?.initializer || roleProperty.initializer.kind !== SyntaxKind.StringLiteral) return;
+			const role = roleProperty.initializer.text.trim();
+			if (!role || !validAriaRoles.has(role)) context.report({
+				data: { role: role || "(empty)" },
+				message: "invalidRole",
+				range: getTSNodeRange(roleProperty, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkRole,
+			JsxSelfClosingElement: checkRole
+		} };
+	}
+});
+
+//#endregion
+export { ariaRoleValidity_default as default };
+//# sourceMappingURL=ariaRoleValidity.js.map

package/lib/rules/ariaUnsupportedElements.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "unsupportedElement", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=ariaUnsupportedElements.d.ts.map

package/lib/rules/ariaUnsupportedElements.js

@@ -0,0 +1,89 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+
+//#region src/rules/ariaUnsupportedElements.ts
+const unsupportedElements = new Set([
+	"base",
+	"body",
+	"caption",
+	"col",
+	"colgroup",
+	"datalist",
+	"dd",
+	"details",
+	"dialog",
+	"dt",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"frame",
+	"frameset",
+	"head",
+	"header",
+	"hgroup",
+	"html",
+	"iframe",
+	"legend",
+	"link",
+	"main",
+	"meta",
+	"meter",
+	"nav",
+	"noscript",
+	"optgroup",
+	"option",
+	"output",
+	"param",
+	"picture",
+	"progress",
+	"script",
+	"slot",
+	"style",
+	"template",
+	"textarea",
+	"title",
+	"track"
+]);
+var ariaUnsupportedElements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ARIA attributes on elements that don't support them.",
+		id: "ariaUnsupportedElements",
+		presets: ["logical"]
+	},
+	messages: { unsupportedElement: {
+		primary: "The `{{ element }}` element does not support ARIA roles, states, or properties.",
+		secondary: [
+			"Certain reserved DOM elements do not support ARIA attributes.",
+			"These elements are often not visible or have specific semantic meaning.",
+			"This is required for WCAG 4.1.2 compliance."
+		],
+		suggestions: ["Remove ARIA attributes from this element"]
+	} },
+	setup(context) {
+		function checkElement(node, { sourceFile }) {
+			if (node.tagName.kind !== SyntaxKind.Identifier) return;
+			const elementName = node.tagName.text.toLowerCase();
+			if (!unsupportedElements.has(elementName)) return;
+			if (node.attributes.properties.some((property) => {
+				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) return false;
+				const attributeName = property.name.text.toLowerCase();
+				return attributeName === "role" || attributeName.startsWith("aria-");
+			})) context.report({
+				data: { element: elementName },
+				message: "unsupportedElement",
+				range: getTSNodeRange(node.tagName, sourceFile)
+			});
+		}
+		return { visitors: {
+			JsxOpeningElement: checkElement,
+			JsxSelfClosingElement: checkElement
+		} };
+	}
+});
+
+//#endregion
+export { ariaUnsupportedElements_default as default };
+//# sourceMappingURL=ariaUnsupportedElements.js.map

package/lib/rules/autoFocusProps.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@flint.fyi/core").Rule<import("@flint.fyi/core").RuleAboutWithPresetsAndUrl<"logical" | "logicalStrict" | "stylistic">, object, object, "noAutoFocus", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=autoFocusProps.d.ts.map