@eslint-react/jsx 5.8.9 → 5.8.11

package/dist/index.d.ts

@@ -218,15 +218,21 @@ declare function getAttributeValue(context: RuleContext, element: TSESTree.JSXEl
  * Filters out nodes that React will not render into the DOM:
  *
  * 1. "Padding spaces" — `JSXText` nodes that consist entirely of whitespace
- *    and contain at least one newline. These are code-formatting artefacts
- *    (indentation between tags). While React's client renderer preserves them
- *    as text nodes, browser HTML parsers may discard them during hydration,
- *    causing hydration mismatches.
+ *    and contain at least one newline (see {@link isWhitespace}). These are
+ *    code-formatting artefacts (indentation between tags). While React's client
+ *    renderer preserves them as text nodes, browser HTML parsers may discard
+ *    them during hydration, causing hydration mismatches.
  *
  * 2. Empty string expressions — `JSXExpressionContainer` nodes whose expression
- *    is a string literal with value `""`. React's reconciler and SSR renderer
- *    explicitly skip empty strings, producing no DOM node
- *    (see ReactChildFiber.js and ReactFizzConfigDOM.js).
+ *    is a string literal with value `""` (see {@link isEmptyStringExpression}).
+ *    React's reconciler and SSR renderer explicitly skip empty strings,
+ *    producing no DOM node.
+ *
+ * Whitespace-only text **without** a newline (e.g. the single space in
+ * `<div> </div>`) is intentionally **kept**, because React renders it. For
+ * this reason `getChildren(node).length > 0` is **not** equivalent to
+ * {@link hasChildren}, which applies a stricter "any whitespace-only text is
+ * non-meaningful" heuristic. Pick the one that matches your rule's intent.
  *
  * @param element - A `JSXElement` or `JSXFragment` node.
  * @returns An array of children nodes that contribute to rendered output.
@@ -340,6 +346,13 @@ declare function hasAttribute(context: RuleContext, element: TSESTree.JSXElement
  * non-meaningful because React's reconciler and SSR renderer explicitly skip
  * empty strings, producing no DOM node.
  *
+ * Unlike {@link getChildren} — which only filters whitespace that contains a
+ * newline — this check treats **any** whitespace-only text as non-meaningful
+ * (see {@link isWhitespaceText}). As a result `hasChildren(node)` is **not**
+ * always equal to `getChildren(node).length > 0`: they differ for
+ * whitespace-only children that have no newline, such as `<div> </div>` or
+ * `<div>\t\t</div>`. Choose the API that matches your rule's intent.
+ *
  * @param element - A `JSXElement` or `JSXFragment` node.
  * @returns `true` when the element has at least one meaningful child.
  *
@@ -529,6 +542,28 @@ declare function isWhitespace(node: TSESTree.JSXChild): boolean;
  * @returns `true` when the node is a whitespace‑only `JSXText`.
  */
 declare function isWhitespaceText(node: TSESTree.JSXChild): boolean;
+/**
+ * Check whether a JSX child node is an **empty string expression** (`{""}`).
+ *
+ * React's reconciler and SSR renderer explicitly skip empty strings,
+ * producing no DOM node (see `ReactChildFiber.js` and `ReactFizzConfigDOM.js`).
+ * Such expressions are therefore treated as non-rendered children, in the same
+ * way as whitespace padding.
+ *
+ * @param node - A JSX child node.
+ * @returns `true` when the node is a `{""}` expression container.
+ *
+ * @example
+ * ```ts
+ * import { isEmptyStringExpression } from "@eslint-react/jsx";
+ *
+ * // <div>{""}</div> -> the expression container is an empty string expression
+ * const meaningful = element.children.filter(
+ *   (child) => !isEmptyStringExpression(child),
+ * );
+ * ```
+ */
+declare function isEmptyStringExpression(node: TSESTree.JSXChild): boolean;
 //#endregion
 //#region src/jsx-detection-hint.d.ts
 /**
@@ -597,4 +632,4 @@ declare const DEFAULT_JSX_DETECTION_HINT: JsxDetectionHint;
  */
 declare function resolveAttributeValue(context: RuleContext, attribute: TSESTreeJSXAttributeLike): JsxAttributeValue;
 //#endregion
-export { DEFAULT_JSX_DETECTION_HINT, ElementTest, JsxAttributeValue, JsxDetectionHint, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isElement, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };
+export { DEFAULT_JSX_DETECTION_HINT, ElementTest, JsxAttributeValue, JsxDetectionHint, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };

package/dist/index.js

@@ -292,6 +292,84 @@ function getAttributeValue(context, element, name) {
 	return resolveAttributeValue(context, attr);
 }
 
+//#endregion
+//#region src/is-whitespace.ts
+/**
+* Check whether a JSX child node is **whitespace padding** that React would
+* trim away during rendering.
+*
+* A child is considered whitespace padding when it is a `JSXText` node whose
+* raw content is empty after trimming **and** contains at least one newline.
+* This is the whitespace that appears between JSX tags purely for formatting:
+*
+* ```jsx
+* <div>
+*   <span />     ← the text between </span> and the next tag is padding
+*   <span />
+* </div>
+* ```
+*
+* Use {@link isWhitespaceText} for a looser check that also matches
+* whitespace‑only text that does **not** contain a newline.
+*
+* @param node - A JSX child node.
+* @returns `true` when the node is purely formatting whitespace.
+*
+* @example
+* ```ts
+* import { isWhitespace } from "@eslint-react/jsx";
+*
+* const meaningful = element.children.filter(
+*   (child) => !isWhitespace(child),
+* );
+* ```
+*/
+function isWhitespace(node) {
+	if (node.type !== AST_NODE_TYPES.JSXText) return false;
+	return node.raw.trim() === "" && node.raw.includes("\n");
+}
+/**
+* Check whether a JSX child node is **any** whitespace‑only text.
+*
+* This is a looser variant of {@link isWhitespace} — it matches every
+* `JSXText` node whose raw content is empty after trimming, regardless of
+* whether it contains a newline.
+*
+* @param node - A JSX child node.
+* @returns `true` when the node is a whitespace‑only `JSXText`.
+*/
+function isWhitespaceText(node) {
+	if (node.type !== AST_NODE_TYPES.JSXText) return false;
+	return node.raw.trim() === "";
+}
+/**
+* Check whether a JSX child node is an **empty string expression** (`{""}`).
+*
+* React's reconciler and SSR renderer explicitly skip empty strings,
+* producing no DOM node (see `ReactChildFiber.js` and `ReactFizzConfigDOM.js`).
+* Such expressions are therefore treated as non-rendered children, in the same
+* way as whitespace padding.
+*
+* @param node - A JSX child node.
+* @returns `true` when the node is a `{""}` expression container.
+*
+* @example
+* ```ts
+* import { isEmptyStringExpression } from "@eslint-react/jsx";
+*
+* // <div>{""}</div> -> the expression container is an empty string expression
+* const meaningful = element.children.filter(
+*   (child) => !isEmptyStringExpression(child),
+* );
+* ```
+*/
+function isEmptyStringExpression(node) {
+	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
+	const expr = node.expression;
+	if (expr.type !== AST_NODE_TYPES.Literal) return false;
+	return expr.value === "";
+}
+
 //#endregion
 //#region src/get-children.ts
 /**
@@ -300,15 +378,21 @@ function getAttributeValue(context, element, name) {
 * Filters out nodes that React will not render into the DOM:
 *
 * 1. "Padding spaces" — `JSXText` nodes that consist entirely of whitespace
-*    and contain at least one newline. These are code-formatting artefacts
-*    (indentation between tags). While React's client renderer preserves them
-*    as text nodes, browser HTML parsers may discard them during hydration,
-*    causing hydration mismatches.
+*    and contain at least one newline (see {@link isWhitespace}). These are
+*    code-formatting artefacts (indentation between tags). While React's client
+*    renderer preserves them as text nodes, browser HTML parsers may discard
+*    them during hydration, causing hydration mismatches.
 *
 * 2. Empty string expressions — `JSXExpressionContainer` nodes whose expression
-*    is a string literal with value `""`. React's reconciler and SSR renderer
-*    explicitly skip empty strings, producing no DOM node
-*    (see ReactChildFiber.js and ReactFizzConfigDOM.js).
+*    is a string literal with value `""` (see {@link isEmptyStringExpression}).
+*    React's reconciler and SSR renderer explicitly skip empty strings,
+*    producing no DOM node.
+*
+* Whitespace-only text **without** a newline (e.g. the single space in
+* `<div> </div>`) is intentionally **kept**, because React renders it. For
+* this reason `getChildren(node).length > 0` is **not** equivalent to
+* {@link hasChildren}, which applies a stricter "any whitespace-only text is
+* non-meaningful" heuristic. Pick the one that matches your rule's intent.
 *
 * @param element - A `JSXElement` or `JSXFragment` node.
 * @returns An array of children nodes that contribute to rendered output.
@@ -329,44 +413,11 @@ function getAttributeValue(context, element, name) {
 */
 function getChildren(element) {
 	return element.children.filter((child) => {
-		if (isPaddingSpaces(child)) return false;
-		if (isEmptyStringExpression$1(child)) return false;
+		if (isWhitespace(child)) return false;
+		if (isEmptyStringExpression(child)) return false;
 		return true;
 	});
 }
-/**
-* A `JSXText` node is considered **padding spaces** when it is purely
-* whitespace *and* contains at least one newline character.
-*
-* These nodes are code-formatting artefacts (indentation between JSX tags).
-* While React's client renderer preserves them as text nodes, browser HTML
-* parsers may discard them during hydration, leading to hydration mismatches.
-*
-* @param node The JSX child node to check.
-* @internal
-*/
-function isPaddingSpaces(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return node.raw.trim() === "" && node.raw.includes("\n");
-}
-/**
-* A `JSXExpressionContainer` node is considered an empty string expression
-* when it wraps a string literal with value `""`.
-*
-* React's reconciler explicitly ignores empty strings
-* (`typeof newChild === 'string' && newChild !== ''` in ReactChildFiber.js),
-* and the SSR renderer skips them as well (`if (text === '') { return; }`
-* in ReactFizzConfigDOM.js). They produce no DOM node.
-*
-* @param node The JSX child node to check.
-* @internal
-*/
-function isEmptyStringExpression$1(node) {
-	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
-	const expr = node.expression;
-	if (expr.type !== AST_NODE_TYPES.Literal) return false;
-	return expr.value === "";
-}
 
 //#endregion
 //#region src/get-element-type.ts
@@ -479,6 +530,13 @@ function hasAttribute(context, element, name) {
 * non-meaningful because React's reconciler and SSR renderer explicitly skip
 * empty strings, producing no DOM node.
 *
+* Unlike {@link getChildren} — which only filters whitespace that contains a
+* newline — this check treats **any** whitespace-only text as non-meaningful
+* (see {@link isWhitespaceText}). As a result `hasChildren(node)` is **not**
+* always equal to `getChildren(node).length > 0`: they differ for
+* whitespace-only children that have no newline, such as `<div> </div>` or
+* `<div>\t\t</div>`. Choose the API that matches your rule's intent.
+*
 * @param element - A `JSXElement` or `JSXFragment` node.
 * @returns `true` when the element has at least one meaningful child.
 *
@@ -501,33 +559,7 @@ function hasAttribute(context, element, name) {
 */
 function hasChildren(element) {
 	if (element.children.length === 0) return false;
-	return !element.children.every((child) => isWhitespaceText$1(child) || isEmptyStringExpression(child));
-}
-/**
-* Whether a JSX child node is a whitespace-only `JSXText` node.
-*
-* Any `JSXText` whose raw content consists entirely of whitespace characters
-* (spaces, tabs, newlines, etc.) is considered whitespace text.  Non-text
-* nodes always return `false`.
-* @param node The JSX child node to check.
-*/
-function isWhitespaceText$1(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return node.raw.trim() === "";
-}
-/**
-* Whether a JSX child node is an empty string expression (`{""}`).
-*
-* React's reconciler and SSR renderer skip empty strings, producing no DOM
-* node. These expressions are therefore considered non-meaningful children.
-*
-* @param node The JSX child node to check.
-*/
-function isEmptyStringExpression(node) {
-	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
-	const expr = node.expression;
-	if (expr.type !== AST_NODE_TYPES.Literal) return false;
-	return expr.value === "";
+	return !element.children.every((child) => isWhitespaceText(child) || isEmptyStringExpression(child));
 }
 
 //#endregion
@@ -665,57 +697,6 @@ function isHostElement(node) {
 	return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
 }
 
-//#endregion
-//#region src/is-whitespace.ts
-/**
-* Check whether a JSX child node is **whitespace padding** that React would
-* trim away during rendering.
-*
-* A child is considered whitespace padding when it is a `JSXText` node whose
-* raw content is empty after trimming **and** contains at least one newline.
-* This is the whitespace that appears between JSX tags purely for formatting:
-*
-* ```jsx
-* <div>
-*   <span />     ← the text between </span> and the next tag is padding
-*   <span />
-* </div>
-* ```
-*
-* Use {@link isWhitespaceText} for a looser check that also matches
-* whitespace‑only text that does **not** contain a newline.
-*
-* @param node - A JSX child node.
-* @returns `true` when the node is purely formatting whitespace.
-*
-* @example
-* ```ts
-* import { isWhitespace } from "@eslint-react/jsx";
-*
-* const meaningful = element.children.filter(
-*   (child) => !isWhitespace(child),
-* );
-* ```
-*/
-function isWhitespace(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return node.raw.trim() === "" && node.raw.includes("\n");
-}
-/**
-* Check whether a JSX child node is **any** whitespace‑only text.
-*
-* This is a looser variant of {@link isWhitespace} — it matches every
-* `JSXText` node whose raw content is empty after trimming, regardless of
-* whether it contains a newline.
-*
-* @param node - A JSX child node.
-* @returns `true` when the node is a whitespace‑only `JSXText`.
-*/
-function isWhitespaceText(node) {
-	if (node.type !== AST_NODE_TYPES.JSXText) return false;
-	return node.raw.trim() === "";
-}
-
 //#endregion
 //#region src/jsx-detection-hint.ts
 const JsxDetectionHint = {
@@ -742,4 +723,4 @@ const JsxDetectionHint = {
 const DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
 
 //#endregion
-export { DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isElement, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };
+export { DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/jsx",
-  "version": "5.8.9",
+  "version": "5.8.11",
   "description": "ESLint React's TSESTree JSX utility module for static analysis of JSX patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,20 +29,20 @@
     "dist"
   ],
   "dependencies": {
-    "@typescript-eslint/types": "^8.60.0",
-    "@typescript-eslint/utils": "^8.60.0",
+    "@typescript-eslint/types": "^8.60.1",
+    "@typescript-eslint/utils": "^8.60.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.8.9",
-    "@eslint-react/shared": "5.8.9",
-    "@eslint-react/var": "5.8.9",
-    "@eslint-react/eslint": "5.8.9"
+    "@eslint-react/ast": "5.8.11",
+    "@eslint-react/eslint": "5.8.11",
+    "@eslint-react/shared": "5.8.11",
+    "@eslint-react/var": "5.8.11"
   },
   "devDependencies": {
     "eslint": "^10.4.1",
     "tsdown": "^0.22.1",
-    "typescript": "5.9.3",
+    "typescript": "6.0.3",
     "@local/configs": "0.0.0",
-    "@local/eff": "3.0.0-beta.72"
+    "@local/eff": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "^10.3.0",