@eslint-react/jsx 5.16.1 → 5.17.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { TSESTree } from "@typescript-eslint/types";
 import { RuleContext } from "@eslint-react/eslint";
 //#region src/collapse-multiline-text.d.ts
 /**
- * Collapse a multiline JSX text string following React's whitespace rules
+ * Collapse a multiline JSX text string following React's whitespace rules.
  *
  * This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
  * 1. Split the raw text into lines.
@@ -11,15 +11,15 @@ import { RuleContext } from "@eslint-react/eslint";
  * 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
+ * @param text The raw JSX text string to collapse.
+ * @returns The collapsed string, or `null` if the text contains only whitespace.
  * @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
  */
 declare function collapseMultilineText(text: string): string | null;
 //#endregion
 //#region src/find-attribute.d.ts
 /**
- * Find a JSX attribute (or spread attribute containing the property) by name on a given element
+ * 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.
@@ -27,43 +27,43 @@ declare function collapseMultilineText(text: string): string | null;
  * 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.
- * @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")
- * @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found
+ * @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").
+ * @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found.
  */
 declare function findAttribute(context: RuleContext, element: TSESTree.JSXElement, name: string): TSESTreeJSXAttributeLike | undefined;
 //#endregion
 //#region src/find-parent-attribute.d.ts
 /**
  * Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
- * and (optionally) passes a predicate
+ * 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.
- * @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 `null` if none is found before reaching the root
+ * @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 `null` if none is found before reaching the root.
  */
 declare function findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | null;
 //#endregion
 //#region src/get-attribute-name.d.ts
 /**
- * Get the stringified name of a `JSXAttribute` node
+ * 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
- * @returns The attribute name as a plain string
+ * - `xml:space` -> `"xml:space"`.
+ * @param node A `JSXAttribute` AST node.
+ * @returns The attribute name as a plain string.
  */
 declare function getAttributeName(node: TSESTree.JSXAttribute): string;
 //#endregion
 //#region src/get-attribute-static-value.d.ts
 /**
  * Find an attribute by name on a JSX element and collapse its value to a plain
- * JavaScript value in a single step
+ * JavaScript value in a single step.
  *
  * This is a convenience composition of {@link findAttribute} ->
  * {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
@@ -72,60 +72,60 @@ declare function getAttributeName(node: TSESTree.JSXAttribute): string;
  * Returns `null` when the attribute is absent, `undefined` when the value cannot
  * be statically determined (including empty expression containers), and the
  * resolved static value otherwise.
- * @param context The ESLint rule context
- * @param element The `JSXElement` node to inspect
- * @param name The attribute name to look up (ex: "className")
- * @returns The static value of the attribute, `null` when absent, or `undefined` when indeterminate
+ * @param context The ESLint rule context.
+ * @param element The `JSXElement` node to inspect.
+ * @param name The attribute name to look up (ex: "className").
+ * @returns The static value of the attribute, `null` when absent, or `undefined` when indeterminate.
  */
 declare function getAttributeStaticValue(context: RuleContext, element: TSESTree.JSXElement, name: string): unknown;
 //#endregion
 //#region src/jsx-attribute-value.d.ts
 /**
- * Discriminated union representing the resolved value of a JSX attribute
+ * Discriminated union representing the resolved value of a JSX attribute.
  *
  * Each variant carries the original AST `node` (where applicable) and a
  * `toStatic()` helper that attempts to collapse the value into a plain
  * JavaScript value at analysis time.
  */
 type JsxAttributeValue = JsxAttributeValueBoolean | JsxAttributeValueElement | JsxAttributeValueLiteral | JsxAttributeValueUnknown | JsxAttributeValueMissing | JsxAttributeValueSpreadChild | JsxAttributeValueSpreadProps;
-/** Boolean attribute with no value (ex: `<input disabled />`) */
+/** Boolean attribute with no value (ex: `<input disabled />`). */
 interface JsxAttributeValueBoolean {
   readonly kind: "boolean";
   readonly node: null;
   toStatic(): true;
 }
-/** JSX element used as an attribute value (ex: `<Slot icon=<Icon /> />`) */
+/** JSX element used as an attribute value (ex: `<Slot icon=<Icon /> />`). */
 interface JsxAttributeValueElement {
   readonly kind: "element";
   readonly node: TSESTree.JSXElement;
   toStatic(): null;
 }
