@flint.fyi/jsx 0.4.0 → 0.6.0

package/lib/rules/autocomplete.js

@@ -1,120 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getStaticStringValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/autocomplete.ts
-const validAutocompleteValues = /* @__PURE__ */ new Set([
-	"address-level1",
-	"address-level2",
-	"address-level3",
-	"address-level4",
-	"address-line1",
-	"address-line2",
-	"address-line3",
-	"bday",
-	"bday-day",
-	"bday-month",
-	"bday-year",
-	"cc-additional-name",
-	"cc-csc",
-	"cc-exp",
-	"cc-exp-month",
-	"cc-exp-year",
-	"cc-family-name",
-	"cc-given-name",
-	"cc-name",
-	"cc-number",
-	"cc-type",
-	"country",
-	"country-name",
-	"current-password",
-	"email",
-	"impp",
-	"language",
-	"name",
-	"new-password",
-	"off",
-	"on",
-	"one-time-code",
-	"organization",
-	"organization-title",
-	"photo",
-	"postal-code",
-	"sex",
-	"street-address",
-	"tel",
-	"tel-area-code",
-	"tel-country-code",
-	"tel-extension",
-	"tel-local",
-	"tel-national",
-	"transaction-amount",
-	"transaction-currency",
-	"url",
-	"username",
-	"webauthn"
-]);
-const billingAndShippingValues = /* @__PURE__ */ new Set([
-	"address-level1",
-	"address-level2",
-	"address-level3",
-	"address-level4",
-	"address-line1",
-	"address-line2",
-	"address-line3",
-	"country",
-	"country-name",
-	"postal-code",
-	"street-address"
-]);
-function isValidAutocompleteValue(value) {
-	const parts = value.trim().split(/\s+/);
-	if (parts.length === 1) return validAutocompleteValues.has(nullThrows(parts[0], "First part is expected to be present by prior length check"));
-	if (parts.length === 2) {
-		const [prefix, token] = parts;
-		if (prefix === "billing" || prefix === "shipping") return billingAndShippingValues.has(nullThrows(token, "Second part is expected to be present by prior length check"));
-	}
-	return false;
-}
-var autocomplete_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Ensure the autocomplete attribute is correct and suitable for the form field.",
-		id: "autocomplete",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { invalid: {
-		primary: "`{{ value }}` is not a valid value for autocomplete.",
-		secondary: [
-			"The autocomplete attribute must use valid tokens from the HTML specification.",
-			"Valid values help browsers and assistive technologies provide better user experiences.",
-			"This is required for WCAG 1.3.5 compliance."
-		],
-		suggestions: [
-			"Use standard autocomplete tokens like 'email', 'name', 'off', or 'tel'",
-			"For address fields, use 'billing' or 'shipping' prefix with appropriate field tokens",
-			"Check the HTML specification for the complete list of valid autocomplete tokens"
-		]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			const { attributes, tagName } = node;
-			if (tagName.kind !== SyntaxKind.Identifier) return;
-			if (tagName.text.toLowerCase() !== "input") return;
-			const autocomplete = attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "autocomplete");
-			if (autocomplete?.kind !== SyntaxKind.JsxAttribute || !autocomplete.initializer) return;
-			const value = getStaticStringValue(autocomplete.initializer);
-			if (value === void 0 || isValidAutocompleteValue(value)) return;
-			context.report({
-				data: { value },
-				message: "invalid",
-				range: getTSNodeRange(autocomplete.name, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkNode,
-			JsxSelfClosingElement: checkNode
-		} };
-	}
-});
-//#endregion
-export { autocomplete_default as default };

package/lib/rules/booleanValues.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer shorthand boolean attributes over explicit {true} values in JSX.";
-    readonly id: "booleanValues";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferShorthand", undefined>;
-export default _default;

