eslint-plugin-react-dom 2.0.4 → 2.0.5-beta.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { DEFAULT_ESLINT_REACT_SETTINGS, getConfigAdapters, getDocsUrl, getSettingsFromContext } from "@eslint-react/shared";
-import { getAttribute, getElementType, hasAttribute, isHostElement, isJsxText, resolveAttributeValue } from "@eslint-react/core";
+import { getJsxAttribute, getJsxElementType, hasJsxAttribute, isJsxHostElement, isJsxText, resolveJsxAttributeValue } from "@eslint-react/core";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { compare } from "compare-versions";
@@ -47,7 +47,7 @@ const settings = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
 //#endregion
 //#region package.json
 var name = "eslint-plugin-react-dom";
-var version = "2.0.4";
+var version = "2.0.5-beta.0";
 
 //#endregion
 //#region src/utils/create-jsx-element-resolver.ts
@@ -65,15 +65,15 @@ var version = "2.0.4";
 function createJsxElementResolver(context) {
 	const { polymorphicPropName } = getSettingsFromContext(context);
 	return { resolve(node) {
-		const elementName = getElementType(context, node);
+		const elementName = getJsxElementType(context, node);
 		const result = {
 			domElementType: elementName,
 			jsxElementType: elementName
 		};
 		if (elementName === elementName.toLowerCase() || polymorphicPropName == null) return result;
-		const polymorphicProp = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(polymorphicPropName);
+		const polymorphicProp = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(polymorphicPropName);
 		if (polymorphicProp != null) {
-			const staticValue = resolveAttributeValue(context, polymorphicProp).toStatic(polymorphicPropName);
+			const staticValue = resolveJsxAttributeValue(context, polymorphicProp).toStatic(polymorphicPropName);
 			if (typeof staticValue === "string") return {
 				...result,
 				domElementType: staticValue
@@ -91,6 +91,7 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl("dom"));
 //#region src/rules/no-dangerously-set-innerhtml.ts
 const RULE_NAME$17 = "no-dangerously-set-innerhtml";
 const RULE_FEATURES$16 = [];
+const DSIH$1 = "dangerouslySetInnerHTML";
 var no_dangerously_set_innerhtml_default = createRule({
 	meta: {
 		type: "problem",
@@ -105,15 +106,14 @@ var no_dangerously_set_innerhtml_default = createRule({
 	create: create$17,
 	defaultOptions: []
 });
-const dangerouslySetInnerHTML$1 = "dangerouslySetInnerHTML";
 function create$17(context) {
-	if (!context.sourceCode.text.includes(dangerouslySetInnerHTML$1)) return {};
+	if (!context.sourceCode.text.includes(DSIH$1)) return {};
 	return { JSXElement(node) {
-		const attribute = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(dangerouslySetInnerHTML$1);
-		if (attribute == null) return;
+		const attr = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(DSIH$1);
+		if (attr == null) return;
 		context.report({
 			messageId: "noDangerouslySetInnerhtml",
-			node: attribute
+			node: attr
 		});
 	} };
 }
@@ -136,36 +136,36 @@ var no_dangerously_set_innerhtml_with_children_default = createRule({
 	create: create$16,
 	defaultOptions: []
 });
-const dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
-function create$16(context) {
-	if (!context.sourceCode.text.includes(dangerouslySetInnerHTML)) return {};
-	return { JSXElement(node) {
-		const attributes = node.openingElement.attributes;
-		const initialScope = context.sourceCode.getScope(node);
-		if ((node.children.some(isSignificantChildren) || hasAttribute(context, "children", attributes, initialScope)) && hasAttribute(context, dangerouslySetInnerHTML, attributes, initialScope)) context.report({
-			messageId: "noDangerouslySetInnerhtmlWithChildren",
-			node
-		});
-	} };
-}
+const DSIH = "dangerouslySetInnerHTML";
 /**
-* Check if a Literal or JSXText node is whitespace
-* @param node The AST node to check
-* @returns boolean `true` if the node is whitespace
+* Checks 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 isWhiteSpace(node) {
-	return typeof node.value === "string" && node.raw.trim() === "";
+function isSignificantChildren(node) {
+	if (!isJsxText(node)) return true;
+	return !(node.raw.trim() === "" && node.raw.includes("\n"));
 }
 /**
-* Check if a Literal or JSXText node is padding spaces
-* @param node The AST node to check
-* @returns boolean
+* Checks if a JSX element has children, either through the `children` prop or as JSX children.
+* @param context The rule context.
+* @param node The JSX element to check.
+* @returns `true` if the element has children, `false` otherwise.
 */
-function isPaddingSpaces(node) {
-	return isJsxText(node) && isWhiteSpace(node) && node.raw.includes("\n");
+function hasChildren(context, node) {
+	if (getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("children") != null) return true;
+	return node.children.some(isSignificantChildren);
 }
-function isSignificantChildren(node) {
-	return node.type !== AST_NODE_TYPES.JSXText || !isPaddingSpaces(node);
+function create$16(context) {
+	if (!context.sourceCode.text.includes(DSIH)) return {};
+	return { JSXElement(node) {
+		const DSIHAttr = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))(DSIH);
+		if (DSIHAttr == null) return;
+		if (hasChildren(context, node)) context.report({
+			messageId: "noDangerouslySetInnerhtmlWithChildren",
+			node: DSIHAttr
+		});
+	} };
 }
 
 //#endregion
@@ -348,25 +348,19 @@ var no_missing_button_type_default = createRule({
 function create$12(context) {
 	const resolver = createJsxElementResolver(context);
 	return { JSXElement(node) {
-		const { domElementType } = resolver.resolve(node);
-		if (domElementType !== "button") return;
-		if (getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("type") != null) return;
+		if (resolver.resolve(node).domElementType !== "button") return;
+		if (getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("type") != null) return;
 		context.report({
 			messageId: "noMissingButtonType",
 			node: node.openingElement,
-			suggest: getSuggest((type) => (fixer) => {
-				return fixer.insertTextAfter(node.openingElement.name, ` type="${type}"`);
-			})
+			suggest: BUTTON_TYPES.map((type) => ({
+				messageId: "addButtonType",
+				data: { type },
+				fix: (fixer) => fixer.insertTextAfter(node.openingElement.name, ` type="${type}"`)
+			}))
 		});
 	} };
 }
-function getSuggest(getFix$3) {
-	return BUTTON_TYPES.map((type) => ({
-		messageId: "addButtonType",
-		data: { type },
-		fix: getFix$3(type)
-	}));
-}
 
 //#endregion
 //#region src/rules/no-missing-iframe-sandbox.ts
@@ -396,8 +390,8 @@ function create$11(context) {
 	return { JSXElement(node) {
 		const { domElementType } = resolver.resolve(node);
 		if (domElementType !== "iframe") return;
-		const sandboxAttribute = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
-		if (sandboxAttribute == null) {
+		const sandboxAttr = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
+		if (sandboxAttr == null) {
 			context.report({
 				messageId: "noMissingIframeSandbox",
 				node: node.openingElement,
@@ -411,17 +405,17 @@ function create$11(context) {
 			});
 			return;
 		}
-		const sandboxAttributeValue = resolveAttributeValue(context, sandboxAttribute);
-		if (typeof sandboxAttributeValue.toStatic("sandbox") === "string") return;
+		const sandboxValue = resolveJsxAttributeValue(context, sandboxAttr);
+		if (typeof sandboxValue.toStatic("sandbox") === "string") return;
 		context.report({
 			messageId: "noMissingIframeSandbox",
-			node: sandboxAttributeValue.node ?? sandboxAttribute,
+			node: sandboxValue.node ?? sandboxAttr,
 			suggest: [{
 				messageId: "addIframeSandbox",
 				data: { value: "" },
 				fix(fixer) {
-					if (sandboxAttributeValue.kind.startsWith("spread")) return null;
-					return fixer.replaceText(sandboxAttribute, `sandbox=""`);
+					if (sandboxValue.kind.startsWith("spread")) return null;
+					return fixer.replaceText(sandboxAttr, `sandbox=""`);
 				}
 			}]
 		});
@@ -448,7 +442,7 @@ var no_namespace_default = createRule({
 });
 function create$10(context) {
 	return { JSXElement(node) {
-		const name$2 = getElementType(context, node);
+		const name$2 = getJsxElementType(context, node);
 		if (typeof name$2 !== "string" || !name$2.includes(":")) return;
 		context.report({
 			messageId: "noNamespace",
@@ -610,7 +604,7 @@ var no_script_url_default = createRule({
 function create$7(context) {
 	return { JSXAttribute(node) {
 		if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.value == null) return;
-		const value = resolveAttributeValue(context, node).toStatic();
+		const value = resolveJsxAttributeValue(context, node).toStatic();
 		if (typeof value === "string" && RE_JAVASCRIPT_PROTOCOL.test(value)) context.report({
 			messageId: "noScriptUrl",
 			node: node.value
@@ -638,13 +632,13 @@ var no_string_style_prop_default = createRule({
 });
 function create$6(context) {
 	return { JSXElement(node) {
-		if (!isHostElement(context, node)) return;
-		const attribute = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("style");
-		if (attribute == null) return;
-		const attributeValue = resolveAttributeValue(context, attribute);
-		if (typeof attributeValue.toStatic() === "string") context.report({
+		if (!isJsxHostElement(context, node)) return;
+		const styleAttr = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("style");
+		if (styleAttr == null) return;
+		const styleValue = resolveJsxAttributeValue(context, styleAttr);
+		if (typeof styleValue.toStatic() === "string") context.report({
 			messageId: "noStringStyleProp",
-			node: attributeValue.node ?? attribute
+			node: styleValue.node ?? styleAttr
 		});
 	} };
 }
@@ -1787,12 +1781,15 @@ function create$5(context) {
 //#region src/rules/no-unsafe-iframe-sandbox.ts
 const RULE_NAME$4 = "no-unsafe-iframe-sandbox";
 const RULE_FEATURES$4 = [];
-const unsafeSandboxValues = [["allow-scripts", "allow-same-origin"]];
-function isSafeSandbox(value) {
+const UNSAFE_SANDBOX_VALUES = ["allow-scripts", "allow-same-origin"];
+/**
+* Checks if the sandbox attribute value contains an unsafe combination.
+* @param value The value of the sandbox attribute.
+* @returns `true` if the value is a string and contains an unsafe combination, `false` otherwise.
+*/
+function isUnsafeSandboxCombination(value) {
 	if (typeof value !== "string") return false;
-	return !unsafeSandboxValues.some((values) => {
-		return values.every((v) => value.includes(v));
-	});
+	return UNSAFE_SANDBOX_VALUES.every((v) => value.includes(v));
 }
 var no_unsafe_iframe_sandbox_default = createRule({
 	meta: {
@@ -1811,15 +1808,14 @@ var no_unsafe_iframe_sandbox_default = createRule({
 function create$4(context) {
 	const resolver = createJsxElementResolver(context);
 	return { JSXElement(node) {
-		const { domElementType } = resolver.resolve(node);
-		if (domElementType !== "iframe") return;
-		const sandboxAttribute = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
-		if (sandboxAttribute == null) return;
-		const sandboxValue = resolveAttributeValue(context, sandboxAttribute);
+		if (resolver.resolve(node).domElementType !== "iframe") return;
+		const sandboxAttr = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node))("sandbox");
+		if (sandboxAttr == null) return;
+		const sandboxValue = resolveJsxAttributeValue(context, sandboxAttr);
 		const sandboxValueStatic = sandboxValue.toStatic("sandbox");
-		if (!isSafeSandbox(sandboxValueStatic)) context.report({
+		if (isUnsafeSandboxCombination(sandboxValueStatic)) context.report({
 			messageId: "noUnsafeIframeSandbox",
-			node: sandboxValue.node ?? sandboxAttribute
+			node: sandboxValue.node ?? sandboxAttr
 		});
 	} };
 }
@@ -1872,15 +1868,15 @@ function create$3(context) {
 	return { JSXElement(node) {
 		const { domElementType } = resolver.resolve(node);
 		if (domElementType !== "a") return;
-		const getAttributeEx = getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node));
-		const targetAttribute = getAttributeEx("target");
+		const findAttribute = getJsxAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node));
+		const targetAttribute = findAttribute("target");
 		if (targetAttribute == null) return;
-		if (resolveAttributeValue(context, targetAttribute).toStatic("target") !== "_blank") return;
-		const hrefAttribute = getAttributeEx("href");
+		if (resolveJsxAttributeValue(context, targetAttribute).toStatic("target") !== "_blank") return;
+		const hrefAttribute = findAttribute("href");
 		if (hrefAttribute == null) return;
-		const hrefAttributeValue = resolveAttributeValue(context, hrefAttribute).toStatic("href");
+		const hrefAttributeValue = resolveJsxAttributeValue(context, hrefAttribute).toStatic("href");
 		if (!isExternalLinkLike(hrefAttributeValue)) return;
-		const relAttribute = getAttributeEx("rel");
+		const relAttribute = findAttribute("rel");
 		if (relAttribute == null) {
 			context.report({
 				messageId: "noUnsafeTargetBlank",
@@ -1894,7 +1890,7 @@ function create$3(context) {
 			});
 			return;
 		}
-		const relAttributeValue = resolveAttributeValue(context, relAttribute).toStatic("rel");
+		const relAttributeValue = resolveJsxAttributeValue(context, relAttribute).toStatic("rel");
 		if (isSafeRel(relAttributeValue)) return;
 		context.report({
 			messageId: "noUnsafeTargetBlank",
@@ -2016,16 +2012,12 @@ function create$1(context) {
 	const resolver = createJsxElementResolver(context);
 	return { JSXElement(node) {
 		const { domElementType: elementName } = resolver.resolve(node);
-		if (elementName.length === 0 || !voidElements.has(elementName)) return;
-		if (node.children.length > 0) context.report({
-			messageId: "noVoidElementsWithChildren",
-			node,
-			data: { element: elementName }
-		});
+		if (!voidElements.has(elementName)) return;
 		const { attributes } = node.openingElement;
 		const initialScope = context.sourceCode.getScope(node);
-		const hasAttributeEx = (name$2) => hasAttribute(context, name$2, attributes, initialScope);
-		if (hasAttributeEx("children") || hasAttributeEx("dangerouslySetInnerHTML")) context.report({
+		const hasChildrenProp = hasJsxAttribute(context, "children", attributes, initialScope);
+		const hasDangerouslySetInnerHTML = hasJsxAttribute(context, "dangerouslySetInnerHTML", attributes, initialScope);
+		if (node.children.length > 0 || hasChildrenProp || hasDangerouslySetInnerHTML) context.report({
 			messageId: "noVoidElementsWithChildren",
 			node,
 			data: { element: elementName }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-dom",
-  "version": "2.0.4",
+  "version": "2.0.5-beta.0",
   "description": "ESLint React's ESLint plugin for React DOM related rules.",
   "keywords": [
     "react",
@@ -41,17 +41,17 @@
     "compare-versions": "^6.1.1",
     "string-ts": "^2.2.1",
     "ts-pattern": "^5.8.0",
-    "@eslint-react/ast": "2.0.4",
-    "@eslint-react/eff": "2.0.4",
-    "@eslint-react/shared": "2.0.4",
-    "@eslint-react/kit": "2.0.4",
-    "@eslint-react/core": "2.0.4",
-    "@eslint-react/var": "2.0.4"
+    "@eslint-react/ast": "2.0.5-beta.0",
+    "@eslint-react/core": "2.0.5-beta.0",
+    "@eslint-react/shared": "2.0.5-beta.0",
+    "@eslint-react/eff": "2.0.5-beta.0",
+    "@eslint-react/kit": "2.0.5-beta.0",
+    "@eslint-react/var": "2.0.5-beta.0"
   },
   "devDependencies": {
-    "@types/react": "^19.1.15",
+    "@types/react": "^19.1.16",
     "@types/react-dom": "^19.1.9",
-    "tsdown": "^0.15.5",
+    "tsdown": "^0.15.6",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {