@flint.fyi/jsx 0.4.0 → 0.6.0

package/lib/rules/iframeTitles.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports <iframe> elements without a title prop.";
-    readonly id: "iframeTitles";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingTitle", undefined>;
-export default _default;

package/lib/rules/iframeTitles.js

@@ -1,61 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/iframeTitles.ts
-var iframeTitles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports <iframe> elements without a title prop.",
-		id: "iframeTitles",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingTitle: {
-		primary: "This <iframe> element is missing a `title` prop.",
-		secondary: [
-			"The title attribute provides a label for the iframe that describes its content to screen reader users.",
-			"Without it, users may have difficulty understanding the purpose of the iframe.",
-			"This is required for WCAG 2.4.1 and 4.1.2 compliance."
-		],
-		suggestions: ["Add a descriptive title prop (e.g., title=\"Embedded content\")", "Ensure the title clearly describes the iframe's content"]
-	} },
-	setup(context) {
-		function checkIframe({ attributes, tagName }, { sourceFile }) {
-			if (tagName.kind !== SyntaxKind.Identifier || tagName.text.toLowerCase() !== "iframe") return;
-			const titleAttribute = attributes.properties.find((property) => {
-				return property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "title";
-			});
-			if (titleAttribute?.kind !== SyntaxKind.JsxAttribute) {
-				context.report({
-					message: "missingTitle",
-					range: getTSNodeRange(tagName, sourceFile)
-				});
-				return;
-			}
-			if (!titleAttribute.initializer) {
-				context.report({
-					message: "missingTitle",
-					range: getTSNodeRange(tagName, sourceFile)
-				});
-				return;
-			}
-			if (titleAttribute.initializer.kind === SyntaxKind.StringLiteral) {
-				if (titleAttribute.initializer.text === "") context.report({
-					message: "missingTitle",
-					range: getTSNodeRange(tagName, sourceFile)
-				});
-			} else if (titleAttribute.initializer.kind === SyntaxKind.JsxExpression) {
-				const { expression } = titleAttribute.initializer;
-				if (!expression) return;
-				if (expression.kind === SyntaxKind.StringLiteral && expression.text === "" || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral && expression.text === "" || expression.kind === SyntaxKind.Identifier && expression.text === "undefined") context.report({
-					message: "missingTitle",
-					range: getTSNodeRange(tagName, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			JsxOpeningElement: checkIframe,
-			JsxSelfClosingElement: checkIframe
-		} };
-	}
-});
-//#endregion
-export { iframeTitles_default as default };

package/lib/rules/interactiveElementRoles.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports interactive elements with non-interactive ARIA roles.";
-    readonly id: "interactiveElementRoles";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidRole", undefined>;
-export default _default;

package/lib/rules/interactiveElementRoles.js

@@ -1,91 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/interactiveElementRoles.ts
-const interactiveElements = /* @__PURE__ */ new Set([
-	"a",
-	"audio",
-	"button",
-	"details",
-	"input",
-	"select",
-	"summary",
-	"textarea",
-	"video"
-]);
-const nonInteractiveRoles = /* @__PURE__ */ new Set([
-	"article",
-	"banner",
-	"complementary",
-	"contentinfo",
-	"definition",
-	"directory",
-	"document",
-	"feed",
-	"figure",
-	"form",
-	"group",
-	"heading",
-	"img",
-	"list",
-	"listitem",
-	"log",
-	"main",
-	"marquee",
-	"math",
-	"meter",
-	"navigation",
-	"none",
-	"note",
-	"presentation",
-	"region",
-	"rowgroup",
-	"search",
-	"separator",
-	"status",
-	"table",
-	"tabpanel",
-	"term",
-	"timer",
-	"tooltip"
-]);
-var interactiveElementRoles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports interactive elements with non-interactive ARIA roles.",
-		id: "interactiveElementRoles",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { invalidRole: {
-		primary: "Interactive element <{{ element }}> should not have the non-interactive role `'{{ role }}'`.",
-		secondary: [
-			"Interactive elements should not be converted to non-interactive elements using ARIA roles.",
-			"This removes expected browser interactions from the element.",
-			"This is required for WCAG 4.1.2 compliance."
-		],
-		suggestions: ["Remove the role attribute", "Use a native non-interactive element instead"]
-	} },
-	setup(context) {
-		function checkElement(element, { sourceFile }) {
-			if (element.tagName.kind !== SyntaxKind.Identifier) return;
-			const elementName = element.tagName.text.toLowerCase();
-			if (!interactiveElements.has(elementName)) return;
-			const roleProperty = element.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
-			if (roleProperty?.kind !== SyntaxKind.JsxAttribute || roleProperty.initializer?.kind !== SyntaxKind.StringLiteral) return;
-			const role = roleProperty.initializer.text;
-			if (nonInteractiveRoles.has(role)) context.report({
-				data: {
-					element: elementName,
-					role
-				},
-				message: "invalidRole",
-				range: getTSNodeRange(roleProperty, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { interactiveElementRoles_default as default };

package/lib/rules/interactiveElementsFocusable.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports interactive elements that are not focusable via keyboard.";
-    readonly id: "interactiveElementsFocusable";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "notFocusable", undefined>;
-export default _default;

package/lib/rules/interactiveElementsFocusable.js

@@ -1,170 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/interactiveElementsFocusable.ts
-const interactiveHandlers = [
-	"onClick",
-	"onKeyDown",
-	"onKeyPress",
-	"onKeyUp",
-	"onMouseDown",
-	"onMouseUp"
-];
-const interactiveRoles = /* @__PURE__ */ new Set([
-	"button",
-	"checkbox",
-	"columnheader",
-	"combobox",
-	"grid",
-	"gridcell",
-	"link",
-	"listbox",
-	"menu",
-	"menubar",
-	"menuitem",
-	"menuitemcheckbox",
-	"menuitemradio",
-	"option",
-	"progressbar",
-	"radio",
-	"radiogroup",
-	"row",
-	"rowheader",
-	"searchbox",
-	"slider",
-	"spinbutton",
-	"switch",
-	"tab",
-	"tablist",
-	"textbox",
-	"toolbar",
-	"tree",
-	"treegrid",
-	"treeitem"
-]);
-const inherentlyFocusableElements = /* @__PURE__ */ new Set([
-	"a",
-	"audio",
-	"button",
-	"input",
-	"select",
-	"textarea",
-	"video"
-]);
-const nonInteractiveElements = /* @__PURE__ */ new Set([
-	"article",
-	"aside",
-	"body",
-	"br",
-	"details",
-	"div",
-	"footer",
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"h5",
-	"h6",
-	"header",
-	"hr",
-	"img",
-	"li",
-	"main",
-	"nav",
-	"ol",
-	"p",
-	"section",
-	"span",
-	"table",
-	"td",
-	"ul"
-]);
-const nonInteractiveRoles = /* @__PURE__ */ new Set([
-	"article",
-	"banner",
-	"complementary",
-	"img",
-	"listitem",
-	"main",
-	"navigation",
-	"region",
-	"tooltip"
-]);
-var interactiveElementsFocusable_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports interactive elements that are not focusable via keyboard.",
-		id: "interactiveElementsFocusable",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { notFocusable: {
-		primary: "The '{{ role }}' role makes this element interactive, so it should also be focusable.",
-		secondary: [
-			"Interactive elements must be reachable via keyboard navigation.",
-			"Add a tabIndex attribute or use an inherently focusable element.",
-			"This is required for WCAG 2.1.1 compliance."
-		],
-		suggestions: [
-			"Add tabIndex={0} to make the element tabbable",
-			"Add tabIndex={-1} to make the element programmatically focusable",
-			"Use a native interactive element like <button> or <a>"
-		]
-	} },
-	setup(context) {
-		function getTabIndexValue(node) {
-			const tabIndex = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "tabIndex");
-			if (!tabIndex?.initializer) return;
-			if (tabIndex.initializer.kind === SyntaxKind.JsxExpression) {
-				const expression = tabIndex.initializer.expression;
-				if (expression?.kind === SyntaxKind.NumericLiteral) return Number(expression.text);
-			}
-			if (tabIndex.initializer.kind === SyntaxKind.StringLiteral) return Number(tabIndex.initializer.text);
-		}
-		function getRoleValue(node) {
-			const role = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
-			if (role?.kind === SyntaxKind.JsxAttribute && role.initializer?.kind === SyntaxKind.StringLiteral) return role.initializer.text;
-		}
-		function isAriaHidden(node) {
-			const ariaHidden = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "aria-hidden");
-			if (ariaHidden?.kind !== SyntaxKind.JsxAttribute || !ariaHidden.initializer) return false;
-			if (ariaHidden.initializer.kind === SyntaxKind.JsxExpression) return ariaHidden.initializer.expression?.kind === SyntaxKind.TrueKeyword;
-			if (ariaHidden.initializer.kind === SyntaxKind.StringLiteral) return ariaHidden.initializer.text === "true";
-			return false;
-		}
-		function hasInteractiveHandler(node) {
-			return node.attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && interactiveHandlers.includes(property.name.text));
-		}
-		function isDisabled(node) {
-			const disabledProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "disabled");
-			if (disabledProperty?.kind !== SyntaxKind.JsxAttribute) return false;
-			if (!disabledProperty.initializer) return true;
-			if (disabledProperty.initializer.kind === SyntaxKind.JsxExpression) return disabledProperty.initializer.expression?.kind === SyntaxKind.TrueKeyword;
-			return false;
-		}
-		function checkElement(node, { sourceFile }) {
-			if (node.tagName.kind !== SyntaxKind.Identifier) return;
-			const elementName = node.tagName.text.toLowerCase();
-			if (elementName !== node.tagName.text || !hasInteractiveHandler(node) || isAriaHidden(node) || isDisabled(node)) return;
-			const role = getRoleValue(node);
-			if (role === "presentation" || role === "none") return;
-			if (!(role !== void 0 && interactiveRoles.has(role) || role === void 0 && !nonInteractiveElements.has(elementName))) return;
-			if (role && nonInteractiveRoles.has(role)) return;
-			const hasInherentFocus = inherentlyFocusableElements.has(elementName);
-			const hasFocusableTabIndex = getTabIndexValue(node) !== void 0;
-			const roleProperty = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "role");
-			if (!hasInherentFocus && !hasFocusableTabIndex) {
-				const displayRole = role ?? elementName;
-				context.report({
-					data: { role: displayRole },
-					message: "notFocusable",
-					range: getTSNodeRange(roleProperty?.kind === SyntaxKind.JsxAttribute ? roleProperty : node.tagName, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { interactiveElementsFocusable_default as default };

package/lib/rules/labelAssociatedControls.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports <label> elements without an associated control element.";
-    readonly id: "labelAssociatedControls";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingAssociatedControl", undefined>;
-export default _default;

package/lib/rules/labelAssociatedControls.js

@@ -1,68 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/labelAssociatedControls.ts
-const controlElements = /* @__PURE__ */ new Set([
-	"input",
-	"meter",
-	"output",
-	"progress",
-	"select",
-	"textarea"
-]);
-var labelAssociatedControls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports <label> elements without an associated control element.",
-		id: "labelAssociatedControls",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingAssociatedControl: {
-		primary: "This <label> element is missing an associated control element.",
-		secondary: [
-			"Labels must be associated with a control element to be accessible to screen readers.",
-			"Use the htmlFor prop to reference a control by id, or nest the control inside the label.",
-			"This is required for WCAG 1.3.1, 2.4.6, and 4.1.2 compliance."
-		],
-		suggestions: ["Add an htmlFor prop that references a control element by id", "Nest a control element (input, select, textarea) inside the label"]
-	} },
-	setup(context) {
-		function hasHtmlForAttribute(attributes) {
-			return attributes.properties.some((property) => {
-				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier || property.name.text !== "htmlFor" || !property.initializer) return false;
-				if (property.initializer.kind === SyntaxKind.StringLiteral) return property.initializer.text !== "";
-				if (property.initializer.kind === SyntaxKind.JsxExpression) {
-					const { expression } = property.initializer;
-					if (!expression) return false;
-					if (expression.kind === SyntaxKind.StringLiteral && expression.text === "" || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral && expression.text === "" || expression.kind === SyntaxKind.Identifier && expression.text === "undefined" || expression.kind === SyntaxKind.NullKeyword) return false;
-				}
-				return true;
-			});
-		}
-		function hasNestedControl(children) {
-			return children.some((child) => {
-				if (child.kind === SyntaxKind.JsxElement) {
-					const { tagName } = child.openingElement;
-					return tagName.kind === SyntaxKind.Identifier && controlElements.has(tagName.text.toLowerCase()) || hasNestedControl(child.children);
-				}
-				if (child.kind === SyntaxKind.JsxSelfClosingElement) return child.tagName.kind === SyntaxKind.Identifier && controlElements.has(child.tagName.text.toLowerCase());
-				return false;
-			});
-		}
-		function checkLabel(node, { sourceFile }) {
-			if (node.kind === SyntaxKind.JsxElement && hasNestedControl(node.children)) return;
-			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
-			if (tagName.kind !== SyntaxKind.Identifier || tagName.text.toLowerCase() !== "label") return;
-			if (hasHtmlForAttribute(node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes)) return;
-			context.report({
-				message: "missingAssociatedControl",
-				range: getTSNodeRange(tagName, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxElement: checkLabel,
-			JsxSelfClosingElement: checkLabel
-		} };
-	}
-});
-//#endregion
-export { labelAssociatedControls_default as default };

package/lib/rules/langValidity.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports invalid lang attribute values.";
-    readonly id: "langValidity";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidLang", undefined>;
-export default _default;

package/lib/rules/langValidity.js

@@ -1,41 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import languageTags from "language-tags";
-//#region src/rules/langValidity.ts
-var langValidity_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports invalid lang attribute values.",
-		id: "langValidity",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { invalidLang: {
-		primary: "The lang attribute value '{{ value }}' is not a valid BCP 47 language tag.",
-		secondary: [
-			"The lang attribute must contain a valid BCP 47 language tag.",
-			"Valid examples include 'en', 'en-US', 'zh-Hans', or 'fr-CA'.",
-			"This is required for WCAG 3.1.2 compliance."
-		],
-		suggestions: ["Use a valid BCP 47 language tag like 'en' or 'en-US'", "Check the language code spelling and format"]
-	} },
-	setup(context) {
-		function checkElement(node, { sourceFile }) {
-			const langAttribute = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "lang");
-			if (!langAttribute?.initializer) return;
-			if (langAttribute.initializer.kind === SyntaxKind.StringLiteral) {
-				const langValue = langAttribute.initializer.text;
-				if (!languageTags.check(langValue)) context.report({
-					data: { value: langValue || "(empty)" },
-					message: "invalidLang",
-					range: getTSNodeRange(langAttribute.initializer, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { langValidity_default as default };

package/lib/rules/mediaCaptions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports media elements without captions.";
-    readonly id: "mediaCaptions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingCaptions", undefined>;
-export default _default;

package/lib/rules/mediaCaptions.js

@@ -1,50 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/mediaCaptions.ts
-var mediaCaptions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports media elements without captions.",
-		id: "mediaCaptions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingCaptions: {
-		primary: "This media element is missing <track> element captions.",
-		secondary: [
-			"Captions are essential for deaf users to follow along with media content.",
-			"The <track> element with kind='captions' provides this accessibility feature.",
-			"This is required for WCAG 1.2.2 and 1.2.3 compliance."
-		],
-		suggestions: ["Add a <track kind=\"captions\"> element as a child", "Add the muted attribute if the media has no audio"]
-	} },
-	setup(context) {
-		function checkMediaElement(node, { sourceFile }) {
-			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
-			if (tagName.kind !== SyntaxKind.Identifier) return;
-			const elementName = tagName.text.toLowerCase();
-			if (elementName !== "audio" && elementName !== "video") return;
-			if ((node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((properties) => properties.kind === SyntaxKind.JsxAttribute && properties.name.kind === SyntaxKind.Identifier && properties.name.text === "muted")) return;
-			if (node.kind === SyntaxKind.JsxElement && node.children.some(isCaptionsTrack)) return;
-			context.report({
-				message: "missingCaptions",
-				range: getTSNodeRange(tagName, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxElement: checkMediaElement,
-			JsxSelfClosingElement: checkMediaElement
-		} };
-	}
-});
-function isCaptionsTrack(node) {
-	if (node.kind !== SyntaxKind.JsxElement && node.kind !== SyntaxKind.JsxSelfClosingElement) return false;
-	const childTagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
-	if (childTagName.kind !== SyntaxKind.Identifier || childTagName.text !== "track") return false;
-	return (node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((property) => {
-		if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier || property.name.text !== "kind") return false;
-		if (property.initializer?.kind === SyntaxKind.StringLiteral) return property.initializer.text === "captions";
-		return false;
-	});
-}
-//#endregion
-export { mediaCaptions_default as default };

package/lib/rules/mouseEventKeyEvents.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports mouse events without corresponding keyboard events.";
-    readonly id: "mouseEventKeyEvents";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingKeyEvent", undefined>;
-export default _default;

package/lib/rules/mouseEventKeyEvents.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/mouseEventKeyEvents.ts
-const mouseNamesToKeyboardNames = /* @__PURE__ */ new Map([["onMouseOut", "onBlur"], ["onMouseOver", "onFocus"]]);
-var mouseEventKeyEvents_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports mouse events without corresponding keyboard events.",
-		id: "mouseEventKeyEvents",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingKeyEvent: {
-		primary: "`{{ mouseEvent }}` is missing an accompanying `{{ keyEvent }}` for keyboard accessibility.",
-		secondary: [
-			"Mouse events should have keyboard equivalents for users who cannot use a mouse.",
-			"This ensures that functionality is accessible to all users, such as those with limited hardware or personal disabilities.",
-			"Required for WCAG 2.1.1 compliance."
-		],
-		suggestions: ["Add the corresponding keyboard event handler", "Ensure both mouse and keyboard users can access the functionality"]
-	} },
-	setup(context) {
-		function checkMouseEvents(node, { sourceFile }) {
-			const { attributes } = node;
-			const presentAttributes = /* @__PURE__ */ new Set();
-			for (const property of attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) presentAttributes.add(property.name.text);
-			for (const property of attributes.properties) {
-				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) continue;
-				const mouseEvent = property.name.text;
-				const keyEvent = mouseNamesToKeyboardNames.get(mouseEvent);
-				if (keyEvent && !presentAttributes.has(keyEvent)) context.report({
-					data: {
-						keyEvent,
-						mouseEvent
-					},
-					message: "missingKeyEvent",
-					range: getTSNodeRange(property.name, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			JsxOpeningElement: checkMouseEvents,
-			JsxSelfClosingElement: checkMouseEvents
-		} };
-	}
-});
-//#endregion
-export { mouseEventKeyEvents_default as default };

package/lib/rules/nonInteractiveElementInteractions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-interactive elements with interactive event handlers.";
-    readonly id: "nonInteractiveElementInteractions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidHandler", undefined>;
-export default _default;