-/** Literal value (ex: `<img alt="photo" />`) */
+/** Literal value (ex: `<img alt="photo" />`). */
 interface JsxAttributeValueLiteral {
   readonly kind: "literal";
   readonly node: TSESTree.Literal;
   toStatic(): TSESTree.Literal["value"];
 }
-/** Expression container value (ex: `<Comp value={expr} />`) */
+/** Expression container value (ex: `<Comp value={expr} />`). */
 interface JsxAttributeValueUnknown {
   readonly kind: "unknown";
   readonly node: TSESTree.JSXExpressionContainer["expression"];
   toStatic(): unknown;
 }
-/** Empty expression container (ex: `<Comp value={} />`) */
+/** Empty expression container (ex: `<Comp value={} />`). */
 interface JsxAttributeValueMissing {
   readonly kind: "missing";
   readonly node: TSESTree.JSXEmptyExpression;
   toStatic(): null;
 }
-/** Spread child expression (ex: `{...items}` as children) */
+/** Spread child expression (ex: `{...items}` as children). */
 interface JsxAttributeValueSpreadChild {
   readonly kind: "spreadChild";
   getChildren(): unknown;
   readonly node: TSESTree.JSXSpreadChild["expression"];
   toStatic(): null;
 }
-/** Spread props (ex: `<Comp {...props} />`) */
+/** Spread props (ex: `<Comp {...props} />`). */
 interface JsxAttributeValueSpreadProps {
   readonly kind: "spreadProps";
   getProperty(name: string): unknown;
@@ -135,21 +135,21 @@ interface JsxAttributeValueSpreadProps {
 //#endregion
 //#region src/get-attribute-value.d.ts
 /**
- * Find an attribute by name on a JSX element and resolve its value in a single call
+ * 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.
- * @param context The ESLint rule context
- * @param element The `JSXElement` node to search
- * @param name The attribute name to look up (ex: "className")
- * @returns A {@link JsxAttributeValue} descriptor, or `null` when the attribute is not present on the element
+ * @param context The ESLint rule context.
+ * @param element The `JSXElement` node to search.
+ * @param name The attribute name to look up (ex: "className").
+ * @returns A {@link JsxAttributeValue} descriptor, or `null` when the attribute is not present on the element.
  */
 declare function getAttributeValue(context: RuleContext, element: TSESTree.JSXElement, name: string): JsxAttributeValue | null;
 //#endregion
 //#region src/get-children.d.ts
 /**
- * Get the meaningful children of a JSX element or fragment
+ * Get the meaningful children of a JSX element or fragment.
  *
  * Mirrors Babel's `buildChildren` helper:
  * 1. Iterate over `element.children`.
@@ -157,69 +157,69 @@ declare function getAttributeValue(context: RuleContext, element: TSESTree.JSXEl
  * 3. Skip `JSXExpressionContainer` nodes whose expression is empty.
  * 4. Skip `JSXEmptyExpression` nodes.
  * 5. Collect everything else.
- * @param element A `JSXElement` or `JSXFragment` node
- * @returns An array of children nodes that contribute to rendered output
+ * @param element A `JSXElement` or `JSXFragment` node.
+ * @returns An array of children nodes that contribute to rendered output.
  */
 declare function getChildren(element: TSESTreeJSXElementLike): TSESTree.JSXChild[];
 //#endregion
 //#region src/get-element-type.d.ts
 /**
- * Get the string representation of a JSX element's type
+ * Get the string representation of a JSX element's type.
  *
  * - `<div>` -> `"div"`
  * - `<Foo.Bar>` -> `"Foo.Bar"`
  * - `<React.Fragment>` -> `"React.Fragment"`
- * - `<></>` -> `""`
- * @param node A `JSXElement` or `JSXFragment` node
- * @returns The fully-qualified element type string
+ * - `<></>` -> `""`.
+ * @param node A `JSXElement` or `JSXFragment` node.
+ * @returns The fully-qualified element type string.
  */
 declare function getElementFullType(node: TSESTreeJSXElementLike): string;
 /**
- * Get the self name (last dot-separated segment) of a JSX element type
+ * Get the self name (last dot-separated segment) of a JSX element type.
  *
  * - `<Foo.Bar.Baz>` -> `"Baz"`
  * - `<div>` -> `"div"`
- * - `<></>` -> `""`
- * @param node A `JSXElement` or `JSXFragment` node
- * @returns The last segment of the element type, or `""` for fragments
+ * - `<></>` -> `""`.
+ * @param node A `JSXElement` or `JSXFragment` node.
+ * @returns The last segment of the element type, or `""` for fragments.
  */
 declare function getElementSelfType(node: TSESTreeJSXElementLike): string;
 //#endregion
 //#region src/has-any-attribute.d.ts
 /**
- * Check whether a JSX element carries at least one of the given attributes
+ * 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}).
- * @param context The ESLint rule context (needed for variable resolution in spread attributes)
- * @param element The `JSXElement` node to inspect
- * @param names The attribute names to look for
- * @returns `true` when at least one of the attributes is present
+ * @param context The ESLint rule context (needed for variable resolution in spread attributes).
+ * @param element The `JSXElement` node to inspect.
+ * @param names The attribute names to look for.
+ * @returns `true` when at least one of the attributes is present.
  */
 declare function hasAnyAttribute(context: RuleContext, element: TSESTree.JSXElement, names: string[]): boolean;
 //#endregion
 //#region src/has-attribute.d.ts
 /**
- * Check whether a JSX element carries a given attribute (prop)
+ * 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.
  *
  * Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
  * will report `true` for `"disabled"`.
- * @param context The ESLint rule context (needed for variable resolution in spread attributes)
- * @param element The `JSXElement` node to inspect
- * @param name The attribute name to look for (ex: "className")
- * @returns `true` when the attribute is present on the element
+ * @param context The ESLint rule context (needed for variable resolution in spread attributes).
+ * @param element The `JSXElement` node to inspect.
+ * @param name The attribute name to look for (ex: "className").
+ * @returns `true` when the attribute is present on the element.
  */
 declare function hasAttribute(context: RuleContext, element: TSESTree.JSXElement, name: string): boolean;
 //#endregion
 //#region src/has-children.d.ts
 /**
  * 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
+ * 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
@@ -236,38 +236,38 @@ declare function hasAttribute(context: RuleContext, element: TSESTree.JSXElement
  * 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
+ * @param element A `JSXElement` or `JSXFragment` node.
+ * @returns `true` when the element has at least one meaningful child.
  */
 declare function hasChildren(element: TSESTreeJSXElementLike): boolean;
 //#endregion
 //#region src/has-every-attribute.d.ts
 /**
- * Check whether a JSX element carries all of the given attributes (props)
+ * 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}).
- * @param context The ESLint rule context (needed for variable resolution in spread attributes)
- * @param element The `JSXElement` node to inspect
- * @param names The attribute names to look for
- * @returns `true` when every name in `names` is present on the element
+ * @param context The ESLint rule context (needed for variable resolution in spread attributes).
+ * @param element The `JSXElement` node to inspect.
+ * @param names The attribute names to look for.
+ * @returns `true` when every name in `names` is present on the element.
  */
 declare function hasEveryAttribute(context: RuleContext, element: TSESTree.JSXElement, names: string[]): boolean;
 //#endregion
 //#region src/is-element.d.ts
 /**
- * A test that determines whether a JSX element matches
+ * A test that determines whether a JSX element matches.
  *
  * - `string` matches against the full element type (ex: "div", "React.Fragment")
  * - `string[]` matches when the element type equals any of the given strings
- * - `function` receives the element type string and returns a boolean
+ * - `function` receives the element type string and returns a 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
+ * matches a given test.
  *
  * Modelled after
  * [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
@@ -275,15 +275,15 @@ type ElementTest = string | readonly string[] | ((elementType: string, node: TSE
  *
  * When called without a test, the function acts as a simple type-guard
  * for `JSXElement | JSXFragment`.
- * @param node The AST node to test
- * @param test Optional test to match the element type against
- * @returns `true` when the node is a matching JSX element
+ * @param node The AST node to test.
+ * @param test Optional test to match the element type against.
+ * @returns `true` when the node is a matching JSX element.
  */
 declare function isElement(node: TSESTree.Node | null | undefined, test?: ElementTest): node is TSESTreeJSXElementLike;
 //#endregion
 //#region src/is-fragment-element.d.ts
 /**
- * Check whether a node is a React Fragment element
+ * Check whether a node is a React Fragment element.
  *
  * Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the
  * explicit `<Fragment>` / `<React.Fragment>` form (`JSXElement`).
@@ -291,70 +291,70 @@ declare function isElement(node: TSESTree.Node | null | undefined, test?: Elemen
  * 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
- * @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment")
- * @returns `true` when the node represents a React Fragment
+ * @param node The AST node to test.
+ * @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment").
+ * @returns `true` when the node represents a React Fragment.
  */
 declare function isFragmentElement(node: TSESTree.Node, jsxFragmentFactory?: string): node is TSESTreeJSXElementLike;
 //#endregion
 //#region src/is-host-element.d.ts
 /**
- * Check whether a node is a host (intrinsic / DOM) element
+ * 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
+ * @param node The AST node to test.
+ * @returns `true` when the node is a `JSXElement` with a lowercase tag name.
  */
 declare function isHostElement(node: TSESTree.Node): node is TSESTree.JSXElement;
 //#endregion
 //#region src/is-whitespace.d.ts
 /**
  * Check whether a JSX child node is whitespace padding that React would
- * trim away during rendering
+ * 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`). This is the whitespace that appears between
  * JSX tags purely for formatting.
- * @param node A JSX child node
- * @returns `true` when the node is purely formatting whitespace
+ * @param node A JSX child node.
+ * @returns `true` when the node is purely formatting whitespace.
  */
 declare function isWhitespace(node: TSESTree.JSXChild): boolean;
 /**
- * Check whether a JSX child node is any whitespace-only text
+ * 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`
+ * @param node A JSX child node.
+ * @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 (`{""}`)
+ * 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
+ * @param node A JSX child node.
+ * @returns `true` when the node is a `{""}` expression container.
  */
 declare function isEmptyStringExpression(node: TSESTree.JSXChild): boolean;
 //#endregion
 //#region src/jsx-detection-hint.d.ts
 /**
- * BitFlags for configuring JSX detection behavior
+ * BitFlags for configuring JSX detection behavior.
  *
  * Used by `isJsxLike` to control which AST node kinds are considered
  * "JSX-like". Combine flags with the `|` operator.
  */
 type JsxDetectionHint = bigint;
 /**
- * Hints for JSX detection
+ * Hints for JSX detection.
  */
 declare const JsxDetectionHint: {
   readonly None: 0n;
@@ -371,7 +371,7 @@ declare const JsxDetectionHint: {
   readonly RequireBothBranchesOfConditionalExpressionToBeJsx: bigint;
 };
 /**
- * Default JSX detection hint
+ * Default JSX detection hint.
  *
  * Skips number, bigint, boolean, string, and undefined literals,
  * the value types that are commonly returned alongside JSX in React
@@ -382,14 +382,14 @@ declare const DEFAULT_JSX_DETECTION_HINT: JsxDetectionHint;
 //#region src/resolve-attribute-value.d.ts
 /**
  * Resolve the value of a JSX attribute (or spread attribute) into a
- * {@link JsxAttributeValue} descriptor that can be inspected further
+ * {@link JsxAttributeValue} 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}.
- * @param context The ESLint rule context (needed for scope look-ups)
- * @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node
- * @returns A discriminated-union descriptor of the attribute's value
+ * @param context The ESLint rule context (needed for scope look-ups).
+ * @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
+ * @returns A discriminated-union descriptor of the attribute's value.
  */
 declare function resolveAttributeValue(context: RuleContext, attribute: TSESTreeJSXAttributeLike): JsxAttributeValue;
 //#endregion

package/dist/index.js

@@ -6,7 +6,7 @@ import { P, match } from "ts-pattern";
 
 //#region src/collapse-multiline-text.ts
 /**
-* Collapse a multiline JSX text string following React's whitespace rules
+* Collapse a multiline JSX text string following React's whitespace rules.
 *
 * This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
 * 1. Split the raw text into lines.
@@ -14,8 +14,8 @@ import { P, match } from "ts-pattern";
 * 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
+* @param text The raw JSX text string to collapse.
+* @returns The collapsed string, or `null` if the text contains only whitespace.
 * @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
 */
 function collapseMultilineText(text) {
@@ -42,14 +42,14 @@ function collapseMultilineText(text) {
 //#endregion
 //#region src/get-attribute-name.ts
 /**
-* Get the stringified name of a `JSXAttribute` node
+* 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
-* @returns The attribute name as a plain string
+* - `xml:space` -> `"xml:space"`.
+* @param node A `JSXAttribute` AST node.
+* @returns The attribute name as a plain string.
 */
 function getAttributeName(node) {
 	if (node.name.type === AST_NODE_TYPES.JSXIdentifier) return node.name.name;
@@ -59,7 +59,7 @@ function getAttributeName(node) {
 //#endregion
 //#region src/find-attribute.ts
 /**
-* Find a JSX attribute (or spread attribute containing the property) by name on a given element
+* 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.
@@ -67,10 +67,10 @@ function getAttributeName(node) {
 * 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.
-* @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")
-* @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found
+* @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").
+* @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found.
 */
 function findAttribute(context, element, name) {
 	function findProperty(properties, name, seen = /* @__PURE__ */ new Set()) {
@@ -115,13 +115,13 @@ function findAttribute(context, element, name) {
 //#region src/find-parent-attribute.ts
 /**
 * Walk up the AST from `node` to find the nearest ancestor that is a `JSXAttribute`
-* and (optionally) passes a predicate
+* 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.
-* @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 `null` if none is found before reaching the root
+* @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 `null` if none is found before reaching the root.
 */
 function findParentAttribute(node, test = () => true) {
 	const guard = (n) => {
@@ -134,14 +134,14 @@ function findParentAttribute(node, test = () => true) {
 //#region src/resolve-attribute-value.ts
 /**
 * Resolve the value of a JSX attribute (or spread attribute) into a
-* {@link JsxAttributeValue} descriptor that can be inspected further
+* {@link JsxAttributeValue} 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}.
-* @param context The ESLint rule context (needed for scope look-ups)
-* @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node
-* @returns A discriminated-union descriptor of the attribute's value
+* @param context The ESLint rule context (needed for scope look-ups).
+* @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
+* @returns A discriminated-union descriptor of the attribute's value.
 */
 function resolveAttributeValue(context, attribute) {
 	if (attribute.type === AST_NODE_TYPES.JSXAttribute) return resolveJsxAttribute(context, attribute);
@@ -221,7 +221,7 @@ function resolveJsxSpreadAttribute(context, node) {
 //#region src/get-attribute-static-value.ts
 /**
 * Find an attribute by name on a JSX element and collapse its value to a plain
-* JavaScript value in a single step
+* JavaScript value in a single step.
 *
 * This is a convenience composition of {@link findAttribute} ->
 * {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
@@ -230,10 +230,10 @@ function resolveJsxSpreadAttribute(context, node) {
 * Returns `null` when the attribute is absent, `undefined` when the value cannot
 * be statically determined (including empty expression containers), and the
 * resolved static value otherwise.
-* @param context The ESLint rule context
-* @param element The `JSXElement` node to inspect
-* @param name The attribute name to look up (ex: "className")
-* @returns The static value of the attribute, `null` when absent, or `undefined` when indeterminate
+* @param context The ESLint rule context.
+* @param element The `JSXElement` node to inspect.
+* @param name The attribute name to look up (ex: "className").
+* @returns The static value of the attribute, `null` when absent, or `undefined` when indeterminate.
 */
 function getAttributeStaticValue(context, element, name) {
 	const attr = findAttribute(context, element, name);
@@ -247,15 +247,15 @@ function getAttributeStaticValue(context, element, name) {
 //#endregion
 //#region src/get-attribute-value.ts
 /**
-* Find an attribute by name on a JSX element and resolve its value in a single call
+* 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.
-* @param context The ESLint rule context
-* @param element The `JSXElement` node to search
-* @param name The attribute name to look up (ex: "className")
-* @returns A {@link JsxAttributeValue} descriptor, or `null` when the attribute is not present on the element
+* @param context The ESLint rule context.
+* @param element The `JSXElement` node to search.
+* @param name The attribute name to look up (ex: "className").
+* @returns A {@link JsxAttributeValue} descriptor, or `null` when the attribute is not present on the element.
 */
 function getAttributeValue(context, element, name) {
 	const attr = findAttribute(context, element, name);
@@ -267,42 +267,42 @@ function getAttributeValue(context, element, name) {
 //#region src/is-whitespace.ts
 /**
 * Check whether a JSX child node is whitespace padding that React would
-* trim away during rendering
+* 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`). This is the whitespace that appears between
 * JSX tags purely for formatting.
-* @param node A JSX child node
-* @returns `true` when the node is purely formatting whitespace
+* @param node A JSX child node.
+* @returns `true` when the node is purely formatting whitespace.
 */
 function isWhitespace(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 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`
+* @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 (`{""}`)
+* 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
+* @param node A JSX child node.
+* @returns `true` when the node is a `{""}` expression container.
 */
 function isEmptyStringExpression(node) {
 	if (node.type !== AST_NODE_TYPES.JSXExpressionContainer) return false;
@@ -314,7 +314,7 @@ function isEmptyStringExpression(node) {
 //#endregion
 //#region src/get-children.ts
 /**
-* Get the meaningful children of a JSX element or fragment
+* Get the meaningful children of a JSX element or fragment.
 *
 * Mirrors Babel's `buildChildren` helper:
 * 1. Iterate over `element.children`.
@@ -322,8 +322,8 @@ function isEmptyStringExpression(node) {
 * 3. Skip `JSXExpressionContainer` nodes whose expression is empty.
 * 4. Skip `JSXEmptyExpression` nodes.
 * 5. Collect everything else.
-* @param element A `JSXElement` or `JSXFragment` node
-* @returns An array of children nodes that contribute to rendered output
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns An array of children nodes that contribute to rendered output.
 */
 function getChildren(element) {
 	const elements = [];
@@ -348,14 +348,14 @@ function getChildren(element) {
 //#endregion
 //#region src/get-element-type.ts
 /**
-* Get the string representation of a JSX element's type
+* Get the string representation of a JSX element's type.
 *
 * - `<div>` -> `"div"`
 * - `<Foo.Bar>` -> `"Foo.Bar"`
 * - `<React.Fragment>` -> `"React.Fragment"`
-* - `<></>` -> `""`
-* @param node A `JSXElement` or `JSXFragment` node
-* @returns The fully-qualified element type string
+* - `<></>` -> `""`.
+* @param node A `JSXElement` or `JSXFragment` node.
+* @returns The fully-qualified element type string.
 */
 function getElementFullType(node) {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
@@ -369,13 +369,13 @@ function getElementFullType(node) {
 	return getQualifiedName(node.openingElement.name);
 }
 /**
-* Get the self name (last dot-separated segment) of a JSX element type
+* Get the self name (last dot-separated segment) of a JSX element type.
 *
 * - `<Foo.Bar.Baz>` -> `"Baz"`
 * - `<div>` -> `"div"`
-* - `<></>` -> `""`
-* @param node A `JSXElement` or `JSXFragment` node
-* @returns The last segment of the element type, or `""` for fragments
+* - `<></>` -> `""`.
+* @param node A `JSXElement` or `JSXFragment` node.
+* @returns The last segment of the element type, or `""` for fragments.
 */
 function getElementSelfType(node) {
 	return getElementFullType(node).split(".").at(-1) ?? "";
@@ -384,16 +384,16 @@ function getElementSelfType(node) {
 //#endregion
 //#region src/has-any-attribute.ts
 /**
-* Check whether a JSX element carries at least one of the given attributes
+* 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}).
-* @param context The ESLint rule context (needed for variable resolution in spread attributes)
-* @param element The `JSXElement` node to inspect
-* @param names The attribute names to look for
-* @returns `true` when at least one of the attributes is present
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param names The attribute names to look for.
+* @returns `true` when at least one of the attributes is present.
 */
 function hasAnyAttribute(context, element, names) {
 	return names.some((name) => findAttribute(context, element, name) != null);
@@ -402,17 +402,17 @@ function hasAnyAttribute(context, element, names) {
 //#endregion
 //#region src/has-attribute.ts
 /**
-* Check whether a JSX element carries a given attribute (prop)
+* 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.
 *
 * Spread attributes are taken into account: `<Comp {...{ disabled: true }} />`
 * will report `true` for `"disabled"`.
-* @param context The ESLint rule context (needed for variable resolution in spread attributes)
-* @param element The `JSXElement` node to inspect
-* @param name The attribute name to look for (ex: "className")
-* @returns `true` when the attribute is present on the element
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param name The attribute name to look for (ex: "className").
+* @returns `true` when the attribute is present on the element.
 */
 function hasAttribute(context, element, name) {
 	return findAttribute(context, element, name) != null;
@@ -422,7 +422,7 @@ function hasAttribute(context, element, name) {
 //#region src/has-children.ts
 /**
 * 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
+* 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
@@ -439,8 +439,8 @@ function hasAttribute(context, element, name) {
 * 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
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns `true` when the element has at least one meaningful child.
 */
 function hasChildren(element) {
 	if (element.children.length === 0) return false;
@@ -450,16 +450,16 @@ function hasChildren(element) {
 //#endregion
 //#region src/has-every-attribute.ts
 /**
-* Check whether a JSX element carries all of the given attributes (props)
+* 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}).
-* @param context The ESLint rule context (needed for variable resolution in spread attributes)
-* @param element The `JSXElement` node to inspect
-* @param names The attribute names to look for
-* @returns `true` when every name in `names` is present on the element
+* @param context The ESLint rule context (needed for variable resolution in spread attributes).
+* @param element The `JSXElement` node to inspect.
+* @param names The attribute names to look for.
+* @returns `true` when every name in `names` is present on the element.
 */
 function hasEveryAttribute(context, element, names) {
 	return names.every((name) => findAttribute(context, element, name) != null);
@@ -469,7 +469,7 @@ function hasEveryAttribute(context, element, names) {
 //#region src/is-element.ts
 /**
 * Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
-* matches a given test
+* matches a given test.
 *
 * Modelled after
 * [`hast-util-is-element`](https://github.com/syntax-tree/hast-util-is-element):
@@ -477,9 +477,9 @@ function hasEveryAttribute(context, element, names) {
 *
 * When called without a test, the function acts as a simple type-guard
 * for `JSXElement | JSXFragment`.
-* @param node The AST node to test
-* @param test Optional test to match the element type against
-* @returns `true` when the node is a matching JSX element
+* @param node The AST node to test.
+* @param test Optional test to match the element type against.
+* @returns `true` when the node is a matching JSX element.
 */
 function isElement(node, test) {
 	if (node == null) return false;
@@ -496,7 +496,7 @@ function isElement(node, test) {
 //#endregion
 //#region src/is-fragment-element.ts
 /**
-* Check whether a node is a React Fragment element
+* Check whether a node is a React Fragment element.
 *
 * Recognizes both the shorthand `<>...</>` syntax (`JSXFragment`) and the
 * explicit `<Fragment>` / `<React.Fragment>` form (`JSXElement`).
@@ -504,9 +504,9 @@ function isElement(node, test) {
 * 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
-* @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment")
-* @returns `true` when the node represents a React Fragment
+* @param node The AST node to test.
+* @param jsxFragmentFactory The configured fragment factory string (ex: "React.Fragment").
+* @returns `true` when the node represents a React Fragment.
 */
 function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return true;
@@ -518,13 +518,13 @@ function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 //#endregion
 //#region src/is-host-element.ts
 /**
-* Check whether a node is a host (intrinsic / DOM) element
+* 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
+* @param node The AST node to test.
+* @returns `true` when the node is a `JSXElement` with a lowercase tag name.
 */
 function isHostElement(node) {
 	if (node.type !== AST_NODE_TYPES.JSXElement) return false;
@@ -537,7 +537,7 @@ function isHostElement(node) {
 //#endregion
 //#region src/jsx-detection-hint.ts
 /**
-* Hints for JSX detection
+* Hints for JSX detection.
 */
 const JsxDetectionHint = {
 	None: 0n,
@@ -554,7 +554,7 @@ const JsxDetectionHint = {
 	RequireBothBranchesOfConditionalExpressionToBeJsx: 1n << 10n
 };
 /**
-* Default JSX detection hint
+* Default JSX detection hint.
 *
 * Skips number, bigint, boolean, string, and undefined literals,
 * the value types that are commonly returned alongside JSX in React

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/jsx",
-  "version": "5.16.1",
+  "version": "5.17.0",
   "description": "ESLint React's TSESTree JSX utility module for static analysis of JSX patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -32,17 +32,17 @@
     "@typescript-eslint/types": "^8.64.0",
     "@typescript-eslint/utils": "^8.64.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.16.1",
-    "@eslint-react/eslint": "5.16.1",
-    "@eslint-react/shared": "5.16.1",
-    "@eslint-react/var": "5.16.1"
+    "@eslint-react/ast": "5.17.0",
+    "@eslint-react/eslint": "5.17.0",
+    "@eslint-react/shared": "5.17.0",
+    "@eslint-react/var": "5.17.0"
   },
   "devDependencies": {
     "eslint": "^10.7.0",
     "tsdown": "^0.22.7",
     "typescript": "6.0.3",
-    "@local/configs": "0.0.0",
-    "@local/eff": "0.0.0"
+    "@local/eff": "0.0.0",
+    "@local/configs": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "*",