package/lib/rules/booleanValues.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/booleanValues.ts
-var booleanValues_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer shorthand boolean attributes over explicit {true} values in JSX.",
-		id: "booleanValues",
-		presets: ["stylistic"]
-	},
-	messages: { preferShorthand: {
-		primary: "Prefer shorthand boolean attribute `{{ name }}` over explicit `{{ name }}={true}`.",
-		secondary: ["Boolean attributes with explicit `{true}` values are redundant and verbose.", "The shorthand syntax is more concise and idiomatic in JSX."],
-		suggestions: ["Use the shorthand syntax: `{{ name }}`"]
-	} },
-	setup(context) {
-		function checkElement(node, { sourceFile }) {
-			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.initializer?.kind === SyntaxKind.JsxExpression && property.initializer.expression?.kind === SyntaxKind.TrueKeyword) context.report({
-				data: { name: property.name.text },
-				message: "preferShorthand",
-				range: getTSNodeRange(property, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { booleanValues_default as default };

package/lib/rules/bracedStatements.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallow unnecessary JSX curly braces around literals and JSX elements.";
-    readonly id: "bracedStatements";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBraces", undefined>;
-export default _default;

package/lib/rules/bracedStatements.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/bracedStatements.ts
-var bracedStatements_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow unnecessary JSX curly braces around literals and JSX elements.",
-		id: "bracedStatements",
-		presets: ["stylistic"]
-	},
-	messages: { unnecessaryBraces: {
-		primary: "Curly braces are unnecessary around {{ type }}.",
-		secondary: ["Curly braces are unnecessary when they wrap simple literals or JSX elements.", "Removing them improves readability and reduces visual clutter."],
-		suggestions: ["Remove the curly braces and use the content directly."]
-	} },
-	setup(context) {
-		return { visitors: { JsxExpression(node, { sourceFile }) {
-			if (!node.expression || node.parent.kind !== SyntaxKind.JsxElement && node.parent.kind !== SyntaxKind.JsxFragment) return;
-			let unnecessaryType;
-			if (node.expression.kind === SyntaxKind.StringLiteral) unnecessaryType = "string literals";
-			else if (node.expression.kind === SyntaxKind.JsxElement || node.expression.kind === SyntaxKind.JsxSelfClosingElement || node.expression.kind === SyntaxKind.JsxFragment) unnecessaryType = "JSX elements";
-			if (unnecessaryType) context.report({
-				data: { type: unnecessaryType },
-				message: "unnecessaryBraces",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { bracedStatements_default as default };

package/lib/rules/buttonTypes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports button elements without an explicit type attribute.";
-    readonly id: "buttonTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidType" | "missingType", undefined>;
-export default _default;

package/lib/rules/buttonTypes.js

@@ -1,68 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getStaticStringValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/buttonTypes.ts
-const validButtonTypes = /* @__PURE__ */ new Set([
-	"button",
-	"reset",
-	"submit"
-]);
-var buttonTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports button elements without an explicit type attribute.",
-		id: "buttonTypes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		invalidType: {
-			primary: "Button type '{{ type }}' is invalid. Use 'button', 'submit', or 'reset'.",
-			secondary: ["The type attribute must be one of: 'button', 'submit', or 'reset'.", "Invalid types will not behave as expected in all browsers."],
-			suggestions: [
-				"Change to type='button' for general action buttons",
-				"Change to type='submit' for form submission buttons",
-				"Change to type='reset' for form reset buttons"
-			]
-		},
-		missingType: {
-			primary: "It is generally preferable to add an explicit `type` attribute to buttons.",
-			secondary: [
-				"Buttons without an explicit type default to 'submit', which can cause unintended form submissions.",
-				"Valid button types are 'button', 'submit', and 'reset'.",
-				"Specify an explicit type to make the button's behavior clear."
-			],
-			suggestions: [
-				"Add type='button' for general action buttons",
-				"Add type='submit' for form submission buttons",
-				"Add type='reset' for form reset buttons"
-			]
-		}
-	},
-	setup(context) {
-		function checkElement(node, { sourceFile }) {
-			if (node.tagName.kind !== SyntaxKind.Identifier) return;
-			if (node.tagName.text.toLowerCase() !== "button") return;
-			const typeAttribute = node.attributes.properties.find((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "type");
-			if (!typeAttribute) {
-				context.report({
-					message: "missingType",
-					range: getTSNodeRange(node.tagName, sourceFile)
-				});
-				return;
-			}
-			const typeInitializer = typeAttribute.initializer;
-			const typeExpression = typeInitializer?.kind === SyntaxKind.JsxExpression ? typeInitializer.expression : typeInitializer;
-			const typeValue = typeExpression && getStaticStringValue(typeExpression);
-			if (typeValue && !validButtonTypes.has(typeValue)) context.report({
-				data: { type: typeValue },
-				message: "invalidType",
-				range: getTSNodeRange(typeAttribute, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { buttonTypes_default as default };

package/lib/rules/childrenProps.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports usage of the children prop.";
-    readonly id: "childrenProps";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noChildrenProp", undefined>;
-export default _default;

package/lib/rules/childrenProps.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/childrenProps.ts
-var childrenProps_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports usage of the children prop.",
-		id: "childrenProps",
-		presets: ["stylistic"]
-	},
-	messages: { noChildrenProp: {
-		primary: "Prefer providing children as content between opening and closing tags, not as a `children` prop.",
-		secondary: [
-			"Using the `children` prop is not idiomatic in JSX.",
-			"Pass children as content between opening and closing tags instead.",
-			"This makes the JSX more readable and maintainable."
-		],
-		suggestions: ["Remove the children prop and pass children as content between tags."]
-	} },
-	setup(context) {
-		function checkElement(node, { sourceFile }) {
-			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text === "children") {
-				context.report({
-					message: "noChildrenProp",
-					range: getTSNodeRange(property, sourceFile)
-				});
-				return;
-			}
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { childrenProps_default as default };

package/lib/rules/clickEventKeyEvents.d.ts

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

package/lib/rules/clickEventKeyEvents.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/clickEventKeyEvents.ts
-const interactiveElements = /* @__PURE__ */ new Set([
-	"a",
-	"button",
-	"input",
-	"select",
-	"textarea"
-]);
-var clickEventKeyEvents_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports onClick without keyboard event handlers.",
-		id: "clickEventKeyEvents",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingKeyEvent: {
-		primary: "This `onClick` is missing accompanying `onKeyUp`, `onKeyDown`, and/or `onKeyPress` keyboard events.",
-		secondary: [
-			"Click events should have keyboard equivalents for users who cannot use a mouse.",
-			"This is important for users with physical disabilities and screen reader users.",
-			"Required for WCAG 2.1.1 compliance."
-		],
-		suggestions: ["Add onKeyDown, onKeyUp, and/or onKeyPress handlers", "Use a button element which is inherently keyboard accessible"]
-	} },
-	setup(context) {
-		function checkClickEvent(node, { sourceFile }) {
-			if (node.tagName.kind !== SyntaxKind.Identifier || node.tagName.text.toLowerCase() !== node.tagName.text) return;
-			const elementName = node.tagName.text.toLowerCase();
-			if (interactiveElements.has(elementName)) return;
-			let onClickName;
-			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier) switch (property.name.text) {
-				case "aria-hidden":
-				case "onKeyDown":
-				case "onKeyPress":
-				case "onKeyUp": return;
-				case "onClick":
-					onClickName = property.name;
-					break;
-			}
-			if (onClickName) context.report({
-				message: "missingKeyEvent",
-				range: getTSNodeRange(onClickName, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkClickEvent,
-			JsxSelfClosingElement: checkClickEvent
-		} };
-	}
-});
-//#endregion
-export { clickEventKeyEvents_default as default };

package/lib/rules/commentTextNodes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports JSX text nodes that contain comment syntax but are rendered as text.";
-    readonly id: "commentTextNodes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "commentAsText", undefined>;
-export default _default;

package/lib/rules/commentTextNodes.js

@@ -1,30 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/commentTextNodes.ts
-var commentTextNodes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports JSX text nodes that contain comment syntax but are rendered as text.",
-		id: "commentTextNodes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { commentAsText: {
-		primary: "This text looks like a comment but will be rendered as text in the JSX output.",
-		secondary: [
-			"In JSX, text that looks like comments (// or /* */) is rendered as literal text.",
-			"To add actual comments in JSX, wrap them in braces: {/* comment */}.",
-			"If this is intentional text, consider making it clearer that it's not a comment."
-		],
-		suggestions: ["Use {/* comment */} for actual comments", "Remove the comment-like syntax if it's unintended"]
-	} },
-	setup(context) {
-		return { visitors: { JsxText(node, { sourceFile }) {
-			const text = node.text;
-			if (/^\s*(?:\/\/|\/\*)/.test(text)) context.report({
-				message: "commentAsText",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { commentTextNodes_default as default };

package/lib/rules/distractingElements.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports distracting elements like <marquee> and <blink>.";
-    readonly id: "distractingElements";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noDistractingElement", undefined>;
-export default _default;

package/lib/rules/distractingElements.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/distractingElements.ts
-const distractingElements = /* @__PURE__ */ new Set(["blink", "marquee"]);
-var distractingElements_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports distracting elements like <marquee> and <blink>.",
-		id: "distractingElements",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noDistractingElement: {
-		primary: "The <{{ element }}> element is distracting and deprecated.",
-		secondary: [
-			"Visually distracting elements cause accessibility issues for users with visual impairments.",
-			"The <marquee> and <blink> elements are deprecated and should not be used.",
-			"Use modern CSS animations if movement is necessary for your design."
-		],
-		suggestions: ["Remove the distracting element", "Use CSS animations for visual effects"]
-	} },
-	setup(context) {
-		function checkElement({ tagName }, { sourceFile }) {
-			if (tagName.kind !== SyntaxKind.Identifier) return;
-			const elementName = tagName.text.toLowerCase();
-			if (distractingElements.has(elementName)) context.report({
-				data: { element: elementName },
-				message: "noDistractingElement",
-				range: getTSNodeRange(tagName, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { distractingElements_default as default };

package/lib/rules/elementChildrenValidity.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports void DOM elements that have children, which is invalid HTML.";
-    readonly id: "elementChildrenValidity";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "voidElementWithChildren", undefined>;
-export default _default;

package/lib/rules/elementChildrenValidity.js

@@ -1,52 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/elementChildrenValidity.ts
-const voidElements = /* @__PURE__ */ new Set([
-	"area",
-	"base",
-	"br",
-	"col",
-	"embed",
-	"hr",
-	"img",
-	"input",
-	"link",
-	"meta",
-	"param",
-	"source",
-	"track",
-	"wbr"
-]);
-var elementChildrenValidity_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports void DOM elements that have children, which is invalid HTML.",
-		id: "elementChildrenValidity",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { voidElementWithChildren: {
-		primary: "The `<{{ element }}>` element is a void element and cannot have children.",
-		secondary: [
-			"Void elements are self-closing and cannot contain any content or children.",
-			"Remove the children or use a different element type.",
-			"This violates HTML specification and may cause rendering issues."
-		],
-		suggestions: ["Remove the children from the element", "Use a self-closing syntax: `<{{ element }} />`"]
-	} },
-	setup(context) {
-		return { visitors: { JsxElement(node, { sourceFile }) {
-			if (!node.children.length) return;
-			const openingElement = node.openingElement;
-			if (openingElement.tagName.kind !== SyntaxKind.Identifier) return;
-			const elementName = openingElement.tagName.text.toLowerCase();
-			if (!voidElements.has(elementName)) return;
-			context.report({
-				data: { element: elementName },
-				message: "voidElementWithChildren",
-				range: getTSNodeRange(openingElement.tagName, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { elementChildrenValidity_default as default };

package/lib/rules/headingContents.d.ts

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

package/lib/rules/headingContents.js

@@ -1,52 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/headingContents.ts
-const headingElements = /* @__PURE__ */ new Set([
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"h5",
-	"h6"
-]);
-var headingContents_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports heading elements without accessible content.",
-		id: "headingContents",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { emptyHeading: {
-		primary: "This heading element is missing accessible content.",
-		secondary: [
-			"Headings without content are not accessible to screen readers.",
-			"Ensure the heading has text content or uses aria-label/aria-labelledby.",
-			"This is required for WCAG 2.4.6 compliance."
-		],
-		suggestions: ["Add text content to the heading", "Use aria-label or aria-labelledby to provide accessible text"]
-	} },
-	setup(context) {
-		function checkHeading(node, { sourceFile }) {
-			const tagName = node.kind === SyntaxKind.JsxElement ? node.openingElement.tagName : node.tagName;
-			if (tagName.kind !== SyntaxKind.Identifier || !headingElements.has(tagName.text.toLowerCase())) return;
-			if ((node.kind === SyntaxKind.JsxElement ? node.openingElement.attributes : node.attributes).properties.some((property) => {
-				if (property.kind !== SyntaxKind.JsxAttribute || property.name.kind !== SyntaxKind.Identifier) return false;
-				return (property.name.text === "aria-label" || property.name.text === "aria-labelledby") && !!property.initializer;
-			})) return;
-			if (node.kind === SyntaxKind.JsxElement && node.children.some((child) => {
-				if (child.kind === SyntaxKind.JsxText) return !!child.text.trim().length;
-				return child.kind === SyntaxKind.JsxElement || child.kind === SyntaxKind.JsxSelfClosingElement || child.kind === SyntaxKind.JsxExpression;
-			})) return;
-			context.report({
-				message: "emptyHeading",
-				range: getTSNodeRange(tagName, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxElement: checkHeading,
-			JsxSelfClosingElement: checkHeading
-		} };
-	}
-});
-//#endregion
-export { headingContents_default as default };

package/lib/rules/htmlLangs.d.ts

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

package/lib/rules/htmlLangs.js

@@ -1,30 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/htmlLangs.ts
-var htmlLangs_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports <html> elements without a lang prop.",
-		id: "htmlLangs",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { missingLang: {
-		primary: "This <html> element is missing a `lang` prop.",
-		secondary: [
-			"The lang attribute identifies the language of the document for screen readers and assistive technologies.",
-			"Without it, screen readers may default to the user's system language, causing confusion.",
-			"This is required for WCAG 3.1.1 compliance."
-		],
-		suggestions: ["Add a lang prop with a valid language code (e.g., lang=\"en\")", "Use lang=\"en-US\" for more specific localization"]
-	} },
-	setup(context) {
-		return { visitors: { JsxOpeningElement(node, { sourceFile }) {
-			if (node.tagName.kind === SyntaxKind.Identifier && node.tagName.text === "html" && !node.attributes.properties.some((property) => property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "lang")) context.report({
-				message: "missingLang",
-				range: getTSNodeRange(node.tagName, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { htmlLangs_default as default };