@flint.fyi/jsx 0.3.3 → 0.5.0

package/lib/rules/ariaHiddenFocusables.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/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?.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?.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) {
-		if (ariaHiddenProperty.initializer.expression?.kind === SyntaxKind.TrueKeyword) return true;
-	}
-	return false;
-}
-//#endregion
-export { ariaHiddenFocusables_default as default };
-
-//# sourceMappingURL=ariaHiddenFocusables.js.map

package/lib/rules/ariaPropTypes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports ARIA properties with invalid value types.";
-    readonly id: "ariaPropTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidPropType", undefined>;
-export default _default;
-//# sourceMappingURL=ariaPropTypes.d.ts.map

package/lib/rules/ariaPropTypes.js

@@ -1,224 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#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;
-		case "idlist": return typeof value === "string" && !!value.trim().length;
-		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;
-			return tokenValues[propertyName]?.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", "logicalStrict"]
-	},
-	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

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports invalid ARIA properties.";
-    readonly id: "ariaProps";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidAriaProp", undefined>;
-export default _default;
-//# sourceMappingURL=ariaProps.d.ts.map

package/lib/rules/ariaProps.js

@@ -1,92 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#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", "logicalStrict"]
-	},
-	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

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports invalid or abstract ARIA roles.";
-    readonly id: "ariaRoleValidity";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidRole", undefined>;
-export default _default;
-//# sourceMappingURL=ariaRoleValidity.d.ts.map

package/lib/rules/ariaRoleValidity.js

@@ -1,113 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#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", "logicalStrict"]
-	},
-	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?.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

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports ARIA attributes on elements that don't support them.";
-    readonly id: "ariaUnsupportedElements";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unsupportedElement", undefined>;
-export default _default;
-//# sourceMappingURL=ariaUnsupportedElements.d.ts.map

package/lib/rules/ariaUnsupportedElements.js

@@ -1,88 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#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", "logicalStrict"]
-	},
-	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

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports autoFocus props that are not set to false.";
-    readonly id: "autoFocusProps";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noAutoFocus", undefined>;
-export default _default;
-//# sourceMappingURL=autoFocusProps.d.ts.map

package/lib/rules/autoFocusProps.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { SyntaxKind } from "typescript";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/autoFocusProps.ts
-var autoFocusProps_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports autoFocus props that are not set to false.",
-		id: "autoFocusProps",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noAutoFocus: {
-		primary: "The `autoFocus` prop disruptively forces unintuitive focus behavior.",
-		secondary: [
-			"Auto-focusing elements can cause usability issues for sighted and non-sighted users.",
-			"It can be disruptive to users who rely on screen readers or keyboard navigation.",
-			"Consider letting users focus elements manually instead."
-		],
-		suggestions: ["Remove the autoFocus prop", "Set autoFocus to false: autoFocus={false}"]
-	} },
-	setup(context) {
-		function isSetToFalse(property) {
-			if (!property.initializer) return false;
-			if (property.initializer.kind === SyntaxKind.StringLiteral) return true;
-			if (property.initializer.kind === SyntaxKind.JsxExpression) {
-				if (property.initializer.expression?.kind === SyntaxKind.FalseKeyword) return true;
-			}
-			return false;
-		}
-		function checkElement(node, { sourceFile }) {
-			for (const property of node.attributes.properties) if (property.kind === SyntaxKind.JsxAttribute && property.name.kind === SyntaxKind.Identifier && property.name.text.toLowerCase() === "autofocus" && !isSetToFalse(property)) context.report({
-				message: "noAutoFocus",
-				range: getTSNodeRange(property, sourceFile)
-			});
-		}
-		return { visitors: {
-			JsxOpeningElement: checkElement,
-			JsxSelfClosingElement: checkElement
-		} };
-	}
-});
-//#endregion
-export { autoFocusProps_default as default };
-
-//# sourceMappingURL=autoFocusProps.js.map