eslint-plugin-react-dom 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/index.d.ts

@@ -1,26 +1,9 @@
-import * as _eslint_react_shared0 from "@eslint-react/shared";
+import { ESLint, Linter } from "eslint";
 
 //#region src/index.d.ts
-declare const _default: {
-  configs: {
-    recommended: {
-      plugins: {};
-      name?: string;
-      rules?: Record<string, _eslint_react_shared0.RuleConfig>;
-      settings?: _eslint_react_shared0.SettingsConfig;
-    };
-    strict: {
-      plugins: {};
-      name?: string;
-      rules?: Record<string, _eslint_react_shared0.RuleConfig>;
-      settings?: _eslint_react_shared0.SettingsConfig;
-    };
-  };
-  meta: {
-    name: string;
-    version: string;
-  };
-  rules: Record<string, _eslint_react_shared0.CompatibleRule>;
+type ConfigName = "recommended" | "strict";
+declare const finalPlugin: ESLint.Plugin & {
+  configs: Record<ConfigName, Linter.Config>;
 };
 //#endregion
-export { _default as default };
+export { finalPlugin as default };

package/dist/index.js

@@ -1,8 +1,9 @@
-import { DEFAULT_ESLINT_REACT_SETTINGS, RE_JAVASCRIPT_PROTOCOL, WEBSITE_URL, getConfigAdapters, getSettingsFromContext } from "@eslint-react/shared";
-import * as core from "@eslint-react/core";
+import { DEFAULT_ESLINT_REACT_SETTINGS, RE_JAVASCRIPT_PROTOCOL, WEBSITE_URL, defineRuleListener, getSettingsFromContext } from "@eslint-react/shared";
+import { JsxInspector } from "@eslint-react/core";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { compare } from "compare-versions";
+import "ts-pattern";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -23,7 +24,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$2 = "eslint-plugin-react-dom";
-var version = "3.0.0-beta.7";
+var version = "3.0.0-beta.71";
 
 //#endregion
 //#region src/utils/create-jsx-element-resolver.ts
@@ -40,21 +41,19 @@ var version = "3.0.0-beta.7";
 */
 function createJsxElementResolver(context) {
 	const { polymorphicPropName } = getSettingsFromContext(context);
+	const jsx = JsxInspector.from(context);
 	return { resolve(node) {
-		const elementName = core.getJsxElementType(context, node);
+		const elementName = jsx.getElementType(node);
 		const result = {
 			domElementType: elementName,
 			jsxElementType: elementName
 		};
 		if (elementName === elementName.toLowerCase() || polymorphicPropName == null) return result;
-		const polymorphicProp = core.getJsxAttribute(context, node)(polymorphicPropName);
-		if (polymorphicProp != null) {
-			const staticValue = core.resolveJsxAttributeValue(context, polymorphicProp).toStatic(polymorphicPropName);
-			if (typeof staticValue === "string") return {
-				...result,
-				domElementType: staticValue
-			};
-		}
+		const polyPropValue = jsx.getAttributeValue(node, polymorphicPropName)?.toStatic();
+		if (typeof polyPropValue === "string") return {
+			...result,
+			domElementType: polyPropValue
+		};
 		return result;
 	} };
 }
@@ -67,72 +66,73 @@ function getDocsUrl(ruleName) {
 const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
 //#endregion
-//#region src/rules/no-dangerously-set-innerhtml.ts
-const RULE_NAME$17 = "no-dangerously-set-innerhtml";
-const DSIH$1 = "dangerouslySetInnerHTML";
-var no_dangerously_set_innerhtml_default = createRule({
+//#region src/rules/no-dangerously-set-innerhtml-with-children/no-dangerously-set-innerhtml-with-children.ts
+const RULE_NAME$17 = "no-dangerously-set-innerhtml-with-children";
+var no_dangerously_set_innerhtml_with_children_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallows DOM elements from using 'dangerouslySetInnerHTML'." },
-		messages: { default: "Using 'dangerouslySetInnerHTML' may have security implications." },
+		docs: { description: "Disallows DOM elements from using 'dangerouslySetInnerHTML' and 'children' at the same time." },
+		messages: { default: "A DOM component cannot use both children and 'dangerouslySetInnerHTML'." },
 		schema: []
 	},
 	name: RULE_NAME$17,
 	create: create$17,
 	defaultOptions: []
 });
+const DSIH$1 = "dangerouslySetInnerHTML";
+/**
+* Check if a JSX child node is considered significant (i.e., not just whitespace for formatting)
+* @param node The JSX child node to check
+* @returns `true` if the node is significant, `false` otherwise
+*/
+function isSignificantChildren(node) {
+	if (!JsxInspector.isJsxText(node)) return true;
+	return !(node.raw.trim() === "" && node.raw.includes("\n"));
+}
 function create$17(context) {
 	if (!context.sourceCode.text.includes(DSIH$1)) return {};
-	return { JSXElement(node) {
-		const dsihProp = core.getJsxAttribute(context, node)(DSIH$1);
-		if (dsihProp == null) return;
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
+		if (!jsx.hasAttribute(node, DSIH$1)) return;
+		const childrenPropOrNode = jsx.findAttribute(node, "children") ?? node.children.find(isSignificantChildren);
+		if (childrenPropOrNode == null) return;
 		context.report({
 			messageId: "default",
-			node: dsihProp
+			node: childrenPropOrNode
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-dangerously-set-innerhtml-with-children.ts
-const RULE_NAME$16 = "no-dangerously-set-innerhtml-with-children";
-var no_dangerously_set_innerhtml_with_children_default = createRule({
+//#region src/rules/no-dangerously-set-innerhtml/no-dangerously-set-innerhtml.ts
+const RULE_NAME$16 = "no-dangerously-set-innerhtml";
+const DSIH = "dangerouslySetInnerHTML";
+var no_dangerously_set_innerhtml_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallows DOM elements from using 'dangerouslySetInnerHTML' and 'children' at the same time." },
-		messages: { default: "A DOM component cannot use both children and 'dangerouslySetInnerHTML'." },
+		docs: { description: "Disallows DOM elements from using 'dangerouslySetInnerHTML'." },
+		messages: { default: "Using 'dangerouslySetInnerHTML' may have security implications." },
 		schema: []
 	},
 	name: RULE_NAME$16,
 	create: create$16,
 	defaultOptions: []
 });
-const DSIH = "dangerouslySetInnerHTML";
-/**
-* Check if a JSX child node is considered significant (i.e., not just whitespace for formatting)
-* @param node The JSX child node to check
-* @returns `true` if the node is significant, `false` otherwise
-*/
-function isSignificantChildren(node) {
-	if (!core.isJsxText(node)) return true;
-	return !(node.raw.trim() === "" && node.raw.includes("\n"));
-}
 function create$16(context) {
 	if (!context.sourceCode.text.includes(DSIH)) return {};
-	return { JSXElement(node) {
-		const findJsxAttribute = core.getJsxAttribute(context, node);
-		if (findJsxAttribute(DSIH) == null) return;
-		const childrenPropOrNode = findJsxAttribute("children") ?? node.children.find(isSignificantChildren);
-		if (childrenPropOrNode == null) return;
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
+		const dsihProp = jsx.findAttribute(node, DSIH);
+		if (dsihProp == null) return;
 		context.report({
 			messageId: "default",
-			node: childrenPropOrNode
+			node: dsihProp
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-find-dom-node.ts
+//#region src/rules/no-find-dom-node/no-find-dom-node.ts
 const RULE_NAME$15 = "no-find-dom-node";
 var no_find_dom_node_default = createRule({
 	meta: {
@@ -148,7 +148,7 @@ var no_find_dom_node_default = createRule({
 const findDOMNode = "findDOMNode";
 function create$15(context) {
 	if (!context.sourceCode.text.includes(findDOMNode)) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		const { callee } = node;
 		switch (callee.type) {
 			case AST_NODE_TYPES.Identifier:
@@ -164,11 +164,11 @@ function create$15(context) {
 				});
 				return;
 		}
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-flush-sync.ts
+//#region src/rules/no-flush-sync/no-flush-sync.ts
 const RULE_NAME$14 = "no-flush-sync";
 var no_flush_sync_default = createRule({
 	meta: {
@@ -184,7 +184,7 @@ var no_flush_sync_default = createRule({
 const flushSync = "flushSync";
 function create$14(context) {
 	if (!context.sourceCode.text.includes(flushSync)) return {};
-	return { CallExpression(node) {
+	return defineRuleListener({ CallExpression(node) {
 		const { callee } = node;
 		switch (callee.type) {
 			case AST_NODE_TYPES.Identifier:
@@ -200,11 +200,11 @@ function create$14(context) {
 				});
 				return;
 		}
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-hydrate.ts
+//#region src/rules/no-hydrate/no-hydrate.ts
 const RULE_NAME$13 = "no-hydrate";
 var no_hydrate_default = createRule({
 	meta: {
@@ -224,21 +224,21 @@ function create$13(context) {
 	if (compare(getSettingsFromContext(context).version, "18.0.0", "<")) return {};
 	const reactDomNames = /* @__PURE__ */ new Set();
 	const hydrateNames = /* @__PURE__ */ new Set();
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			switch (true) {
 				case node.callee.type === AST_NODE_TYPES.Identifier && hydrateNames.has(node.callee.name):
 					context.report({
+						fix: getFix$2(context, node),
 						messageId: "default",
-						node,
-						fix: getFix$2(context, node)
+						node
 					});
 					return;
 				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === hydrate && reactDomNames.has(node.callee.object.name):
 					context.report({
+						fix: getFix$2(context, node),
 						messageId: "default",
-						node,
-						fix: getFix$2(context, node)
+						node
 					});
 					return;
 			}
@@ -257,7 +257,7 @@ function create$13(context) {
 					continue;
 			}
 		}
-	};
+	});
 }
 function getFix$2(context, node) {
 	const getText = (n) => context.sourceCode.getText(n);
@@ -269,7 +269,7 @@ function getFix$2(context, node) {
 }
 
 //#endregion
-//#region src/rules/no-missing-button-type.ts
+//#region src/rules/no-missing-button-type/no-missing-button-type.ts
 const RULE_NAME$12 = "no-missing-button-type";
 const BUTTON_TYPES = [
 	"button",
@@ -293,23 +293,24 @@ var no_missing_button_type_default = createRule({
 });
 function create$12(context) {
 	const resolver = createJsxElementResolver(context);
-	return { JSXElement(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
 		if (resolver.resolve(node).domElementType !== "button") return;
-		if (core.getJsxAttribute(context, node)("type") != null) return;
+		if (jsx.hasAttribute(node, "type")) return;
 		context.report({
 			messageId: "missingTypeAttribute",
 			node: node.openingElement,
 			suggest: BUTTON_TYPES.map((type) => ({
-				messageId: "addTypeAttribute",
 				data: { type },
-				fix: (fixer) => fixer.insertTextAfter(node.openingElement.name, ` type="${type}"`)
+				fix: (fixer) => fixer.insertTextAfter(node.openingElement.name, ` type="${type}"`),
+				messageId: "addTypeAttribute"
 			}))
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-missing-iframe-sandbox.ts
+//#region src/rules/no-missing-iframe-sandbox/no-missing-iframe-sandbox.ts
 const RULE_NAME$11 = "no-missing-iframe-sandbox";
 var no_missing_iframe_sandbox_default = createRule({
 	meta: {
@@ -329,43 +330,45 @@ var no_missing_iframe_sandbox_default = createRule({
 });
 function create$11(context) {
 	const resolver = createJsxElementResolver(context);
-	return { JSXElement(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
 		const { domElementType } = resolver.resolve(node);
 		if (domElementType !== "iframe") return;
-		const sandboxProp = core.getJsxAttribute(context, node)("sandbox");
+		const sandboxProp = jsx.findAttribute(node, "sandbox");
 		if (sandboxProp == null) {
 			context.report({
 				messageId: "missingSandboxAttribute",
 				node: node.openingElement,
 				suggest: [{
-					messageId: "addSandboxAttribute",
 					data: { value: "" },
 					fix(fixer) {
 						return fixer.insertTextAfter(node.openingElement.name, ` sandbox=""`);
-					}
+					},
+					messageId: "addSandboxAttribute"
 				}]
 			});
 			return;
 		}
-		const sandboxValue = core.resolveJsxAttributeValue(context, sandboxProp);
-		if (typeof sandboxValue.toStatic("sandbox") === "string") return;
+		const sandboxValue = jsx.resolveAttributeValue(sandboxProp);
+		if (typeof sandboxValue.toStatic() === "string") return;
+		if (sandboxValue.kind === "spreadProps" && typeof sandboxValue.getProperty("sandbox") === "string") return;
 		context.report({
 			messageId: "missingSandboxAttribute",
 			node: sandboxValue.node ?? sandboxProp,
 			suggest: [{
-				messageId: "addSandboxAttribute",
 				data: { value: "" },
 				fix(fixer) {
 					if (sandboxValue.kind.startsWith("spread")) return null;
 					return fixer.replaceText(sandboxProp, `sandbox=""`);
-				}
+				},
+				messageId: "addSandboxAttribute"
 			}]
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-namespace.ts
+//#region src/rules/no-namespace/no-namespace.ts
 const RULE_NAME$10 = "no-namespace";
 var no_namespace_default = createRule({
 	meta: {
@@ -379,26 +382,33 @@ var no_namespace_default = createRule({
 	defaultOptions: []
 });
 function create$10(context) {
-	return { JSXElement(node) {
-		const name = core.getJsxElementType(context, node);
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
+		const name = jsx.getElementType(node);
 		if (typeof name !== "string" || !name.includes(":")) return;
 		context.report({
+			data: { name },
 			messageId: "default",
-			node: node.openingElement.name,
-			data: { name }
+			node: node.openingElement.name
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-render.ts
-const RULE_NAME$9 = "no-render";
-var no_render_default = createRule({
+//#region src/rules/no-render-return-value/no-render-return-value.ts
+const RULE_NAME$9 = "no-render-return-value";
+const banParentTypes = [
+	AST_NODE_TYPES.VariableDeclarator,
+	AST_NODE_TYPES.Property,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ArrowFunctionExpression,
+	AST_NODE_TYPES.AssignmentExpression
+];
+var no_render_return_value_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Replaces usage of 'ReactDOM.render()' with 'createRoot(node).render()'." },
-		fixable: "code",
-		messages: { default: "[Deprecated] Use 'createRoot(node).render()' instead." },
+		docs: { description: "Disallows the return value of 'ReactDOM.render'." },
+		messages: { default: "Do not depend on the return value from 'ReactDOM.render'." },
 		schema: []
 	},
 	name: RULE_NAME$9,
@@ -406,25 +416,21 @@ var no_render_default = createRule({
 	defaultOptions: []
 });
 function create$9(context) {
-	if (!context.sourceCode.text.includes("render")) return {};
-	if (compare(getSettingsFromContext(context).version, "18.0.0", "<")) return {};
 	const reactDomNames = new Set(["ReactDOM", "ReactDOM"]);
 	const renderNames = /* @__PURE__ */ new Set();
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			switch (true) {
-				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name):
+				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name) && banParentTypes.includes(node.parent.type):
 					context.report({
 						messageId: "default",
-						node,
-						fix: getFix$1(context, node)
+						node
 					});
 					return;
-				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name):
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name) && banParentTypes.includes(node.parent.type):
 					context.report({
 						messageId: "default",
-						node,
-						fix: getFix$1(context, node)
+						node
 					});
 					return;
 			}
@@ -443,38 +449,18 @@ function create$9(context) {
 					continue;
 			}
 		}
-	};
-}
-/**
-* Provides a fixer function to replace `render(app, container)` with `createRoot(container).render(app)`
-* @param context The rule context
-* @param node The `CallExpression` node to fix
-* @returns A fixer function or null if the fix cannot be applied
-*/
-function getFix$1(context, node) {
-	const getText = (n) => context.sourceCode.getText(n);
-	return (fixer) => {
-		const [arg0, arg1] = node.arguments;
-		if (arg0 == null || arg1 == null) return null;
-		return [fixer.insertTextBefore(context.sourceCode.ast, "import { createRoot } from \"react-dom/client\";\n"), fixer.replaceText(node, `createRoot(${getText(arg1)}).render(${getText(arg0)})`)];
-	};
+	});
 }
 
 //#endregion
-//#region src/rules/no-render-return-value.ts
-const RULE_NAME$8 = "no-render-return-value";
-const banParentTypes = [
-	AST_NODE_TYPES.VariableDeclarator,
-	AST_NODE_TYPES.Property,
-	AST_NODE_TYPES.ReturnStatement,
-	AST_NODE_TYPES.ArrowFunctionExpression,
-	AST_NODE_TYPES.AssignmentExpression
-];
-var no_render_return_value_default = createRule({
+//#region src/rules/no-render/no-render.ts
+const RULE_NAME$8 = "no-render";
+var no_render_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallows the return value of 'ReactDOM.render'." },
-		messages: { default: "Do not depend on the return value from 'ReactDOM.render'." },
+		docs: { description: "Replaces usage of 'ReactDOM.render()' with 'createRoot(node).render()'." },
+		fixable: "code",
+		messages: { default: "[Deprecated] Use 'createRoot(node).render()' instead." },
 		schema: []
 	},
 	name: RULE_NAME$8,
@@ -482,19 +468,23 @@ var no_render_return_value_default = createRule({
 	defaultOptions: []
 });
 function create$8(context) {
+	if (!context.sourceCode.text.includes("render")) return {};
+	if (compare(getSettingsFromContext(context).version, "18.0.0", "<")) return {};
 	const reactDomNames = new Set(["ReactDOM", "ReactDOM"]);
 	const renderNames = /* @__PURE__ */ new Set();
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			switch (true) {
-				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name) && banParentTypes.includes(node.parent.type):
+				case node.callee.type === AST_NODE_TYPES.Identifier && renderNames.has(node.callee.name):
 					context.report({
+						fix: getFix$1(context, node),
 						messageId: "default",
 						node
 					});
 					return;
-				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name) && banParentTypes.includes(node.parent.type):
+				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "render" && reactDomNames.has(node.callee.object.name):
 					context.report({
+						fix: getFix$1(context, node),
 						messageId: "default",
 						node
 					});
@@ -515,11 +505,25 @@ function create$8(context) {
 					continue;
 			}
 		}
+	});
+}
+/**
+* Provides a fixer function to replace `render(app, container)` with `createRoot(container).render(app)`
+* @param context The rule context
+* @param node The `CallExpression` node to fix
+* @returns A fixer function or null if the fix cannot be applied
+*/
+function getFix$1(context, node) {
+	const getText = (n) => context.sourceCode.getText(n);
+	return (fixer) => {
+		const [arg0, arg1] = node.arguments;
+		if (arg0 == null || arg1 == null) return null;
+		return [fixer.insertTextBefore(context.sourceCode.ast, "import { createRoot } from \"react-dom/client\";\n"), fixer.replaceText(node, `createRoot(${getText(arg1)}).render(${getText(arg0)})`)];
 	};
 }
 
 //#endregion
-//#region src/rules/no-script-url.ts
+//#region src/rules/no-script-url/no-script-url.ts
 const RULE_NAME$7 = "no-script-url";
 var no_script_url_default = createRule({
 	meta: {
@@ -533,18 +537,19 @@ var no_script_url_default = createRule({
 	defaultOptions: []
 });
 function create$7(context) {
-	return { JSXAttribute(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXAttribute(node) {
 		if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.value == null) return;
-		const value = core.resolveJsxAttributeValue(context, node).toStatic();
+		const value = jsx.resolveAttributeValue(node).toStatic();
 		if (typeof value === "string" && RE_JAVASCRIPT_PROTOCOL.test(value)) context.report({
 			messageId: "default",
 			node: node.value
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-string-style-prop.ts
+//#region src/rules/no-string-style-prop/no-string-style-prop.ts
 const RULE_NAME$6 = "no-string-style-prop";
 var no_string_style_prop_default = createRule({
 	meta: {
@@ -558,20 +563,21 @@ var no_string_style_prop_default = createRule({
 	defaultOptions: []
 });
 function create$6(context) {
-	return { JSXElement(node) {
-		if (!core.isJsxHostElement(context, node)) return;
-		const styleProp = core.getJsxAttribute(context, node)("style");
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
+		if (!jsx.isHostElement(node)) return;
+		const styleProp = jsx.findAttribute(node, "style");
 		if (styleProp == null) return;
-		const styleValue = core.resolveJsxAttributeValue(context, styleProp);
+		const styleValue = jsx.resolveAttributeValue(styleProp);
 		if (typeof styleValue.toStatic() === "string") context.report({
 			messageId: "default",
 			node: styleValue.node ?? styleProp
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-unknown-property.ts
+//#region src/rules/no-unknown-property/no-unknown-property.ts
 const RULE_NAME$5 = "no-unknown-property";
 const DEFAULTS = {
 	ignore: [],
@@ -679,7 +685,6 @@ const SVGDOM_ATTRIBUTE_NAMES = {
 * Map of attributes that are only valid on specific HTML tags
 */
 const ATTRIBUTE_TAGS_MAP = {
-	as: ["link"],
 	abbr: ["th", "td"],
 	align: [
 		"applet",
@@ -698,6 +703,7 @@ const ATTRIBUTE_TAGS_MAP = {
 		"tr"
 	],
 	allowFullScreen: ["iframe", "video"],
+	as: ["link"],
 	autoPictureInPicture: ["video"],
 	charset: ["meta"],
 	checked: ["input"],
@@ -1562,9 +1568,9 @@ function tagNameHasDot(node) {
 * @returns Standard name or undefined
 */
 function getStandardName(name, context) {
-	if (has(DOM_ATTRIBUTE_NAMES, name)) return DOM_ATTRIBUTE_NAMES[name];
-	if (has(SVGDOM_ATTRIBUTE_NAMES, name)) return SVGDOM_ATTRIBUTE_NAMES[name];
-	return getDOMPropertyNames(context).find((element) => element.toLowerCase() === name.toLowerCase());
+	if (has(DOM_ATTRIBUTE_NAMES, name)) return DOM_ATTRIBUTE_NAMES[name] ?? null;
+	if (has(SVGDOM_ATTRIBUTE_NAMES, name)) return SVGDOM_ATTRIBUTE_NAMES[name] ?? null;
+	return getDOMPropertyNames(context).find((element) => element.toLowerCase() === name.toLowerCase()) ?? null;
 }
 /**
 * Check if an object has a property
@@ -1646,20 +1652,20 @@ function create$5(context) {
 	function getRequireDataLowercase() {
 		return context.options[0]?.requireDataLowercase ?? DEFAULTS.requireDataLowercase;
 	}
-	return { JSXAttribute(node) {
+	return defineRuleListener({ JSXAttribute(node) {
 		const ignoreNames = getIgnoreConfig();
 		const actualName = getText(context, node.name);
-		if (ignoreNames.indexOf(actualName) >= 0) return;
+		if (ignoreNames.includes(actualName)) return;
 		const name = normalizeAttributeCase(actualName);
 		if (tagNameHasDot(node)) return;
 		if (isValidDataAttribute(name)) {
 			if (getRequireDataLowercase() && hasUpperCaseCharacter(name)) context.report({
-				messageId: "dataLowercaseRequired",
-				node,
 				data: {
 					name: actualName,
 					lowerCaseName: actualName.toLowerCase()
-				}
+				},
+				messageId: "dataLowercaseRequired",
+				node
 			});
 			return;
 		}
@@ -1669,14 +1675,14 @@ function create$5(context) {
 		if (!isValidHTMLTagInJSX(node)) return;
 		const allowedTags = has(ATTRIBUTE_TAGS_MAP, name) ? ATTRIBUTE_TAGS_MAP[name] : null;
 		if (tagName != null && allowedTags != null) {
-			if (allowedTags.indexOf(tagName) === -1) context.report({
-				messageId: "invalidPropOnTag",
-				node,
+			if (!allowedTags.includes(tagName)) context.report({
 				data: {
 					name: actualName,
 					allowedTags: allowedTags.join(", "),
 					tagName
-				}
+				},
+				messageId: "invalidPropOnTag",
+				node
 			});
 			return;
 		}
@@ -1685,28 +1691,28 @@ function create$5(context) {
 		if (standardName != null && standardName === name) return;
 		if (hasStandardNameButIsNotUsed) {
 			context.report({
-				messageId: "unknownPropWithStandardName",
-				node,
 				data: {
 					name: actualName,
 					standardName
 				},
 				fix(fixer) {
 					return fixer.replaceText(node.name, standardName);
-				}
+				},
+				messageId: "unknownPropWithStandardName",
+				node
 			});
 			return;
 		}
 		context.report({
+			data: { name: actualName },
 			messageId: "unknownProp",
-			node,
-			data: { name: actualName }
+			node
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-unsafe-iframe-sandbox.ts
+//#region src/rules/no-unsafe-iframe-sandbox/no-unsafe-iframe-sandbox.ts
 const RULE_NAME$4 = "no-unsafe-iframe-sandbox";
 const UNSAFE_SANDBOX_VALUES = ["allow-scripts", "allow-same-origin"];
 /**
@@ -1733,20 +1739,21 @@ var no_unsafe_iframe_sandbox_default = createRule({
 });
 function create$4(context) {
 	const resolver = createJsxElementResolver(context);
-	return { JSXElement(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
 		if (resolver.resolve(node).domElementType !== "iframe") return;
-		const sandboxProp = core.getJsxAttribute(context, node)("sandbox");
+		const sandboxProp = jsx.findAttribute(node, "sandbox");
 		if (sandboxProp == null) return;
-		const sandboxValue = core.resolveJsxAttributeValue(context, sandboxProp);
-		if (isUnsafeSandboxCombination(sandboxValue.toStatic("sandbox"))) context.report({
+		const sandboxValue = jsx.resolveAttributeValue(sandboxProp);
+		if (isUnsafeSandboxCombination(sandboxValue.kind === "spreadProps" ? sandboxValue.getProperty("sandbox") : sandboxValue.toStatic())) context.report({
 			messageId: "default",
 			node: sandboxValue.node ?? sandboxProp
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-unsafe-target-blank.ts
+//#region src/rules/no-unsafe-target-blank/no-unsafe-target-blank.ts
 const RULE_NAME$3 = "no-unsafe-target-blank";
 /**
 * Check if a value appears to be an external link.
@@ -1786,46 +1793,50 @@ var no_unsafe_target_blank_default = createRule({
 });
 function create$3(context) {
 	const resolver = createJsxElementResolver(context);
-	return { JSXElement(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
 		const { domElementType } = resolver.resolve(node);
 		if (domElementType !== "a") return;
-		const findAttribute = core.getJsxAttribute(context, node);
+		const findAttribute = (name) => jsx.findAttribute(node, name);
 		const targetProp = findAttribute("target");
 		if (targetProp == null) return;
-		if (core.resolveJsxAttributeValue(context, targetProp).toStatic("target") !== "_blank") return;
+		const targetValue = jsx.resolveAttributeValue(targetProp);
+		if ((targetValue.kind === "spreadProps" ? targetValue.getProperty("target") : targetValue.toStatic()) !== "_blank") return;
 		const hrefProp = findAttribute("href");
 		if (hrefProp == null) return;
-		if (!isExternalLinkLike(core.resolveJsxAttributeValue(context, hrefProp).toStatic("href"))) return;
+		const hrefValue = jsx.resolveAttributeValue(hrefProp);
+		if (!isExternalLinkLike(hrefValue.kind === "spreadProps" ? hrefValue.getProperty("href") : hrefValue.toStatic())) return;
 		const relProp = findAttribute("rel");
 		if (relProp == null) {
 			context.report({
 				messageId: "default",
 				node: node.openingElement,
 				suggest: [{
-					messageId: "addRelNoreferrerNoopener",
 					fix(fixer) {
 						return fixer.insertTextAfter(node.openingElement.name, ` rel="noreferrer noopener"`);
-					}
+					},
+					messageId: "addRelNoreferrerNoopener"
 				}]
 			});
 			return;
 		}
-		if (isSafeRel(core.resolveJsxAttributeValue(context, relProp).toStatic("rel"))) return;
+		const relValue = jsx.resolveAttributeValue(relProp);
+		if (isSafeRel(relValue.kind === "spreadProps" ? relValue.getProperty("rel") : relValue.toStatic())) return;
 		context.report({
 			messageId: "default",
 			node: relProp,
 			suggest: [{
-				messageId: "addRelNoreferrerNoopener",
 				fix(fixer) {
 					return fixer.replaceText(relProp, `rel="noreferrer noopener"`);
-				}
+				},
+				messageId: "addRelNoreferrerNoopener"
 			}]
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/no-use-form-state.ts
+//#region src/rules/no-use-form-state/no-use-form-state.ts
 const RULE_NAME$2 = "no-use-form-state";
 var no_use_form_state_default = createRule({
 	meta: {
@@ -1844,21 +1855,21 @@ function create$2(context) {
 	if (compare(getSettingsFromContext(context).version, "19.0.0", "<")) return {};
 	const reactDomNames = /* @__PURE__ */ new Set();
 	const useFormStateNames = /* @__PURE__ */ new Set();
-	return {
+	return defineRuleListener({
 		CallExpression(node) {
 			switch (true) {
 				case node.callee.type === AST_NODE_TYPES.Identifier && useFormStateNames.has(node.callee.name):
 					context.report({
+						fix: getFix(context, node),
 						messageId: "default",
-						node,
-						fix: getFix(context, node)
+						node
 					});
 					return;
 				case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "useFormState" && reactDomNames.has(node.callee.object.name):
 					context.report({
+						fix: getFix(context, node),
 						messageId: "default",
-						node,
-						fix: getFix(context, node)
+						node
 					});
 					return;
 			}
@@ -1877,7 +1888,7 @@ function create$2(context) {
 					continue;
 			}
 		}
-	};
+	});
 }
 function getFix(context, node) {
 	const { importSource } = getSettingsFromContext(context);
@@ -1887,7 +1898,7 @@ function getFix(context, node) {
 }
 
 //#endregion
-//#region src/rules/no-void-elements-with-children.ts
+//#region src/rules/no-void-elements-with-children/no-void-elements-with-children.ts
 const RULE_NAME$1 = "no-void-elements-with-children";
 const voidElements = new Set([
 	"area",
@@ -1920,26 +1931,26 @@ var no_void_elements_with_children_default = createRule({
 });
 function create$1(context) {
 	const resolver = createJsxElementResolver(context);
-	return { JSXElement(node) {
+	const jsx = JsxInspector.from(context);
+	return defineRuleListener({ JSXElement(node) {
 		const { domElementType } = resolver.resolve(node);
 		if (!voidElements.has(domElementType)) return;
-		const findJsxAttribute = core.getJsxAttribute(context, node);
-		const hasChildrenProp = findJsxAttribute("children") != null;
-		const hasDangerouslySetInnerHTML = findJsxAttribute("dangerouslySetInnerHTML") != null;
+		const hasChildrenProp = jsx.hasAttribute(node, "children");
+		const hasDangerouslySetInnerHTML = jsx.hasAttribute(node, "dangerouslySetInnerHTML");
 		if (node.children.length > 0 || hasChildrenProp || hasDangerouslySetInnerHTML) context.report({
+			data: { elementType: domElementType },
 			messageId: "default",
-			node,
-			data: { elementType: domElementType }
+			node
 		});
-	} };
+	} });
 }
 
 //#endregion
-//#region src/rules/prefer-namespace-import.ts
+//#region src/rules/prefer-namespace-import/prefer-namespace-import.ts
 const RULE_NAME = "prefer-namespace-import";
 var prefer_namespace_import_default = createRule({
 	meta: {
-		type: "problem",
+		type: "suggestion",
 		docs: { description: "Enforces importing React DOM via a namespace import." },
 		fixable: "code",
 		messages: { default: "Prefer importing React DOM via a namespace import." },
@@ -1955,13 +1966,11 @@ const importSources = [
 	"react-dom/server"
 ];
 function create(context) {
-	return { [`ImportDeclaration ImportDefaultSpecifier`](node) {
+	return defineRuleListener({ [`ImportDeclaration ImportDefaultSpecifier`](node) {
 		const importSource = node.parent.source.value;
 		if (!importSources.includes(importSource)) return;
 		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
 		context.report({
-			messageId: "default",
-			node: hasOtherSpecifiers ? node : node.parent,
 			data: { importSource },
 			fix(fixer) {
 				const importDeclarationText = context.sourceCode.getText(node.parent);
@@ -1972,9 +1981,11 @@ function create(context) {
 				if (!hasOtherSpecifiers) return fixer.replaceText(node.parent, `${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`);
 				const specifiers = importDeclarationText.slice(importDeclarationText.indexOf("{"), importDeclarationText.indexOf("}") + 1);
 				return fixer.replaceText(node.parent, [`${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`, `${importStringPrefix} ${specifiers} from ${importSourceQuoted}${semi}`].join("\n"));
-			}
+			},
+			messageId: "default",
+			node: hasOtherSpecifiers ? node : node.parent
 		});
-	} };
+	} });
 }
 
 //#endregion
@@ -2052,14 +2063,13 @@ const settings = { ...settings$1 };
 
 //#endregion
 //#region src/index.ts
-const { toFlatConfig } = getConfigAdapters("react-dom", plugin);
-var src_default = {
+const finalPlugin = {
 	...plugin,
 	configs: {
-		["recommended"]: toFlatConfig(recommended_exports),
-		["strict"]: toFlatConfig(strict_exports)
+		["recommended"]: recommended_exports,
+		["strict"]: strict_exports
 	}
 };
 
 //#endregion
-export { src_default as default };
+export { finalPlugin as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-dom",
-  "version": "3.0.0-beta.7",
+  "version": "3.0.0-beta.71",
   "description": "ESLint React's ESLint plugin for DOM related rules.",
   "keywords": [
     "react",
@@ -43,16 +43,17 @@
     "@typescript-eslint/utils": "canary",
     "compare-versions": "^6.1.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-beta.7",
-    "@eslint-react/core": "3.0.0-beta.7",
-    "@eslint-react/eff": "3.0.0-beta.7",
-    "@eslint-react/shared": "3.0.0-beta.7",
-    "@eslint-react/var": "3.0.0-beta.7"
+    "@eslint-react/ast": "3.0.0-beta.71",
+    "@eslint-react/eff": "3.0.0-beta.71",
+    "@eslint-react/core": "3.0.0-beta.71",
+    "@eslint-react/shared": "3.0.0-beta.71",
+    "@eslint-react/var": "3.0.0-beta.71"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "tsdown": "^0.20.3",
+    "eslint": "^10.0.2",
+    "tsdown": "^0.21.0-beta.2",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
@@ -68,6 +69,6 @@
   "scripts": {
     "build": "tsdown",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }