@eslint-react/jsx 5.20.0 → 5.20.2

package/dist/index.d.ts

@@ -3,15 +3,12 @@ import { TSESTree } from "@typescript-eslint/types";
 import { RuleContext } from "@eslint-react/eslint";
 //#region src/attribute-find.d.ts
 /**
- * Find a JSX attribute (or spread attribute containing the property) by name on a given element.
- *
- * Returns the last matching attribute to mirror React's behavior where later props win,
- * or `undefined` when the attribute is not present.
+ * Find a JSX attribute (or a spread attribute containing the property) by name.
  *
+ * Returns the last matching attribute to mirror React's behavior where later props win.
  * Spread attributes are resolved when possible: if the spread argument is an identifier
- * that resolves to an object expression, the object's properties are searched for a matching key.
- * Nested object expressions and nested spread identifiers are also resolved
- * (see {@link findSpreadProperty}).
+ * that resolves to an object expression, the object's properties are searched for a
+ * matching key (see {@link findSpreadProperty}).
  * @param context The ESLint rule context (needed for variable resolution in spread attributes).
  * @param element The `JSXElement` node to search.
  * @param name The attribute name to look for (ex: "className").
@@ -19,14 +16,10 @@ import { RuleContext } from "@eslint-react/eslint";
  */
 export declare function findAttribute(context: RuleContext, element: TSESTree.JSXElement, name: string): TSESTreeJSXAttributeLike | undefined;
 /**
- * Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
- * and (optionally) passes a predicate.
- *
- * This is useful when a rule visitor enters a deeply nested node (ex: a `Literal`
- * inside an expression container) and needs to know which JSX attribute it belongs to.
+ * Walk up the AST from `node` to find the nearest `JSXAttribute` ancestor, optionally matching a predicate.
  * @param node The starting node for the upward search.
- * @param test Optional predicate to filter candidate `JSXAttribute` nodes. When omitted every `JSXAttribute` ancestor matches.
- * @returns The first matching `JSXAttribute` ancestor, or `undefined` if none is found before reaching the root.
+ * @param test Optional predicate to filter candidate `JSXAttribute` nodes.
+ * @returns The first matching `JSXAttribute` ancestor, or `undefined` when none is found.
  */
 export declare function findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | undefined;
 /**
@@ -55,43 +48,30 @@ export declare function findSpreadProperty(context: RuleContext, argument: TSEST
 //#endregion
 //#region src/attribute-has.d.ts
 /**
- * Check whether a JSX element carries a given attribute (prop).
- *
- * This is a thin convenience wrapper around {@link findAttribute} for the
- * common case where you only need a boolean answer.
+ * Check if the element has an attribute with the given name.
  *
  * Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
- * will report `true` for `"disabled"`.
+ * reports `true` for `"disabled"` (see {@link findAttribute}).
  * @param context The ESLint rule context (needed for variable resolution in spread attributes).
- * @param element The `JSXElement` node to inspect.
+ * @param element The `JSXElement` node to check.
  * @param name The attribute name to look for (ex: "className").
- * @returns `true` when the attribute is present on the element.
+ * @returns `true` if the attribute is present on the element.
  */
 export declare function hasAttribute(context: RuleContext, element: TSESTree.JSXElement, name: string): boolean;
 /**
- * Check whether a JSX element carries at least one of the given attributes.
- *
- * This is a batch variant of {@link hasAttribute} for the common pattern of
- * short-circuiting on multiple prop names.
- *
- * Spread attributes are taken into account (see {@link findAttribute}).
+ * Check if the element has at least one of the given attributes.
  * @param context The ESLint rule context (needed for variable resolution in spread attributes).
- * @param element The `JSXElement` node to inspect.
+ * @param element The `JSXElement` node to check.
  * @param names The attribute names to look for.
- * @returns `true` when at least one of the attributes is present.
+ * @returns `true` if at least one of the attributes is present.
  */
 export declare function hasAnyAttribute(context: RuleContext, element: TSESTree.JSXElement, names: string[]): boolean;
 /**
- * Check whether a JSX element carries all of the given attributes (props).
- *
- * This is a batch variant of {@link hasAttribute} for the common pattern
- * where a rule needs to verify that a set of required props are all present.
- *
- * Spread attributes are taken into account (see {@link findAttribute}).
+ * Check if the element has all of the given attributes.
  * @param context The ESLint rule context (needed for variable resolution in spread attributes).
- * @param element The `JSXElement` node to inspect.
+ * @param element The `JSXElement` node to check.
  * @param names The attribute names to look for.
- * @returns `true` when every name in `names` is present on the element.
+ * @returns `true` if every attribute is present on the element.
  */
 export declare function hasEveryAttribute(context: RuleContext, element: TSESTree.JSXElement, names: string[]): boolean;
 //#endregion
@@ -99,16 +79,15 @@ export declare function hasEveryAttribute(context: RuleContext, element: TSESTre
 /**
  * Get the stringified name of a `JSXAttribute` node.
  *
- * Handles both simple identifiers and namespaced names:
  * - `className` -> `"className"`
  * - `aria-label` -> `"aria-label"`
  * - `xml:space` -> `"xml:space"`.
- * @param node A `JSXAttribute` AST node.
+ * @param node The `JSXAttribute` node to get the name from.
  * @returns The attribute name as a plain string.
  */
 export declare function getAttributeName(node: TSESTree.JSXAttribute): string;
 /**
- * Check whether a node is a `JSXAttribute` with the given name.
+ * Check if the node is a `JSXAttribute` with the given name.
  *
  * Only plain identifier names are matched (ex: `className`); namespaced
  * attributes (ex: `xml:space`) do not match.
@@ -116,9 +95,9 @@ export declare function getAttributeName(node: TSESTree.JSXAttribute): string;
  * Supports both data-first and data-last (curried) call styles:
  * - `isAttribute(node, "className")`
  * - `isAttribute("className")(node)`.
- * @param node The AST node to test.
+ * @param node The node to check.
  * @param name The attribute name to match (ex: "className").
- * @returns `true` when the node is a `JSXAttribute` named `name`.
+ * @returns `true` if the node is a `JSXAttribute` named `name`.
  */
 export declare const isAttribute: {
   (name: string): (node: TSESTree.Node) => node is TSESTree.JSXAttribute;
@@ -129,13 +108,11 @@ export declare const isAttribute: {
 /**
  * Discriminated union representing the resolved value of a JSX attribute.
  *
- * Each variant carries the original AST `node` (where applicable — the
- * `boolean` variant has no value node and reports `null`) and a `toStatic()`
- * helper that attempts to collapse the value into a plain JavaScript value
- * at analysis time.
- *
- * `toStatic()` returns `undefined` whenever no static value is available;
- * structural information is carried by `kind`, value information by `toStatic()`.
+ * Each variant carries the original AST `node` (the `boolean` variant has no value
+ * node and reports `null`) and a `toStatic()` helper that attempts to collapse the
+ * value into a plain JavaScript value at analysis time. `toStatic()` returns
+ * `undefined` when no static value is available; structural information is carried
+ * by `kind`, value information by `toStatic()`.
  */
 type AttributeValue = {
   readonly kind: "boolean";
@@ -168,17 +145,11 @@ type AttributeValue = {
   toStatic(): unknown;
 };
 /**
- * Resolve the value of a JSX attribute (or spread attribute) into an
- * {@link AttributeValue} descriptor that can be inspected further.
- *
- * This is the low-level building block; it operates on a single attribute
- * node that the caller has already located. For the higher-level "find by
- * name and resolve" combo, see {@link getAttributeValue}.
+ * Resolve the value of a JSX attribute (or spread attribute) into an {@link AttributeValue} descriptor.
  *
- * When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the
- * same name the attribute was found by) makes `toStatic()` return the static
- * value of that named property, eliminating the need to branch on
- * `kind === "spreadProps"` at the call site.
+ * When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the name
+ * the attribute was found by) makes `toStatic()` return the static value of that
+ * named property. For the higher-level "find by name and resolve" combo, see {@link getAttributeValue}.
  * @param context The ESLint rule context (needed for scope look-ups).
  * @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
  * @param name Optional property name used to resolve `toStatic()` for spread attributes.
@@ -188,28 +159,20 @@ export declare function resolveAttributeValue(context: RuleContext, attribute: T
 /**
  * Find an attribute by name on a JSX element and resolve its value in a single call.
  *
- * This is a convenience composition of {@link findAttribute} and
- * {@link resolveAttributeValue} that eliminates the most common two-step
- * pattern in lint rules.
+ * Convenience composition of {@link findAttribute} and {@link resolveAttributeValue}.
  * @param context The ESLint rule context.
  * @param element The `JSXElement` node to search.
  * @param name The attribute name to look up (ex: "className").
- * @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present on the element.
+ * @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present.
  */
 export declare function getAttributeValue(context: RuleContext, element: TSESTree.JSXElement, name: string): AttributeValue | undefined;
 /**
- * Find an attribute by name on a JSX element and collapse its value to a plain
- * JavaScript value in a single step.
+ * Find an attribute by name on a JSX element and collapse its value to a plain JavaScript value.
  *
- * This is a convenience composition of {@link findAttribute} ->
- * {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
- * `spreadProps` case (extracts the named property from the spread object).
- *
- * Returns `undefined` both when the attribute is absent and when its value
- * cannot be statically determined; use {@link findAttribute} or
- * {@link hasAttribute} when presence itself matters.
+ * Returns `undefined` both when the attribute is absent and when its value cannot
+ * be statically determined; use {@link hasAttribute} when presence itself matters.
  * @param context The ESLint rule context.
- * @param element The `JSXElement` node to inspect.
+ * @param element The `JSXElement` node to check.
  * @param name The attribute name to look up (ex: "className").
  * @returns The static value of the attribute, or `undefined` when absent or indeterminate.
  */
@@ -226,30 +189,18 @@ export declare function getAttributeStaticValue(context: RuleContext, element: T
  * 4. Skip empty string expressions (`{""}`), which produce no DOM node.
  * 5. Collect everything else.
  * @param element A `JSXElement` or `JSXFragment` node.
- * @returns An array of children nodes that contribute to rendered output.
+ * @returns The children nodes that contribute to rendered output.
  */
 export declare function getChildren(element: TSESTreeJSXElementLike): TSESTree.JSXChild[];
 /**
- * Check whether a JSX element (or fragment) has meaningful children, that is,
- * at least one child that is not purely whitespace text or an empty string expression.
- *
- * A `JSXText` child whose `raw` content is empty after trimming is considered
- * non-meaningful because it is typically a code-formatting artifact
- * (indentation between tags). While React's client renderer preserves these
- * nodes as text nodes, they rarely represent intentionally rendered content.
+ * Check if the element has at least one meaningful child, that is, a child that
+ * is not purely whitespace text or an empty string expression (`{""}`).
  *
- * An empty string expression (`children={""}`) is also considered
- * 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.
+ * Unlike {@link getChildren} (which only filters whitespace containing a newline),
+ * this check treats any whitespace-only text as non-meaningful, so `hasChildren(node)`
+ * is not always equal to `getChildren(node).length > 0` (ex: `<div> </div>`).
  * @param element A `JSXElement` or `JSXFragment` node.
- * @returns `true` when the element has at least one meaningful child.
+ * @returns `true` if the element has at least one meaningful child.
  */
 export declare function hasChildren(element: TSESTreeJSXElementLike): boolean;
 //#endregion
@@ -263,42 +214,34 @@ export declare function hasChildren(element: TSESTreeJSXElementLike): boolean;
  */
 type ElementTest = string | readonly string[] | ((elementType: string, node: TSESTreeJSXElementLike) => boolean);
 /**
- * Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
- * matches a given test.
- *
- * Modelled after
- * [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
- * the `test` parameter controls what counts as a match.
+ * Check if the node is a `JSXElement` (or `JSXFragment`), optionally matching a given test.
  *
- * When called without a test, the function acts as a simple type-guard
- * for `JSXElement | JSXFragment`.
- * @param node The AST node to test.
+ * Modelled after [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
+ * the `test` parameter controls what counts as a match. When called without a test,
+ * the function acts as a simple type guard for `JSXElement | JSXFragment`.
+ * @param node The node to check.
  * @param test Optional test to match the element type against.
- * @returns `true` when the node is a matching JSX element.
+ * @returns `true` if the node is a matching JSX element.
  */
 export declare function isElement(node: TSESTree.Node | null | undefined, test?: ElementTest): node is TSESTreeJSXElementLike;
 /**
- * Check whether a node is a React Fragment element.
- *
- * Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the
- * explicit `<Fragment>` / `<React.Fragment>` form (`JSXElement`).
- *
- * The comparison is performed against the self name (last dot-separated
- * segment) of both the node and the configured factory, so `<React.Fragment>`
- * matches `"React.Fragment"` and `<Fragment>` matches `"Fragment"`.
- * @param node The AST node to test.
+ * Check if the node is a React Fragment element.
+ *
+ * Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the explicit
+ * `<Fragment>` / `<React.Fragment>` form (`JSXElement`). The comparison is performed
+ * against the self name (last dot-separated segment) of both the node and the
+ * configured factory, so `<React.Fragment>` matches `"React.Fragment"` and
+ * `<Fragment>` matches `"Fragment"`.
+ * @param node The node to check.
  * @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment").
- * @returns `true` when the node represents a React Fragment.
+ * @returns `true` if the node represents a React Fragment.
  */
 export declare function isFragmentElement(node: TSESTree.Node, jsxFragmentFactory?: string): node is TSESTreeJSXElementLike;
 /**
- * Check whether a node is a host (intrinsic / DOM) element.
- *
- * A host element is a `JSXElement` whose tag name is a plain `JSXIdentifier`
- * starting with a lowercase letter, the same heuristic React uses to
- * distinguish `<div>` from `<MyComponent>`.
- * @param node The AST node to test.
- * @returns `true` when the node is a `JSXElement` with a lowercase tag name.
+ * Check if the node is a host (intrinsic / DOM) element, that is, a `JSXElement`
+ * whose tag name starts with a lowercase letter (ex: `<div>` vs `<MyComponent>`).
+ * @param node The node to check.
+ * @returns `true` if the node is a `JSXElement` with a lowercase tag name.
  */
 export declare function isHostElement(node: TSESTree.Node): node is TSESTree.JSXElement;
 //#endregion
@@ -311,8 +254,8 @@ export declare function isHostElement(node: TSESTree.Node): node is TSESTree.JSX
  * - `<React.Fragment>` -> `"React.Fragment"`
  * - `<xml:space>` -> `"xml:space"`
  * - `<></>` -> `""`.
- * @param node A `JSXElement` or `JSXFragment` node.
- * @returns The fully-qualified element type string.
+ * @param node The `JSXElement` or `JSXFragment` node.
+ * @returns The fully qualified element type string.
  */
 export declare function getElementFullType(node: TSESTreeJSXElementLike): string;
 /**
@@ -321,7 +264,7 @@ export declare function getElementFullType(node: TSESTreeJSXElementLike): string
  * - `<Foo.Bar.Baz>` -> `"Baz"`
  * - `<div>` -> `"div"`
  * - `<></>` -> `""`.
- * @param node A `JSXElement` or `JSXFragment` node.
+ * @param node The `JSXElement` or `JSXFragment` node.
  * @returns The last segment of the element type, or `""` for fragments.
  */
 export declare function getElementSelfType(node: TSESTreeJSXElementLike): string;
@@ -330,51 +273,44 @@ export declare function getElementSelfType(node: TSESTreeJSXElementLike): string
 /**
  * Collapse a multiline JSX text string following React's whitespace rules.
  *
- * This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
+ * Mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
  * 1. Split the raw text into lines.
  * 2. Find the last non-empty line.
  * 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
  * 4. Collapse tabs into spaces.
  * 5. Append a single space after each non-last non-empty line.
  * @param text The raw JSX text string to collapse.
- * @returns The collapsed string, or `null` if the text contains only whitespace.
+ * @returns The collapsed string, or `null` when the text contains only whitespace.
  * @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
  */
 export declare function collapseMultilineText(text: string): string | null;
 /**
- * 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
- * content is empty after applying React's whitespace normalization
- * (see {@link collapseMultilineText}, modelled after Babel's
- * `cleanJSXElementLiteralChild`) **and** it contains a newline. This is the
- * whitespace that appears between JSX tags purely for formatting.
+ * Check if the node is whitespace padding that React would trim away during
+ * rendering, that is, a `JSXText` node that cleans to nothing (see
+ * {@link collapseMultilineText}) and contains a newline.
  *
  * For the looser "any whitespace-only text" check, see {@link isWhitespaceText}.
- * @param node A JSX child node.
- * @returns `true` when the node is purely formatting whitespace.
+ * @param node The JSX child node to check.
+ * @returns `true` if the node is purely formatting whitespace.
  */
 export declare function isPaddingWhitespace(node: TSESTree.JSXChild): boolean;
 /**
- * Check whether a JSX child node is any whitespace-only text.
+ * Check if the node is whitespace-only text.
  *
- * This is a looser variant of {@link isPaddingWhitespace}; 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`.
+ * Looser variant of {@link isPaddingWhitespace}; matches every `JSXText` node
+ * whose raw content is empty after trimming, regardless of newlines.
+ * @param node The JSX child node to check.
+ * @returns `true` if the node is a whitespace-only `JSXText`.
  */
 export declare function isWhitespaceText(node: TSESTree.JSXChild): boolean;
 /**
- * Check whether a JSX child node is an empty string expression (`{""}`).
+ * Check if the 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.
+ * React's reconciler and SSR renderer explicitly skip empty strings, producing no
+ * DOM node, so such expressions are treated as non-rendered children, same as
+ * whitespace padding.
+ * @param node The JSX child node to check.
+ * @returns `true` if the node is a `{""}` expression container.
  */
 export declare function isEmptyStringExpression(node: TSESTree.JSXChild): boolean;
 //#endregion

package/dist/index.js

@@ -481,11 +481,10 @@ const takeWhile = dual(2, (xs, pred) => {
 /**
 * Get the stringified name of a `JSXAttribute` node.
 *
-* Handles both simple identifiers and namespaced names:
 * - `className` -> `"className"`
 * - `aria-label` -> `"aria-label"`
 * - `xml:space` -> `"xml:space"`.
-* @param node A `JSXAttribute` AST node.
+* @param node The `JSXAttribute` node to get the name from.
 * @returns The attribute name as a plain string.
 */
 function getAttributeName(node) {
@@ -493,7 +492,7 @@ function getAttributeName(node) {
 	return node.name.namespace.name + ":" + node.name.name.name;
 }
 /**
-* Check whether a node is a `JSXAttribute` with the given name.
+* Check if the node is a `JSXAttribute` with the given name.
 *
 * Only plain identifier names are matched (ex: `className`); namespaced
 * attributes (ex: `xml:space`) do not match.
@@ -501,9 +500,9 @@ function getAttributeName(node) {
 * Supports both data-first and data-last (curried) call styles:
 * - `isAttribute(node, "className")`
 * - `isAttribute("className")(node)`.
-* @param node The AST node to test.
+* @param node The node to check.
 * @param name The attribute name to match (ex: "className").
-* @returns `true` when the node is a `JSXAttribute` named `name`.
+* @returns `true` if the node is a `JSXAttribute` named `name`.
 */
 const isAttribute = dual(2, (node, name) => {
 	return node.type === AST_NODE_TYPES.JSXAttribute && node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === name;
@@ -512,15 +511,12 @@ const isAttribute = dual(2, (node, name) => {
 //#endregion
 //#region src/attribute-find.ts
 /**
-* Find a JSX attribute (or spread attribute containing the property) by name on a given element.
-*
-* Returns the last matching attribute to mirror React's behavior where later props win,
-* or `undefined` when the attribute is not present.
+* Find a JSX attribute (or a spread attribute containing the property) by name.
 *
+* Returns the last matching attribute to mirror React's behavior where later props win.
 * Spread attributes are resolved when possible: if the spread argument is an identifier
-* that resolves to an object expression, the object's properties are searched for a matching key.
-* Nested object expressions and nested spread identifiers are also resolved
-* (see {@link findSpreadProperty}).
+* that resolves to an object expression, the object's properties are searched for a
+* matching key (see {@link findSpreadProperty}).
 * @param context The ESLint rule context (needed for variable resolution in spread attributes).
 * @param element The `JSXElement` node to search.
 * @param name The attribute name to look for (ex: "className").
@@ -533,14 +529,10 @@ function findAttribute(context, element, name) {
 	});
 }
 /**
-* Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
-* and (optionally) passes a predicate.
-*
-* This is useful when a rule visitor enters a deeply nested node (ex: a `Literal`
-* inside an expression container) and needs to know which JSX attribute it belongs to.
+* Walk up the AST from `node` to find the nearest `JSXAttribute` ancestor, optionally matching a predicate.
 * @param node The starting node for the upward search.
-* @param test Optional predicate to filter candidate `JSXAttribute` nodes. When omitted every `JSXAttribute` ancestor matches.
-* @returns The first matching `JSXAttribute` ancestor, or `undefined` if none is found before reaching the root.
+* @param test Optional predicate to filter candidate `JSXAttribute` nodes.
+* @returns The first matching `JSXAttribute` ancestor, or `undefined` when none is found.
 */
 function findParentAttribute(node, test = () => true) {
 	const guard = (n) => {
@@ -605,47 +597,34 @@ function findSpreadProperty(context, argument, name, seen = /* @__PURE__ */ new
 //#endregion
 //#region src/attribute-has.ts
 /**
-* Check whether a JSX element carries a given attribute (prop).
-*
-* This is a thin convenience wrapper around {@link findAttribute} for the
-* common case where you only need a boolean answer.
+* Check if the element has an attribute with the given name.
 *
 * Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
-* will report `true` for `"disabled"`.
+* reports `true` for `"disabled"` (see {@link findAttribute}).
 * @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
+* @param element The `JSXElement` node to check.
 * @param name The attribute name to look for (ex: "className").
-* @returns `true` when the attribute is present on the element.
+* @returns `true` if the attribute is present on the element.
 */
 function hasAttribute(context, element, name) {
 	return findAttribute(context, element, name) != null;
 }
 /**
-* Check whether a JSX element carries at least one of the given attributes.
-*
-* This is a batch variant of {@link hasAttribute} for the common pattern of
-* short-circuiting on multiple prop names.
-*
-* Spread attributes are taken into account (see {@link findAttribute}).
+* Check if the element has at least one of the given attributes.
 * @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
+* @param element The `JSXElement` node to check.
 * @param names The attribute names to look for.
-* @returns `true` when at least one of the attributes is present.
+* @returns `true` if at least one of the attributes is present.
 */
 function hasAnyAttribute(context, element, names) {
 	return names.some((name) => findAttribute(context, element, name) != null);
 }
 /**
-* Check whether a JSX element carries all of the given attributes (props).
-*
-* This is a batch variant of {@link hasAttribute} for the common pattern
-* where a rule needs to verify that a set of required props are all present.
-*
-* Spread attributes are taken into account (see {@link findAttribute}).
+* Check if the element has all of the given attributes.
 * @param context The ESLint rule context (needed for variable resolution in spread attributes).
-* @param element The `JSXElement` node to inspect.
+* @param element The `JSXElement` node to check.
 * @param names The attribute names to look for.
-* @returns `true` when every name in `names` is present on the element.
+* @returns `true` if every attribute is present on the element.
 */
 function hasEveryAttribute(context, element, names) {
 	return names.every((name) => findAttribute(context, element, name) != null);
@@ -654,17 +633,11 @@ function hasEveryAttribute(context, element, names) {
 //#endregion
 //#region src/attribute-value.ts
 /**
-* Resolve the value of a JSX attribute (or spread attribute) into an
-* {@link AttributeValue} descriptor that can be inspected further.
-*
-* This is the low-level building block; it operates on a single attribute
-* node that the caller has already located. For the higher-level "find by
-* name and resolve" combo, see {@link getAttributeValue}.
+* Resolve the value of a JSX attribute (or spread attribute) into an {@link AttributeValue} descriptor.
 *
-* When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the
-* same name the attribute was found by) makes `toStatic()` return the static
-* value of that named property, eliminating the need to branch on
-* `kind === "spreadProps"` at the call site.
+* When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the name
+* the attribute was found by) makes `toStatic()` return the static value of that
+* named property. For the higher-level "find by name and resolve" combo, see {@link getAttributeValue}.
 * @param context The ESLint rule context (needed for scope look-ups).
 * @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
 * @param name Optional property name used to resolve `toStatic()` for spread attributes.
@@ -677,13 +650,11 @@ function resolveAttributeValue(context, attribute, name) {
 /**
 * Find an attribute by name on a JSX element and resolve its value in a single call.
 *
-* This is a convenience composition of {@link findAttribute} and
-* {@link resolveAttributeValue} that eliminates the most common two-step
-* pattern in lint rules.
+* Convenience composition of {@link findAttribute} and {@link resolveAttributeValue}.
 * @param context The ESLint rule context.
 * @param element The `JSXElement` node to search.
 * @param name The attribute name to look up (ex: "className").
-* @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present on the element.
+* @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present.
 */
 function getAttributeValue(context, element, name) {
 	const attr = findAttribute(context, element, name);
@@ -691,18 +662,12 @@ function getAttributeValue(context, element, name) {
 	return resolveAttributeValue(context, attr, name);
 }
 /**
-* Find an attribute by name on a JSX element and collapse its value to a plain
-* JavaScript value in a single step.
+* Find an attribute by name on a JSX element and collapse its value to a plain JavaScript value.
 *
-* This is a convenience composition of {@link findAttribute} ->
-* {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
-* `spreadProps` case (extracts the named property from the spread object).
-*
-* Returns `undefined` both when the attribute is absent and when its value
-* cannot be statically determined; use {@link findAttribute} or
-* {@link hasAttribute} when presence itself matters.
+* Returns `undefined` both when the attribute is absent and when its value cannot
+* be statically determined; use {@link hasAttribute} when presence itself matters.
 * @param context The ESLint rule context.
-* @param element The `JSXElement` node to inspect.
+* @param element The `JSXElement` node to check.
 * @param name The attribute name to look up (ex: "className").
 * @returns The static value of the attribute, or `undefined` when absent or indeterminate.
 */
@@ -778,14 +743,14 @@ function resolveJsxSpreadAttribute(context, node, name) {
 /**
 * Collapse a multiline JSX text string following React's whitespace rules.
 *
-* This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
+* Mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
 * 1. Split the raw text into lines.
 * 2. Find the last non-empty line.
 * 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
 * 4. Collapse tabs into spaces.
 * 5. Append a single space after each non-last non-empty line.
 * @param text The raw JSX text string to collapse.
-* @returns The collapsed string, or `null` if the text contains only whitespace.
+* @returns The collapsed string, or `null` when the text contains only whitespace.
 * @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
 */
 function collapseMultilineText(text) {
@@ -809,45 +774,38 @@ function collapseMultilineText(text) {
 	return str === "" ? null : str;
 }
 /**
-* 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
-* content is empty after applying React's whitespace normalization
-* (see {@link collapseMultilineText}, modelled after Babel's
-* `cleanJSXElementLiteralChild`) **and** it contains a newline. This is the
-* whitespace that appears between JSX tags purely for formatting.
+* Check if the node is whitespace padding that React would trim away during
+* rendering, that is, a `JSXText` node that cleans to nothing (see
+* {@link collapseMultilineText}) and contains a newline.
 *
 * For the looser "any whitespace-only text" check, see {@link isWhitespaceText}.
-* @param node A JSX child node.
-* @returns `true` when the node is purely formatting whitespace.
+* @param node The JSX child node to check.
+* @returns `true` if the node is purely formatting whitespace.
 */
 function isPaddingWhitespace(node) {
 	if (node.type !== AST_NODE_TYPES.JSXText) return false;
 	return collapseMultilineText(node.value) == null && node.value.includes("\n");
 }
 /**
-* Check whether a JSX child node is any whitespace-only text.
+* Check if the node is whitespace-only text.
 *
-* This is a looser variant of {@link isPaddingWhitespace}; 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`.
+* Looser variant of {@link isPaddingWhitespace}; matches every `JSXText` node
+* whose raw content is empty after trimming, regardless of newlines.
+* @param node The JSX child node to check.
+* @returns `true` if 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 (`{""}`).
+* Check if the 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.
+* React's reconciler and SSR renderer explicitly skip empty strings, producing no
+* DOM node, so such expressions are treated as non-rendered children, same as
+* whitespace padding.
+* @param node The JSX child node to check.
+* @returns `true` if the node is a `{""}` expression container.
 */
 function isEmptyStringExpression(node) {
 	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
@@ -868,7 +826,7 @@ function isEmptyStringExpression(node) {
 * 4. Skip empty string expressions (`{""}`), which produce no DOM node.
 * 5. Collect everything else.
 * @param element A `JSXElement` or `JSXFragment` node.
-* @returns An array of children nodes that contribute to rendered output.
+* @returns The children nodes that contribute to rendered output.
 */
 function getChildren(element) {
 	const children = [];
@@ -883,26 +841,14 @@ function getChildren(element) {
 	return children;
 }
 /**
-* Check whether a JSX element (or fragment) has meaningful children, that is,
-* at least one child that is not purely whitespace text or an empty string expression.
-*
-* A `JSXText` child whose `raw` content is empty after trimming is considered
-* non-meaningful because it is typically a code-formatting artifact
-* (indentation between tags). While React's client renderer preserves these
-* nodes as text nodes, they rarely represent intentionally rendered content.
-*
-* An empty string expression (`children={""}`) is also considered
-* non-meaningful because React's reconciler and SSR renderer explicitly skip
-* empty strings, producing no DOM node.
+* Check if the element has at least one meaningful child, that is, a child that
+* is not purely whitespace text or an empty string expression (`{""}`).
 *
-* 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.
+* Unlike {@link getChildren} (which only filters whitespace containing a newline),
+* this check treats any whitespace-only text as non-meaningful, so `hasChildren(node)`
+* is not always equal to `getChildren(node).length > 0` (ex: `<div> </div>`).
 * @param element A `JSXElement` or `JSXFragment` node.
-* @returns `true` when the element has at least one meaningful child.
+* @returns `true` if the element has at least one meaningful child.
 */
 function hasChildren(element) {
 	if (element.children.length === 0) return false;
@@ -919,8 +865,8 @@ function hasChildren(element) {
 * - `<React.Fragment>` -> `"React.Fragment"`
 * - `<xml:space>` -> `"xml:space"`
 * - `<></>` -> `""`.
-* @param node A `JSXElement` or `JSXFragment` node.
-* @returns The fully-qualified element type string.
+* @param node The `JSXElement` or `JSXFragment` node.
+* @returns The fully qualified element type string.
 */
 function getElementFullType(node) {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
@@ -939,7 +885,7 @@ function getElementFullType(node) {
 * - `<Foo.Bar.Baz>` -> `"Baz"`
 * - `<div>` -> `"div"`
 * - `<></>` -> `""`.
-* @param node A `JSXElement` or `JSXFragment` node.
+* @param node The `JSXElement` or `JSXFragment` node.
 * @returns The last segment of the element type, or `""` for fragments.
 */
 function getElementSelfType(node) {
@@ -949,18 +895,14 @@ function getElementSelfType(node) {
 //#endregion
 //#region src/element-is.ts
 /**
-* Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
-* matches a given test.
+* Check if the node is a `JSXElement` (or `JSXFragment`), optionally matching a given test.
 *
-* Modelled after
-* [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
-* the `test` parameter controls what counts as a match.
-*
-* When called without a test, the function acts as a simple type-guard
-* for `JSXElement | JSXFragment`.
-* @param node The AST node to test.
+* Modelled after [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
+* the `test` parameter controls what counts as a match. When called without a test,
+* the function acts as a simple type guard for `JSXElement | JSXFragment`.
+* @param node The node to check.
 * @param test Optional test to match the element type against.
-* @returns `true` when the node is a matching JSX element.
+* @returns `true` if the node is a matching JSX element.
 */
 function isElement(node, test) {
 	if (node == null) return false;
@@ -974,17 +916,16 @@ function isElement(node, test) {
 	}
 }
 /**
-* Check whether a node is a React Fragment element.
-*
-* Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the
-* explicit `<Fragment>` / `<React.Fragment>` form (`JSXElement`).
+* Check if the node is a React Fragment element.
 *
-* The comparison is performed against the self name (last dot-separated
-* segment) of both the node and the configured factory, so `<React.Fragment>`
-* matches `"React.Fragment"` and `<Fragment>` matches `"Fragment"`.
-* @param node The AST node to test.
+* Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the explicit
+* `<Fragment>` / `<React.Fragment>` form (`JSXElement`). The comparison is performed
+* against the self name (last dot-separated segment) of both the node and the
+* configured factory, so `<React.Fragment>` matches `"React.Fragment"` and
+* `<Fragment>` matches `"Fragment"`.
+* @param node The node to check.
 * @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment").
-* @returns `true` when the node represents a React Fragment.
+* @returns `true` if the node represents a React Fragment.
 */
 function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return true;
@@ -993,13 +934,10 @@ function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	return getElementFullType(node).split(".").at(-1) === fragment;
 }
 /**
-* Check whether a node is a host (intrinsic / DOM) element.
-*
-* A host element is a `JSXElement` whose tag name is a plain `JSXIdentifier`
-* starting with a lowercase letter, the same heuristic React uses to
-* distinguish `<div>` from `<MyComponent>`.
-* @param node The AST node to test.
-* @returns `true` when the node is a `JSXElement` with a lowercase tag name.
+* Check if the node is a host (intrinsic / DOM) element, that is, a `JSXElement`
+* whose tag name starts with a lowercase letter (ex: `<div>` vs `<MyComponent>`).
+* @param node The node to check.
+* @returns `true` if the node is a `JSXElement` with a lowercase tag name.
 */
 function isHostElement(node) {
 	if (node.type !== AST_NODE_TYPES.JSXElement) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/jsx",
-  "version": "5.20.0",
+  "version": "5.20.2",
   "description": "ESLint React's TSESTree JSX utility module for static analysis of JSX patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,10 +29,10 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.20.0",
-    "@eslint-react/eslint": "5.20.0",
-    "@eslint-react/shared": "5.20.0",
-    "@eslint-react/var": "5.20.0",
+    "@eslint-react/ast": "5.20.2",
+    "@eslint-react/eslint": "5.20.2",
+    "@eslint-react/shared": "5.20.2",
+    "@eslint-react/var": "5.20.2",
     "@typescript-eslint/types": "^8.70.0",
     "@typescript-eslint/utils": "^8.70.0",
     "ts-pattern": "^5.9.0"
@@ -41,7 +41,7 @@
     "@local/configs": "0.0.0",
     "@local/eff": "0.0.0",
     "@local/testkit": "0.0.0",
-    "eslint": "^10.10.0",
+    "eslint": "^10.11.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3"
   },